Discussion :

[fernet]

Bonjour à tous!
En somme j'ai converti mon jeu d'échec compilé avec Delphi en Lazarus, et j'ai testé le calcul d'une position
me servant à voir l'amélioration de l'exécution.
Alors Delphi la calcule en 40 secondes et Lazarus en 61 secondes, ce qui est beaucoup comme différence pour les
mêmes calcules et la même solution de retour.
Je me suis assuré des points suivants:
- Compiler en mode(release) avec l'optimisation -03.
- Que la case de plus petit plutôt que plus rapide n'est pas coché.
- Tester l'évaluation boolean incomplète si elle est bien par défaut.
- Rechercher sur le forum et wiki si quelqu'un à discuter de ce fait(aucun).

Une chose que je ne peut pas faire c'est de compiler pour la cible X86_64 car FPC 3.2.2 i386 WIN32 ne la prend pas en charge.
J'ai WIN10 32 bits avec INTEL R double core 64 bits.
J'espère que quelqu'un saura m'apporter une réponse. Salut!

[Guesset]

Bonjour Fernet,

...Tester l'évaluation boolean complète si elle est bien par défaut.

Je présume que c'est l'évaluation booléenne optimisée donc a priori incomplète qui est activée. L'évaluation complète est plus lente et peut être dangereuse comme par exemple :

Code PASCAL :

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

if (i in [imin..imax]) and (a[i] <> 0) then ...

Lequel plantera en évaluation complète si i n'est pas dans la plage requise.

La portabilité de Lazarus ne le rend pas rapide. Pour standardiser les accès systèmes, ils sont très souvent dotés de fonctions intermédiaires d'adaptation à l'OS.

Pour la cible 32/64, il faut avoir la bonne version de Lazarus (donc FP) donc au moins une version 64 bit ou mieux 32/64.

Salutations

[alanglet]

Bonjour,

Si Windows est une version 32 bits, je ne pense pas qu'il soit possible de compiler en 64b, même si le processeur est un 64b.
Par contre sur win10 64b, FPCUPdeluxe permet d'installer la version 32b ou 64b de FPC/Lazarus et le cross-compilateur pour l'autre version.
J'ai commencé avec FPC/Lazarus 64b et le cross-compilateur 32b, mais il y a un problème de conversion des Datetime en Timestamp dont j'ai parlé ici.
J'ai donc refait l'installation inverse, qui fonctionne bien et qui permet de compiler en 32b ou en 64b. Il faut juste passer au debugger GNU pour compiler en 64b.

André

[fernet]

Je suis d'accord avec toi Guesset et j'ai changé (complète pour incomplète) car si l'évaluation complète était active
mon programme planterait a coup sûre.
Dans un programme d'échec on utilise beaucoup le type Uint64(Qword) pour représenter les 64 cases de l'échiquier.
Si je pointe un tableau de Uint64 sous Delphi on voit plusieurs variables négatives, mais sous Lazarus on en voit aucune.
Ce qui me laisse supposer que FPC reconnait mieux les Uint64 que Delphi. Et dans un code comme celui ci, Delhi va s'arrêter
au (then) tant disque Lazarus me renvoi un avertissement disant que cette condition sera toujours (false) a cause de L'étendu
de la variable.

Code :

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

1
2
3
4
5
6
procedure tesUint64;
 var neg:Uint64;
begin
  if neg < 0
  then neg := 0;
end;

Alors je crois (alanglet) que les deux EDI utilise (EAX + EDX) deux registres 32b pour composer le 64b, mais çà c'est pareille pour les
deux et ne devrait pas causer cette différence de temps d'exécution puisqu'il s'exécute sur le même système.
Fernand salut!

[Guesset]

Bonjour,

Alanglet à raison, un système 32 bits n'exécute pas du code 64 bits. Mais il m'étonnerait que la version de Windows soit en 32 bits sur une machine 64 bits (ce n'est pas impossible mais peu probable). Il y a peut être une mauvaise interprétation de Win32 qui ne désigne pas l'OS mais l'API Windows (toute la logique d'appels des fonctions système).

A l'opposé un système 64 bits peut faire tourner des applications 32 bits. Par exemple, une version 32 bits de Lazarus/FPC et une version 64 bits de Delphi. C'est pourquoi je conseillais éventuellement de charger une version mixte de Lazarus.

Les version 32 bits utilisent effectivement des combinaisons de deux registres 32 bits pour simuler un registre 64 bits mais aussi des registres des jeux d'instruction SIMD (MMX, SSE etc.).

Il est intéressant de travailler en 64 bits, pas tant pour la taille des registres (souvent 32 bits sont largement suffisants) mais surtout pour le plus grand nombre de registres qui permet au compilateur de mieux optimiser son code (et en l'occurrence 16 est plus que le double de 8 à cause des registres réservés).

Salutations

[tourlourou]

Si je pointe un tableau de Uint64 sous Delphi on voit plusieurs variables négatives, mais sous Lazarus on en voit aucune.

Est-ce le débogueur qui montre des valeurs négatives ? Ou bien le code trouve-t-il ces valeurs négatives ?

[fernet]

Bonjour!
Il est bien sûre que si Delphi code en 64 bits il sera beaucoup plus vite que Lazarus en 32 bits.

J'ai lu dans ce wiki qu'il est possible d'installer un deuxième compilateur, mais je ne sait pas si je peut le faire.
Va falloir que j'étudie sérieusement la question.

https://wiki.lazarus.freepascal.org/...rsion_Switcher

P.S. Guesset, mon OS était Win7 32 bits, et c'est pour çà que j'ai du le convertir en Win10 32 bits.

Fernand salut!

[thierrybo]

Bonjour,

normalement sur la page de téléchargement de Lazarus 32 bit pour Windows, tu dois installer le lien en dessous "lazarus-2.2.2-fpc-3.2.2-cross-x86_64-win64-win32.exe" pour pouvoir compiler en 64 bits depuis Lazarus 32 bits.

[Guesset]

Bonjour Thierrybo,

...tu dois installer le lien en dessous "lazarus-2.2.2-fpc-3.2.2-cross-x86_64-win64-win32.exe" pour pouvoir compiler en 64 bits depuis Lazarus 32 bits...

C'est exact, mais si la machine tourne en Windows 10 32 bits comme indiqué, elle ne saura pas exécuter le code 64 bits résultant. Nous sommes alors dans le cas d'une cross-compilation et il faudra trouver une machine cible dotée du bon système pour faire tourner le binaire produit.

C'est quand même dommage qu'un machine 64 bits soit sous utilisée. J'inciterais à un migration en Windows 64 bits mais je ne sais pas si c'est payant. Par ailleurs, les codes 64 bits sont plus volumineux et consommateur de mémoire, 8 Go semblent la norme aujourd'hui (l'utilisateur n'aura jamais besoin de plus de 1 Mo de RAM disait Bill Gates ).

Salut

[fernet]

Bonjour!

tourlourou
Est-ce le débogueur qui montre des valeurs négatives ? Ou bien le code trouve-t-il ces valeurs négatives ?

Quant je déboguais sous Delphi (tourloulou) a un point d'arrêt, en pointant un tableau de Uint64 on voyait des valeurs
négatives. De toute façon pour un jeu d'échec çà n'a pas d'importance car c'est le bit qui compte.

En somme (Guesset) je ne sait pas si mon jeu en Delphi est 64 bits, mais je sais qu'il est plus gros.
(Delphi = 2,802 ko) et (Lazarus = 2,283 ko) Au départ je croyais que c'était a cause des unités que FPC nous fait
enlever comme (Message et Lmessage) qui ne serve pas.

Si mon jeu en Delphi est 64 bits, alors cela veut dire que ma machine peut rouler des programme coder 64 bits et
si non, pourquoi alors cette différence énorme dans le temps d'exécution. C'est la question que je me pose.

Fernand, Salutation!

[tourlourou]

Il est donc vraisemblable que pas plus Delphi que Lazarus ne mette de valeur négative dans un UInt64, mais que le débogueur ne sait montrer les entiers sur 8 octets que comme s'ils étaient signés.
Si if aUInt64 <0 est testé vrai, il y a sûrement un rapport de bogue à faire.

[fernet]

Bonjour!
A vrai dire (tourlourou) je crois que j'ai fait ce teste de négation sur Delphi 2005 pro et non sur DX 3.3.2, mais il est
vrai que si pointe un tableau de Uint64 on voit des valeurs négative sous Delphi mais pas avec FPC.

Par contre sur un teste négatif, FPC me renvoie que cette condition sera toujours (false). Mais il y a une contradiction
dans la fait que si compile en mode (release ou default), j'obtient les warnings de cette capture d'écran et le programme
est exécuté.
Mais si je compile en mode (debug) tous ces warnings ce changent en Erreur avec (le stop en rouge) et le programme ne
s'exécute pas. Ces warnings apparaisse quant le bit de poids fort est à 1 comme (Uint64 = $FFFFFFFFFFFFFFFF) = -1 en
signé.
Je ne sait pas si on s'éloigne du sujet, mais le pointage est toujours de 40 sec Delphi/61 sec FPC !

Fernand, salut!

[tourlourou]

Bonjour,
Un peu du code en question expliciterait pê le problème : conversions implicites ? affectations sans transtypage ?

[fernet]

Bonjour!
Je te met ce bout de code mais je ne sait pas si c'est çà que tu veut. Il faut dire que quant il calcul une position
il ne ce sert d'aucune (string ou objet) c'est juste du code pascal très simple.

Par contre pour les tables de hahshing j'utilise des tableaux de pointer (3 * array[2048 * 2048]) pour ne pas embourber
les variables globales.
Au cas ou: Hashing = (position que l'on fait suivre dans une hakey(Uint64) avec (or et xor) et que l'on conserve dans des tableaux)

La (procédure entrer) s'exécute une seule fois a l'initialisation, et elle met a 1 tous les bits se situant entre dp et pn exclusivement.
Les procédures du bas se serve de ces tableaux pour identifier le vide entre deux positions sur l'échiquier.

J'espère que çà t'aidera a comprendre, Fernand, salut!

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
 
procedure entrer; //Bitboard pour determiner le vide entre deux positions
 var dp,pn,ind,cke,fne:integer;
begin                           //entt pour (ranger et colonne)
  for dp := 0 to 63 do          //entf pour (les diagonales)
  for pn := 0 to 63 do          //entr pour (ranger et colonne et diagonale)
  begin
    entr[dp,pn] := 0;entf[dp,pn] := 0;entt[dp,pn] := 0;
    if fool[dp] and board[pn] <> 0
    then begin
      entt[dp,pn] := $FFFFFFFFFFFFFFFF;
      ind := inde[pn,dp];cke := pn + ind;fne := dp;
      while cke <> fne do
      begin
        entr[dp,pn] := entr[dp,pn] or board[cke];
        entf[dp,pn] := entf[dp,pn] or board[cke];
        inc(cke,ind); end;end else
    if tool[dp] and board[pn] <> 0
    then begin
      entf[dp,pn] := $FFFFFFFFFFFFFFFF;
      ind := inde[pn,dp];cke := pn + ind;fne := dp;
      while cke <> fne do
      begin
        entr[dp,pn] := entr[dp,pn] or board[cke];
        entt[dp,pn] := entt[dp,pn] or board[cke];
        inc(cke,ind); end;end
    else if pn <> dp
         then begin
           entr[dp,pn] := $FFFFFFFFFFFFFFFF;
           entt[dp,pn] := $FFFFFFFFFFFFFFFF;
           entf[dp,pn] := $FFFFFFFFFFFFFFFF; end;end;
end;
 
      function decsep(dee:integer):boolean;  //Fou ou dame humaine attaque pion Projechec en diagonal(-7)
      begin
        if ((f1h <> nue) and (dia1[f1h] = dia1[dee]) and (entf[f1h,dee] and bdtou = vid) and (posy[f1h] < posy[dee]))
        or ((f2h <> nue) and (dia1[f2h] = dia1[dee]) and (entf[f2h,dee] and bdtou = vid) and (posy[f2h] < posy[dee]))
        or ((d1h <> nue) and (dia1[d1h] = dia1[dee]) and (entf[d1h,dee] and bdtou = vid) and (posy[d1h] < posy[dee]))
        then result := false
        else result := true;
      end;
      function dechui(dee:integer):boolean;  //Tour ou dame humaine attaque pion Projechec en colonne(-8)
      begin
        if ((t1h <> nue) and (posx[t1h] = posx[dee]) and (entt[t1h,dee] and bdtou = vid))
        or ((t2h <> nue) and (posx[t2h] = posx[dee]) and (entt[t2h,dee] and bdtou = vid))
        or ((d1h <> nue) and (posx[d1h] = posx[dee]) and (entt[d1h,dee] and bdtou = vid))
        then result := false
        else result := true;
      end;
      function decneu(dee:integer):boolean;  //Fou ou dame humaine attaque pion Projechec en diagonal(-9)
      begin
        if ((f1h <> nue) and (dia8[f1h] = dia8[dee]) and (entf[f1h,dee] and bdtou = vid) and (posy[f1h] < posy[dee]))
        or ((f2h <> nue) and (dia8[f2h] = dia8[dee]) and (entf[f2h,dee] and bdtou = vid) and (posy[f2h] < posy[dee]))
        or ((d1h <> nue) and (dia8[d1h] = dia8[dee]) and (entf[d1h,dee] and bdtou = vid) and (posy[d1h] < posy[dee]))
        then result := false
        else result := true;
      end;

[tourlourou]

Bonjour,
Un test sous Delphi 10.4 W32 montre des choses amusantes :

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
procedure TForm1.Button1Click(Sender: TObject);
const
  constante_non_typee_4xFFFF = $FFFFFFFFFFFFFFFF;
  constante_non_typee_moins1 = -1;
 
  constante_i32_typee_moins1 : Int32 = -1;
 
  constante_i64_typee_4xFFFF : Int64 = $FFFFFFFFFFFFFFFF; // W1012 L'expression constante dépasse les limites de sous-étendue
  constante_i64_typee_moins1 : Int64 = -1;
 
  constante_u64_typee_4xFFFF : UInt64 = $FFFFFFFFFFFFFFFF;
{ constante_u64_typee_moins1 : UInt64 = -1; // E1012 L'expression constante dépasse les limites de sous-étendue }
  constante_u64_casteemoins1 : UInt64 = UInt64(-1);
 
begin
  variable_u64 := constante_non_typee_4xFFFF; Memo1.Lines.Append(variable_u64.ToHexString + constante_non_typee_4xFFFF.ToString);
 
{ variable_u64 := constante_non_typee_moins1; // E1012 L'expression constante dépasse les limites de sous-étendue }
  Memo1.Lines.Append('gare au non typé' + constante_non_typee_moins1.ToString);
 
  variable_u64 := constante_i32_typee_moins1; Memo1.Lines.Append(variable_u64.ToHexString + constante_i32_typee_moins1.ToString);
 
  variable_u64 := constante_i64_typee_4xFFFF; Memo1.Lines.Append(variable_u64.ToHexString + constante_i64_typee_4xFFFF.ToString);
 
  variable_u64 := constante_i64_typee_moins1; Memo1.Lines.Append(variable_u64.ToHexString + constante_i64_typee_moins1.ToString);
 
  variable_u64 := constante_u64_typee_4xFFFF; Memo1.Lines.Append(variable_u64.ToHexString + constante_u64_typee_4xFFFF.ToString);
 
  variable_u64 := constante_u64_casteemoins1; Memo1.Lines.Append(variable_u64.ToHexString + constante_u64_casteemoins1.ToString);
 
  variable_u64 := $FFFFFFFFFFFFFFFF;          Memo1.Lines.Append(variable_u64.ToHexString + $FFFFFFFFFFFFFFFF.ToString);
 
  FillChar(variable_u64, 8, $FF);             Memo1.Lines.Append(variable_u64.ToHexString);
 
  Int64(variable_u64) := -1;                  Memo1.Lines.Append(variable_u64.ToHexString);
end;

On ne peut pas faire n'importe quoi, mais quand même ! Il y a les cas 2 et 3 où en mettant une constante qui vaut -1 dans un UInt64, on obtient plus Mais seulement si c'est une constante typée, même de taille différente !

Au final, mon Delphi ne me montre pas - à l'exécution - de valeur négative pour un UInt64 affecté même par -1 ! Ni d'avertissement en lui affectant $FFFFFFFFFFFFFFFF, au contraire d'un Int64.

[fernet]

Bonjour!
Je ne sais pas pourquoi FPC m'indique ces erreurs mais si je compile une deuxième fois il exécute le programme
en mode(debug) sans aucune erreur d'exécution.

Pour une tel différence de temps d'exécution je pencherais plutôt pour des choses comme celle ci:
- L'utilisation du cache memory.
- L'alignement des données dans la mémoire.
- De mettre des procédures (inline) si c'est possible.
- Ou bien il faut absolument que j'installe (PPCcrossx64)

Citation Envoyé par thierrybo Voir le message
...tu dois installer le lien en dessous "lazarus-2.2.2-fpc-3.2.2-cross-x86_64-win64-win32.exe" pour pouvoir compiler en 64 bits depuis Lazarus 32 bits...

J'ai lu quelque par, qu'il fallait désinstallé comme il faut Lazarus pour installer une nouvelle version, mais je ne sait plus ou.
J'étudie la question pour l'instant. Salut!

[tourlourou]

Tiens, le test parallèle dans CodeTyphon ne me donne pas le même résultat !

FFFFFFFFFFFFFFFF18446744073709551615
gare au non typé-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF18446744073709551615
FFFFFFFFFFFFFFFF18446744073709551615
FFFFFFFFFFFFFFFF18446744073709551615
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF

FFFFFFFFFFFFFFFF-1
gare au non typé-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF18446744073709551615
FFFFFFFFFFFFFFFF18446744073709551615
FFFFFFFFFFFFFFFF-1
FFFFFFFFFFFFFFFF
FFFFFFFFFFFFFFFF

CodeTyphon prend la constante non typée comme Int64 et non UInt64 si elle déborde, affectée par $FFFFFFFFFFFFFFFF. Ce qui ne change pas la valeur del'UInt64 auquel on l'affecte.

[BeanzMaster]

Salut, il y a beaucoup d'options disponibles sous Lazarus pour l'optimisation en plus du simple -O3. Ensuite tout dépend de comment tu as convertie ton application vers Lazarus. As-tu utilisé le convertisseur automatique ?
Dans le code que tu as mis quelques optimisations sont possibles surtout sur les conditions et l'accès sur les tableaux.
L'utilisation de type ????64 n'est pas recommandé sur un système 32 bit. Comme le mentionnait @Guesset il est dommage d'utiliser une version de Windows 32 bits sur un PC avec une archi 64bit. Tu devrais essayer de passer W10 en 64bit cf https://www.windowscentral.com/how-u...20Windows%2010 et

Pourrais-tu nous mettre les sources complètes de ton applications Lazarus en zip ici stp afin de pouvoir tester ?

A+
Jérôme

[fernet]

J'ai utilisé le convertisseur automatique, et étant donné que j'utilise que des composants (standard) il y a eu aucun
problème de conversion.

À mon avis Delphi détecte mon CPU 64 bits et le compile en conséquence. Je vais m'arranger pour compiler en 64 bits
pour voir la différence.

En ce qui concerne mon code source, j'imagine que si je le met ici, toute la communauté vas pouvoir le voir. Pour
l'instant j'aime mieux pas, mais je pourrais zipper le exe avec ces fichiers.

Fernand, Salut!

[Guesset]

Bonjour Fernand,

À mon avis Delphi détecte mon CPU 64 bits et le compile en conséquence.

Si c'est le cas et que cela fonctionne sur ta machine, c'est que ton Windows est une version 64 bits car une version 32 bits ne saura pas lancer un exécutable 64 bits.

Pour le vérifier c'est assez simple. Tu passes en mode debug et tu ouvres la fenêtre du code assembleur. Tu lances une exécution pas à pas. Si dans la fenêtre assembleur tu vois des rax, rdx, rcx, r8, r9, r10 etc. alors tu es en mode 64 bits. S'il n'y a que des eax, edx, ecx, ebx... tu es en 32 bits. Attention, le mode 64 bits peut aussi utiliser des registres 32 bits mais le mode 32 bits ne peut utiliser des registres standards 64 bits. Une autre manière de faire est d'ouvrir, toujours en mode debug, la fenêtre des registres. Pareillement, si il y a les 16 registres r.. nous sommes en 64 bits sinon en 32 bits.

Tu as aussi système/informations système qui te donnera la version en cours de l'OS.

Salut