Ich habe ein Projekt wo ich nervig viele Berechnungen auf float Arrays machen muss. Ich habe daher jetzt mal eine Hilfsklasse gebastelt:
Code: Alles auswählen
class Field : public std::vector<float>
{
public:
using vector::vector;
inline const Field& operator= (float value);
inline const Field& operator*= (float value);
inline const Field& operator*= (const Field& other); // element wise multiplication
};
Field operator* (Field a, Field b);
Field operator* (Field a, float v);
Field operator*(Field a, float v)
{
Field res(a.size());
for( auto i=0; i<a.size(); ++i)
res[i] = a[i] * v;
return res;
}
// etc....
Code: Alles auswählen
void Function(const std::vector<float>& f);
for(auto i=0; i<num_voxels; ++i)
{
tmp[i] = m_w[i] * 0.5f * m_n[i];
}
Function(tmp);
Code: Alles auswählen
Function( m_w * 0.5f * m_n);
Aber wie viel kostet mich das ganze? 3 Felder nacheinander multiplizieren erzeugt einerseits temporäre Variable, andererseits gibts aber z.B. auch 2 Schleifen anstatt nur einer. Der Schleifenkörper ist eh schon fast leer, die Hälfte der Arbeit geht ja aufs Hochzählen drauf und das will man dann vielleicht nicht doppelt machen. Andererseits ist es aber auch plausibel, und darauf spekuliere ich, dass alles wegoptimiert wird und ich am Ende den selben Code habe.
Ich hab jetzt keine große Übung darin Assembler-Code zu lesen. Kann ich erwartungsgemäß davon ausgehen, dass die Optimierung gut klappt?