Optimierte Cee Funktion atoi
 
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern

Folgende Funktion atoi_C() ist tatsächlich fast doppelt so schnell wie die atoi_L() in FunktionenInAssembler/atoi L, und etwa 40% schneller als die schnellste Original-Lib-atoi(), die HelmutSchellong je testete.

const int d9[]= {
0000000000, 1000000000, 2000000000, 2000000000,
2000000000, 2000000000, 2000000000, 2000000000,
2000000000, 2000000000,
};
const int d8[]= {
000000000, 100000000, 200000000, 300000000,
400000000, 500000000, 600000000, 700000000,
800000000, 900000000,
};
const int d7[]= {
00000000, 10000000, 20000000, 30000000,
40000000, 50000000, 60000000, 70000000,
80000000, 90000000,
};
const int d6[]= {
0000000, 1000000, 2000000, 3000000,
4000000, 5000000, 6000000, 7000000,
8000000, 9000000,
};
const int d5[]= {
000000, 100000, 200000, 300000,
400000, 500000, 600000, 700000,
800000, 900000,
};
const int d4[]= {
00000, 10000, 20000, 30000,
40000, 50000, 60000, 70000,
80000, 90000,
};
const int d3[]= {
0000, 1000, 2000, 3000, 4000,
5000, 6000, 7000, 8000, 9000,
};
const int d2[]= {
000, 100, 200, 300, 400,
500, 600, 700, 800, 900,
};
const int d1[]= {
00, 10, 20, 30, 40,
50, 60, 70, 80, 90,
};


static int atoi_C(const char *a)
{
   int i, m=0;
   if (*a<='0')  { //<-- nicht 100% portabel
     if (a[0]==0||a[1]==0)  return (0);
     while (*a==' '||*a=='\t')  ++a;
     if (*a=='-'&&(m=1,1)||*a=='+')  ++a;
     while (*a=='0')  ++a;
   }
   i=0;
   if (a[0]>'9'||a[0]<'0')  goto ADD0;
   if (a[1]>'9'||a[1]<'0')  {       goto ADD1; }
   if (a[2]>'9'||a[2]<'0')  { a+=1; goto ADD2; }
   if (a[3]>'9'||a[3]<'0')  { a+=2; goto ADD3; }
   if (a[4]>'9'||a[4]<'0')  { a+=3; goto ADD4; }
   if (a[5]>'9'||a[5]<'0')  { a+=4; goto ADD5; }
   if (a[6]>'9'||a[6]<'0')  { a+=5; goto ADD6; }
   if (a[7]>'9'||a[7]<'0')  { a+=6; goto ADD7; }
   if (a[8]>'9'||a[8]<'0')  { a+=7; goto ADD8; }
   if (a[9]>'9'||a[9]<'0')  { a+=8; goto ADD9; }
                              a+=9;
          i+= d9[a[-9]-'0'];
   ADD9:  i+= d8[a[-8]-'0'];
   ADD8:  i+= d7[a[-7]-'0'];
   ADD7:  i+= d6[a[-6]-'0'];
   ADD6:  i+= d5[a[-5]-'0'];
   ADD5:  i+= d4[a[-4]-'0'];
   ADD4:  i+= d3[a[-3]-'0'];
   ADD3:  i+= d2[a[-2]-'0'];
   ADD2:  i+= d1[a[-1]-'0'];
   ADD1:  i+=    a[ 0]-'0';
   ADD0:;
   return (m?-i:i);
}

Messungen:
atoi/atoi_L        4.516           1.488  [us]          ta/tb =   3.03
Bem.:   1234567899   PENTIUM-60

atoi/atoi_C        0.101           0.063  [us]          ta/tb =   1.61
Bem.:   1234567899   PentiumIII700

atoi/atoi_C        0.047           0.035  [us]          ta/tb =   1.35
Bem.:   12345   PentiumIII700

atoi/atoi_C        0.027           0.022  [us]          ta/tb =   1.24
Bem.:   0   PentiumIII700

strtoll/atoll_C    0.666           0.147  [us]          ta/tb =   4.53
Bem.:   1234567890987654321   PentiumIII700

sprintf/itoa_C     0.905           0.148  [us]          ta/tb =   6.10
Bem.:   1234567899   PentiumIII700

--HelmutSchellong


Test von einem PII400/256MB (x86) unter Linux mit gcc und der glibc2.2.2:

nicht optimierend compiliert
 null[s]test[s]
atoi0.150.71
atoi_C0.140.33

optimierend compiliert
 null[s]test[s]
atoi0.050.59
atoi_C0.050.15

Kompletter Source siehe http://club.josefine.at/david/atoi

Es würde mich interessieren wie Du auf die 40% kommst. -- DavidSchmitt

Ganz einfach: Siehe oben meine Messungen.

Weil das oben meine Daten sind, die mit einer speziellen Meßsoftware festgestellt wurden, die sehr präzise mißt, sogar die Zeit von einzelnen Instruktionen messen kann, und zwar nur das Meßobjekt und nicht den Code drumherum! --hs

Mieser Benchmark

[Anm: Der hier angesprochene Code ist unter old/ zu finden]

Über Deinen Meßcode bin ich total verwundert!

Der ist so unlogisch und ungeeignet, daß die Aussagekraft Deiner Werte gegen Null geht.

Man kann doch um das Meßobjekt herum nicht Code anordnen, dessen Zeitbedarf man mitmißt und der möglicherweise 30-fach mehr Zeit braucht als das Meßobjekt selbst!

Außerdem können die Lib-atoi() sehr unterschiedlich sein! Es gibt gaaaanz schlechte aber auch recht gute. Die erste oben ist eine ganz schlechte... --hs

Ja, da hab ich jetzt etwas aufgeräumt und es ist tatsächlich ein Unterschied. Ich bin beeindruckt. -- DavidSchmitt

Verwende:
a=clock()
loop:  test1()
b=clock()
t1= b-a
a=clock()
loop:  test1(), test1()
b=clock()
t2= b-a
T1= (t2-t1)/cnt1 

dito

T2= (t2-t1)/cnt2
Damit eliminiert man die Schleifencodezeit.


Siehe SpeicherplatzFürPerformance, TabellenStattBerechnungen und OptimierenJaOderNein
KategorieProgrammierBeispiele KategorieOptimierung KategorieSchellong
StartSeite | Neues | TestSeite | ForumSeite | Teilnehmer | Kategorien | Index | Hilfe | Einstellungen | Ändern
Text dieser Seite ändern (zuletzt geändert: 10. September 2003 1:01 (diff))
Suchbegriff: gesucht wird
im Titel
im Text