--- rpl/src/gestion_variables.c 2011/06/20 17:54:15 1.35 +++ rpl/src/gestion_variables.c 2011/07/22 07:38:35 1.44 @@ -1,6 +1,6 @@ /* ================================================================================ - RPL/2 (R) version 4.1.0.prerelease.1 + RPL/2 (R) version 4.1.1 Copyright (C) 1989-2011 Dr. BERTRAND Joël This file is part of RPL/2. @@ -46,13 +46,16 @@ liste_variables_par_niveaux(struct_proce struct_liste_chainee *e; - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); printf(" Liste des variables par niveaux\n"); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); if ((*s_etat_processus).l_liste_variables_par_niveau == NULL) { - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); return; } @@ -68,8 +71,8 @@ liste_variables_par_niveaux(struct_proce while(e != NULL) { - printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, - e->donnee, ((struct_variable *) e->donnee)->niveau); + printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, + e, e->donnee, ((struct_variable *) e->donnee)->niveau); e = e->suivant; c++; if (c > 100) @@ -93,8 +96,8 @@ liste_variables_par_niveaux(struct_proce while(e != NULL) { - printf("%s (%p, %d) ", ((struct_variable *) e->donnee)->nom, - e->donnee, ((struct_variable *) e->donnee)->niveau); + printf("%s (%p->%p, %d) ", ((struct_variable *) e->donnee)->nom, + e, e->donnee, ((struct_variable *) e->donnee)->niveau); e = e->suivant; c++; if (c > 100) exit(0); @@ -105,7 +108,8 @@ liste_variables_par_niveaux(struct_proce l = l->suivant; } while(l != (*s_etat_processus).l_liste_variables_par_niveau); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); if (fin == d_vrai) exit(0); @@ -184,7 +188,8 @@ liste_variables_tas(struct_processus *s_ } while((*arbre).feuille != l); } - printf("-----------------------------------------------------------\n"); + printf("----------------------------------------------------------" + "----------------------\n"); for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) { @@ -204,14 +209,172 @@ liste_variables_tas(struct_processus *s_ static void liste_variables_par_feuilles(struct_processus *s_etat_processus) { - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); printf(" Liste des variables sur le tas\n"); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); liste_variables_tas(s_etat_processus, (*s_etat_processus).s_arbre_variables); - printf("===========================================================\n"); + printf("==========================================================" + "======================\n"); + + return; +} + + +/* +================================================================================ + Routine de gestion du cache mémoire sur l'arbre des variables +================================================================================ + Entrée : +-------------------------------------------------------------------------------- + Sortie : +-------------------------------------------------------------------------------- + Effets de bords : néant +================================================================================ +*/ + +static inline struct_arbre_variables * +allocation_noeud(struct_processus *s_etat_processus) +{ + struct_arbre_variables *objet; + + if ((*s_etat_processus).pointeur_variables_noeud > 0) + { + objet = (*s_etat_processus).variables_noeud + [--(*s_etat_processus).pointeur_variables_noeud]; + } + else + { + objet = malloc(sizeof(struct_arbre_variables)); + } + + return(objet); +} + +static inline void +liberation_noeud(struct_processus *s_etat_processus, + struct_arbre_variables *objet) +{ + if ((*s_etat_processus).pointeur_variables_noeud < TAILLE_CACHE) + { + (*s_etat_processus).variables_noeud + [(*s_etat_processus).pointeur_variables_noeud++] = objet; + } + else + { + free(objet); + } + + return; +} + +static inline struct_arbre_variables ** +allocation_tableau_noeuds(struct_processus *s_etat_processus) +{ + struct_arbre_variables **objet; + + if ((*s_etat_processus).pointeur_variables_tableau_noeuds > 0) + { + objet = (*s_etat_processus).variables_tableau_noeuds + [--(*s_etat_processus).pointeur_variables_tableau_noeuds]; + } + else + { + objet = malloc((*s_etat_processus).nombre_caracteres_variables + * sizeof(struct_arbre_variables *)); + } + + return(objet); +} + +static inline void +liberation_tableau_noeuds(struct_processus *s_etat_processus, + struct_arbre_variables **objet) +{ + if ((*s_etat_processus).pointeur_variables_tableau_noeuds < TAILLE_CACHE) + { + (*s_etat_processus).variables_tableau_noeuds + [(*s_etat_processus).pointeur_variables_tableau_noeuds++] = + objet; + } + else + { + free(objet); + } + + return; +} + +static inline struct_liste_variables * +allocation_feuille(struct_processus *s_etat_processus) +{ + struct_liste_variables *objet; + + if ((*s_etat_processus).pointeur_variables_feuille > 0) + { + objet = (*s_etat_processus).variables_feuille + [--(*s_etat_processus).pointeur_variables_feuille]; + } + else + { + objet = malloc(sizeof(struct_liste_variables)); + } + + return(objet); +} + +static inline void +liberation_feuille(struct_processus *s_etat_processus, + struct_liste_variables *objet) +{ + if ((*s_etat_processus).pointeur_variables_feuille < TAILLE_CACHE) + { + (*s_etat_processus).variables_feuille + [(*s_etat_processus).pointeur_variables_feuille++] = objet; + } + else + { + free(objet); + } + + return; +} + +static inline struct_variable * +allocation_variable(struct_processus *s_etat_processus) +{ + struct_variable *objet; + + if ((*s_etat_processus).pointeur_variables_variable > 0) + { + objet = (*s_etat_processus).variables_variable + [--(*s_etat_processus).pointeur_variables_variable]; + } + else + { + objet = malloc(sizeof(struct_variable)); + } + + return(objet); +} + +static inline void +liberation_variable(struct_processus *s_etat_processus, + struct_variable *objet) +{ + if ((*s_etat_processus).pointeur_variables_variable < TAILLE_CACHE) + { + (*s_etat_processus).variables_variable + [(*s_etat_processus).pointeur_variables_variable++] = objet; + } + else + { + free(objet); + } return; } @@ -256,7 +419,7 @@ ajout_variable(struct_processus *s_etat_ if ((*s_etat_processus).s_arbre_variables == NULL) { if (((*s_etat_processus).s_arbre_variables = - malloc(sizeof(struct_arbre_variables))) == NULL) + allocation_noeud(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -268,8 +431,7 @@ ajout_variable(struct_processus *s_etat_ (*(*s_etat_processus).s_arbre_variables).noeud_pere = NULL; if (((*(*s_etat_processus).s_arbre_variables).noeuds = - malloc((*s_etat_processus).nombre_caracteres_variables - * sizeof(struct_arbre_variables))) == NULL) + allocation_tableau_noeuds(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -288,7 +450,7 @@ ajout_variable(struct_processus *s_etat_ while((*ptr) != d_code_fin_chaine) { BUG((*s_etat_processus).pointeurs_caracteres_variables[*ptr] < 0, - printf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom, + uprintf("Variable=\"%s\", (*ptr)='%c'\n", (*s_variable).nom, *ptr)); if ((*l_variable_courante).noeuds[(*s_etat_processus) @@ -299,7 +461,7 @@ ajout_variable(struct_processus *s_etat_ if (((*l_variable_courante).noeuds[(*s_etat_processus) .pointeurs_caracteres_variables[*ptr]] = - malloc(sizeof(struct_arbre_variables))) == NULL) + allocation_noeud(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -336,8 +498,7 @@ ajout_variable(struct_processus *s_etat_ if (((*(*l_variable_courante).noeuds[(*s_etat_processus) .pointeurs_caracteres_variables[*ptr]]).noeuds = - malloc((*s_etat_processus).nombre_caracteres_variables - * sizeof(struct_arbre_variables))) == NULL) + allocation_tableau_noeuds(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -364,8 +525,8 @@ ajout_variable(struct_processus *s_etat_ // variables de même nom. Cette liste boucle en premier lieu sur // elle-même. - if (((*l_variable_courante).feuille = malloc( - sizeof(struct_liste_variables))) == NULL) + if (((*l_variable_courante).feuille = allocation_feuille( + s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -383,7 +544,7 @@ ajout_variable(struct_processus *s_etat_ // Allocation de la variable sur l'élément de la liste. if (((*(*l_variable_courante).feuille).variable = - malloc(sizeof(struct_variable))) == NULL) + allocation_variable(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -395,7 +556,7 @@ ajout_variable(struct_processus *s_etat_ } else { - if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) + if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -412,7 +573,7 @@ ajout_variable(struct_processus *s_etat_ BUG((*(*(*l_variable_courante).feuille).variable).niveau >= (*s_variable).niveau, - printf("Variable=\"%s\"\n", (*s_variable).nom)); + uprintf("Variable=\"%s\"\n", (*s_variable).nom)); // On ajoute la variable à la liste existante. @@ -428,7 +589,7 @@ ajout_variable(struct_processus *s_etat_ (*l_variable_courante).feuille = l_nouvelle_variable; if (((*(*l_variable_courante).feuille).variable = - malloc(sizeof(struct_variable))) == NULL) + allocation_variable(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -452,7 +613,7 @@ ajout_variable(struct_processus *s_etat_ BUG((*(*l_variable_candidate).variable).niveau == (*s_variable).niveau, - printf("Variable=\"%s\"\n", (*s_variable).nom)); + uprintf("Variable=\"%s\"\n", (*s_variable).nom)); l_variable_candidate = (*l_variable_candidate).precedent; } while((l_variable_candidate != (*l_variable_courante).feuille) && @@ -497,7 +658,7 @@ ajout_variable(struct_processus *s_etat_ } if (((*l_nouvelle_variable).variable = - malloc(sizeof(struct_variable))) == NULL) + allocation_variable(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -516,7 +677,7 @@ ajout_variable(struct_processus *s_etat_ { // Le niveau courant n'existe pas. Il est créé. - if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) + if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -532,7 +693,7 @@ ajout_variable(struct_processus *s_etat_ // Ajout de la variable en tête de la liste - if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -550,7 +711,7 @@ ajout_variable(struct_processus *s_etat_ { // Le niveau courant n'existe pas. Il est créé. - if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) + if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -572,7 +733,7 @@ ajout_variable(struct_processus *s_etat_ // Ajout de la variable en tête de la liste - if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -612,7 +773,7 @@ ajout_variable(struct_processus *s_etat_ if (niveau_acceptable == d_faux) { - if ((l_nouvelle_variable = malloc(sizeof(struct_liste_variables))) + if ((l_nouvelle_variable = allocation_feuille(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; @@ -645,7 +806,7 @@ ajout_variable(struct_processus *s_etat_ // Ajout de la variable en tête de la liste l_variable_candidate. - if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -659,7 +820,7 @@ ajout_variable(struct_processus *s_etat_ { // Ajout de la variable en tête de la liste - if ((l_nouvel_element = malloc(sizeof(struct_liste_chainee))) == NULL) + if ((l_nouvel_element = allocation_maillon(s_etat_processus)) == NULL) { (*s_etat_processus).erreur_systeme = d_es_allocation_memoire; return(d_erreur); @@ -1040,6 +1201,8 @@ retrait_variable(struct_processus *s_eta unsigned long niveau; + (*s_etat_processus).niveau_supprime = d_faux; + if (recherche_variable(s_etat_processus, nom_variable) == d_vrai) { // Une variable correspondant au nom recherché est accessible. @@ -1120,7 +1283,6 @@ retrait_variable(struct_processus *s_eta variable_a_supprimer = (*s_etat_processus) .pointeur_feuille_courante; - //s_arbre_courant = (*variable_a_supprimer).noeud_pere; s_arbre_courant = (*variable_a_supprimer).noeud; BUG((*s_arbre_courant).noeuds_utilises == 0, uprintf("Freed node !\n")); @@ -1137,8 +1299,9 @@ retrait_variable(struct_processus *s_eta if (s_arbre_courant == NULL) { - free((*s_arbre_a_supprimer).noeuds); - free(s_arbre_a_supprimer); + liberation_tableau_noeuds(s_etat_processus, + (*s_arbre_a_supprimer).noeuds); + liberation_noeud(s_etat_processus, s_arbre_a_supprimer); (*s_etat_processus).s_arbre_variables = NULL; break; @@ -1154,8 +1317,9 @@ retrait_variable(struct_processus *s_eta (*s_arbre_courant).noeuds[(*s_arbre_a_supprimer) .indice_tableau_pere] = NULL; - free((*s_arbre_a_supprimer).noeuds); - free(s_arbre_a_supprimer); + liberation_tableau_noeuds(s_etat_processus, + (*s_arbre_a_supprimer).noeuds); + liberation_noeud(s_etat_processus, s_arbre_a_supprimer); BUG((*s_arbre_courant).noeuds_utilises == 0, uprintf("Freed node !\n")); @@ -1241,10 +1405,14 @@ retrait_variable(struct_processus *s_eta (*l_element_courant).suivant; } - free(l_element_courant); + liberation_maillon(s_etat_processus, + l_element_courant); if ((*variables_par_niveau).liste == NULL) { + (*s_etat_processus).niveau_supprime = + d_vrai; + if ((*s_etat_processus) .l_liste_variables_par_niveau == variables_par_niveau) @@ -1265,7 +1433,8 @@ retrait_variable(struct_processus *s_eta .precedent = (*variables_par_niveau) .precedent; - free(variables_par_niveau); + liberation_feuille(s_etat_processus, + variables_par_niveau); } variable_supprimee = d_vrai; @@ -1293,8 +1462,8 @@ retrait_variable(struct_processus *s_eta free((*(*variable_a_supprimer).variable).nom); liberation(s_etat_processus, (*(*variable_a_supprimer).variable).objet); - free((*variable_a_supprimer).variable); - free(variable_a_supprimer); + liberation_variable(s_etat_processus, (*variable_a_supprimer).variable); + liberation_feuille(s_etat_processus, variable_a_supprimer); erreur = d_absence_erreur; } @@ -1473,7 +1642,7 @@ retrait_variable_par_niveau(struct_proce .l_liste_variables_par_niveau; (*s_etat_processus).l_liste_variables_par_niveau = (*l_element_a_supprimer).suivant; - free(l_element_a_supprimer); + liberation_feuille(s_etat_processus, l_element_a_supprimer); } return(d_absence_erreur); @@ -1521,9 +1690,11 @@ liberation_arbre_variables(struct_proces do { l_element_suivant = (*l_element_courant).suivant; - free(l_element_courant); + liberation_feuille(s_etat_processus, l_element_courant); l_element_courant = l_element_suivant; } while(l_element_courant != (*arbre).feuille); + + (*arbre).feuille = NULL; } for(i = 0; i < (*s_etat_processus).nombre_caracteres_variables; i++) @@ -1532,6 +1703,7 @@ liberation_arbre_variables(struct_proces { liberation_arbre_variables(s_etat_processus, (*arbre).noeuds[i], retrait_definitions); + (*arbre).noeuds[i] = NULL; } } @@ -1557,25 +1729,28 @@ liberation_arbre_variables(struct_proces (*l_element_courant_liste).donnee)).objet); free((*((struct_variable *) (*l_element_courant_liste) .donnee)).nom); - free((*l_element_courant_liste).donnee); } l_element_suivant_liste = (*l_element_courant_liste).suivant; - free(l_element_courant_liste); + liberation_variable(s_etat_processus, (struct_variable *) + (*l_element_courant_liste).donnee); + liberation_maillon(s_etat_processus, + l_element_courant_liste); l_element_courant_liste = l_element_suivant_liste; } l_element_suivant = (*l_element_courant).suivant; - free(l_element_courant); + liberation_feuille(s_etat_processus, l_element_courant); l_element_courant = l_element_suivant; } while(l_element_courant != (*s_etat_processus) .l_liste_variables_par_niveau); } } - free((*arbre).noeuds); - free(arbre); + liberation_tableau_noeuds(s_etat_processus, (*arbre).noeuds); + liberation_noeud(s_etat_processus, arbre); + arbre = NULL; return; } @@ -1682,19 +1857,115 @@ liste_variables(struct_processus *s_etat ================================================================================ */ -struct_arbre_variables * -copie_arbre_variables(struct_processus *s_etat_processus) +void +copie_arbre_variables(struct_processus *s_etat_processus, struct_processus + *s_nouvel_etat_processus) { // Les définitions sont partagées entre tous les threads et ne sont pas // copiées. // // NB : on ne copie que les variables de niveaux 0 et 1, les autres // variables locales étant masquées par le processus de création de thread - // ou de processus, elles sont inaccessibles. + // ou de processus, elles seront inaccessibles de tous les points + // du fil d'exécution fils. - BUG(1, uprintf("Oops !\n")); + // Pour copier ces variables, on récupère les variables depuis la liste par + // niveaux (niveaux 0 et 1) et on ajoute les variables dans la nouvelle + // structure. Les variables de niveau 0 étant non modifiables, elles + // ne sont pas dupliquées. - return(d_absence_erreur); + int i; + + struct_liste_chainee *l_element_courant; + + struct_liste_variables *l_niveau_courant; + + struct_variable s_variable; + + (*s_nouvel_etat_processus).s_arbre_variables = NULL; + (*s_nouvel_etat_processus).l_liste_variables_par_niveau = NULL; + + l_niveau_courant = (*s_etat_processus).l_liste_variables_par_niveau; + + // Si la variable en tête n'est pas une variable de niveau 0, le niveau + // 0, s'il existe est le nivau précédent la valeur courante dans la + // boucle. + + if ((*((struct_variable *) (*(*l_niveau_courant).liste).donnee)).niveau + != 0) + { + l_niveau_courant = (*l_niveau_courant).precedent; + } + + // Les variables de niveaux 0 et 1 sont accessibles en au plus trois + // itérations (par construction). + + for(i = 0; i <= 2; i++) + { + if ((*((struct_variable *) (*(*l_niveau_courant).liste) + .donnee)).niveau == 0) + { + l_element_courant = (*l_niveau_courant).liste; + + while(l_element_courant != NULL) + { + if (ajout_variable(s_nouvel_etat_processus, + (struct_variable *) (*l_element_courant).donnee) + == d_erreur) + { + return; + } + + l_element_courant = (*l_element_courant).suivant; + } + } + else if ((*((struct_variable *) (*(*l_niveau_courant).liste) + .donnee)).niveau == 1) + { + l_element_courant = (*l_niveau_courant).liste; + + while(l_element_courant != NULL) + { + s_variable = (*((struct_variable *) + (*l_element_courant).donnee)); + + if ((s_variable.nom = strdup((*((struct_variable *) + (*l_element_courant).donnee)).nom)) == NULL) + { + (*s_nouvel_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if ((s_variable.objet = copie_objet(s_nouvel_etat_processus, + (*((struct_variable *) (*l_element_courant).donnee)) + .objet, 'P')) == NULL) + { + (*s_nouvel_etat_processus).erreur_systeme = + d_es_allocation_memoire; + return; + } + + if (ajout_variable(s_nouvel_etat_processus, &s_variable) + == d_erreur) + { + return; + } + + l_element_courant = (*l_element_courant).suivant; + } + + // Les variables de niveau 0 ayant déjà été copiées, on + // peut sortir de la boucle car toutes les variables sont + // maintenant disponibles dans le fil d'exécution fils. + + break; + } + + l_niveau_courant = (*l_niveau_courant).precedent; + } + + return; }