Discussion :

[dtrack]

Bonjour, j'ai un problème que je n'arrive pas a résoudre,

J'ai une fonction creer_processus donc le code est le suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
int creer_processus(int num_id,float taille,float tps_exec,int priorite){
    //declaration des variables
    int espace_disque,ram_dispo,hdd_dispo,nb_a_creer,num;
    int i,j,k,cpt;
    float tps,new_taille;
    struct processus *proc=NULL;
    struct cluster *running=NULL;
    struct cluster *previous=NULL;
    struct cluster *first=NULL;
    struct _adress *adresse=NULL; 
    struct _adress *adresse_init=NULL;  
 
    adresse_init=(struct _adress *)malloc(sizeof(struct _adress));
    espace_disque=espace_total();                          //mesure l'espace disque total disponible
    ram_dispo=espace_libre(ram);                           //mesure l'espace libre dans la RAM      
    hdd_dispo=espace_libre(hdd);                           //mesure l'espace libre dans le HDD
 
    if (taille>espace_disque) return 9;                    //cas ou l'espace memoire est insuffisant
/*1*/    if (taille>20){                                        //cas ou le processus est plus grand que la taille de la RAM
                   nb_a_creer=floor(taille/10)+1;          //nombre de sous_processus a creer        
/*2*/                   for (cpt=1;nb_a_creer-1 ;cpt++){
                       num=num_id*1000+cpt;                   //creation des sous-processus, gestion du paging
                       tps=tps_exec/nb_a_creer;             //tps d'execution du sous_processus
                       add_pages(num);                       //referencement du nouveau sous processus dans pages
/*3*/                       j=creer_processus(num,10,tps,priorite);
                       }
                    num=nb_a_creer+1000;                      //dernier sous-processus a creer
                    tps=tps_exec/nb_a_creer;
                    add_pages(num);
                    new_taille=taille-(10*(nb_a_creer-1));
                    j=creer_processus(num,new_taille,tps,priorite);           
                    return 0;                   
                   }
   if (taille>ram_dispo) {
                         //ecriture du premier mo du processus (different des suivants car "->begin" = NULL)
                         adresse_init=recherche_hdd();
                         i=adresse_init->x;
                         j=adresse_init->y;
                         k=adresse_init->z;
                         running=move_to(i,j,k);
                         printf("position du *running: (%d,%d,%d)\n",i,j,k);
                         proc=(struct processus *)malloc(sizeof(struct processus));
                         proc->num_id=num_id;
                         proc->priorite=priorite;
                         proc->tps_exec=tps_exec;
                         if (taille<1)proc->taille = taille;
                            else proc->taille=1;
                         proc->next=NULL;
                         proc->begin=NULL;
                         running->processus=proc;
                         first=running;
                         previous=running;
                         //fin d'ecriture du premier mo
                         taille=taille-1;
 
                        //ecriture des differents mo du processus dans les clusters du hdd 
                        while (taille>0){
                                 proc=(struct processus *)malloc(sizeof(struct processus));
                                 adresse=recherche_hdd();
                                 i=adresse->x;
                                 j=adresse->y;
                                 k=adresse->z;
                                 running=move_to(i,j,k);
                                 printf("position du *running: (%d,%d,%d)\n",i,j,k);
                                 proc->begin=first;
                                 if (taille<1)proc->taille = taille;
                                    else proc->taille=1;
                                 proc->num_id=num_id;
                                 proc->priorite=priorite;
                                 proc->tps_exec=tps_exec;
                                 proc->next=NULL;
                                 running->processus=proc;
                                 previous->processus->next=running;
                                 taille=taille-1;
                                 }
                                 add_pile(num_id,adresse_init,priorite);
                         return 0;
 
                         }
   else {                //ecriture du premier mo du processus (different des suivants car "->begin" = NULL)
                         adresse_init=recherche_ram();
                         i=adresse_init->x;
                         j=adresse_init->y;
                         k=adresse_init->z;
                         running=move_to(i,j,k);
                         printf("position du *running: (%d,%d,%d)\n",i,j,k);
                         proc=(struct processus *)malloc(sizeof(struct processus));
                         proc->num_id=num_id;
                         proc->priorite=priorite;
                         proc->tps_exec=tps_exec;
                         if (taille<1)proc->taille = taille;
                            else proc->taille=1;
                         proc->next=NULL;
                         proc->begin=NULL;
                         running->processus=proc;
                         first=running;
                         previous=running;
                         //fin d'ecriture du premier mo
                         taille=taille-1;
 
                        //ecriture des differents mo du processus dans les clusters du hdd 
                        while (taille>0){
                                 proc=(struct processus *)malloc(sizeof(struct processus));
                                 adresse=recherche_ram();
                                 i=adresse->x;
                                 j=adresse->y;
                                 k=adresse->z;
                                 running=move_to(i,j,k);
                                 printf("position du *running: (%d,%d,%d)\n",i,j,k);
                                 proc->begin=first;
                                 if (taille<1)proc->taille = taille;
                                    else proc->taille=1;
                                 proc->num_id=num_id;
                                 proc->priorite=priorite;
                                 proc->tps_exec=tps_exec;
                                 proc->next=NULL;
                                 running->processus=proc;
                                 previous->processus->next=running;
                                 taille=taille-1;
                                 }
                        add_pile(num_id,adresse_init,priorite);
                         return 0;
        }
 
};

Voila mon probleme est le suivant :

Si je cree un processus avec une taille superieure strictement a 20 (cas traité a l'endroit ou je met /*1*/);
Alors je crée des sous_processus en divisant le processus de grande taille par des processus de maniere que taille= 10*x+y avec x le nombre de processus de taille 10 et y la taille du dernier sous_processus a creer.

Ma boucle for (cf repere /*2*/ ) s'incremente avec le compteur "cpt".
Mon probleme est que lorsque je fais un appel recursif a ma fonction (cf /*3*/) creer_processus mon cpt passe a 65536 et donc je me retrouve avec une boucle sans fin.
Je ne comprend pas d'ou vient ce probleme sachant que je n'ai aucune autre variable qui s'apelle cpt. faut-il que je passe cpt en variable globale?

Merci d'avance
Jeremy

[Pacorabanix]

Personnellement je n'ai pas bien compris tout ton code donc je ne vais pas te dire ce qui ne joue pas.

Mais par rapport à ça :

Je ne comprend pas d'ou vient ce probleme sachant que je n'ai aucune autre variable qui s'apelle cpt. faut-il que je passe cpt en variable globale?

Mais lors de l'appel d'une fonction récursivement, c'est comme l'appel d'une fonction normale : chaque variable locale existe pour son "instance" de la fonction, la variable cpt du premier appel n'est en aucun cas modifiable (et pas accessible) par des appels recursif à la fonction. Si tu as besoin de la valeur de cpt pour les appels récursifs il faut la passer en argument de ta fonction. Si tu as besoin de modifier cette valeur il faut passer un pointeur vers cpt en argument de la fonction.

Utiliser une variable globale est possible aussi, mais ce n'est pas de la programmation propre : cela rendra ton code plus difficile à maintenir.

[dtrack]

Merci, Pacorabanix
Je comprend que mon code soit difficile a comprendre, cette fonction creer_processus est la plus longue de mon code et j'ai eu du mal a l'isoler pour exposer mon probleme vu tous les appels vers d'autres fonctions qu'elle fait.
En fait que je passe cpt en var globale ou locale ne change rien.
Au moment de la fin de la premiere recursion mon cpt passe a 655536 et je ne comprend pas pourquoi, ce qui fait que ma boucle for n'arrive jamais au bout (boucle for au niveau de /*1*/)

Je vais essayer de séparer ma fonction en plusieurs sous-fonctions pour éclaircir.

Precision : Dans la premiere recursion, comme l'espace disque dans la ram est suffisant (on suppose) l'execution pass directement dans le else (elle passe tous les if qui ont la taille du processus en condition)

[dtrack]

C'est bon j'ai trouvé mon erreur il n'y avait pas de test d'arret dans la bouble for.
Merci