K8 : Systèmes d'Exploitations

Comme on peut s'en douter, il n'est pas, à l'heure actuelle, évident de tester une plate-forme comme le K8 d'AMD. Si le fonctionnement en 32 bits ne pose généralement, pas de problème grâce a la compatibilité parfaite du processeur avec les systèmes d'exploitation 32 bits, ce n'est pas le cas du mode 64 bits. A l'heure actuelle, à part une rarissime version alpha de Windows .NET x86-64, il n'existe que linux dont le kernel supporte le jeu d'instructions 64 bits d'AMD. D'autre part, après le système d'exploitation, il faut aussi que les applications soient portées puis compilées correctement pour tirer parti du x86-64.

Comme à l'heure actuelle, aucune application n'est portée pour les extensions 64 bits d'AMD, nous avons dû nous rabattre sur des tests 32 bits. Les tests 64 bits arriveront dans la deuxième partie de notre saga K8, quand les applications dédiées seront prêtes. Cependant, il fallait pouvoir tester sous Windows. Pour cela, nous avons utilisé les OS suivants : Windows .NET Server RC2, Windows "Longhorn" basé sur XP (Build 3617) et pour finir, une RedHat 7.3 avec les extensions x86-64.

I) Windows .NET 2003 RC2 :

Windows .NET est en fait le remplaçant de la famille Server de Windows 2000. Si tout va bien, Windows .NET devrait être disponible d'ici quelques mois. Cependant, il y a peu de chance qu'une version x86-64 sorte directement lors de l'annonce de ce nouveau système d'exploitation. Disponible actuellement en Beta RC2 (très proche de la version finale), nous avons installé le K8 d'AMD sur ce système. Contrairement à Windows 2000 et Windows XP, Windows .NET a reconnu immédiatement tous les composants de la carte mère, en particulier l'AMD 8151 et l'AMD 8111. Voyons ça :

Comme on le voit, la chaîne (erronée) "AMD Opteron(tm) Processor", inscrite par le BIOS dans le PSN du processeur au boot, revient bien dans le menu système. La fréquence est correctement détectée. Quant aux périphériques, tout est parfaitement identifié pour ce qui est du chipset AMD. Pour le VIA K8T400, l'installation des drivers Hyperion 4.45v suffit à faire reconnaître le chipset.

II) Windows Longhorn XP Alpha :

Une version Alpha de Windows Longhorn a filtré, il y a quelques semaines, des laboratoires de Microsoft. Ce nouveau système d'exploitation, qui devrait sortir en 2004, sera le successeur de Windows XP. Bien que le système soit extrêmement alpha, certaines rumeurs parlaient d'un possible support du jeu d'instructions x86-64 dans cette pré-version. Nous avons donc tenté l'expérience :

Malheureusement, si le système a reconnu tous les éléments de la carte mère sans trop de problèmes, on ne voit nulle part la présence du support 64 bits. A terme, Windows Longhorn ne pourra se permettre de ne pas supporter le processeur d'AMD, mais à l'heure actuelle, l'X86-64 ne semble pas géré. De même, vue la grande instabilité de cette version, nous avons choisi d'utiliser exclusivement Windows .NET RC2 pour les tests et autres benchmarks. A titre d'informations, on ne constate aucun écart de performances entre Windows .NET et Windows XP. Les résultats peuvent donc être considérés comme stables.

• Détection du Hammer

Petite annexe, certains se demanderont sûrement comment est détecté le nouveau processeur d'AMD actuellement par les différents logiciels de reconnaissance. Voyons pour commencer CPU-Z (modifié pour l'occasion) et wcpuid :

On le voit, aucun des deux logiciels ne parvient à détecter le coefficient ni la fréquence de base utilisée (7 x 200 dans notre cas). Selon Franck, ce n'est qu'une affaire de temps avant que CPUZ ne parviennent à identifier correctement les spécifications du nouveau processeur. Après ces deux logiciels, pourquoi pas un petit Sandra ? Bien que la version AA64 de Sandra ne soit pas encore disponible, la version actuelle nous donne quelques informations (mais guère plus que CPUZ) :

Il faudra probablement attendre quelques mois avant que tous ces logiciels de détection ne soient disponibles pour l'architecture K8 d'AMD et tous les contrôleurs qui gravitent autour.

III) Linux - RedHat 7.3 - x86-64

Seul système vraiment à même de supporter le jeu d'instructions 64 bits d'AMD à l'heure actuelle, Linux dispose d'un kernel adapté à l'Athlon 64 et à l'Opteron. Cependant, comme nous allons le voir, l'installation d'un tel noyau n'est pas une partie de plaisir. Pour notre test, nous nous sommes basés sur une Redhat 7.3. La majorité des informations et des téléchargements sur l'architecture x86-64 sous linux sont disponibles ici.

Pour installer un système capable de compiler et d'exécuter du code x86-64, il faut construire la toolchain. C'est a dire un ensemble de programmes permettant de compiler un kernel x86-64 et donc de faire fonctionner correctement l'OS. Après avoir consulté plusieurs pages de documentations parsemées ici et la, nous avons tenté l'expérience. Voici donc un mini-HOWTO de l'installation x86-64 sous linux à partir d'une RedHat 7.3 :

• Installation des BinUtils

Avant toute chose, il faut installer les BinUtils. Car avant de compiler des programmes évolués en C ou C++, il faut déjà pouvoir générer du code assembleur. Les binutils sont donc un package comprenant principalement l'assembleur GNU (x86-64 dans notre cas), le linker ASM ainsi que les utilitaires nécessaires à la compilation du code assembleur. On trouve la dernière version des binutils sur ftp://ftp.x86-64.org/pub/stable-tools/current/. Procédure d'installation :

$ cd /usr/src
$ wget ftp://ftp.x86-64.org/pub/stable-tools/current/binutils.tar.bz2
$ bunzip2 binutils.tar.bz2
$ tar xfv binutils.tar
$ cd binutils
$ ./configure --target=x86_64-unknown-linux --prefix=/opt/x86-64
$ make
$ make install

Normalement, tout devrait se passer sans problème. On passe donc à l'étape suivante : GCC.

• Installation de GCC x86-64 (1)

GCC est le compilateur C et C++ de Linux, c'est lui qui permet de compiler les programmes, en x86-64 dans notre cas. La réinstallation de GCC est une étape trés délicate. Voila comment procéder :

$ cd /usr/src
$ wget ftp://ftp.x86-64.org/pub/stable-tools/current/gcc.tar.bz2
$ bunzip2 gcc.tar.bz2
$ tar xfv gcc.tar
$ cd gcc
$ PATH=$PATH:/opt/x86-64/bin/
$ CFLAGS="-O2 -Dinhibit_libc" ../gcc/configure --target=x86_64-unknown-linux /
--prefix=/opt/x86-64 --enable-languages=c --disable-shared --disable-multilib /
--enable-threads=single
$ make
$ make install

Comme on le voit, on ne compile GCC que pour le support du C et pas du C++. En effet, il faut la GlibC appropriée pour pouvoir compiler le C++. Cependant, l'installation de la gcc nééessite les sources du Kernel de linux. Installons donc ces sources :

• Installation des sources de linux + dépendances

Avant toute chose, il faut préciser que les sources officielles de linux, disponibles sur kernel.org, doivent souvent être patchées avec un patch adapté qu'on trouve sur x86-64.org. Dans notre exemple, tout a fonctionné sans problème et sans patch. De même, après le kernel stable (2.4.20 au moment des tests), vous pourrez tenter l'installation d'un kernel Beta comme le 2.5.59 (toujours au moment des tests) qui supporte mieux les composants des cartes mères K8.

$ cd /usr/src
$ wget ftp://ftp.x86-64.org/pub/linux-x86_64/v2.4/linux-x86_64-24.20-1.tar.gz
$ bunzip2 linux-x86_64-2.4.20-1.tar.bz2
$ tar xfv linux-x86_64-2.4.20-1.tar
$ cd /usr/src/linux
$ make include/linux/version.h
$ cd /opt/x86-64/x86_64-unknown-linux
$ mkdir include
$ ln -s include sys-include
$ cd include
$ ln -s /usr/src/linux/include/linux linux
$ ln -s /usr/src/linux/include/asm-x86_64 asm
$ cd /opt/x86-64/bin
$ ln -s x86_64-unknown-linux-addr2line x86_64-linux-addr2line
$ ln -s x86_64-unknown-linux-ar x86_64-linux-ar
$ ln -s x86_64-unknown-linux-as x86_64-linux-as
$ ln -s x86_64-unknown-linux-c++ x86_64-linux-c++
$ ln -s x86_64-unknown-linux-c++filt x86_64-linux-c++filt
$ ln -s x86_64-unknown-linux-cpp x86_64-linux-cpp
$ ln -s x86_64-unknown-linux-g++ x86_64-linux-g++
$ ln -s x86_64-unknown-linux-gcc x86_64-linux-gcc
$ ln -s x86_64-unknown-linux-gccbug x86_64-linux-gccbug
$ ln -s x86_64-unknown-linux-gcov x86_64-linux-gcov
$ ln -s x86_64-unknown-linux-ld x86_64-linux-ld
$ ln -s x86_64-unknown-linux-nm x86_64-linux-nm
$ ln -s x86_64-unknown-linux-objcopy x86_64-linux-objcopy
$ ln -s x86_64-unknown-linux-objdump x86_64-linux-objdump
$ ln -s x86_64-unknown-linux-ranlib x86_64-linux-ranlib
$ ln -s x86_64-unknown-linux-readelf x86_64-linux-readelf
$ ln -s x86_64-unknown-linux-size x86_64-linux-size
$ ln -s x86_64-unknown-linux-strings x86_64-linux-strings
$ ln -s x86_64-unknown-linux-strip x86_64-linux-strip

On peut ensuite passer à l'installation de la Glibc :

• Installation de GLibc

La GlibC est un ensemble de librairies indispensable pour compiler du C++. Son installation est elle aussi très délicate au vu des nombreux liens symboliques indispensables. Procédons :

$ cd /usr/src
$ wget ftp://ftp.x86-64.org/pub/stable-tools/current/glibc.tar.bz2
$ bunzip2 glibc.tar.bz2
$ tar xfv glibc.tar
$ cd glibc
$ CC=/opt/x86-64/bin/x86_64-unknown-linux-gcc ../glibc/configure /
--disable-profile --prefix=/opt/x86-64/x86_64-unknown-linux -without-cvs /
--enable-add-ons x86_64-unknown-linux
$ make
$ make install

De même, tout devrait se passer sans problème. Une fois la GlibC installée, on peut compiler de nouveau GCC avec, cette fois, le support C++ :

• Installation de GCC x86-64 (2)

Procédons à la deuxième installation (finale) de GCC avec le support C++. Il n'est pas conseillé ici d'ajouter le support pour d'autres languages comme Fortran ou Java :

$ cd /usr/src/gcc
$ ./configure --target=x86_64-unknown-linux --prefix=/opt/x86-64 /
--enable-languages=c,c++ --enable-threads=posix --disable-multilib
$ ln -s /usr/src/gcc/include /usr/src/gcc/x86_64-unknown-linux/include
$ make
$ make install

C'est fini !

Il reste ensuite à compiler le kernel en spécifiant bien une architecture de type "Athlon64/Opteron/K8/Hammer". On peut ensuite tenter de booter sur le nouveau noyau. Dans notre cas, le 2.4.20 plantait sur la détection de l'APIC, mais le 2.5.59 n'a pas eu ce problème et tout a directement fonctionné du premier coup :

Suite ( K8 : Architecture matérielle )