Discussion :

[PapyJohn]

Bonjour,

J'essaye d'intégrer directement dans une fonction pascal quelques lignes d'assembleur.
J'utilise pour me guider le cours disponible sur le forum (Merci Nono40)
Malheureusement il n'y a pas d'exemple sur l'usage de tableaux avec des strings ou de éléments de tailles diverses interdisant, a priori, l'usage de la directive Type

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
 
function Doublons: longint;
var i: Longint;
 Index: Longint;
 L:array[0..99] of strng[9];
begin
 for i:=0 to 99
   L[i]:= IntotoStr((Random 1000)+1);
 i := 0;
 Index := 0;
 repeat
  if L[i] <> L[i + 1] then
   begin
    Inc(Index);
    asm
      PUSH    ESI
      PUSH    EDI
      LEA     ESI, L[i]
      LEA     EDI, L[Index]
      MOV    ECX, 2
      REP     MOVSD //  8
      MOVSW          // 2
      POP   EDI
      POP   ESI
 
    end;
   //  L[Index]:= L[i];
   end;
  inc(i);
 until i >= 98;
 Doublons := Index;
end;

Il est normal que cela ne fonctionne pas car le L[[I] n'est pas correct il devrait être L[[I * 10] 10 tant la sizeof(string[9]);
Le LEA attends l'offset pas l'index
Le problème est que je ne trouve pas la syntaxe correcte
Le compilateur me refuse L[i * 10]
Quelqu'un peu-il me donner la bonne syntaxe?
Merci
PapyJohn

J'ai pense à poster sur le forum assembleur mais comme il s'agit d'intyegration dans Delphi je pense avoir plus de reponse ici.

[sjrd]

Il s'agit pourtant bien d'assembleur pur, dans ce cas. Tu ne peux pas faire de *10 dans un index de tableau. Tu ne peux faire que des *4. Pour faire un *10 tu dois utiliser MUL

Code :

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

1
2
3
MOV EAX,10
MUL i // si mes souvenirs sont bons MUL travaille toujours sur EAX
LEA ESI,L[EAX]

Cela dit, il ne faut pas utiliser d'assembleur pour ce que tu veux faire. Utilise plutôt la fonction Move.

L'assembleur ne doit jamais être utilisé dans des buts d'optimisation. Il ne doit être utilisé que lorsqu'il faut faire quelque chose qu'il n'est pas possible de faire en Delphi. Tout simplement parce que le compilo optimise mieux que toi.

Code :

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

Move(L[i], L[Index], 10);

Remplace avantageusement ton code assembleur en entier.

Edit : en fait l'affectation Pascal := est encore mieux

[PapyJohn]

Je ne vois pas pourquoi on ne doit pas optimiser un code , meme en assembleur.
C'est aussi valable pour le Pascal?

Si tu as besoin ponctuellement d'aller vite c'est ton probleme en face de toi tu as un d'environnement robuste et bien écrit ce n'est pas le problème Le problème c'est que le code est généraliste, traite tous les cas et aussi les erreurs.
Il faut avoir conscience que l'optimisation apporte de la fragilié mais qu'elle peut être remarquablement efficace

Dans des logiciels de calcul comme ceux que j'écris actuellement , j'examine des milliards de combinaisons quand je gagne 10% sur un calcul qui dure 10 jours le gain est plus que certain

Il a des des choses qui on besoin d'être optimisées pas 'autres cela depands du besoin L'optimisation est une des faces de l(informatique et je pense que des jugements trop tranchés ont tendance à etre faux; Si Borland s'applique a mettre un ASM dans Delphi je doute que se soit pour moi: Il y a beaucoup de gens qui l'utilise

Mais en corolaire il m'arrive parfois, apres une optimisation ASM de chercher a générer le même code a partir du Pascal et l'exercice est interressant.
Mais il faut avoir le temps moi je suis à la retraite lors cela m'occupe l'esprit

PapyJohn



PAPY

[sjrd]

Je ne vois pas pourquoi on ne doit pas optimiser un code , meme en assembleur.
C'est aussi valable pour le Pascal?

Je te l'ai dit : c'est parce que le compilateur Delphi optimise mieux que toi, car il a une puissance de calcul et connaît des règles d'optimisation des instructions Intel dont tu n'as même pas idée (et moi non plus, hein, je ne me prétends pas être un dieu).

Si tu as besoin ponctuellement d'aller vite c'est ton probleme en face de toi tu as un d'environnement robuste et bien écrit ce n'est pas le problème Le problème c'est que le code est généraliste, traite tous les cas et aussi les erreurs.
Il faut avoir conscience que l'optimisation apporte de la fragilié mais qu'elle peut être remarquablement efficace

Dans des logiciels de calcul comme ceux que j'écris actuellement , j'examine des milliards de combinaisons quand je gagne 10% sur un calcul qui dure 10 jours le gain est plus que certain

L'optimisation ne se fait pas en terme de quelques instructions, mais en termes de préallocations de la mémoire, de non-recopies inutiles de mémoire, d'améliorations de la complexité des algorithmes, des accès en bloc au disque dur, etc. Bref dans "notre ère" l'optimisation est de la macro-optimisation.

Si Borland s'applique a mettre un ASM dans Delphi je doute que se soit pour moi: Il y a beaucoup de gens qui l'utilise

Non, peu de gens l'utilisent, et c'est seulement pour faire des choses qu'il est impossible de faire dans le langage Delphi (et pas plus en C, d'ailleurs). Par exemple faire changer à Windows le cadre de pile de ton exécution.

[PapyJohn]

Excuses moi mais tu as tout faux au niveau de l'optimisation s'entends

Regarde par exemple la discussion sur la recopîe des fichiers texte elle a devié sur les tris et suppressions de doublons. Et bien les rsuyltats laisse les routines Borlaaand loin derrière. Il u a d'ailleurs eu iun debat autoyut de indexof qui a fini par une nouvelle méthode

Tu as raison quand tu évoques les multiples aspect de l(optimisation il n'y a pas que les cycles gagné loin de la. Mais ils en font aussi partie.
u as 'oublie' un point nouveau qui est devenu important avec la génération des INEL: les temps de latence et la c'est indiscutable le compilateur est le plus fort: il gère lui mime les enchainement.


Mais bien sur tu n'es pas obligé de me croire . En toute sympatie je te propose un exemple: dans le classes.pas tu as

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
 
 
function Recherche(var Cherche: ShortString): integer;
var sup, mi, inf: integer;
begin
 Sup := NbLignes;
 Inf := 1;
 Recherche := -1;
 while inf <= Sup do
  begin
   mi := (inf + sup) shr 1;
   if L[mi] < Cherche then
    Inf := Mi + 1
   else
    if L[mi] > Cherche then
    Sup := Mi - 1
   else
    begin
     Recherche := mi;
     exit;
    end
  end;
end;

C'est directement du code Borland
Je te propse de chercher à optimiser: moi je pense qu'il il a a gagner

Et toi
PapyJohn

[sjrd]

Regarde par exemple la discussion sur la recopîe des fichiers texte elle a devié sur les tris et suppressions de doublons. Et bien les rsuyltats laisse les routines Borlaaand loin derrière. Il u a d'ailleurs eu iun debat autoyut de indexof qui a fini par une nouvelle méthode

J'ai suivi cette discussion, et je n'ai vu nulle part de trace d'assembleur. Ce que j'ai vu par contre, ce sont des préallocations de mémoire, des améliorations de complexité en temps et en mémoire, et des lectures par bloc des fichiers disques.

Les routines Borland n'ont rien à voir avec ça. Elles sont excellentes pour la gestion de petits fichiers, et ne sont tout simplement pas prévues pour de grosses quantité de mémoire. C'est spécifié dans la documentation.

Mais bien sur tu n'es pas obligé de me croire . En toute sympatie je te propose un exemple: dans le classes.pas tu as
...
C'est directement du code Borland
Je te propse de chercher à optimiser: moi je pense qu'il il a a gagner

Du code Borland, ça ? Jamais de la vie, rien qu'avec des noms de variables en français, il n'y a aucune chance. Mais en plus le style d'écriture n'est pas Borland. Accessoirement, il n'y a aucune fonction dans Classes.pas qui accepte une ShortString et renvoie un Integer.

Et non, il n'y a pas moyen d'améliorer une telle routine, à moins d'avoir à disposition une table de hashage. Car la recherche dichotomique est la meilleure recherche sur tableau trié.

[PapyJohn]

Erreur de ma part voici le code delphi

Il y a juste a remplacer la ligne de comparaison pour pouvoir l'utilliser
et a ùmetre le dupliocate en commentaire
Je te propose
C:=0;
If Str1>Str 2 then C:=1
else if STR2>Str1 then C:=-1

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
 
function TStringList.Find(const S: string; var Index: Integer): Boolean;
var
 L, H, I, C: Integer;
begin
 Result := False;
 L := 0;
 H := FCount - 1;
 while L <= H do
  begin
   I := (L + H) shr 1;
   C := CompareStrings(FList^[I].FString, S);
   if C < 0 then
    L := I + 1
   else
    begin
     H := I - 1;
     if C = 0 then
      begin
       Result := True;
//       if Duplicates <> dupAccept then L := I;
      end;
    end;
  end;
 Index := L;
end;

Et on essaye d'aller plus vite?
Elle a visiblement déjà fait l'objet d'une optimisation: le shr en est la preive
Le but n'est pas de prouver que Pierre ou Paul est meilleur que l'autre:simplement que dans un certain nombre de cas les rotines généralistes peuvent être accélérer. Et que meme des recherche dico, bubble ou quick Sort i exise des implémentation différentes: regarde le handicap du quick Sort recursif C'est flagrant le mime tri va 20 fois plus vite et avec le meêm tri.

Les impératifs des programmeurs de Borland ne sont pas les mêmes que nous.

Dans le débat sur les listes j'ai veiller a ne pas mettre d'ASM pour essayer de toucher un maximum de gens et garder un coté généraliste au débat.
J'ai des versions plus rapides mais plus specifiques

En réalité l'ASM n'est utile que pour les Moves et pour les comparaisons de string Il est faacile de comprendre que
Str1:=Str2 est moins performant qu'un move(Str2,Str1,Byte(Sr2[0]+1)

PapyJohn

[sjrd]

Il y a juste a remplacer la ligne de comparaison pour pouvoir l'utilliser
et a ùmetre le dupliocate en commentaire
Je te propose
C:=0;
If Str1>Str 2 then C:=1
else if STR2>Str1 then C:=-1

Bien entendu, si tu réduis la comparaison de chaînes à l'ordre ASCII, c'est très bien. Mais les String List permettent plus. Au prix d'une baisse légère de performances, il est vrai. Mais il a été déjà dit, et pas que par moi, que les string list sont un confort d'utilisation qu'il faut éviter si on cherche l'optimisation. Les tableaux dynamiques ça existe aussi.

Les impératifs des programmeurs de Borland ne sont pas les mêmes que nous.

La question n'est pas là. C'est l'objectif des classes de Classes.pas qui ne correspond pas à ce dont tu as besoin dans le cas précis dans lequel tu te trouves pour l'instant. En effet, ces classes ont pour but de faciliter la vie du programmeur dans ses codes de tous les jours. Elles n'ont pas pour but d'être des monstres de rapidité difficiles à manipuler.

En réalité l'ASM n'est utile que pour les Moves et pour les comparaisons de string Il est faacile de comprendre que
Str1:=Str2 est moins performant qu'un move(Str2,Str1,Byte(Sr2[0]+1)

Certainement, c'est facile à comprendre. Ce qui va être dur pour toi, c'est d'admettre que c'est faux.
En effet, l'affectation Str1 := Str2 ne fait pas de déplacement de mémoire, et donc est monstrueusement plus rapide

[PapyJohn]

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
procedure Copie;;
var J: integer;
 FStart, FStop, FElapsed: int64;
 Str3,Str2: String[9];
begin
 Str3:='0123456789';
 QueryPerformanceCounter(FStart);
 for j:=1 to 100000 do
   Move(Str3,str2,10);
 QueryPerformanceCounter(FStop);
 FStop := (FStop - FStart);
  FElapsed := (FStop - FStart); QueryPerformanceCounter(FStart);
 
 for j:=1 to 100000 do
   Str2:=Str3;
 QueryPerformanceCounter(FStop);
 If FSTOP<FElapsed then
  MessageDlg('Papy sucre les fraises', mtInformation,[mbOk], 0)
 else
  MessageDlg('Les vieux n''ont pas forcement tord', mtInformation,[mbOk], 0);
end;

Excusez moi je n'avais pas précisez qu'il fallait regarder le code généré pour voir la différence et pour voir qu'il y a bien recopie des caractères et pas seulement de l'adresse

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure MoveX10(const Source; var DeS1);
asm
        PUSH    ESI
        PUSH    EDI
        MOV     ESI, EAX
        MOV     EDI, EDX
        MOV     ECX, 2
        REP     MOVSD
        MOVSW      // + 2
@Fin:  
        POP     EDI
        POP     ESI
end;

Et si il a des épris de vitesse voila ce que j'ai réussi à faire de mieux!
Je le répète la routine est spécifique et ne grée que le transfert de 10 octets
, pas les chevauchements ni les zones identiques
Je suis assez fier du MOVSW qui profite du post incrément de EDI et ESI dans le REP
J'attends vos suggestions: je suis loin de maitriser l'ASM (voir lme titre du Tread)
Aucune difficulté a reconnaitre mon erreur mais je n'ai pas pas trouvé le swap d'adresse dans le code généré. Tu es sur de toi? Si c'est vrai il n'y a pas photo :le swap d'adresse est PLUS Rapide que le move
J'utilise delphi 6 qui génére le code suivant

Code :

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

1
2
3
4
lea eax,[ebp-44]          // adresse de depart
lea eax,[ebp-48]          // adresse de destination
mov cl,09                  //  nombre d'octets a recopiez
Call @PSTRNCopy        // Appel de la routine de la unit System.pas

Il est rare de voir exactement le travail d'un compilateur nous en avons un ici
Pour appeler le PNSTRcopy il faut savoir combien on doit recopier d'octets
Le compilateur regarde combien d'octets sont a recopier en comparant les deux longueurs, ici identiques, enlève la taille [0] et génère le code valeur immediate
Si les chaines avait été de tailles différentes il aurait veiller a ne pas depasser la taille maxi Par exemple

Code :

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

1
2
3
4
5
6
7
 
Str1:String[9]
Str2:String[3]
 
Str1:='0123456789'
Str2:=Str1 il generera
mov vl,03

autant de temps gagner lors de l'exécution.

Bien entendu, si tu réduis la comparaison de chaines à l'ordre ASCII,

Je ne crois pas réduire je laisse le compilo faire Tu ferais comment?
J'ai pas voulu ressortir de routines de StrComp 'd'Electron Libre' pour ne pas surchauffer nos processeurs !
Félicitations à ceux qui s'occupent du site les affichages des codes et quote sont très agréable et la listbox c'est Top.
Bravo

PapyJohn

[Rayek]

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
procedure Copie;;
var J: integer;
 FStart, FStop, FElapsed: int64;
 Str3,Str2: String[9];
begin
 Str3:='0123456789';
 QueryPerformanceCounter(FStart);
 for j:=1 to 100000 do
   Move(Str3,str2,10);
 QueryPerformanceCounter(FStop);
 FStop := (FStop - FStart); // pourquoi on soustrait ici
 FElapsed := (FStop - FStart); // puis encore ici FStart ????
 
 QueryPerformanceCounter(FStart);
 
 for j:=1 to 100000 do
   Str2:=Str3;
 QueryPerformanceCounter(FStop);
 If FSTOP<FElapsed then
  MessageDlg('Papy sucre les fraises', mtInformation,[mbOk], 0)
 else
  MessageDlg('Les vieux n''ont pas forcement tord', mtInformation,[mbOk], 0);
end;

Le code ci-dessus est franchement pas correct, la valeur de FElapsed n'est pas la bonne car on soustrait 2 fois FStart

[PapyJohn]

C'est une erreur de copier coller
en réalité j'avais mis ma technique en second mais comme je craignais
que l'on l'accuse de profiter d'un cache putatif j'ai inverse ainsi s'il y a mise en cache c'est le = qui en profite. Pour être sur vous pouvez aussi inverser les traitements

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
 
procedure Copie;;
var J: integer;
 FStart, FStop, FElapsed: int64;
 Str3,Str2: String[9];
begin
 Str3:='0123456789';
 QueryPerformanceCounter(FStart);
 for j:=1 to 100000 do
   Move(Str3,str2,10);
 QueryPerformanceCounter(FStop);: FElapsed := (FStop - FStart); //temps du 1° traitement
 
 QueryPerformanceCounter(FStart); 
 for j:=1 to 100000 do
   Str2:=Str3;
 QueryPerformanceCounter(FStop);
 FStop := (FStop - FStart); //  temps du 2° traitement
 
 If FSTOP<FElapsed then
  MessageDlg('Papy sucre les fraises', mtInformation,[mbOk], 0)
 else
  MessageDlg('Les vieux n''ont pas forcement tord', mtInformation,[mbOk], 0);
end;

Le code ci-dessus est franchement pas correct,

Je pense qu'il l'est maintenant. Il donne quoi chez vous?

PapyJohn
Je suis désolé de toutes ces erreurs mais je suis multi-handicapé, pratiquement aveugle, je souffre de tremblements.
Il n'y a que mon cerveau qui fonctionne par moment, alors si vous pouvez être indulgents indulgents
Merci

[sjrd]

Je le répète la routine est spécifique et ne grée que le transfert de 10 octets
, pas les chevauchements ni les zones identiques
Je suis assez fier du MOVSW qui profite du post incrément de EDI et ESI dans le REP
J'attends vos suggestions: je suis loin de maitriser l'ASM (voir lme titre du Tread)

Le problème, c'est que les quatre PUSH/POP sont déjà suffisant à être moins efficace que :

Code :

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

1
2
3
4
procedure MoveX10(var Dest; const Source);
begin
  Extended(Dest) := Extended(Source);
end;

Ou même que :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
procedure MoveX10(var Dest; const Source);
type
  TStrRec = packed record
    Val1: Integer;
    Val2: Integer;
    Val3: Word;
  end;
begin
  TStrRec(Dest).Val1 := TStrRec(Source).Val1;
  TStrRec(Dest).Val2 := TStrRec(Source).Val2;
  TStrRec(Dest).Val3 := TStrRec(Source).Val3;
end;

Ce qui correspond bien gentillement à :

Code :

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

1
2
3
4
5
6
procedure MoveX10(var Dest; const Source);
asm
        MOV     DWORD PTR [EAX+0],[EDX+0]
        MOV     DWORD PTR [EAX+4],[EDX+4]
        MOV     WORD PTR [EAX+8],[EDX+8]
end;

Aucune difficulté a reconnaitre mon erreur mais je n'ai pas pas trouvé le swap d'adresse dans le code généré. Tu es sur de toi? Si c'est vrai il n'y a pas photo :le swap d'adresse est PLUS Rapide que le move

La recopie d'adresse fonctionne avec les string, dont nous parlions avant, pas avec les ShortString avec lesquelles on travaille maintenant.