Identifier les propriétés de CPUs

Version imprimable

26/04/2007, 23h33
Charlemagne

Identifier les propriétés de CPUs
Pour qu'un programme puisse s'adapter automatiquement au processeur de la machine sur laquelle il tourne, il me faut identifier les propriétés du processeur.

J'ai fait un petit programme de test pour cela. Vous le trouverez ci-joint et ça serait sympa si quelques uns pouvaient l'essayer sur leur processeur respectif sous Windows: en particulier les processeurs récents (Intel Core 2 Duo...) et les AMDs.

A titre d'exemple voici ce que ça donne sur mon "vieux" P4 2.6GHz HT
Code:

1 2 3 4 5 6 7 8 9 10 amd 0 mmx 1 sse 1 sse2 1 sse3 0 3dnow 0 multithreaded 1 logical cpu 2 L1 cache 1 L2 cache 1
26/04/2007, 23h41
Laurent Gomila
Voilà ce que ça donne sur mon Athlon 64 X2 DualCore 3800+ :
Code:

1 2 3 4 5 6 7 8 9 10 amd 0 mmx 0 sse 0 sse2 0 sse3 0 3dnow 0 multithreaded 0 logical cpu 1 L1 cache 1 L2 cache 1
C'est pas encore tout à fait au point ;)

Si tu veux une référence, j'ai croisé récemment un bout de code qui faisait ça, dans le code source de la SDL (fichier SDL_cpuinfo.c). Les sources sont dispo sur le site officiel.
26/04/2007, 23h54
Charlemagne

Merci
De toute évidence, ça marche pas vraiment avec les AMDs. Même pas la toute première fonction qui est pourtant sensée en reconnaître un!

Tu peux me donner un lien sur le code que tu proposes S'il-te-plaît, que je puisse l'examiner. Si tu ne l'as plus, je tacherai de le retrouver grâce à Google.

J'ai trouvé un fichier 'SDL_cpuinfo.c' sur internet, à toute première vue, il ne tient pas compte des processeurs AMD.

Sinon voici mes sources, si tu veux bien les compiler et debugger pour voir ce qui ne va pas sur ton AMD...

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
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
#ifndef CPUID_H
#define CPUID_H
 
struct cpuid_reg { unsigned int eax,ebx,ecx,edx; };
 
#if defined(__ICL) || defined(_MSC_VER)
#include <windows.h>
inline cpuid_reg _cpuid(unsigned int a, unsigned int c=0)
{
  cpuid_reg r;
  __try 
  {
    _asm  
    {
      mov eax, a
      mov ecx, c
      cpuid
      mov r.eax, eax
      mov r.ebx, ebx
      mov r.ecx, ecx
      mov r.edx, edx
    }
  } __except (EXCEPTION_EXECUTE_HANDLER) { r.eax=r.ebx=r.ecx=r.edx=0; }
  return r;
}
#elif defined(__GNUC__)
inline cpuid_reg _cpuid(unsigned int a, unsigned int c=0)
{
  cpuid_reg r;
  __asm__("cpuid":"=a"(r.eax),"=b"(r.ebx),"=c" (r.ecx),"=d"(r.edx):"a"(a),"c"(c));
  return r;
}
#endif
 
inline cpuid_reg cpuid(unsigned int a, unsigned int c=0)
{
  if (a<_cpuid(0).eax) 
    return _cpuid(a,c);
  cpuid_reg r={0,0,0,0};
  return r;
}
 
 
static char _cpu_name[13];
char *cpu_name() { cpuid_reg reg = cpuid(0); (unsigned int&)_cpu_name[0] = reg.ebx; (unsigned int&)_cpu_name[4] = reg.edx; (unsigned int&)_cpu_name[8] = reg.ecx; _cpu_name[12]='\0'; return _cpu_name; }
 
 
bool is_mmx_cpu          () { return (cpuid(1).edx & 0x00800000); }
bool is_sse_cpu          () { return (cpuid(1).edx & 0x02000000); }
bool is_sse2_cpu         () { return (cpuid(1).edx & 0x04000000); }
bool is_sse3_cpu         () { return (cpuid(1).ecx & 0x00000001); }
bool is_multithreaded_cpu() { return (cpuid(1).edx & 0x10000000); }
unsigned int logical_cpu_count() { return is_multithreaded_cpu()?(cpuid(1).ebx>>16)&0xFF:1; }
 
bool is_amd_cpu          () { return (cpuid(0x80000000).eax==0x80000000); }
bool is_3dnow_cpu        () { return (cpuid(0x80000001).edx & 0x80000000); }
 
unsigned int l1_cache_size() { cpuid_reg reg = cpuid(4,1); return (((reg.ebx>>22)&0x3FF)+1)*(((reg.ebx>>12)&0x3FF)+1)*((reg.ebx&0xFFF)+1)*(reg.ecx+1); }
unsigned int l2_cache_size() { cpuid_reg reg = cpuid(4,2); return (((reg.ebx>>22)&0x3FF)+1)*(((reg.ebx>>12)&0x3FF)+1)*((reg.ebx&0xFFF)+1)*(reg.ecx+1); }
 
#endif

Essaye peut-être en premier lieu de commenter la ligne

Code:

if (a<_cpuid(0).eax)

J'ai recompilé sans cette ligne:

27/04/2007, 07h36
Laurent Gomila
Voilà les nouveaux résultats :
Code:

1 2 3 4 5 6 7 8 9 10 amd 0 mmx 1 sse 1 sse2 1 sse3 1 3dnow 1 multithreaded 1 logical cpu 2 L1 cache 1 L2 cache 1
C'est mieux mais pas encore correct à 100% (a priori il reste le flag amd qui est incorrect, le reste est bon).

Je viens de trouver le logiciel gratuit AMD CPUID qui donne les informations sur le CPU, je pense qu'il peut t'aider : il donne toutes les constantes, registres et bits correspondant à chaque fonctionnalité (pour processeurs AMD tout du moins).
27/04/2007, 09h02
Charlemagne

Le problème c'est que les instructions d'identification ne sont pas compatibles entre Intel et AMD. Je le savais, mais je pensais connaître suffisamment de différence.

Le petit programme AMD_CPUID corrobore mes résultats sur mon CPU.
Tu pourrais me donner les résultats de ce programme sur le tien s'il-te-plait.
Développe toutes les arborescences. Fais peut-être une ou deux captures d'écran car c'est sûrement fastidieux de tout recopier.

En fait les 2 dernières lignes de mon programme sont sensées donner la taille des mémoires caches. Mais il faut pour cela que le niveau 4 de cpuid soit implémenté dans le CPU.

Et certes la 2ème version compilée marche mieux sur un AMD, mais j'ai supprimé un test de validité qu'il vaudrait mieux remettre. j'espère pouvoir corriger ça grâce a tes données.
27/04/2007, 10h31
Charlemagne

J'ai fait quelques modifs, j'espère que ça marchera maintenant sur un AMD.

Ca serait bien si d'autres personnes pouvaient l'essayer sur tout processeur sous Windows. (il faut exécuter le programme dans la fenêtre DOS, sinon on n'a pas le temps de voir l'affichage)
27/04/2007, 10h36
Laurent Gomila
Voilà les résultats de CPUID sur mon processeur :
http://loulou.developpez.com/CPUID_A...2_DualCore.pdf

Et les résultats avec la nouvelle version :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 name AuthenticAMD intel 0 amd 1 mmx 1 sse 1 sse2 1 sse3 1 3dnow 1 logical processor count 2 L1 cache 1 L2 cache 1
Ca a l'air bon cette fois ;)

Merci Laurent, ça m'aide bien.
Même si je ne compte pas exploiter tous les bits...

Voici une nouvelle version, avec quelques fonctions supplémentaires.
Je me répète, mais si quelqu'un pouvait le tester avec d'autres processeurs, ça serait sympa.

Voici par exemple ce que j'obtiens avec mon vieux P4 HT 2.6GHz:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 name Intel(R) Pentium(R) 4 CPU 2.60GHz vendor GenuineIntel intel 1 amd 0 mmx 1 sse 1 sse2 1 sse3 0 3dnow 0 physical core count 1 logical processor count 2 L1 cache size 1 L2 cache size 1

Athlon 1200 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
name  	AMD Athlon(tm) Processor
vendor	AuthenticAMD
intel 	0
amd   	1
mmx   	1
sse   	0
sse2  	0
sse3  	0
3dnow 	1
 
physical core count    	1
logical processor count	1
L1 cache size          	1
L2 cache size          	1

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
name                  Intel(R) Pentium(R) 4 CPU 2.40GHz
vendor  GenuineIntel
intel   1
amd     0
mmx     1
sse     1
sse2    1
sse3    0
3dnow   0
 
physical core count     1
logical processor count 1
L1 cache size           1
L2 cache size           1

Avec ce qui a bien été détecté !!! ;)

Merci
L'idéal serait maintenant de tester encore avec un "Core 2 Duo" (entre autres pour le calcul de la taille des caches)

Pour ceux que ça intéresse voici mes sources. Vous pouvez me faire vos commentaire. Certes ça aurait pu être "plus optimisé", mais j'ai voulu restreindre le code assembleur au strict minimum.

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
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
63
64
65
66
67
68
69
70
71
72
73
74
#ifndef CPUID_H
#define CPUID_H
 
#include <string.h>
 
struct cpuid_reg { unsigned int eax,ebx,ecx,edx; };
 
#if defined(__ICL) || defined(_MSC_VER)
#include <windows.h>
inline cpuid_reg _cpuid(unsigned int a, unsigned int c=0)
{
  cpuid_reg r;
  __try 
  {
    _asm  
    {
      mov eax, a
      mov ecx, c
      cpuid
      mov r.eax, eax
      mov r.ebx, ebx
      mov r.ecx, ecx
      mov r.edx, edx
    }
  } __except (EXCEPTION_EXECUTE_HANDLER) { r.eax=r.ebx=r.ecx=r.edx=0; }
  return r;
}
#elif defined(__GNUC__)
inline cpuid_reg _cpuid(unsigned int a, unsigned int c=0)
{
  cpuid_reg r;
  __asm__("cpuid":"=a"(r.eax),"=b"(r.ebx),"=c" (r.ecx),"=d"(r.edx):"a"(a),"c"(c));
  return r;
}
#endif
 
inline cpuid_reg cpuid(unsigned int a, unsigned int c=0)
{
  if (a<=_cpuid(0).eax) 
    return _cpuid(a,c);
  cpuid_reg r={0,0,0,0};
  return r;
}
 
inline cpuid_reg cpuid_ext(unsigned int a, unsigned int c=0)
{
  a|=0x80000000;
  if (a<=_cpuid(0x80000000).eax) 
    return _cpuid(a,c);
  cpuid_reg r={0,0,0,0};
  return r;
}
 
static char _cpu_vendor[13];
static char _cpu_name[48];
char *cpu_vendor() { unsigned int *p=(unsigned int *)_cpu_vendor; cpuid_reg reg=cpuid(0); p[0]=reg.ebx; p[1]=reg.edx; p[2]=reg.ecx; _cpu_vendor[12]='\0'; return _cpu_vendor; }
char *cpu_name  () { unsigned int *p=(unsigned int *)_cpu_name; cpuid_reg reg; reg=cpuid_ext(2); p[0]=reg.eax; p[1]=reg.ebx; p[2]=reg.ecx;  p[3]=reg.edx; reg=cpuid_ext(3); p[4]=reg.eax; p[5]=reg.ebx; p[6]=reg.ecx;  p[7]=reg.edx; reg=cpuid_ext(4); p[8]=reg.eax; p[9]=reg.ebx; p[10]=reg.ecx;  p[11]=reg.edx; return _cpu_name; }
bool is_intel_cpu() { return strcmp(cpu_vendor(),"GenuineIntel")==0; }
bool is_amd_cpu  () { return strcmp(cpu_vendor(),"AuthenticAMD")==0; }
bool is_mmx_cpu  () { return (cpuid(1).edx & 0x00800000); }
bool is_sse_cpu  () { return (cpuid(1).edx & 0x02000000); }
bool is_sse2_cpu () { return (cpuid(1).edx & 0x04000000); }
bool is_sse3_cpu () { return (cpuid(1).ecx & 0x00000001); }
 
bool is_3dnow_cpu() { return (cpuid_ext(1).edx & 0x80000000); }
 
unsigned int physical_core_count    () { return ((cpuid(4,0).eax>>26)&0x03F)+1; }
unsigned int l1_thread_count        () { return ((cpuid(4,1).eax>>14)&0xFFF)+1; }
unsigned int l2_thread_count        () { return ((cpuid(4,2).eax>>14)&0xFFF)+1; }
unsigned int logical_processor_count() { cpuid_reg reg = cpuid(1  ); return (reg.edx&0x10000000)?(reg.ebx>>16)&0xFF:1; }
unsigned int l1_cache_size          () { cpuid_reg reg = cpuid(4,1); return (((reg.ebx>>22)&0x3FF)+1)*(((reg.ebx>>12)&0x3FF)+1)*((reg.ebx&0xFFF)+1)*(reg.ecx+1); }
unsigned int l2_cache_size          () { cpuid_reg reg = cpuid(4,2); return (((reg.ebx>>22)&0x3FF)+1)*(((reg.ebx>>12)&0x3FF)+1)*((reg.ebx&0xFFF)+1)*(reg.ecx+1); }
 
#endif