Discussion :

[Pedro]

juste un truc mais

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
  for i := -2048 to 2047 - 1 do
    FValues[i] := IntToStr(Trunc(256 * (i + 2048) / 4096));

il y a pas le -1 (habituel) pour 2047
pour 2047 ca te donnerait n'importe quel valeur

Argh... L'aide au code... Merci TicTacToe

[Mode pinaille]
sinon "(i+2048) shr 4" marche aussi mais c'est moins parlant.
[/Mode pinaille]

Bah, comme c'est un traitement hors processus, c'est pas bien grave

PS: Zip (encore) mis à jour

[themei]

l'autre question importante est : est-ce que le temps de traitement est important ?

l'avantage du REadLn/WriteLn c'est que c'est très simple à mettre en oeuvre, c'est très peu consommateur en mémoire et ça fonctionnera quelque soir la taille du fichier.

tout charger dans un TStringList me parait la plus mauvaise solution, car le LoadFromFile place une copie du fichier en mémoire et l'affecte par SetTextStr() qui va faire un découpage de chaque ligne.

il serait probablement intéressant de tester (encore une fois si le temps d'execution est important) en travaillent sur un buffer de taille "suffisante"

en pseudo code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
 while RemplirBuffer=True do begin
  TrouverFinDeLigne;
  ExtraireDernierEntier;
  GenererNouvelleLigne;
  EcrireNouvelleLigne;
  DecalerBuffer;
 end;

Perso c'est ce qui m'était "sauter" à l'esprit.

Cepandant il va avoir beaucoup d'I/O. Alors je ne connais pas trop le Delphi pour les I/O, mais avoir un tableau statique de String qui contient quelque ligne et les ecrire par block ca gagnerais p'tet pas mal. Apres comme dit je sais pas comment est géré Writeln, si la primitive prends du temps, si elle est bien bufferisée, etc.

[themei]

Argh... L'aide au code... Merci TicTacToe

Bah, comme c'est un traitement hors processus, c'est pas bien grave

PS: Zip (encore) mis à jour

J'veut rien dire, mais pourquoi ne pas avoir :

const MA_TABLE_DE_CONVERSION: array [-2048..2047] of Integer qui contivent directement la bonne valeur sans faire la boucle ?
Bon okay c'est lourd à ecrire mais bon

[TicTacToe]

@TheMei: c'est vrai mais bon... comme le dis Pedro c'est une action initiale qui prends un temps infime et fixe comparé au temps de traitement alors bon

Sinon Pedro, juste une petite chose pour encore grapiller,

Si le format initial est vraiment bien figé, que le nombre de décimales est bien systématiquement 6 pour les composantes, et que la partie entiere des composantes ne dépassent jamais 999, il se trouve que le dernier espace ne peut pas être avant la position 27 de la chaine

--> un seul PosEx( ' ', Chaine, 27) suffirait au lieu de 3.
à voir si tu grapilles encore.

[themei]

Oui le plus simple c'est de partir de la fin et de s'arreter au premier espace. Alors je sais pas si Delphi a des fonction pour...

[banban54]

bonjour

Bon courage Tiens-moi au courant si tes recherches aboutissent
PS: j'ai mis le ZIP à jour

elles ont abouti, mais je ne joue pas dans la cour des grands!...

Je suis parti sur une base de 3M lignes avec comme comparatif le dernier Zip de Tictactoe (je n'ai pas réussi à compiler je dernier de Pedro).
methode1 (StringList): 6796 ms
methode2 (textfiles) : 7062 ms
methode3 (textfiles par blocs) : 3016 ms (sans les dernières optimisations )
"l'autre (binaire) : 6156 ms (dont 60% = 3470 ms rien que pour les calculs...)



Par contre sur les gros fichiers (44M lignes), les écarts se réduisent un peu, 136s pour 96s et, chez moi la methode 1 retourne un "out of memory".

Je met mon code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
procedure TForm1.Button1Click(Sender: TObject);
var
  Fromfic, Tofic        : file of byte ;   // si > 2Go utiliser TFileStream
  NumRead, NumWritten   : Integer;
  Buf1: array[1..40960] of byte;   // taille à optimiser en fonction de
  Buf2: array[1..40960] of byte;   // celle du fichier à lire
  NbSpace       : integer;         // nombre d'espaces dans la ligne lue
  i, j, k       : integer  ;
  valeur        : string;
  TickDebut     : Cardinal;
 
begin
  if OpenDialog1.Execute then begin
    AssignFile(Fromfic, OpenDialog1.FileName);
    Reset(FromFic);
 
    if SaveDialog1.Execute then begin
      AssignFile(ToFic, SaveDialog1.FileName);
      Rewrite(ToFic);
      TickDebut := GetTickCount;
      NbSpace := 0;    // après CRLF aussi  #13#10
      valeur := '';
      repeat
        BlockRead(FromFic, Buf1, SizeOf(Buf1), NumRead); // prévoir un talon
        i := 1;
        j := 0;  // nombre transférés
        for i := 1 to NumRead do begin
          if NbSpace < 3 then begin 
            inc(j);
            Buf2[j] := Buf1[i];
            if Buf1[i] = 32 then inc(NbSpace); // on copie tout jusqu'au 3eme espace
          end else begin  // if NbSpace < 3
            if Buf1[i] > 13 then valeur := valeur + chr(Buf1[i])  // # CRLF
            else begin
              if Buf1[i] = 13 then begin    // CR
                valeur := IntToStr((StrToInt(valeur)+ 2048) shr 4); // @Tictactoe
                // (valeur + 2048) shr 4 semble 10 fois plus rapide que
                // Trunc(256 * (Valeur + 2048) / 4096)
                for k := 1 to length(valeur) do begin  // 1 à 5 caractères
                  inc(j);
                  Buf2[j] := ord(valeur[k]);
                end;
              end;
              inc(j);
              Buf2[j] := Buf1[i];
              if Buf1[i] = 10 then begin    // LF réinit
                NbSpace := 0;
                valeur := '';
              end;
            end; // else if Buf1[i] > 13
 
          end;  // else begin
        end;  // for i := 1 to NumRead
        BlockWrite(ToFic, Buf2, j, NumWritten);
      until (NumRead = 0);  // repeat
      CloseFile(FromFic);
      CloseFile(ToFic);
    end;  // if SaveDialog1.Execute
  end;  // if OpenDialog1.Execute
  Button1.Caption := IntToStr( GetTickCount - TickDebut ) + ' ms';
end;

bonne continuation
à+

[Pedro]

bonjour
Je suis parti sur une base de 3M lignes avec comme comparatif le dernier Zip de Tictactoe (je n'ai pas réussi à compiler je dernier de Pedro).

Dis-moi ce qui ne va pas comme ça tout le monde pourra en profiter

Sinon Pedro, juste une petite chose pour encore grapiller,

Si le format initial est vraiment bien figé, que le nombre de décimales est bien systématiquement 6 pour les composantes, et que la partie entiere des composantes ne dépassent jamais 999, il se trouve que le dernier espace ne peut pas être avant la position 27 de la chaine

--> un seul PosEx( ' ', Chaine, 27) suffirait au lieu de 3.
à voir si tu grapilles encore.

Hélàs non, tu penses bien que j'y avais pensé Comme les points sont en coordonnée X, Y, Z et que l'origine est l'axe de l'appareil (en position centrale), il y a donc des valeurs négatives Donc je suis obligé de garder les 3 PosEx
Par contre, peut-être en changeant le premier PosEx en Pos, on peut grapiller encore des millièmes (un test en moins)

[Edit]
Derniers tests:
2 400 000 lignes => 4.3 secondes
Avec 3 PosEx => 4.4 secondes

PS: ZIP mis à jour

[TicTacToe]

Hélàs non, tu penses bien que j'y avais pensé Comme les points sont en coordonnée X, Y, Z et que l'origine est l'axe de l'appareil (en position centrale), il y a donc des valeurs négatives Donc je suis obligé de garder les 3 PosEx

Non non, je me suis mal exprimé, si la valeur absolu de tes composantes ne dépasse pas 999 (-999.123456 est donc autorisé), un seul PosEx suffit en position 27.

Dans tous les cas on est sur qu'à cette position 27 on est avant le 3eme espace, mais on est sur aussi d'être après le 2eme...
(un coup de bloc note pour s'en convaincre)

Enfin bon

[sjrd]

Oui le plus simple c'est de partir de la fin et de s'arreter au premier espace. Alors je sais pas si Delphi a des fonction pour...

Je pense aussi. Il existe bien LastDelimiter, mais cette fonction part du début car elle supporte les MBCS.

En voici une qui part vraiment du bout :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
function RightPos(C: Char; const Str: string): Integer;
begin
  Result := Length(Str);
  while Result > 0 do
  begin
    if Str[Result] = C then
      Exit;
    Dec(Result);
  end;
end;

Renvoie 0 si non trouvé.

Pas la peine d'en faire une version ASM, on peut pas faire mieux que ce code compilé Vive le compilo Delphi

Edit : oui bon en fait y'a moyen de faire un peu mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function RightPos(C: Char; const Str: string): Integer;
asm
        MOV     CL,AL
        MOV     EAX,EDX
        TEST    EAX,EAX
        JZ      @@exit
        MOV     EAX,[EAX-4]
@@loop:
        CMP     CL,[EDX+EAX-1]
        JE      @@exit
        DEC     EAX
        JNZ     @@loop
@@exit:
end;

(code testé)

[Pedro]

Non non, je me suis mal exprimé, si la valeur absolu de tes composantes ne dépasse pas 999 (-999.123456 est donc autorisé), un seul PosEx suffit en position 27.

Ah Ok j'ai compris
Je vais essayer ça

Edit : oui bon en fait y'a moyen de faire un peu mieux :

Je vais aussi essayer ça
Résultats dans quelques minutes...

[Pedro]

Résultats pour 2 405 002 lignes très exactement:
Optimisation TicTacToe: 4 secondes pile
Optimisation sjrd: A peine plus (entre 1 et 3 centièmes)

Pas la peine d'en faire une version ASM, on peut pas faire mieux que ce code compilé Vive le compilo Delphi

+1000

Je vous dis: ça va être instantané!