Dev c++ et 64 bits

bonsoir à tous!

Voila j'en suis toujours à développer un jeu d'échecs sous dev c++(que vous pouvez voir jouer sur WBEC et Chesswar).
Je me suis récemment attaqué aux "hashtables" (tables de transposition) . C'est nécessaire pour arriver à un niveau correct... Las ! si j'ai bien compris , dev c++ ne compile qu'en 32 bit? Pour les hashtables , j'ai besoin de gérer les positions sur 64 bits .
Y a t-il un moyen de compiler avec dev c++ en 64 bits ? Pour l'instant les limitations sont d'un "long" "normal" à savoir :

Code:

---

printf("taille : %llu\n",0xFFFFFFFFFFFFFFLLU);

---

affiche 4294967295

Merci pour votre aide précieuse ;-)

Salut,

Quels flags de compilation? (ça doit etre affiché dans le log de compilation)

Gio,

Comme il s'agit de DevC++, je suppose que tu utilises gcc.

Si c'est le cas, la version habituelle de gcc pour windows nécessite le paramètre %I64u pour afficher une variable unsigned sur 64 bits:

Code:

---

printf("taille : %I64u\n",0xFFFFFFFFFFFFFFLLU);

---

:)

Ce n'est pas "gcc pour Windows" mais "La C Run-Time Library de Microsoft", qui est utilisée même par les programmes compilés avec gcc.

Et comme les c*$^*$^ùds de ches M$ ont décidé de faire fi des standards du C, la fonction printf() se retrouve réduite à utiliser les extensions M$ au lieu du préfixe standard pour un long long...

Citation:

---

Envoyé par dany9

Voila j'en suis toujours à développer un jeu d'échecs sous dev c++(que vous pouvez voir jouer sur WBEC et Chesswar).
Je me suis récemment attaqué aux "hashtables" (tables de transposition) . C'est nécessaire pour arriver à un niveau correct... Las ! si j'ai bien compris , dev c++ ne compile qu'en 32 bit? Pour les hashtables , j'ai besoin de gérer les positions sur 64 bits .
Y a t-il un moyen de compiler avec dev c++ en 64 bits ? Pour l'instant les limitations sont d'un "long" "normal" à savoir :

Code:

---

printf("taille : %llu\n",0xFFFFFFFFFFFFFFLLU);

---

affiche 4294967295

---

"ll" n'est pas pris en compte par le CRT (C-runtime) de Windows. Il faut utiliser "I64", ce qui est assez casse-pieds...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <stdio.h>   #ifdef WIN32 #define LL "I64" #else #define LL "ll" #endif   int main (void) { printf ("taille : %" LL "u\n", 0xFFFFFFFFFFFFFFLLU); return 0; }

---

Code:

---

1 2 3 4

taille : 72057594037927935   Press ENTER to continue.

---

Et c'est encore plus casse-mivonks quand tu commences à bosser en unicode ou en TCHAR...

Citation:

---

Envoyé par Médinoc

Et c'est encore plus casse-mivonks quand tu commences à bosser en unicode ou en TCHAR...

---

Frell ! Farscape-fan detected !

Code:

---

1 2 3 4 5 6 7 8 9

#include <stdio.h> #include <tchar.h> #define LL _T("I64")   int _tmain (void) { _tprintf (_T("taille : %") LL _T("u\n"), 0xFFFFFFFFFFFFFFULL); return 0; }

---

Bonsoir à tous !
tout d'abord , merci pour vos réponses nombreuses et rapides ;) , quand je disait que c'était le meilleur forum pour la prog et tout ...!
Bon bien sur , le petit code fourni par emmanuel est impec : ça affiche bel et bien en 64 bits ... reste à savoir comment les définir ces" long long " pour qu'il soient traités en 64 bits pour ma hashtable ...
J'ai essayé:

Code:

---

1 2	typedef unsigned long long U64; #define U64 _int64

---

je ne sais pas trop quoi utiliser , en fait pour être franc , je suis un peu perdu dans les méandres du 64 bits !;)


Enfin pour finir , Jars (c'est le nom de mon jeu d'échecs !) à obtenu un elo (pour ceux qui connaissent ...) de 1891
ça donne du beaume au coeur pour continuer !
Ci joint le lien de "Jars" , pour ceux que ça interresse



http://wbec-ridderkerk.nl/html/details/Jars.html

A bientot !

Citation:

---

Envoyé par dany9

comment les définir ces" long long " pour qu'il soient traités en 64 bits pour ma hashtable ...

Code:

---

1 2	typedef unsigned long long U64; #define U64 _int64

---

je ne sais pas trop quoi utiliser , en fait pour être franc , je suis un peu perdu dans les méandres du 64 bits !;)

---

A mettre dans un header (et à combiner avec la définition de LL)

EDIT:

Code:

---

1 2 3 4 5 6

#ifdef WIN32 typedef unsigned __int64 ull; #else typedef unsigned long long ull; #endif

---

et tu utilises ull comme type de variable.

merci encore emmanuel , quel puits de science :) Je donnerais des nouvelles de mon"poulain" avec hashtables ;)

Bonne nuit!

Dany

LONGLONG
64-bit signed integer.
This type is declared in WinNT.h as follows:

Code:

---

1 2 3 4 5 6

#if !defined(_M_IX86) typedef __int64 LONGLONG; #else typedef double LONGLONG; #endif

---

Citation:

---

Envoyé par nicolas.sitbon

LONGLONG
64-bit signed integer.
This type is declared in WinNT.h as follows:

Code:

---

1 2	typedef double LONGLONG;

---

---

This is hardly an integer...

C'est pourtant bien un entier selon microsoft...
y a aussi

Code:

---

typedef __int64 LONG64;

---

Visual utilise des doubles pour les plate-formes ne supportant pas les __int64 de base.

De plus, il me semble que Visual 2005 supporte les long long.
Donc, je dirais plutôt un truc de ce genre pour les typedefs:

Code:

---

1 2 3 4 5

#if defined(_MSC_VER) && _MSC_VER < 1400 typedef unsigned __int64 ull; #else typedef unsigned long long ull; #endif

---

bonsoir à tous et merci encore pour vos aides précieuses..

En fait j'avais defini les long long avec __int64 , le problème , c'est que j'avais oublié un '_' ! ça ne risquait pas de marcher !

Ok et maintenant je reviens avec un nouveau (petit) problème :
J'ai donc mes positions codées en 64 bits , la table de transposition étant définie comme suit :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

#define HASH_TAILLE 10000 /*valeur arbitraire : très petite table!*/   /*structure table de hashage*/ typedef struct tagHASHE { ull key; int profondeur; int flags; int evaluation; int meilleur; } HASHE;   /*la table de transposition*/ HASHE tab_tt[HASH_TAILLE+1];

---

Ok , le nombre de positions rencontrées au cours de l'analyse va être énorme , on ne peut pas les enregistrer toute , alors on y accède à l'aide du modulo :

Code:

---

index = hashcode % HASH_TAILLE;

---

mais dans mon code , la valeur index obtenue doit être un int compris entre 0 et 10000 (HASH_TAILLE) , au lieu de cela , j'ai un chiffre "absurde" (-1738304..)
et même en faisant :

Code:

---

index = (int)(hashcode % HASH_TAILLE)

---

chercher l'erreur ... :-)

Typiquement, ta variable "hashcode" n'est pas initialisée

ok ;) hashcode est en 64 bits:

Code:

---

ull hashcode;

---

c'est la position sur l'échiquier codée et je voudrais obtenir un index en int en faisant :

Code:

---

index = hashcode % HASH_TAILLE;

---

voila donc comment obtenir un résultat en int ?

hello !

toujours pas d'idées alors sur le non fonctionnement de l'opérateur de cast suivant?

Code:

---

1 2 3 4 5

int index ; ull hashcode;   index = (int)(hashcode % 1000);

---

je n'obtients pas un int (en l'occurence les 3 derniers chiffres du hashcode , ici avec 1000) mais un nombre négatif ?

Merci pour vos conseils et réponses !

Un int peut être négatif, tu sais...

Ici, je dirais que tu as le résultat de hashcode%1000 sous forme de ull, qui est ensuite casté en int. Mais ça n'explique pas le changement de signe, alors que hashcode est forcément positif...

Citation:

---

Envoyé par dany9

Code:

---

index = (int)(hashcode % HASH_TAILLE)

---

chercher l'erreur ... :-)

---

Code:

---

unsigned index = (unsigned)(hashcode % HASH_TAILLE)

---

et l'affichage doit se faire avec "%u" et non "%d"...

euh .. désolé mais ça n'a pas l'air de fonctionner tel que tu propose emmanuel si j'ai ce bout de code :

Code:

---

1 2 3

unsigned index = (unsigned)(hash_code%HASH_TAILLE); printf("index : %u\n",index);

---

où hashcode vaut 18446744072274528121 (ouf!)
et HASH_TAILLE = 1000
index devrait valoir 121
(modulo avec 1000 revient à ne conserver que les 3 derniers chiffres
du code , qu'on prend ensuite en index de tableau)

or j'obtients : 4294966801 ???

bizarre ...

Citation:

---

Envoyé par dany9

euh .. désolé mais ça n'a pas l'air de fonctionner tel que tu propose emmanuel si j'ai ce bout de code :
<...>
or j'obtiens : 4294966801 ???

bizarre ...

---

Ben montre ton code, parce que :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

#include <stdio.h>   int main (void) { unsigned __int64 hash_code = 18446744072274528121ULL; unsigned HASH_TAILLE = 1000; unsigned index = (unsigned) (hash_code % HASH_TAILLE); printf ("index : %u\n", index);   return 0; }

---

donne :

Code:

---

1 2 3 4

index : 121   Press ENTER to continue.

---

avec MinGW32...

bonjour et merci pour ta demonstration emmanuel!
Bon , je ne peux pas montrer tout le code .. c'est un jeu d'échecs alors ...
Mais en fait je fais comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10

typedef struct ull __int64; #define HASH_TAILLE 1000 /*taille de la hash table*/ #define MAX_COUPS 500 /*nbre max de coups d'une partie*/   ull hash_code[MAX_COUPS+1]; /*hash code pour chaque coup joué*/   /*dans la fonction qui récupère l'index*/ unsigned index = (unsigned) (hash_code[nb_coups] % HASH_TAILLE); printf("index : %u\n",index);

---

Et ... je n'obtient pas 121 ... ? mais je viens de voir que tu as mis hash_taille en unsigned , moi c'est un define ... ? à cause de ça surement...

merci quand même ;)


edit :

bon grace a toi emmanuel j'ai trouvé une solution :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

typedef struct ull __int64; #define HASH_TAILLE 1000 /*taille de la hash table*/ #define MAX_COUPS 500 /*nbre max de coups d'une partie*/   ull hash_code[MAX_COUPS+1]; /*hash code pour chaque coup joué*/   /*dans la fonction qui récupère l'index*/ unsigned ull hash = hash_code[nb_coups]; unsigned index = (unsigned) (hash % HASH_TAILLE); printf("index : %u\n",index);

---

et là j'obtient le fameux 121 , cool merci encore !!

dois je mettre résolu ? ou atendre que tu lises manu ? ;)

Citation:

---

Envoyé par dany9

bonjour et merci pour ta demonstration emmanuel!
Bon , je ne peux pas montrer tout le code .. c'est un jeu d'échecs alors ...
Mais en fait je fais comme ça :

Code:

---

1 2 3 4 5 6 7 8 9 10

typedef struct ull __int64; #define HASH_TAILLE 1000 /*taille de la hash table*/ #define MAX_COUPS 500 /*nbre max de coups d'une partie*/   ull hash_code[MAX_COUPS+1]; /*hash code pour chaque coup joué*/   /*dans la fonction qui récupère l'index*/ unsigned index = (unsigned) (hash_code[nb_coups] % HASH_TAILLE); printf("index : %u\n",index);

---

Et ... je n'obtient pas 121 ... ? mais je viens de voir que tu as mis hash_taille en unsigned , moi c'est un define ... ? à cause de ça surement...

merci quand même ;)


edit :

bon grace a toi emmanuel j'ai trouvé une solution :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

typedef struct ull __int64; #define HASH_TAILLE 1000 /*taille de la hash table*/ #define MAX_COUPS 500 /*nbre max de coups d'une partie*/   ull hash_code[MAX_COUPS+1]; /*hash code pour chaque coup joué*/   /*dans la fonction qui récupère l'index*/ unsigned ull hash = hash_code[nb_coups]; unsigned index = (unsigned) (hash % HASH_TAILLE); printf("index : %u\n",index);

---

et là j'obtient le fameux 121 , cool merci encore !!

dois je mettre résolu ? ou atendre que tu lises manu ? ;)

---

Attention, ta définition de ull est.. fantaisiste...

Ca ne fonctionne pas chez moi. En fait, pour que le % fonctionne correctement, il faut que les 2 opérandes soient de type ull :

Code:

---

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

#include <stdio.h>   typedef __int64 ull; #define HASH_TAILLE 1000ull /*taille de la hash table */ #define MAX_COUPS 2 /*nbre max de coups d'une partie */   int main (void) { ull hash_code[MAX_COUPS + 1]; /*hash code pour chaque coup joué */ int nb_coups = 1;   hash_code[nb_coups] = 18446744072274528121ULL;   /*dans la fonction qui récupère l'index*/ { ull hash = hash_code[nb_coups]; printf (" hash : %I64u\n", hash); printf (" hash MOD HASH_TAILLE: %I64u\n", hash % HASH_TAILLE); { unsigned index = (unsigned) (hash % HASH_TAILLE); printf ("index : %u\n", index); } }   return 0; }

---

Code:

---

1 2 3 4 5 6

hash : 18446744072274528121 hash MOD HASH_TAILLE: 121 index : 121   Press ENTER to continue.

---

Maintenant, c'est OK.

Sous visual 2008 pas de problème avec ce code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

#include <stdio.h> #include <limits.h>   int main (void) { unsigned long long var1 = ULLONG_MAX; unsigned __int64 var2 = ULLONG_MAX; __int64 var3 = LLONG_MAX; printf ("%llu %llu %lld\n", var1, var2, var3); return 0; }

---

mais je ne sais pas si sous mingw ça passe : à voir.

bonsoir!

oui ... c'est sur emmanuel tu as raison : loufoque la definition de ull ... :mouarf:

je devais avoir bien la tête ailleurs;)
sinon c'est sur , bien expliqué c'est plus facile ! ton code marche et j'ai capté maintenant , merci à tous!

a bientot

dany