Executer 2 action en meme temps

Question

Bonjour, 

je souhaite exécuter les deux codes suivant mais simultanément pour qu'ils puissent tournés en parrallèles. Je n'ai trouvé aucun moyen de le faire.

org 100h
     
;===================================================================================

boucle PROC     ; debut de la fonction


;===================affichage du message "appuyer sur Entree"=======================


    GOTOXY 30, 20  ; le curseur se rend au coordonnees 30,20
       
        jmp start      
        
             msg:    db      "Appuyez sur Entree", 0Dh,0Ah, 24h
            
             start:              
                    mov dx, msg  ; charge l'offset du message dans dx
                    mov ah, 09h  ; fonction d'affichage 9.
                    int 21h      ; on utilise l'interruption 21h pour afficher les 
                                 ; caractere a l'ecran     
                    
    GOTOXY 30, 20  ; le curseur se rend au coordonnees 30,20                  
           
        jmp effStart
             
            effmsg :  db    "                  ", 0Dh,0Ah, 24h
            
            effStart:         
                     mov dx, effmsg  ; charge l'offset du message dans dx
                     mov ah, 09h     ; fonction d'affichage 9.
                     int 21h         ; on utilise l'interruption 21h pour afficher les 
                                     ; caractere a l'ecran
                                          
            recup :
                    
                    mov ah, 01h   ; permet de recupere une frappe clavier
                    
                    int 16h      ; attente de la touche
                    
            
          
                    cmp al, 13   ; on compare la valeur  de al a celle de la touche 
                                 ; entrer qui correspond au caractere ASCii 13
                    je finProg   ; si egal fin du programme
                                                             
                                                             
    jmp boucle   ; boucle sur la fonction boucle

ENDP



finProg: ; fin du programme
     
en meme temps que celui-ci :
;initialisation de la memoire video 

MOV AX, 0B800h
MOV DS, AX



MOV AX,0
MOV DX,0
ADD BX,0
MOV CX,0 
 

;========================PROCEDURE REBOND========================




rebond1:   

    MOV BX,AX            
    MOV [01h+BX], 40h    ; couleur du tracer laisser par  la balle (rouge)
    
    MOV BX,DX            
    MOV [01h+BX], 0F0h   ; couleur de la balle 
    
    MOV AX,BX            
    ADD BX, 162          
    MOV DX,BX            
     

    
    INC CL 
    INC CH  
    
    
    ;on verifie si la balle est touche le bas de la fenetre
    
    CMP CL,24  
    JGE rebond2
    
    
    ;on verifie si la balle touche le cote droit de la fenetre
    
    CMP CH,79
    JGE rebond4
      
    
    ; si aucunes de ces 2 conditions n'est concretise on relance l'etiquette executee
    
    JMP rebond1



    
rebond2:  

    MOV BX,AX
    MOV [01h+BX], 40h   ;couleur du tracer laisser par  la balle (rouge)
    
    MOV BX,DX
    MOV [01h+BX], 0F0h 

    MOV AX,BX
    SUB BX,158
    MOV DX,BX 

    DEC CL
    INC CH    
    
    
    ;on verifie si la balle touche le haut de la fenetre   
    
    CMP CL,0
    JLE rebond1   
    
    
    ;on verifie si la balle touche le cote droit de la fenetre
    
    CMP CH,79
    JGE rebond3  
    
    
    ;si aucunes de ces 2 conditions n'est concretise on relance l'etiquette executee 
    
    JMP rebond2




rebond3: 

    MOV BX,AX
    MOV [01h+BX], 40h              ;couleur du tracer laisser par  la balle (rouge)
    
    MOV BX,DX
    MOV [01h+BX], 0F0h 
    
    
    MOV AX,BX
    SUB BX,162
    MOV DX,BX 
    
    DEC CL
    DEC CH   
    
          
    ;on verifie si la balle touche le haut de la fenetre 
    
    CMP CL,0
    JLE rebond4 
    
    
    ;on verifie si la balle touche le cote gauche de la fenetre
    
    CMP CH,0
    JLE rebond2 
    
    
    ;si aucunes de ces 2 conditions n'est concretise on relance l'etiquette executee
    
    JMP rebond3




rebond4:      

    MOV BX,AX
    MOV [01h+BX], 40h         ;couleur du tracer laisser par  la balle (rouge)
    
    MOV BX,DX
    MOV [01h+BX], 0F0h 
    
    MOV AX,BX
    ADD BX,158
    MOV DX,BX 

    INC CL
    DEC CH  
    
    
    ;on verifie si la balle touche le bas de la fenetre 
    
    CMP CL,24
    JGE rebond3
    
    
    ;on verifie si la balle touche le cote gauche de la fenetre
    
    CMP CH,0
    JLE rebond1 
    
    
    ;si aucunes de ces 2 conditions n'est concretise on relance l'etiquette executee  
    
    JMP rebond4

RET

merci de votre réponse :)

cs_patatalo · Answer

salut,


Du multiprocesseur en mode réel, chaud bouillant. Les 2 codes ne pourront s'executer que simultanément en donnant seulement l'impression de tourner en même temps.

J'ai déjà vu des codes sur le net pour faire du multitâche en mode réel sous DOS. Par contre, je ne suis pas du tout sûr que l'on puisse utiliser plusieurs processeurs.

@++

HirOinEvOl · Answer

arf c'est chiant. Jdois faire une animation en asm alors si je peut pas exécuter plusieurs actions en même temps, je peut faire comment pour afficher plusieurs choses différentes à l'écran ?

(c'est un programme de rattrapage pour des 1ère année de Supinfo hein...) si c'est chaud comme ca et beh.*

Mais chez moi j'ai un quad-core alors peut etre que ca passe mais bon jdois l'uploader sur une platforme supinfo donc eux si ils ont des bécanes pourries ca sert a rien.

Si tu peut éclairé...

cs_patatalo · Answer

re,


Oups, j'avais mal lu. Utilise le Timer 0 (interruption 8 ou 1Ch des vecteurs du mode réel) en le surchargeant. Par defaut, le temps entre chaque interruption est de 18 ms en gros.

A chaque interruption, tu sauvegardes les registres d'execution courant et tu restaures ceux de l'execution suivante. Tu retournes sur le code a executer avec un iret, retf ou jmp far, suivant ton implémentation.

@++

HirOinEvOl · Answer

WAAAAAAAHhH va falloir que je potasse, j'capte que dalle -_- mais je vais test

HirOinEvOl · Answer

j'ai trouvé ca sur le net

IT 8 : tic horloge (timer) appelé toutes les 55 ms (18,2 fois/s.). Elle sert par exemple à arrêter
le moteur de l'unité de disquette lorsque aucun accès à la disquette n'est exécuté. Cette interruption
08H, après avoir lancé le programme correspondant, appelle l'interruption 1CH. Cette dernière ne
contient qu'un retour IRET afin de permettre aux programmeurs d'implanter leurs propres
programmes d'interruption (objectifs : programmation concurrente, multitâche,....)

je le code comme ca en gros : non ?
org 100h

; 1er prog ici non ??

mov ah, 08h

iret mon prog ; la je met mon 2eme prog ??

ret

mais surement avec des MOV a certains endroits ?

(dsl je pose bcp de questions :) )

cs_patatalo · Answer

re,

oui, je me suis trompé entre fréquence et nombre d'appels par seconde.

Old_int8:
dw 0,0 ; cs:ip vers ancien vecteur.

Current_context:
dw 0; bascule code 0, code 1

Save_context_Code1:
dw 0,0,0,... ; ax, bx, cx, ...
dw Code1,0 ; ip, cs
dw 0 ; flags

Save_context_Code2:
dw 0,0,0,... ; ax, bx, cx, ...
dw Code2,0 ; ip, cs.
dw 0 ; flags

Hook_int8:
; quand une interruption survient, les registres cs:ip et flags se retrouvent dans la pile.
pop Save_context[Current_context].ip
pop Save_context[Current_context].cs
pop Save_context[Current_context].flags
mov Save_context[Current_context].ax,ax
...

Current_context += 1;

push Save_context[Current_context].flags
push Save_context[Current_context].cs
push Save_context[Current_context].ip
mov ax,Save_context[Current_context].ax
...

jmp far [Old_int8]


Code1:
...

Code2:
...


@++

cs_patatalo · Answer

re,

chaque thread devra avoir obligatoirement sa propre pile. Il faudra la mettre a jour avant de pusher les nouvelles valeurs dans le hook de l'interruption 8.

@++

cs_patatalo · Answer

Old_int8: 
dw 0,0 ; cs:ip vers ancien vecteur. 

Current_context: 
dw 0; bascule code 0, code 1 

reg_sp:
dw 0, 0 ; sp1, sp2

Hook_int8: 
; quand une interruption survient, les registres cs:ip et flags se retrouvent dans la pile. 
pusha
mov reg_sp[Current_context & 1],sp 

Current_context += 1

mov sp,reg_sp[Current_context & 1] 
popa

jmp far [Old_int8] 

la pile du code2 devra être initialisée pour simuler une interruption précedente

mov sp, stack_code2
pushf
push cs
push offset Code2
pusha
mov reg_sp[1], sp
mov sp, stack_code1
mov reg_sp[0], sp
call HookInt8
Code1:
...
jmp Code1
Code2:
...
jmp Code2

un truc comme ça en gros.

@++

HirOinEvOl · Answer

ok merci je mettrait ca en application ce week end

Guilou34 · Answer

Salut 
Il me semble qu'il y a une solution plus simple qu'utiliser les interruptions. Les procédures sont tout indiquées pour ce genre de problème.
Mais ce que tu appelles procédure n'en est pas : il manque l'instruction ret   
Il suffit d'écrire, par exemple :
 
Rebond1:
Call clavier
?
  ;ici ton code pour déplacer le curseur 
?
jmp rebond1 

proc clavier 
; afficher un message
; a-t-on pressé une touche ?
; si oui exécuter  le code prévu
; sinon :

ret
endp

cs_patatalo · Answer

re,


la procedure simule un système coopératif ou l'interruption simule un système préemptif.

@++

HirOinEvOl · Answer

Bonjour, 
je n'arrive pas a faire fonctionner ton code... comment doit-on déclarer la pile stack_code2 car lors de la compilation il m'indique que cela est un mauvais paramètre.


include "emu8086.inc"   ; on inclu la bibliotheque pour pouvoir utiliser
                        ; des fonctions deja pretes.
                        

org 100h

Old_int8:
dw 0,0  ; cs:ip vers ancien vecteur.

Current_context:
dw 0    ; bascule code 0, code 1

reg_sp:
dw 0, 0 ; sp1, sp2

Hook_int8:
; quand une interruption survient, les registres cs:ip et flags se retrouvent dans la pile.
pusha
mov reg_sp[Current_context & 1],sp

;Current_context +=  1      <======= Il me retourne une erreur arrivé ici. Je pense que c'est à cause du += 

mov sp,reg_sp[Current_context & 1]
popa

jmp far [Old_int8]


;la pile du code2 devra être initialisée pour simuler une interruption précedente
 
ASSUME SS:segment_pile               < == ======== j'ai déclaré la pile de cette façon mais cela ne fonctionne pas 

MOV  AX, segment_pile
MOV  SS, AX		; initialise le segment de pile
MOV  SP, base_pile ; copie l'adresse de la base de la pile dans SP 
 
mov sp, segment_pile         < ========cela bloque également ici mais je ne sais pourquoi
pushf
push cs
push offset Code2
pusha
mov reg_sp[1], sp
mov sp, stack_code1
mov reg_sp[0], sp
call HookInt8

code1:
..............

Si qqn peut m'éclairer...

Merci

cs_patatalo · Answer

salut,

mon code n'est pas fonctionnel, c'est la technique utilisée qu'il montre grossièrement.

A toi de le faire réellement.

v +1 v++ == inc v.


@++

Executer 2 action en meme temps

13 réponses

Votre réponse

Discussions similaires