3. Länge eines stringstreams, wie?

Länge eines stringstreams, wie?

  • U

    ich wollte eigentlich mal gucken, wieso der unterschied zwischen den ifs(bzw deren reihenfolge) so groß ist, aber bin dabei auf was anderes komisches gestoßen:

    typedef unsigned int UInt32;

#if 0
//x32 16bit 18.91
//x32 32bit 28.77
//x64 16bit 20.80
//x64 32bit 28.74
UInt32 get_length(UInt32 x){
    if(x<=9) return 1;
    if(x<=99) return 2;
    if(x<=999) return 3;
    if(x<=9999) return 4;
    if(x<=99999) return 5;
    if(x<=999999) return 6;
    if(x<=9999999) return 7;
    if(x<=99999999) return 8;
    if(x<=999999999) return 9;
    return 10;
} 
#elif 1
//x32 16bit 24.15
//x32 32bit 6.06
//x64 16bit 24.07
//x64 32bit 6.05
UInt32 get_length(UInt32 x){
    if(x>=1000000000) return 10;
    if(x>=100000000) return 9;
    if(x>=10000000) return 8;
    if(x>=1000000) return 7;
    if(x>=100000) return 6;
    if(x>=10000) return 5;
    if(x>=1000) return 4;
    if(x>=100) return 3;
    if(x>=10) return 2;
    return 1;
}
#elif 1
//x32 16bit 7.21
//x32 32bit 6.44
//x64 16bit 8.92
//x64 32bit 6.56
UInt32 get_length(UInt32 x){
    if(x>=100000)//6
        if(x>=100000000)//9
            if(x>=1000000000)//10
                return 10;
            else
                return 9;
        else
            if(x>=10000000)//8
                return 8;
            else
                if(x>=10000000)//7
                    return 7;
                else
                    return 6;
    else
        if(x>=1000)//4
            if(x>=10000)//5
                return 5;
            else
                return 4;
        else
            if(x>=100)//3
                return 3;
            else
                if(x>=10)//2
                    return 2;
                else
                    return 1;
}
#endif

#include <iostream>

#include "my/timer.h"

int main()
{
	my::timer_t timer;

    UInt32 x=0;
    UInt32 s=0;

    do {
            s+=get_length(x %65536);
        ++x;
    } while (x != 0);

	my::timer_t::tick_type ticks = timer();
	std::cout << my::timer_t::get_seconds_from_ticks(ticks) << " seconds" << std::endl;

	std::cout << '\t' << s << std::endl;
}

    hab alle tests mehrfach wiederholt, das ergebnis blieb das gleiche - die extremen schwankungen waren auch im taskmgrU(CPU-Zeit) nachzuvollziehen - also nicht, dass irgend ein prozess iwas blockiert hat...

    msvc9 schrieb:

    /O2 /Oi /GL /D "_MBCS" /FD /EHsc /MD /Gy /Fo"Release\\" /Fd"Release\vc90.pdb" /W3 /nologo /c /Zi /TP /errorReport:prompt

    bzw.

    /O2 /Oi /GL /D "_MBCS" /FD /EHsc /MD /Gy /Fo"x64\Release\\" /Fd"x64\Release\vc90.pdb" /W3 /nologo /c /Zi /TP /errorReport:prompt

    CPU ist auch ein E8400@3,00GHz
    OS Win7, 64bit

    Falls iwer damit mehr anfangen kann als ich:

    do {
            s+=get_length(x %65536);
000000013FEE1210  movzx       ecx,dx 
000000013FEE1213  cmp         ecx,9 
000000013FEE1216  ja          main+2Fh (13FEE121Fh) 
000000013FEE1218  mov         eax,1 
000000013FEE121D  jmp         main+0A3h (13FEE1293h) 
000000013FEE121F  cmp         ecx,63h 
000000013FEE1222  ja          main+3Bh (13FEE122Bh) 
000000013FEE1224  mov         eax,2 
000000013FEE1229  jmp         main+0A3h (13FEE1293h) 
000000013FEE122B  cmp         ecx,3E7h 
000000013FEE1231  ja          main+4Ah (13FEE123Ah) 
000000013FEE1233  mov         eax,3 
000000013FEE1238  jmp         main+0A3h (13FEE1293h) 
000000013FEE123A  cmp         ecx,270Fh 
000000013FEE1240  ja          main+59h (13FEE1249h) 
000000013FEE1242  mov         eax,4 
000000013FEE1247  jmp         main+0A3h (13FEE1293h) 
000000013FEE1249  cmp         ecx,1869Fh 
000000013FEE124F  ja          main+68h (13FEE1258h) 
000000013FEE1251  mov         eax,5 
000000013FEE1256  jmp         main+0A3h (13FEE1293h) 
000000013FEE1258  cmp         ecx,0F423Fh 
000000013FEE125E  ja          main+77h (13FEE1267h) 
000000013FEE1260  mov         eax,6 
000000013FEE1265  jmp         main+0A3h (13FEE1293h) 
000000013FEE1267  cmp         ecx,98967Fh 
000000013FEE126D  ja          main+86h (13FEE1276h) 
000000013FEE126F  mov         eax,7 
000000013FEE1274  jmp         main+0A3h (13FEE1293h) 
000000013FEE1276  cmp         ecx,5F5E0FFh 
000000013FEE127C  ja          main+95h (13FEE1285h) 
000000013FEE127E  mov         eax,8 
000000013FEE1283  jmp         main+0A3h (13FEE1293h) 
000000013FEE1285  xor         eax,eax 
000000013FEE1287  cmp         ecx,3B9AC9FFh 
000000013FEE128D  seta        al   
000000013FEE1290  add         eax,9 
000000013FEE1293  add         esi,eax 
        ++x;
000000013FEE1295  add         edx,1 
    } while (x != 0);

    1. variante x64, 16bit zahl

    do {
            s+=get_length(x /*%65536*/);
000000013FF01210  cmp         ecx,9 
000000013FF01213  ja          main+2Ch (13FF0121Ch) 
000000013FF01215  mov         eax,1 
000000013FF0121A  jmp         main+0A0h (13FF01290h) 
000000013FF0121C  cmp         ecx,63h 
000000013FF0121F  ja          main+38h (13FF01228h) 
000000013FF01221  mov         eax,2 
000000013FF01226  jmp         main+0A0h (13FF01290h) 
000000013FF01228  cmp         ecx,3E7h 
000000013FF0122E  ja          main+47h (13FF01237h) 
000000013FF01230  mov         eax,3 
000000013FF01235  jmp         main+0A0h (13FF01290h) 
000000013FF01237  cmp         ecx,270Fh 
000000013FF0123D  ja          main+56h (13FF01246h) 
000000013FF0123F  mov         eax,4 
000000013FF01244  jmp         main+0A0h (13FF01290h) 
000000013FF01246  cmp         ecx,1869Fh 
000000013FF0124C  ja          main+65h (13FF01255h) 
000000013FF0124E  mov         eax,5 
000000013FF01253  jmp         main+0A0h (13FF01290h) 
000000013FF01255  cmp         ecx,0F423Fh 
000000013FF0125B  ja          main+74h (13FF01264h) 
000000013FF0125D  mov         eax,6 
000000013FF01262  jmp         main+0A0h (13FF01290h) 
000000013FF01264  cmp         ecx,98967Fh 
000000013FF0126A  ja          main+83h (13FF01273h) 
000000013FF0126C  mov         eax,7 
000000013FF01271  jmp         main+0A0h (13FF01290h) 
000000013FF01273  cmp         ecx,5F5E0FFh 
000000013FF01279  ja          main+92h (13FF01282h) 
000000013FF0127B  mov         eax,8 
000000013FF01280  jmp         main+0A0h (13FF01290h) 
000000013FF01282  xor         eax,eax 
000000013FF01284  cmp         ecx,3B9AC9FFh 
000000013FF0128A  seta        al   
000000013FF0128D  add         eax,9 
000000013FF01290  add         esi,eax 
        ++x;
000000013FF01292  add         ecx,1 
    } while (x != 0);

    1. Variante, x64, 32bit Zahl

    do {
            s+=get_length(x /*%65536*/);
000000013F261210  cmp         ecx,3B9ACA00h 
000000013F261216  jb          main+2Fh (13F26121Fh) 
000000013F261218  mov         eax,0Ah 
000000013F26121D  jmp         main+9Dh (13F26128Dh) 
000000013F26121F  cmp         ecx,5F5E100h 
000000013F261225  jb          main+3Eh (13F26122Eh) 
000000013F261227  mov         eax,9 
000000013F26122C  jmp         main+9Dh (13F26128Dh) 
000000013F26122E  cmp         ecx,989680h 
000000013F261234  jb          main+4Dh (13F26123Dh) 
000000013F261236  mov         eax,8 
000000013F26123B  jmp         main+9Dh (13F26128Dh) 
000000013F26123D  cmp         ecx,0F4240h 
000000013F261243  jb          main+5Ch (13F26124Ch) 
000000013F261245  mov         eax,7 
000000013F26124A  jmp         main+9Dh (13F26128Dh) 
000000013F26124C  cmp         ecx,186A0h 
000000013F261252  jb          main+6Bh (13F26125Bh) 
000000013F261254  mov         eax,6 
000000013F261259  jmp         main+9Dh (13F26128Dh) 
000000013F26125B  cmp         ecx,2710h 
000000013F261261  jb          main+7Ah (13F26126Ah) 
000000013F261263  mov         eax,5 
000000013F261268  jmp         main+9Dh (13F26128Dh) 
000000013F26126A  cmp         ecx,3E8h 
000000013F261270  jb          main+89h (13F261279h) 
000000013F261272  mov         eax,4 
000000013F261277  jmp         main+9Dh (13F26128Dh) 
000000013F261279  cmp         ecx,64h 
000000013F26127C  jb          main+95h (13F261285h) 
000000013F26127E  mov         eax,3 
000000013F261283  jmp         main+9Dh (13F26128Dh) 
000000013F261285  cmp         ecx,0Ah 
000000013F261288  sbb         eax,eax 
000000013F26128A  add         eax,2 
000000013F26128D  add         esi,eax 
        ++x;
000000013F26128F  add         ecx,1 
    } while (x != 0);

    2. Variante, x64, 32bit Zahl

    do {
            s+=get_length(x %65536);
000000013FC61210  movzx       eax,cx 
000000013FC61213  cmp         eax,3B9ACA00h 
000000013FC61218  jb          main+31h (13FC61221h) 
000000013FC6121A  mov         eax,0Ah 
000000013FC6121F  jmp         main+99h (13FC61289h) 
000000013FC61221  cmp         eax,5F5E100h 
000000013FC61226  jb          main+3Fh (13FC6122Fh) 
000000013FC61228  mov         eax,9 
000000013FC6122D  jmp         main+99h (13FC61289h) 
000000013FC6122F  cmp         eax,989680h 
000000013FC61234  jb          main+4Dh (13FC6123Dh) 
000000013FC61236  mov         eax,8 
000000013FC6123B  jmp         main+99h (13FC61289h) 
000000013FC6123D  cmp         eax,0F4240h 
000000013FC61242  jb          main+5Bh (13FC6124Bh) 
000000013FC61244  mov         eax,7 
000000013FC61249  jmp         main+99h (13FC61289h) 
000000013FC6124B  cmp         eax,186A0h 
000000013FC61250  jb          main+69h (13FC61259h) 
000000013FC61252  mov         eax,6 
000000013FC61257  jmp         main+99h (13FC61289h) 
000000013FC61259  cmp         eax,2710h 
000000013FC6125E  jb          main+77h (13FC61267h) 
000000013FC61260  mov         eax,5 
000000013FC61265  jmp         main+99h (13FC61289h) 
000000013FC61267  cmp         eax,3E8h 
000000013FC6126C  jb          main+85h (13FC61275h) 
000000013FC6126E  mov         eax,4 
000000013FC61273  jmp         main+99h (13FC61289h) 
000000013FC61275  cmp         eax,64h 
000000013FC61278  jb          main+91h (13FC61281h) 
000000013FC6127A  mov         eax,3 
000000013FC6127F  jmp         main+99h (13FC61289h) 
000000013FC61281  cmp         eax,0Ah 
000000013FC61284  sbb         eax,eax 
000000013FC61286  add         eax,2 
000000013FC61289  add         esi,eax 
        ++x;
000000013FC6128B  add         ecx,1 
    } while (x != 0);

    2. Variante, x64, 16bit Zahl

    do {
            s+=get_length(x %65536);
000000013F801210  movzx       ecx,dx 
000000013F801213  cmp         ecx,186A0h 
000000013F801219  jb          main+51h (13F801241h) 
000000013F80121B  cmp         ecx,5F5E100h 
000000013F801221  jb          main+40h (13F801230h) 
000000013F801223  cmp         ecx,3B9ACA00h 
000000013F801229  sbb         eax,eax 
000000013F80122B  add         eax,0Ah 
000000013F80122E  jmp         main+7Ah (13F80126Ah) 
000000013F801230  mov         eax,6 
000000013F801235  cmp         ecx,989680h 
000000013F80123B  cmovae      eax,r8d 
000000013F80123F  jmp         main+7Ah (13F80126Ah) 
000000013F801241  cmp         ecx,3E8h 
000000013F801247  jb          main+66h (13F801256h) 
000000013F801249  cmp         ecx,2710h 
000000013F80124F  sbb         eax,eax 
000000013F801251  add         eax,5 
000000013F801254  jmp         main+7Ah (13F80126Ah) 
000000013F801256  cmp         ecx,64h 
000000013F801259  jb          main+72h (13F801262h) 
000000013F80125B  mov         eax,3 
000000013F801260  jmp         main+7Ah (13F80126Ah) 
000000013F801262  cmp         ecx,0Ah 
000000013F801265  sbb         eax,eax 
000000013F801267  add         eax,2 
000000013F80126A  add         esi,eax 
        ++x;
000000013F80126C  add         edx,1 
    } while (x != 0);

    3. variante x64, 16bit zahl

    Kann mir das irgendwer erklären? -.-

    bb

    0
  • ?

    Tja, die gemeinen Compiler.

    0
  • M

    Th69 schrieb:

    Im Vergleich zum restlichen Programm (z.B. bei Benutzereingaben) spielt daher die Performance wohl nur eine untergeordnete Rolle.
    Meines Erachtens hier also ganz klar ein Fall von "POITROAE" (Premature optimization is the root of all evil)!

    Ach, hier gehts doch schon lange nicht mehr um reale Programme, sondern um Sport 🙂

    0

  • Hä, wo ist denn jetzt mein Beitrag hin?
    Schön, daß du - Michael - wenigstens meinen letzten Satz zitiert hast...

    0
  • V

    Th69 schrieb:

    Hä, wo ist denn jetzt mein Beitrag hin?

    Weg. Weil Du überhaupt nicht verstanden hast, was der zitierte Satz bedeutet, und in anderen Forum wie RundUmDieProgrammierung bitte nachfragst.

    0

  • volkard, willst du mich jetzt veräppeln?

    Ich habe eine klare Antwort auf die Frage von "unskilled" gegeben, nämlich daß die Testdaten für die unterschiedliche Performance bzgl. der if-Kaskaden zuständig sind.
    Hier nocheinmal in Zahlen (bei 0 bis 2^32):
    1-stellig: 9 (bzw. 10 wenn man die Null dazuzählt)
    2-stellig: 90
    3-stellig: 900
    ...
    8-stellig: 90000000
    9-stellig: ~3.3 Mrd.

    Also nocheinmal: über 90% der Zahlen sind 8 bzw. 9-stellig!!!

    0
  • V

    So ein Posting hätte ich auch erfreut stehen lassen.

    0

  • volkard, du weißt schon, daß mein Beitrag bzgl. "POITROAE" ironisch gemeint war, oder (sonst hätte ich wohl kaum diese Abkürzung benutzt)?

    Dafür, daß ich jetzt schon seit Jahren hier vielen Leuten im Forum geholfen habe (auch unter meinem Vorgänger-Account "Th"), finde ich es immer noch sehr eigenartig, meinen Beitrag einfach so zu löschen, wo ich inhaltlich genau das gleiche gesagt habe - nur nicht explizit in Zahlen).

    Ich habe mich nur innerlich amüsiert darüber, daß hier wegen so einer praxisirrelevanten Funktion so ein langer Thread entstanden ist - ohne zu erkennen, daß die Testdaten für die Ergebnisse verantwortlich sind...

    0
  • V

    Th69 schrieb:

    volkard, du weißt schon, daß mein Beitrag bzgl. "POITROAE" ironisch gemeint war, oder (sonst hätte ich wohl kaum diese Abkürzung benutzt)?

    Das hatte ich nicht erkannt.

    Th69 schrieb:

    so ein langer Thread entstanden ist - ohne zu erkennen, daß die Testdaten für die Ergebnisse verantwortlich sind...

    Zum Beispiel

    volkard schrieb:

    Da die Zeit mitunter sehr stark von der Verteilung abhängt, messe ich immer diese beiden.

    0
  • ?

    😃

    0
Anmelden zum Antworten