Compréhension globale ordinateur

[saturn1]

Bonjour je souhaite savoir si j'ai une bonne vision globale :

Beaucoup de développeurs utilisent des langages de hauts niveau.(java,php,python..)
Ces langages sont eux même écrit en assembleur.
L'assembleur est un moyen mnémotechnique qui associe le binaire à des mots parlant.

La je ne suis plus trop sur :
Le binaire donne des ordres au matériel physique.


Voilà pouvez vous m'en dire plus, ou me donnez des lecture sur le fonctionnement global (lecture courte si possible ,pas envie de me farcir 400 pages.. :/)

Merci !!

[Nightfall]

Non les langages de haut niveau sont écrits en utilisant d'autres langages, probablement le plus souvent en C. Même s'il est possible, quand nécessaire, de mixer C et assembleur.

Un langage est composé il me semble essentiellement d'un analyseur syntaxique qui ... analyse la syntaxe et d'un compilateur pour les langages compilés ou d'un interpréteur pour les langages interprétés.

Un compilateur compile le programme source soit, pour les langages natifs, dans un fichier binaire directement exécutable par le microprocesseur, soit pour les langages managés (langages .net, java), dans un fichier qui doit être exécuté par un autre programme.

Un interpréteur exécute les instructions ligne par ligne.

OK par contre pour ta définition de l'assembleur.

Effectivement le binaire donne des ordres au matériel.

Il faut raisonner en couches : matériel (dont le processeur qui a son jeu d'instructions) et périphériques (qui ont besoin de pilotes), système d'exploitation (windows, linux, ...), applications.

Les applications écrites par les programmeurs utilisent massivement les fonctions du système d'exploitation, soit de façon explicite (appel des fonctions de windows par exemple) soit indirectement par l'intermédiaire du langage. Le plus souvent c'est indirectement.

Le système d'exploitation gère la mémoire, l'exécution des programmes, l'accès aux périphériques, bref il fait tout !

[saturn1]

merci !!
d'autres réponses sont les bienvenues .... !!

[ymoreau]

J'avais eu un cours là dessus où on partait de simple composant logiques (électroniques en fait, mais tout ça sur papier théorique) et on apprenait à les assembler pour obtenir les composants de base d'un ordinateur. Sans jamais s'intéresser à l'aspect technique/réalisation-électronique seulement à la logique.

Je n'ai eu ce cours que sur papier par contre. Ce cours a l'air de s'en approcher (bon par contre prépare toi à de la lecture, mais ça reste une culture générale informatique intéressante).
http://www.labri.fr/perso/vincent/Enseignement/SdO/

A la fin on voyait comment le processeur lisait un programme assembleur et faisait le lien entre les instructions du code et le code associé du processeur (le code le plus bas niveau).

[Barsy]

En fait, le C est du "simili-assembleur". C'est à dire que chaque instruction en C correspond à un ensemble d'instructions en assembleur. Il y a d'ailleurs un compilateur C par famille de microprocesseur (l'assembleur n'est pas le même d'un µP à l'autre).

C'est pour ça qu'aujourd'hui par exemple, les développeurs "matériels" ne codent pas en assembleur mais en C et que les langages de "haut-niveau" sont développés en C.

Sinon, l'assembleur est tout simplement une suite d'instruction binaires interprétées par le µP.

Par exemple, l'instruction "LOAD R1 0x1234" peut signifier que le µP va charger la valeur situé à la position 0x1234 de la mémoire vive et va la ranger dans le registre R1 (zone de mémoire à l'intérieur du µP). En binaire, cette instruction pourrait correspondre à 01011011 00000001 0001001000110100 ou le premier bloc '01011011' serait la valeur binaire de l'instruction LOAD, le bloc '00000001' correspondrait au registre R1 et '0001001000110100' serait équivalent à l'adresse 0x1234 de la mémoire vive.

Ensuite on peut faire l'instruction "ADD R1 0x1235" qui signifierai qu'on additionne la valeur située dans le registre R1 avec la valeur situé à l'adresse 0x1235 de la mémoire vive. et enfin, on peut aller ranger le résultat dans 0x1236 en faisant par exemple "COPY 0x1236 R1"

Résultat, quand tu écris "c = a + b" en C, ça correspondrait aux trois instructions ci-dessus en assembleur (bien entendu dans mon cas, il s'agit d'un assembleur imaginaire)

En espérant avoir été assez clair, j'ai tenté de simplifier au maximum.

[lilington]

et bien je comprend pour quoi tu mets mac gyver comme image....lol.
je pense que ton explication est tres simple meme.

[Elverion]

Petites informations complémentaires.

Personnellement, quand j'ai appris l'assembleur et le C, je me suis dit "C'est bête, pourquoi ne pas avoir un assembleur pour tous les processeurs?
Ça nous permettrait d'écrire des programmes en assembleur (super rapide) qui fonctionnerait partout!!

J'en ai parlé avec mon professeur d'architecture, et il m'a expliqué pourquoi ce n'était pas possible.

Les processeurs ne prennent pas forcément le binaire dans le même sens.
On a les processeur "Big endian" et les "Little endian". Je m'explique.

Si on prend un chiffre binaire simple : 100 (4 en décimal).
Le processeur en Little endian considère que le bit de poids faible est à la fin.
Il lit donc 4.
Le processeur en Big endian considère que le bit de poids fort est à la fin.
Il lit donc 1.

Alors avec cette différences, les processeurs en 64 ou 32 bits (l'assembleur ainsi que les noms de registres changent), les processeurs à jeu d'instruction réduit ... ya de quoi en devenir maboule

[Barsy]

On nous disait aussi que c'est parce qu'intel et motorola se faisaient concurrence et que dès que l'un choisissait une solution, l'autre prenait la solution inverse.

D'autre part, chaque processeur ne répond pas forcément au même besoin. Certains sont plus optimisés pour effectuer certains calculs. Par exemple, les DSP (processeurs pour le traitement du signal) arrivent à faire en 1 ou 2 coups d'horloges ce qu'un processeur classique met plusieurs dizaines de coup d'horloge à faire.

[Elverion]

Et tout ça pour des processeurs qui font des erreurs en plus !!

La preuve: exécutez le code C suivant dans un main:

Code :

1
2
3
4
5
for(i=0;i!=1;i=i+0.1)
{
        printf("J'en suis au tour numero %d", i);
}

Si je ne me trompe pas, cette boucle ne s'arrêtera jamais

Explication: le chiffre 0.1 n'est pas fini en binaire, il sera donc tronqué et ne sera JAMAIS égale a précisément 0.1.
La variable i n'arrivera donc jamais a exactement 10 et ne s'arrêtera donc jamais

[muad'dib]

Je n'ai pas testé mais je pense que si tu définis i en tant que float le problème n'en sera pas un (d'oú l'introduction des nombres à virgule flottante dans les langages de programmation, les opérations effectuées au niveau binaire ne sont pas tout à fait les mêmes).
Il est possible de réaliser des opérations sur des nombres à virgule flottante d'ailleurs les processeurs (ouhla mes cours sont loins je vais peut-être dire des bêtises) RISC possèdent une unité spéciale pour cela, la FPU (Floating Point Unit)

[BainE]

Envoyé par Elverion

Et tout ça pour des processeurs qui font des erreurs en plus !!

La preuve: exécutez le code C suivant dans un main:

Code :

si i est un int
i = i + 0.1 vaudra toujours 0, on est pas pret de s arreter.

si c est un float
un petit cast
for( i = 0.; (int)i != 1 ; i = i + 0.1)
fait l affaire.

Dire c est une erreur, ca vient surtout du fait que la valeur codée du float est interprété avant d en afficher une "approximation, un arrondi".

[Elverion]

Exactement, il faut faire un cast pour que ça marche, sinon on boucle en infini.
Tout ça parce que les nombres a virgules peuvent être infini en binaire IEEE754

[sovitec]

Euh, on, le cast ne marche pas vraiment non plus, car la boucle va s'arrêter dès que i vaudra 0.5 (arrondi à 1).

[Elverion]

Envoyé par sovitec

Euh, on, le cast ne marche pas vraiment non plus, car la boucle va s'arrêter dès que i vaudra 0.5 (arrondi à 1).

C'est vrai.
Honte sur moi!!!

[Farid63]

Je me pose moi aussi quelques questions.

J'ai lu que plus le langage est de bas niveau, moins il y a d'instructions et plus elles sont simple (additionner, déplacer...), (Je ne connais absolument pas l'assembleur).

Dans ce cas, apprendre un langage d'assemblage (je crois que c'est le terme à utiliser et non pas assembleur) devrait être plus facile à apprendre que le C (je dit bien apprendre parce qu'après faire des super programmes avec les instructions additionner et déplacer forcément ça doit pas être simple...)?

Maintenant comme chaque instructions de tout langage confondus est traduits après plusieurs étapes en langage binaire, comment est-il possible d'afficher des fenêtres dans lesquels on a un personnage en 3D qu'on arrive à déplacer juste avec des instructions aussi simple?

Je commence tout juste la lecture d'un livre sur l'architecture de l'ordinateur et j'aimerai vraiment comprendre comment tout cela marche.

Merci.

[Barsy]

J'ai lu que plus le langage est de bas niveau, moins il y a d'instructions et plus elles sont simple (additionner, déplacer...), (Je ne connais absolument pas l'assembleur).

Dans ce cas, apprendre un langage d'assemblage (je crois que c'est le terme à utiliser et non pas assembleur) devrait être plus facile à apprendre que le C (je dit bien apprendre parce qu'après faire des super programmes avec les instructions additionner et déplacer forcément ça doit pas être simple...)?

En fait, la grosse difficulté quand on développe en assembleur, c'est qu'il faut bien connaître le matériel sur lequel on se trouve. Les instructions ne consistent pas juste à faire a+b pour une addition. Comme je l'ai dit dans mon premier message ici, pour additionner deux valeurs, il faut d'abord aller les chercher en mémoire pour les stocker dans des registres, les additionner puis renvoyer le résultat en mémoire. Et tout cela sans se tromper sur l'adresse des valeur (parce qu'en assembleur, il n'y a pas de nom au variable).

Et puis les boucle et les conditions nécessitent la mise en place de flag. Il n'y a pas de while, de for ou de if en assembleur, c'est que du JUMP (similaire au GOTO).

Bref, le C, par le fait qu'il possède plus d'instructions simplifie le développement.

Maintenant comme chaque instructions de tout langage confondus est traduits après plusieurs étapes en langage binaire, comment est-il possible d'afficher des fenêtres dans lesquels on a un personnage en 3D qu'on arrive à déplacer juste avec des instructions aussi simple?

Il n'y a pas de magie. Tout ne s'est pas fait d'un coup. Au début, on effectuait juste des calculs de base avec les premiers ordinateurs et au fur et à mesure, on a développé des briques qui petits à petit ont conduit au résultat que l'on a dans les logiciels modernes. Les développeurs aujourd'hui ne développent plus en assembleur. Ils se servent d'un existant qui s'enrichit de plus en plus.