IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Lazarus Pascal Discussion :

Exécution lente pour Lazarus 2.2.0 Vs Delphi DX 3.3.2


Sujet :

Lazarus Pascal

  1. #1
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut Exécution lente pour Lazarus 2.2.0 Vs Delphi DX 3.3.2
    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!

    Nom : Capture d’écran 2022-06-13 103825.png
Affichages : 134
Taille : 5,3 Ko

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  2. #2
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    769
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 769
    Points : 2 264
    Points
    2 264
    Par défaut Il y a un OS
    Bonjour Fernet,
    Citation Envoyé par fernet Voir le message
    ...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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  3. #3
    Membre confirmé
    Profil pro
    Inscrit en
    avril 2010
    Messages
    227
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : avril 2010
    Messages : 227
    Points : 489
    Points
    489
    Par défaut
    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é

  4. #4
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  5. #5
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    769
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 769
    Points : 2 264
    Points
    2 264
    Par défaut
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  6. #6
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 689
    Points : 10 647
    Points
    10 647
    Billets dans le blog
    6
    Par défaut
    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 ?
    Delphi 5 Pro - Delphi 10.4 Rio Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  7. #7
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  8. #8
    Membre habitué
    Profil pro
    Inscrit en
    janvier 2006
    Messages
    133
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : janvier 2006
    Messages : 133
    Points : 157
    Points
    157
    Par défaut
    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.

  9. #9
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    769
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 769
    Points : 2 264
    Points
    2 264
    Par défaut Pour mémoire
    Bonjour Thierrybo,

    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...
    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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

  10. #10
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  11. #11
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 689
    Points : 10 647
    Points
    10 647
    Billets dans le blog
    6
    Par défaut
    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.
    Delphi 5 Pro - Delphi 10.4 Rio Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  12. #12
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Nom : Capture d’écran 2022-06-14 155606.png
Affichages : 81
Taille : 16,1 Ko

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  13. #13
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 689
    Points : 10 647
    Points
    10 647
    Billets dans le blog
    6
    Par défaut
    Bonjour,
    Un peu du code en question expliciterait pê le problème : conversions implicites ? affectations sans transtypage ?
    Delphi 5 Pro - Delphi 10.4 Rio Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  14. #14
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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;

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  15. #15
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 689
    Points : 10 647
    Points
    10 647
    Billets dans le blog
    6
    Par défaut
    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.
    Delphi 5 Pro - Delphi 10.4 Rio Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  16. #16
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  17. #17
    Modérateur
    Avatar de tourlourou
    Homme Profil pro
    Biologiste ; Progr(amateur)
    Inscrit en
    mars 2005
    Messages
    3 689
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 59
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Biologiste ; Progr(amateur)

    Informations forums :
    Inscription : mars 2005
    Messages : 3 689
    Points : 10 647
    Points
    10 647
    Billets dans le blog
    6
    Par défaut
    Tiens, le test parallèle dans CodeTyphon ne me donne pas le même résultat !
    Citation Envoyé par Delphi
    FFFFFFFFFFFFFFFF18446744073709551615
    gare au non typé-1
    FFFFFFFFFFFFFFFF-1
    FFFFFFFFFFFFFFFF-1
    FFFFFFFFFFFFFFFF-1
    FFFFFFFFFFFFFFFF18446744073709551615
    FFFFFFFFFFFFFFFF18446744073709551615
    FFFFFFFFFFFFFFFF18446744073709551615
    FFFFFFFFFFFFFFFF
    FFFFFFFFFFFFFFFF
    Citation Envoyé par CodeTyphon
    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.
    Delphi 5 Pro - Delphi 10.4 Rio Community Edition - CodeTyphon 6.90 sous Windows 10 ; CT 6.40 sous Ubuntu 18.04 (VM)
    . Ignorer la FAQ Delphi et les Cours et Tutoriels Delphi nuit gravement à notre code !

  18. #18
    Expert confirmé
    Avatar de BeanzMaster
    Homme Profil pro
    Amateur Passionné
    Inscrit en
    septembre 2015
    Messages
    1 878
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Suisse

    Informations professionnelles :
    Activité : Amateur Passionné
    Secteur : Tourisme - Loisirs

    Informations forums :
    Inscription : septembre 2015
    Messages : 1 878
    Points : 4 260
    Points
    4 260
    Billets dans le blog
    2
    Par défaut
    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
    • "L'Homme devrait mettre autant d'ardeur à simplifier sa vie qu'il met à la compliquer" - Henri Bergson
    • "Bien des livres auraient été plus clairs s'ils n'avaient pas voulu être si clairs" - Emmanuel Kant
    • "La simplicité est la sophistication suprême" - Léonard De Vinci
    • "Ce qui est facile à comprendre ou à faire pour toi, ne l'est pas forcément pour l'autre." - Mon pèrei

    Mes projets sur Github - Blog - Site DVP

  19. #19
    Nouveau membre du Club
    Homme Profil pro
    Technicien maintenance
    Inscrit en
    mars 2006
    Messages
    35
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : Canada

    Informations professionnelles :
    Activité : Technicien maintenance
    Secteur : Bâtiment

    Informations forums :
    Inscription : mars 2006
    Messages : 35
    Points : 26
    Points
    26
    Par défaut
    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!

    Alors là j'en perd mon Latin et mon Pascal aussi!
    Essayer de prouver de toutes ses forces que l'on a raison même si l'on a raison
    bien c'est déjà se tromper.

  20. #20
    Membre émérite

    Homme Profil pro
    Directeur de projet
    Inscrit en
    mai 2013
    Messages
    769
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Yvelines (Île de France)

    Informations professionnelles :
    Activité : Directeur de projet
    Secteur : Service public

    Informations forums :
    Inscription : mai 2013
    Messages : 769
    Points : 2 264
    Points
    2 264
    Par défaut
    Bonjour Fernand,

    Citation Envoyé par fernet Voir le message
    À 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
    Ever tried. Ever failed. No matter. Try Again. Fail again. Fail better. (Samuel Beckett)

Discussions similaires

  1. temps d'exécution très lent pour les boucles for
    Par NELLLY dans le forum MATLAB
    Réponses: 2
    Dernier message: 02/01/2013, 11h00
  2. outlook lent pour excuter!
    Par starsat4200 dans le forum Outlook
    Réponses: 1
    Dernier message: 08/06/2007, 09h05
  3. Exécuter procédure pour chaque ligne d'un Select
    Par Thomad dans le forum MS SQL Server
    Réponses: 2
    Dernier message: 17/08/2006, 08h58
  4. [VBA-E]exécution lente de la macro après aperçu
    Par cwain dans le forum Macros et VBA Excel
    Réponses: 6
    Dernier message: 28/03/2006, 17h49
  5. OpenGL trop lent pour la 2D !!!
    Par kagemusha dans le forum OpenGL
    Réponses: 17
    Dernier message: 14/12/2005, 11h06

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo