Adventsgewinnspiel 2008

BenBE · Verfasst: Mi 26.11.08 20:30

Ich optimiere meine PHP-Version nachher noch durch eine Portierung nach Delphi ... hab ne Idee, wie ich die 1,26ms locker schlagen können müsste ;-)

_________________

Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.

jaenicke · Verfasst: Mi 26.11.08 22:05

So, hab meine Version gerade auf dem 6000er getestet, dort braucht die inkl. Aktualisierung 0,8ms.

Yogu · Verfasst: Mi 26.11.08 22:15

Ha! 0,36 Millisekunden!

(2,59GHz x2)

Mein Algorithmus:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:

const          
  CharCount = 6;
  Chars: array[0..CharCount-1] of Char = ('a', 'd', 'f', 'g', 'v', 'x');   
  UpperChars: array[0..CharCount-1] of Char = ('A', 'D', 'F', 'G', 'V', 'X');

function TMainForm.Decrypt(const S: String): String;
var i, j, k, DecryptedPos, Len: Integer; C, C1, C2: Char; Num: Byte; Found: Boolean;
begin
  SetLength(Result, Length(S));
  DecryptedPos := 1;
  i := 1;
  Len := Length(S);
  while i <= Len do
  begin
    C1 := S[i];
    C2 := S[i+1];

    Found := False;
    for j := 0 to CharCount-1 do
    begin
      if (C1 = Chars[j]) or (C1 = UpperChars[j]) then
      begin
        for k := 0 to CharCount-1 do
        begin
          if (C2 = Chars[k]) or (C2 = UpperChars[k]) then
          begin
            Num := j*CharCount + k;

            if Num < 26 then
            begin
              if C2 in ['a', 'd', 'f', 'g', 'v', 'x'] then
                C := Chr(97+Num)
              else
                C := Chr(65+Num);
            end
            else
              C := Chr(22+Num);

            Result[DecryptedPos] := C;
            inc(DecryptedPos);
            inc(i, 2);  
            Found := True;
            Break;
          end;
        end;
      end;
      if Found then Break;
    end;

    if not Found then
    begin
      Result[DecryptedPos] := S[i];
      inc(DecryptedPos);
      inc(i);
    end;
  end;

  SetLength(Result, DecryptedPos-1);
end;

Wer den knackt, ist Kokusnussknacker

(*freu* *freu* *freu*)

Edit: Keine Angst, ich hab mehr als 2,59MHz. :lol:

Wolle92 · Verfasst: Mi 26.11.08 22:20

Yogu, upp mal das Programm mit ms-Anzeige... Ich wette, meiner ist schneller :mrgreen:

_________________
1405006117752879898543142606244511569936384000000000.

Yogu · Verfasst: Mi 26.11.08 22:26

Wolle92 hat folgendes geschrieben :

Yogu, upp mal das Programm mit ms-Anzeige... Ich wette, meiner ist schneller :mrgreen:

Das werden wir ja sehen :mrgreen:

Einloggen, um Attachments anzusehen!

jaenicke · Verfasst: Mi 26.11.08 22:47

Ja, bei diesen Algorithmen werde ich nicht mithalten können, weil meiner eben ein reiner Tabellenersetzer ist. Dafür kann ich mit meinem auch andere Ersetzungsalgorithmen knacken.

Aber ich werde noch eine optimierte Version für diesen speziellen Fall basteln, wenn ich die Zeit finde.

der organist · Verfasst: Mi 26.11.08 23:11

Sagt mir mal einer, wie ich die ms messen kann? Ohne Timer auf Intervall 1 und dann hochzählen? Dann probier ich das auch noch mal...

_________________
»Gedanken sind mächtiger als Waffen. Wir erlauben es unseren Bürgern nicht, Waffen zu führen - warum sollten wir es ihnen erlauben, selbständig zu denken?« Josef Stalin

jaenicke · Verfasst: Mi 26.11.08 23:14

Das wäre extrem ungenau. :lol:

Schau dir mal meinen Quelltext zum Beispiel an, oder diesen Link:
www.delphipraxis.net...st271529.html#271529

Kha · Verfasst: Mi 26.11.08 23:37

Yogu hat folgendes geschrieben :

Mein Algorithmus:

Was hast du denn mit der inneren Schleife vor?
Hab mir mal die Freiheit genommen, deinen Code etwas anzupassen:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:

function Index(C: Char): Integer; inline;
const Delta = Integer('a') - Integer('A');
begin
  case C of
    'A': Result := 0;
    'D': Result := 1;
    'F': Result := 2;
    'G': Result := 3;
    'V': Result := 4;
    'X': Result := 5;
    'a': Result := Delta + 0;
    'd': Result := Delta + 1;
    'f': Result := Delta + 2;
    'g': Result := Delta + 3;
    'v': Result := Delta + 4;
    'x': Result := Delta + 5;
  else
    Result := -1;
  end;
end;

function Khacrypt(const S: String): String;
var i, j, Len, Num, Num2: Integer; C1, C2: Char;
begin
  SetLength(Result, Length(S));
  i := 1;
  j := 1;
  Len := Length(S);
  while i <= Len do
  begin
    C1 := S[i];
    Num := Index(C1);
    if (Num >= 0) and (Num < 6) then
    begin
      C2 := S[i + 1];
      // Häfigkeitsanalyse ^^
      Num2 := Index(C2);
      if Num2 >= 0 then
      begin
        Num := 6 * Num + Num2 + Integer('A');
        if Num <= Integer('z') then
          Result[j] := Chr(Num)
        else
          Result[j] := Chr(Integer('0') + Num - Integer('z') - 1);
        Inc(i, 2);
        Inc(j);
        continue;
      end;
    end;
    Result[j] := C1;
    Inc(i);
    Inc(j);
  end;
  SetLength(Result, j);
end;

markieren

Quelltext

1:
2:
3:

Benchmark, 100000 Iterationen
Yogu: 343 ms
Meins: 140 ms

Yogu hat folgendes geschrieben :

2,59Mhz

Daran wird's liegen :zwinker:

.

_________________
>λ=

der organist · Verfasst: Do 27.11.08 16:18

jaenicke hat folgendes geschrieben :

Das wäre extrem ungenau. :lol:

Schau dir mal meinen Quelltext zum Beispiel an, oder diesen Link:
www.delphipraxis.net...st271529.html#271529

Soll heissen:
-Ich benutze die Funktion drei mal, mit unterschiedlichen Übergabewerten und mache zwischen (Start) und (Stop) meinen Test.
-Die Millisekunden werden danach über (Stop - Start) * 1000 / Frequenzy) ausgegeben

_________________
»Gedanken sind mächtiger als Waffen. Wir erlauben es unseren Bürgern nicht, Waffen zu führen - warum sollten wir es ihnen erlauben, selbständig zu denken?« Josef Stalin

Heiko · Beiträge: 3169 Erhaltene Danke: 11

der organist hat folgendes geschrieben :

-Die Millisekunden werden danach über (Stop - Start) * 1000 / Frequenzy) ausgegeben

Hälst du die Variante für zuverlässig? Mein NB taktet selten über paar Sekunden gleich

.

Yogu · Verfasst: Do 27.11.08 19:20

Heiko hat folgendes geschrieben :

Mein NB taktet selten über paar Sekunden gleich

.

Das sollte er aber! Wäre sehr seltsam, wenn nicht!

jaenicke · Verfasst: Do 27.11.08 19:24

Heiko hat folgendes geschrieben :

Hälst du die Variante für zuverlässig? Mein NB taktet selten über paar Sekunden gleich

.

Es gibt keine genauere Zeitmessmethode unter Windows. GetTickCount ist relativ ungenau, genauso wie ein Timer o.ä., die Performance Counter sind die einzige sehr genaue Möglichkeit der Zeitmessung.

der organist hat folgendes geschrieben :

Soll heissen:
-Ich benutze die Funktion drei mal, mit unterschiedlichen Übergabewerten und mache zwischen (Start) und (Stop) meinen Test.

Ja, fast, nur dass der eine Aufruf eine andere Funktion aufruft (das ist nicht dreimal die selbe Prozedur), um nämlich die Zeit zwischen Start- und Endwert interpretieren zu können. ;-)

Kha · Verfasst: Do 27.11.08 23:14

jaenicke hat folgendes geschrieben :

Es gibt keine genauere Zeitmessmethode unter Windows. GetTickCount ist relativ ungenau, [...]

Genauso ungenau ist es, nur einen einzelnen Wert zu messen, da springt dir jeder Statistiker an die Decke

. Und bei zehntausenden von Wiederholungen dürfte dann auch GetTickCount exakt genug sein

.

_________________
>λ=

Tilman · Verfasst: Fr 28.11.08 01:15

Man könnte auch versuchen zu messen wieviele Buchstaben(-Paare) eure Algos in 30 Sekunden kodieren / dekodieren. Das wäre vielleicht ein Wert den man besser vergleichen kann.

Wobei ich persönlich den 100. Wettbewerb "wer schreibt den schnellsten Algo" nicht mehr sooo prickelnd finde

ich hab als 2. hier enkodiert reingeschrieben und mich nen Keks darüber gefreut, das genügt mir ^^

P.S. an die Schöpfer des Rätsels:
interessant finde ich in dem Zusammenhang das Wort "Adventsgewinnspiel". Denn es scheint die Antwort auf die Frage zu sein "Geben Sie ein Wort an, welches möglichst viele Informationen zum adfgvx-Kode liefert". Zusammen mit der Zahl 2008 kommen doch tatsächlich alle Pre- und Postfixe darin vor, die Häufigsten Buchstaben E,N,I,S,A und mit 00, NN sowie weiteren Buchstaben ließ sich auch leicht erschließen dass es ein Monoalphabetisches Verfahren ist.

Natürlich weiß ich dass das Wort in jedem Jahr das selbe ist - aber es war hier wirklich perfekt.

_________________
Bringe einen Menschen zum grübeln, dann kannst du heimlich seinen Reis essen.
(Koreanisches Sprichwort)

jaenicke · Verfasst: Fr 28.11.08 02:37

So, ich habe es jetzt auf dem 3700er auf 0,069ms gedrückt, 6000er 0,044ms. Ein Klick auf Start im Anhang macht 1000 Durchläufe.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:

const
  CharList1: array[65..122] of Byte = (0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0);
  CharList2: array[65..122] of Byte = (6, 0, 0, 7, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 10, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0);
  CharTable: array[0..5] of array[0..11] of Char =
    (('a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'),
     ('g', 'h', 'i', 'j', 'k', 'l', 'G', 'H', 'I', 'J', 'K', 'L'),
     ('m', 'n', 'o', 'p', 'q', 'r', 'M', 'N', 'O', 'P', 'Q', 'R'),
     ('s', 't', 'u', 'v', 'w', 'x', 'S', 'T', 'U', 'V', 'W', 'X'),
     ('y', 'z', ' ', ' ', ' ', ' ', 'Y', 'Z', '0', '1', '2', '3'),
     (' ', ' ', ' ', ' ', ' ', ' ', '4', '5', '6', '7', '8', '9'));

var
  CurIn, CurOut, Len: Integer;
  Chars: array of Char;
  tmp: string;
  StartTime, EndTime, Freq: Int64;
  i: Integer;
begin
  QueryPerformanceFrequency(Freq);
  QueryPerformanceCounter(StartTime);

  for i := 1 to 1000 do
  begin
    tmp := memInput.Text;
    Len := Length(tmp);
    SetLength(Chars, Len);
    CopyMemory(@Chars[0], @tmp[1], Len);
    CurIn := 0;
    CurOut := 0;
    while CurIn < Len do
    begin
      if not (Chars[CurIn] in ['a'..'z', 'A'..'Z']) then
      begin
        Chars[CurOut] := Chars[CurIn];
        Inc(CurIn);
      end
      else
      begin
        Chars[CurOut] := CharTable[CharList1[Ord(Chars[CurIn])]]
          [CharList2[Ord(Chars[CurIn + 1])]];
        Inc(CurIn, 2);
      end;
      Inc(CurOut);
    end;
    SetLength(Chars, CurOut);
    SetLength(tmp, CurOut);
    CopyMemory(@tmp[1], @Chars[0], CurOut);
    memOutput.Text := tmp;
  end;

  QueryPerformanceCounter(EndTime);
  ShowMessage(FormatFloat('0.000', (EndTime - StartTime) / Freq) + ' ms');
end;

// EDIT:
Und mit ein wenig Pointerspielerei liege ich jetzt bei 0,032ms.

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:

const
  CharList1: array[65..122] of Byte = (0, 0, 0, 1, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0);
  CharList2: array[65..122] of Byte = (6, 0, 0, 7, 0, 8, 9, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 10, 0, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 3,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0, 0);
  CharTable: array[0..5] of array[0..11] of Char =
    (('a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F'),
     ('g', 'h', 'i', 'j', 'k', 'l', 'G', 'H', 'I', 'J', 'K', 'L'),
     ('m', 'n', 'o', 'p', 'q', 'r', 'M', 'N', 'O', 'P', 'Q', 'R'),
     ('s', 't', 'u', 'v', 'w', 'x', 'S', 'T', 'U', 'V', 'W', 'X'),
     ('y', 'z', ' ', ' ', ' ', ' ', 'Y', 'Z', '0', '1', '2', '3'),
     (' ', ' ', ' ', ' ', ' ', ' ', '4', '5', '6', '7', '8', '9'));

var
  EndAddr: Integer;
  CurIn, CurOut: ^Char;
  tmp: string;
  StartTime, EndTime, Freq: Int64;
  i: Integer;
begin
  QueryPerformanceFrequency(Freq);
  QueryPerformanceCounter(StartTime);

  for i := 1 to 1000 do
  begin
    tmp := memInput.Text;
    EndAddr := Integer(Pointer(tmp)) + Length(tmp);
    CurIn := Pointer(tmp);
    CurOut := CurIn;
    while Integer(CurIn) < EndAddr do
    begin
      if not (CurIn^ in ['a'..'z', 'A'..'Z']) then
      begin
        CurOut^ := CurIn^;
        Inc(CurIn);
      end
      else
      begin
        CurOut^ := CharTable[CharList1[Ord(CurIn^)]]
          [CharList2[Ord(Char(Pointer(Integer(CurIn) + 1)^))]];
        Inc(CurIn, 2);
      end;
      Inc(CurOut);
    end;
    SetLength(tmp, Integer(CurOut) - Integer(Pointer(tmp)));
    memOutput.Text := tmp;
  end;

  QueryPerformanceCounter(EndTime);
  ShowMessage(FormatFloat('0.000', (EndTime - StartTime) / Freq) + ' ms');

Dieser Quelltext liegt auf dem Speed Knopf unterhalb des Startbuttons (Anhang aktualisiert).

// EDIT2:
Post korrigiert, ich hatte noch einen Fehler gemacht in der ersten Version.

// EDIT3:
Offenbar wird das Memo gar nicht aktualisiert, da es immer den selben Text bekommt. Ich habe das BeginUpdate..EndUpdate herausgenommen, weil user profile icon

Yogu sowas auch nicht drin hatte, aber ich glaube mit diesen beiden Zeilen wäre das Ergebnis realistischer. Dafür 10 mal so groß ca.

Einloggen, um Attachments anzusehen!

BenBE · Verfasst: Fr 28.11.08 15:32

Hab jänicke's Programm mal kurz entkernt und hab da mal meine ASM-Variante getestt mit:
Mein Rechner kommt auf 120ms; die Original-Version waren 140ms. Hab nen AMD Athlon64 X2 4000+.

Hier mal meine Routine:

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:

procedure TfrmMain.btnSpeedClick(Sender: TObject);
const
  CharList: array[Char] of Byte = (
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 1, 0, 0, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0,
    0, 1, 0, 0, 2, 0, 3, 4, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    );

  CharTable: array[0..35] of Char = (
    'A', 'B', 'C', 'D', 'E', 'F',
    'G', 'H', 'I', 'J', 'K', 'L',
    'M', 'N', 'O', 'P', 'Q', 'R',
    'S', 'T', 'U', 'V', 'W', 'X',
    'Y', 'Z', '0', '1', '2', '3',
    '4', '5', '6', '7', '8', '9'
    );

var
  EndAddr: Integer;
  CurIn, CurOut: ^Char;
  tmp: string;
  StartTime, EndTime, Freq: Int64;
  i: Integer;
begin
  QueryPerformanceFrequency(Freq);
  QueryPerformanceCounter(StartTime);

  for i := 1 to 1000 do
  begin
    tmp := memInput.Text;
    asm
      PUSH  ESI
      PUSH  EDI
      PUSH  EBX

      //CurIn := Pointer(tmp);
      MOV    ESI, DWORD PTR [tmp]
      //CurOut := CurIn;
      MOV    EDI, ESI
      //ECX := Length(tmp);
      MOV    ECX, DWORD PTR [ESI-4]

      MOV    EBX, OFFSET CharList

      TEST  ECX, ECX
      JMP    @@CheckLoop

@@StartLoop:
      //AL := CurIn^;
      //Inc(CurIn);
      LODSB
      MOV    AH, AL

      //Check AL in ['a'..'z', 'A'..'Z'] AND transform char into correct offset
      XLATB

      OR    AL, AL
      JNZ    @@Got1

      //CurOut^ := CurIn^;
      //Inc(CurOut);
      MOV    AL, AH
      STOSB
      JMP    @@ECycle

@@Got1:
      MOV    EDX, EAX
      //AL := CurIn^;
      //Inc(CurIn);
      LODSB
      MOV    AH, AL

      //Adjust input byte counting
      DEC    ECX

      //Check AL in ['a'..'z', 'A'..'Z'] AND transform char into correct offset
      XLATB
      OR    AL, AL
      JNZ    @@Got2

      //Second byte is not valid: Leave unchanged
      MOV    AL, DH
      STOSB
      MOV    AL, AH
      STOSB
      JMP    @@ECycle

@@Got2:
      //DL := ((DL * 2-2)+DL-1)*2
      DEC    DL
      AND    EDX, 7
      LEA    EDX, DWORD PTR [EDX+EDX*2]
      ADD    EDX, EDX

      //Decode table position into char
      MOV    EBX, OFFSET CharTable
      ADD    AL, DL
      DEC    AL
      XLATB
      MOV    EBX, OFFSET CharList

      //Fix Lowercase\Uppercase
      AND    AH, $20
      ADD    AL, AH

      //Store decrypted char
      STOSB

@@ECycle:
      //Adjust Input Byte counting
      DEC    ECX
@@CheckLoop:
      JNZ    @@StartLoop

      MOV    DWORD PTR [CurOut], EDI

      POP    EBX
      POP    EDI
      POP    ESI
    end;
    SetLength(tmp, Integer(CurOut) - Integer(Pointer(tmp)));
    memOutput.Text := tmp;
  end;

  QueryPerformanceCounter(EndTime);
  ShowMessage(FormatFloat('0.000', (EndTime - StartTime) / Freq) + ' ms');
end;

_________________

Anyone who is capable of being elected president should on no account be allowed to do the job.
Ich code EdgeMonkey - In dubio pro Setting.

jaenicke · Verfasst: Fr 28.11.08 16:51

Bei mir kommt deine Version auf 0,061ms und meine auf 0,044ms (3700+ Single Core), auf dem anderen PC (6000+ X2) sinds 0,049ms bei dir und 0,032ms bei mir. Weshalb das bei dir so viele ms sind weiß ich nicht. :nixweiss:

freedy · Beiträge: 403 Erhaltene Danke: 1 Winows 7 Delphi XE

Also, ich muss schon sagen, dass ich mächtig verwirrt bin. 0,0xx ms? Habt ihr überall vergessen mit 1000 zu multiplizieren? QueryPerformanceFrequency wird ja in Sekunden zurückgegeben.

Somit liegt mein Algo immernoch bei 16ms für die Dekodierung des Anfangsartikels. BenBes habe ich bei mir mit 44ms im Schnitt gemessen. Jaenickes gibt mir einen Fehler bei der Bereichsüberprüfung.

GTA-Place · Verfasst: Fr 28.11.08 17:41

freedy hat folgendes geschrieben :

QueryPerformanceFrequency wird ja in Sekunden zurückgegeben.

Ja, da wird tatsächlich vergessen mit 1000 zu multiplizieren. 0,034 heißt in dem Fall 34ms.

_________________
"Wer Ego-Shooter Killerspiele nennt, muss konsequenterweise jeden Horrorstreifen als Killerfilm bezeichnen." (Zeit.de)

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme