folgende Funktion IsZero() wird wird in meinem Code oft (!) aufgerufen und verursacht laut Profiler 19% meiner Rechenzeit. Meine einfache Frage daher: geht das schneller?

class CUtils
{
public:
    static const float ZERO;
    inline static bool IsZero(float f) 
    {
        return fabs(f) <= ZERO; 
    };
}

// Util.cpp
const float CUtils::ZERO = 1e-5f;

Evtl. machts die Referenz was schneller. Oder du schaust dir genauer an was fabs macht.
Und ob du das optimieren kannst...

return (f > -ZERO) && (f < ZERO);

Ob das schneller ist als fabs?

return (f > -ZERO) && (f < ZERO);

musst du wohl selbst testen/profilen. Evtl. koenntest du auch ueberlegen, welcher der beiden Terme oefter false zurueckgibt und den voran stellen.

inline static bool IsZero(float f)
{
	bool result;
	_asm {
		xor     bl,bl
		fld     f
		fabs
		fcomp   ZERO
		fstsw   ax
		fwait     
		sahf      
		adc     bl,0
		mov     result,bl
	};
	return result;
};

Aber huch! Wo ist denn mein letztes Posting hin? Naja, ich habe das mal geprofiled mit folgendem kleinen Test:

bool IsZero1(float f) 
{
    return fabs(f) <= CUtils::ZERO; 
};
bool IsZero2(float f) 
{
    return (f >= -CUtils::ZERO) && (f <= CUtils::ZERO); 
};

void Test()
{
    for(uint32 i = 0; i < 10000000; i++)
    {
        float f = CUtils::Rand() - 0.5f;  // Rand() liefert float in [0,1]
        bool b1 = IsZero1(f);
        bool b2 = IsZero2(f);
    }
}

Dabei ist herausgekommen, dass IsZero2() nur ca. 40% der Zeit benötigt. Daher habe ich das dahingehend geändert.

@hellihjb
Ich muss gestehen, dass ich Assembler nicht wirklich lesen kann, da ich nur die Grundlegenden Befehle kenne. Ist das ne Implementierung, die du mir vorschlägst? Funktioniert die auf verschiedenen Palttformen (Win / Linux)? Und was macht dabei z.B. xor bl,bl? Wo kommt 'bl' her?!

bl ist das low Register von BX (=16Bit Register => bl die unteren 8Bit).

xor     bl,bl ; löscht das bl register ( => bl ist 0)
        fld     f ; schiebt dein float in die fpu (dort gibts nen stack wo die gespeichert werden)
        fabs  ;fabs halt, denke das ist klar
        fcomp   ZERO ; sollte auch klar sein (vergleich)
        fstsw   ax ; kopiert das fpu status registers nach ax
        fwait ; wartet, da fpu und cpu synchronisieren müssen zum datenaustausch
        sahf  ; kopiert das ah register in die cpu flags (jetzt haben wir das fpu ergebnis in der cpu)   
        adc     bl,0 ; add with carry addiert das carry flag darauf wenn es gesetzt ist, da zusätzlich 0 addiert wird hast du 0+1+0=1 wenn das carryflag gesetzt ist (=> das ergebnis ist null) und 0+0+0=0 wenn das carryflag nicht gesetzt ist (=> das ergebnis ist ungleich null)
        mov     result,bl ;speicher das ergebnis in result (eigentlich quatsch, klüger wäre ein mov eax,ebx)

Ist das ne Implementierung, die du mir vorschlägst?
Funktioniert die auf verschiedenen Palttformen (Win / Linux)?

du koenntest den code zb zum vergleichen beim profilen einsetzen um herauszufinden, ob dein compiler sinnvollen code erzeugt.
oder einfach mal mit dem debugger durch das disassembly-steppen und anzahl der instruktionen zaehlen.
bzgl des codes muss man vielleicht noch kommentieren, dass die position des fpu-compare-flag im ah-register mit der position des carry-flags uebereinstimmt und man deswegen das resultat des vergleichs durch einfaches addieren des carry-flags erhaelt.

Wenn es auch um Performance geht, sind die Dinger wirklich ein Muss. Bei IsZero() hätte ich zum Beispiel ansonsten NIE nachgesehen, was sich machen lässt. Und bei 19% der Gesamtzeit kann man da ja durchaus etwas rumschrauben.

bool IsZero1(float f)
{
    return fabs(f) <= CUtils::ZERO;
};
bool IsZero1Asm(float f)
{
    bool result;
    _asm 
    {
        xor     bl,bl
        fld     f
        fabs
        fcomp   CUtils::ZERO
        fstsw   ax
        fwait    
        sahf      
        adc     bl,0
        mov     result,bl
    };
    return result;
};
bool IsZero2(float f)
{
    return (f >= -CUtils::ZERO) && (f <= CUtils::ZERO);
};

Ergebnisse (100000000 Durchläufe):

IsZero1(): 11,70925581
IsZero1Asm(): 5,12243133
IsZero2(): 4,59284843

Fazit: Der Unterschied zwischen selbst kontrolliertem fabs (IsZero1Asm) und Variante zwei ist ziemlich gering. Die Implementierung von Microsoft fabs() macht offenbar interessante Sachen...

Gib's noch ne Assembler-Variante zu IsZero2()?? Und wie ist der Code für gcc? Und Inkompatibilitäten habe ich nicht zu befüchten, sofern ich für nen x86er kompiliere? Gibt's da nen Compiler-Define, was man abfragen kann? Dann könnte man sowas machen wie

#ifdef _X86 && _GCC
asm mit '%'
#elif _X86 && _MSC_VER
asm ohne '%'
#else
normal 
#endif

float EPS= 0.0001f;
inline bool zero(float a)
{
	_asm {
		mov ecx,a
		xor eax,eax
		and ecx,0x7fffffff
		sub ecx,EPS
		adc eax,0
	};
}

voraussetzung ist, dass "EPS" positiv ist.
da (positive) wachsende floating-point-zahlen in ihrer binaer-repraesentation streng monoton steigend sind, kann man sich das auslesen der fpu-flags sparen...

bzgl gcc gibt's irgendwelche flags die auch inline-assembler mit intel-syntax erlauben, hab's aber auch nicht mehr im kopf - muesste sich per suche finden lassen.

das waere vielleicht noch einen test wert:

float EPS= 0.0001f;
inline bool zero(float a)
{
	_asm {
		mov ecx,a
		xor eax,eax
		and ecx,0x7fffffff
		sub ecx,EPS
		adc eax,0
	};
}

voraussetzung ist, dass "EPS" positiv ist.

Äh, fehlt da nicht noch ein bool result; über und nen mov result,eax im asm block? Und EPS ist doch positiv. Ist doch oben definiert. Wobei ich den code so gar nicht verstehe :)...

inline bool zero(const float& a)
{
	static const float eps = 0.0001f;
	return (reinterpret_cast<const unsigned&>(a)&(~0u>>1))<reinterpret_cast<const unsigned&>(eps);
}

der erzeugte code ist ggf. sogar noch effizienter. das ist mal ein seltener fall, wo es sich lohnt, builtins als referenz-auf-const zu übergeben, da die funktion eigentlich gar nicht mit dem argument in form eine floats arbeitet - jedenfalls verbleibt mit vc2005ee bei einfacher übergabe als float selbst bei höchster optimierung noch eine fld/fstp kombination, wenn das argument per value übergeben wird.

float f;
if (zero(f)) {
}

00401011  mov         ecx,dword ptr [esp] 
00401014  and         ecx,7FFFFFFFh 
0040101A  cmp         ecx,38D1B717h 
00401020  jae         main+31h (401031h)

Jap, das ist effizienter

EDIT:
Feststellung: Ein gut optimierender Compiler hat schon was.

das "<" wird aber wahrscheinlich wieder in einen conditional-branch uebersetzt...

zum glück gibt es seit ewigkeiten (PPro) die setcc befehle