viviNeutron a écrit 18 commentaires

mais openGl utilise la libX pour communiquer avec le serveur X ?

merci beaucoup pour tes réponses, j'ai compris

sur les processeurs risc, quand on fait un add eax, [bp -0x1] comment ca se passe ? cette instruction fait au moins plus de 32 bits donc il faut au moins deux cycles d'horloges pour que les portes logiques du CPU fassent leurs travail pour exécuter cette instruction ?

qu'est ce que tu appelles le coeur d'un processeur ?

car apparemment la taille d'une instruction peut dépasser la taille du bus de données

@chimrod, non je n'en suis pas sur du tout. il me semblait que la soustraction d'un nombre binaire se faisait via le complément A2, donc j'imagine que la procédure pour un sub est not + inc + add.

Justement j'aimerai savoir combien de cycle d'horloge dure un sub, mais je ne connais aucun moyen expérimental pour savoir le nombre de cycle d'horloge pour réaliser une opérande particuliere

ca me dit juste que la limite est calculé par rapport à la formule dans /proc/sys/vm/overcommit_memory, or dans ce fichier je n'ai que le caractere 0.

Il me dit également d'aller voir dans Documentation/vm/overcommit-accounting mais ce fichier n'existe pas :(

je suis sur Ubuntu.

merci pour ta réponse.

Je n'ai pas compris pour le framebuffer. c'est quoi ?

Merci beaucoup pour vos réponses. J'ai une derniere question, quand je fais strace ./a.out j'ai ceci qui apparait :

openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\260\34\2\0\0\0\0\0"…, 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, …}) = 0
mmap(NULL, 4131552, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fb8a349b000

ce que je ne comprend pas, c'est pourquoi placer les 832 premiers octets de la libc sur un pointeur (via read) pour ensuite mettre les premiers 4Mo de la libc en RAM (via mmap)?

merci de ta réponse.

Il me semblait tout de meme que pour minimiser l'espace mémoire de la RAM le noyau ne chargeait pas forcément tout le binaire, cela permet notamment a ce que des binaires qui dépassent la taille de la RAM puissent etre tout de meme lancé. Et lors d'une faute de page le noyau pouvait récupérer la partie du binaire manquant et la charger en RAM. c'est pourquoi le noyau verrouille les binaires.

mais que se passe t'il si je fais tout de meme un malloc ? et pourquoi ce n'est pas safe?

Merci beaucoup Renault pour ta réponse tres complete qui répond parfaitement à ma question.

Une derniere chose. Lors d'un Segfault, est ce que dans mon gestionnaire je peux utiliser la fonction malloc() ou ce n'est pas possible car il y a eu un segfault ?

Merci d'avance pour ta réponse

ok c'est plus clair maintenant, merci beaucoup pour vos réponses :)

pour vous il y a donc 2 buffers différents lors de la lecture et de l'écriture, ce qui me semble logique. Mais lorqu'on utilise les appels systemes read et write on donne le meme file descriptor en argument, c'est ca qui me gene

du coup a quoi sert ces pseudos fichiers ? c'est principalement pour débugger ?

merci beaucoup pour vos réponses, c'est beaucoup plus clair maintenant :)

ok je ne savais pas que les processeurs étaient en quelques sorte connectés entre eux, je pensais qu'ils faisaient leurs vies chacun de leurs cotés.

Donc si j'ai bien compris, des qu'il y a une instruction test_and_set fait par un processeur, tous les processeurs sont au courant, en gros c'est ca ?

non ca ne peut pas être le processeur qui s'occupe de ca car sur un système multi coeur il n'y a aucun moyen de vérifier que deux threads lancent l'instruction test_and_set

"il faut assurer l'atomicité de cette opération particulière vis-à-vis de la mémoire entre les différents cœurs."

ok mais qui gere cette opération ?