[TP] Programmation parallèle

Version imprimable

15/02/2006, 11h52
Cheebe

[TP] Programmation parallèle

Bonjour,
est-il possible de faire de la programmation parallèle sous Turbo Pascal ?
Par exemple, je souhaite faire circuler une balle et en même temps récupérer les touches frappées par l'utilisateur pour déplacer une "raquette".

Pour info, j'utilise Free Pascal sous XP.
15/02/2006, 13h47
M.Dlb

Turbo Pascal ne permet pas de faire de la programmation paralèlle, c'est-à-dire multi-threadée, car à l'origine Turbo Pascal est pour DOS qui est un environnement mono-tâche.

Il faut se tourner vers la programmation pour Windows ou Linux pour avoir des environnements multi-tâches.

Celà, il est tout à fait possible de faire ce que tu indiques, à savoir récupérer les touches en affichant. Il suffit pour celà de donner un "ordre" à ces deux étapes: soit je lis les touches puis j'affiches les résultats, soit j'affiche le résultat précédent puis je lis les touches. Le tout dans une boucle, et ça fonctionne.

A noter que l'on peut utiliser la programmation évènementielle de Turbo Vision, pour gérer l'appui des touches. Il existe un exemple fourni dans Turbo Pascal : breakout.pas

Bonjour,

En DOS pur on pourrait éventuellement utiliser l'interrupteur 1Ch, si les opérations à traiter ne sont pas trop importantes ça peut faire l'affaire.
Par exemple, un programme qui convertirait un fichier texte ASCII pur en ASCII étendu, tout en affichant le pourcentage du fichier traité à l'écran en parallèle :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
 
{****************************************************************************
 * Programme de conversion de fichiers ASCII-Dos en ASCII extended pour     *
 * une lecture Windows(prend en charge les accents).                        *
 ****************************************************************************}
 
uses newdelay,crt,dos,mrgnstrn;
 
var  fichier_in, fichier_out : file;
     value                   : byte;
     name_in,name_out        : string;
     old_addr                : pointer;
     Valeur                  : integer;
     Okay                    : boolean;
 
procedure Copie_Octet; interrupt;  {on évite l'overlay grâce à VALEUR, qui est traitée en dehors de 1C}
begin
     Gotoxy(1,1);
     Write(valeur,' % done');
end;
 
 
begin
     Directvideo:=True;
 
     Assigncrt(output);
     ReWrite(output);
     AssignCrt(input);
     ReSet(input);
 
     Repeat
           okay:=true;
           clrscr;
           Write('Input File (ASCII DOS standard) : ');
           Readln(name_in);
           {$I-}
           Assign(fichier_in,name_in);
           Reset(fichier_in,1);
           If (IOResult<>0) then
           begin
                Colwrite('File does not exist or path unknown',Red);
                Writeln;
                Colwrite('Press enter',red);
                Readln;
                Textcolor(White);
                okay:=false;
           end;
           {$I+}
     Until Okay;
 
     Write('Output File : ');
     Readln(name_out);
     Assign(fichier_out,name_out);
     Rewrite(fichier_out,1);
 
     Getintvec($1c,old_addr);      {sauvegarde le gestionnaire 1C}
     Setintvec($1c,@Copie_Octet);  {redirige Addr(1C) sur la proc}
     Clrscr;
     {$I-}
     Repeat
           Blockread(fichier_in,value,1);
           Case value of                   {hexadécimaux correspondants
                                            aux accents}
                      $82 : value:=$E9;
                      $85 : value:=$E0;
                      $94 : value:=$F6;
                      $93 : value:=$F4;
                      $81 : value:=$FC;
                      $96 : value:=$FB;
                      $89 : value:=$EB;
                      $87 : value:=$E7;
                      $88 : value:=$EA;
                      $8B : value:=$EF;
                      $8C : value:=$EE;
                      $83 : value:=$E2;
                      $84 : value:=$E4;
                      $8A : value:=$E8;
                      $B6 : value:=$C2;
                      $8E : value:=$C4;
                      $D2 : value:=$CA;
                      $D3 : value:=$CB;
                      $D7 : value:=$CE;
                      $D8 : value:=$CF;
                      $E2 : value:=$D4;
                      $99 : value:=$D6;
                      $EA : value:=$DB;
                      $9A : value:=$DC;
                      $98 : value:=$FF;
                      $DC : value:=$3D;
 
           end;
           Blockwrite(fichier_out,value,1);
           valeur:=Round((filesize(fichier_out)/filesize(fichier_in))*100);
           {le résultat de VALEUR est ensuite reporté dans 1C }
     until (EOF(fichier_in)) or (filesize(fichier_out)>=filesize(fichier_in));         
     {$I+}
     Gotoxy(1,1);
     Write('100 % done');
     Setintvec($1c,old_addr);       {restaure l'ancien pointeur dans 1C}
end.

Ah oui, l'unité MRGNSTRN n'est absolument pas vitale, c'est juste une bibli de routines utiles comme Colwrite, etc...

Bon évidemment, le traitement est limité, mais tant qu'on ne calcule pas des images ou des bases de données, ça peut être pratique.

19/02/2006, 10h39
M.Dlb

D'ailleurs pour les plus acharnés, il est possible de faire un ordonnanceur grâce à l'int 1Ch, et ainsi simuler un environnement multi-tâche, mais c'est du haut-niveau là ;)
19/02/2006, 12h11
Eric Sigoillot

Citation:

Envoyé par wormful_sickfoot

D'ailleurs pour les plus acharnés, il est possible de faire un ordonnanceur grâce à l'int 1Ch, et ainsi simuler un environnement multi-tâche, mais c'est du haut-niveau là ;)

Non, il vaut mieux éviter d'user de l'int 1Ch pour faire du multitâche : en effet, l'int 1Ch est une int masquable. On peut donc la désactiver :)

Il vaut mieux se placer sur l'int non masquable, la NMI. Mais ce n'est pas toujours possible.

En tout cas, se placer sur int 8 est plus judicieux car elle permet de régler le temps qui s'écoule entre deux interruptions, là où la 1C est fixée.

@++
19/02/2006, 13h28
M.Dlb

Oui, l'int 8 appele l'int 1Ch, mais c'était juste un exemple ;)