Pb en Asm x86 - Page 2

vala il est mieux la

meercii bcp

ouaf par contre y a un bug c tjrs de moi le dernier post dans divers

attend j'avais une adresse sur ça le temps que je la trouve

euh, Orion, juste un truc... dans ton zip de nasm 0.98, y a pas le linker non?
je dl lequel?

ah, ok, dc nasm le compile direct en .com... okokok

et, euh... y a pas de readme... y a une syntaxe spéciale?

g mis:

Nasm test.asm

y a des options qquonques?

g rien dit... nasm -h

bon g renommé ma source en test.com.asm y a pas une méthode moin barbar pour ke le compilo recrache test.com?

ba pkoi c pas si évident que ça...

certes, certes ...

eeh, c ma formule ça! 'culé ©sBibi

Concernant la vitesse d'exécution des instructions sur les processeurs x86 :

la première chose est que les temps d'exécution et leur calcul varient énormément suivant la génération du processeur (386, 486 ou Pentium). D'autre part, le nombre de cycles d'une instruction ne renseigne en aucun cas sur le temps qu'il faut pour aller chercher le code en mémoire, sur la génération des adresses, etc...

Sur les processeurs Pentium, en gros, la plupart des instructions "simples" (de la forme mov reg, [...] ou mov [...], reg ou mov reg,reg , ainsi que les instructions arithmétiques de base prennent 1 cycle). Le calcul est compliqué par le fait que le Pentium peut exécuter plus d'une instruction par cycle (le Pentium est en effet un processeur super-scalaire).

D'où la nécessité d'apprendre les règles d'optimisation pour obtenir un code rapide.

Concernant l'optimisation : la plupart du temps, il est plutôt nécessaire d'optimiser la taille du code que sa vitesse d'exécution... le programme sera plus léger et plus rapide à charger. Dans les boucles critiques et les portions souvent exécutée, ça vaut la peine de compter les cycles à la main...

Concernant mov ax,0 ou xor ax,ax : les deux prennent 1 cycle. Le seul avantage de xor ax,ax (ou encore plus de xor eax,eax) est sa taille, avantage non négligeable.

ué, ok, pour l'optimisation du pentium j'av lu des trucs dessus, ac le pipeline U et V, par exemple pour une fmul, qu'on peu exécuter d'autres instructions pendant l'exécution de la multiplication... ou fdiv, je c plus, ou les deux... enfin bref...
ce que je voudrais c un document ou on trouve tt ça...
si y a pas, ben je me contenterai du black book... (koike y a déjà pas mal de trucs )

J'ai pas trop regardé ton code d'écriture de chaînes, mais d'après ce que tu dis tu écris à l'écran en appellant une fonction du BIOS pour chaque caractère ?
Il me semble bien que l'on peut écrire directement dans la mémoire vidéo, et c'est carrément plus rapide !!

c clur

Pour des docs, tu as toujours le site d'Intel ou les sites Web sur la prog. assembleur... mais dans tous les cas, rien ne devrait t'épargner à mesurer la vitesse de ton code, on peut avoir des surprises...

bah... ça je mesurerai :]
mais le comptage des cycles c'est inévitable...
même si t'optimise avec les 2 pipelines du proc...
fin bon, si c vrai que quasiment tout fait 1 cycle...

Le comptage de cycles sur pEntium, c'est la mort

a bon

ouarf !

ouarf ! ouarf !

uééééé
g fé ma routine d'affichage de nombres
(la joie du niouby )
nempêche c bizzard la division sur x86 comparé à l'asm 68k

        org 100h

start: jmp debut
mess1 db 'bonjour, comment allez-vous?',10,13,'$'
mess2 db 'L'asm x86 c cool :DD...',10,13,'$'        ;doit faire bip
msg_13h db 'ce message est ecrit en mode 13h',10,13,'le mode graphique 320*200 (je crois) du VGA',10,13,'$'
msg_12h db 'ce message est ecrit en mode 12h',10,13,'le mode graphique 800*600 (je crois) du VGA',10,13,'$'
msg_10h db 'ce message est ecrit en mode 10h',10,13,'le mode graphique 800*400 (sous réserve, en fait j'en sais rien :D) du VGA',10,13,'$'

writem:
       mov ah,09
       int 21h
       ret
set_13h_mode
       mov ax,13h
       int 10h
       ret
set_10h_mode
       mov ax,10h
       int 10h
       ret
set_12h_mode
       mov ax,12h
       int 10h
       ret
;===============================
write_number
       mov cx,0
       mov bx,10
unwise_loop
       mov dx,0
       div bx
       push dx
       inc cx
       cmp ax,0
       jnz unwise_loop
       mov ah,2
write_loop
       pop dx
       add dl,48
       int 21h
       loop write_loop
       ret
;===============================
debut: mov dx,mess1
       call writem
       mov dx,mess2
       call writem
       xor ax,ax
       int 16h
       call set_13h_mode
       mov dx,msg_13h
       call writem
       xor ax,ax
       int 16h
       call set_10h_mode
       mov dx,msg_10h
       call writem
       xor ax,ax
       int 16h
       call set_12h_mode
       mov dx,msg_10h
       call writem
       mov ax,18340
       call write_number
       xor ax,ax
       int 16h
       int 20h

bon, je sais, c'est codé comme une merde... ms bon, c mon premier prog autre que le "hello world" en asm x86

Orion : c'est quoi l'intérêt de coder en assembleur si tu n'en profites pas pour faire des trucs rapides ?
Quant à ton problème de position du curseur, si tu n'y arrives pas, laisse tomber la prog, parceque c'est vraiment d'une simplicité...