rpl/src/gestion_objets.c - diff

Return to gestion_objets.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_objets.c between versions 1.47 and 1.69

version 1.47, 2011/04/14 10:32:59	version 1.69, 2011/09/20 14:36:29
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.0.prerelease.0	RPL/2 (R) version 4.1.3
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2011 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.
Line 111 initialisation_allocateur(struct_process	Line 111 initialisation_allocateur(struct_process
(*s_etat_processus).pointeur_vec = 0;	(*s_etat_processus).pointeur_vec = 0;
(*s_etat_processus).pointeur_maillons = 0;	(*s_etat_processus).pointeur_maillons = 0;

	(*s_etat_processus).pointeur_variables_noeud = 0;
	(*s_etat_processus).pointeur_variables_feuille = 0;
	(*s_etat_processus).pointeur_variables_variable = 0;
	(*s_etat_processus).pointeur_variables_tableau_noeuds = 0;

return;	return;
}	}

Line 143 liberation_allocateur(struct_processus *	Line 148 liberation_allocateur(struct_processus *
for(i = 0; i < (*s_etat_processus).pointeur_maillons;	for(i = 0; i < (*s_etat_processus).pointeur_maillons;
free((*s_etat_processus).maillons[i++]));	free((*s_etat_processus).maillons[i++]));

	for(i = 0; i < (*s_etat_processus).pointeur_variables_noeud;
	free((*s_etat_processus).variables_noeud[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_feuille;
	free((*s_etat_processus).variables_feuille[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_variable;
	free((*s_etat_processus).variables_variable[i++]));
	for(i = 0; i < (*s_etat_processus).pointeur_variables_tableau_noeuds;
	free((*s_etat_processus).variables_tableau_noeuds[i++]));

{	{
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;
Line 234 allocation_maillon(struct_processus *s_e	Line 248 allocation_maillon(struct_processus *s_e

/*	/*
================================================================================	================================================================================
Routine d'allocation d'un maillon d'un objet (liste, expression...)	Routine de libération d'un maillon d'un objet (liste, expression...)
================================================================================	================================================================================
Entrées : structure sur l'état du processus et objet à afficher	Entrées : structure sur l'état du processus et objet à afficher
--------------------------------------------------------------------------------	--------------------------------------------------------------------------------
Line 274 liberation_maillon(struct_processus *s_e	Line 288 liberation_maillon(struct_processus *s_e
================================================================================	================================================================================
*/	*/

void *	struct_objet *
allocation(struct_processus *s_etat_processus, enum t_type type)	allocation(struct_processus *s_etat_processus, enum t_type type)
{	{
struct_objet *s_objet;	struct_objet *s_objet;
Line 758 liberation(struct_processus *s_etat_proc	Line 772 liberation(struct_processus *s_etat_proc
{	{
logical1 drapeau;	logical1 drapeau;

sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_suivant;	struct_liste_chainee *l_element_suivant;

Line 1130 liberation(struct_processus *s_etat_proc	Line 1141 liberation(struct_processus *s_etat_proc

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}
Line 1166 liberation(struct_processus *s_etat_proc	Line 1171 liberation(struct_processus *s_etat_proc
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

(*s_etat_processus).erreur_systeme = d_es_processus;	(*s_etat_processus).erreur_systeme = d_es_processus;
return;	return;
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

if (drapeau == d_vrai)	if (drapeau == d_vrai)
{	{
pthread_mutex_destroy(&(((((struct_processus_fils *)	pthread_mutex_destroy(&(((((struct_processus_fils *)
Line 1513 struct_objet *	Line 1512 struct_objet *
copie_objet(struct_processus *s_etat_processus,	copie_objet(struct_processus *s_etat_processus,
struct_objet *s_objet, unsigned char type)	struct_objet *s_objet, unsigned char type)
{	{
sigset_t oldset;
sigset_t set;

struct_liste_chainee *l_element_base;	struct_liste_chainee *l_element_base;
struct_liste_chainee *l_element_courant;	struct_liste_chainee *l_element_courant;
struct_liste_chainee *l_element_courant_ecriture;	struct_liste_chainee *l_element_courant_ecriture;
Line 2286 copie_objet(struct_processus *s_etat_pro	Line 2282 copie_objet(struct_processus *s_etat_pro

case PRC :	case PRC :
{	{
sigfillset(&set);
pthread_sigmask(SIG_BLOCK, &set, &oldset);

if (pthread_mutex_lock(&(((((struct_processus_fils *)	if (pthread_mutex_lock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return(NULL);	return(NULL);
}	}

Line 2304 copie_objet(struct_processus *s_etat_pro	Line 2294 copie_objet(struct_processus *s_etat_pro
if (pthread_mutex_unlock(&(((((struct_processus_fils *)	if (pthread_mutex_unlock(&(((((struct_processus_fils *)
(*s_objet).objet)).thread).mutex_nombre_references)) != 0)	(*s_objet).objet)).thread).mutex_nombre_references)) != 0)
{	{
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

return(NULL);	return(NULL);
}	}

pthread_sigmask(SIG_SETMASK, &oldset, NULL);
sigpending(&set);

if (type != 'O')	if (type != 'O')
{	{
incrementation_atomique(s_objet);	incrementation_atomique(s_objet);
Line 2817 copie_etat_processus(struct_processus *s	Line 2801 copie_etat_processus(struct_processus *s
* n'ont aucune raison de changer.	* n'ont aucune raison de changer.
*/	*/

	pthread_mutexattr_init(&attributs_mutex);
	pthread_mutexattr_settype(&attributs_mutex, PTHREAD_MUTEX_NORMAL);

# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);	sem_init(&((*s_nouvel_etat_processus).semaphore_fork), 0, 0);
# else	# else
if (((*s_nouvel_etat_processus).semaphore_fork = sem_init2(0, sem_fork))	if (((*s_etat_processus).semaphore_fork = sem_init3(0, getpid(),
== SEM_FAILED)	pthread_self())) == SEM_FAILED)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
}	}
# endif	# endif

	initialisation_contexte_cas(s_etat_processus);

(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;	(*s_nouvel_etat_processus).var_volatile_processus_pere = 0;
(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;	(*s_nouvel_etat_processus).var_volatile_processus_racine = 0;
(*s_nouvel_etat_processus).fichiers_graphiques = NULL;	(*s_nouvel_etat_processus).fichiers_graphiques = NULL;
Line 2841 copie_etat_processus(struct_processus *s	Line 2830 copie_etat_processus(struct_processus *s
(*s_nouvel_etat_processus).processus_detache = d_faux;	(*s_nouvel_etat_processus).processus_detache = d_faux;
(*s_nouvel_etat_processus).evaluation_forcee = 'N';	(*s_nouvel_etat_processus).evaluation_forcee = 'N';

	(*s_nouvel_etat_processus).compteur_violation_d_acces = 0;

(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;	(*s_nouvel_etat_processus).nombre_objets_envoyes_non_lus = 0;
(*s_nouvel_etat_processus).nombre_objets_injectes = 0;	(*s_nouvel_etat_processus).nombre_objets_injectes = 0;
(*s_nouvel_etat_processus).presence_fusible = d_faux;	(*s_nouvel_etat_processus).presence_fusible = d_faux;
Line 3110 copie_etat_processus(struct_processus *s	Line 3101 copie_etat_processus(struct_processus *s
* Copie de la table des variables	* Copie de la table des variables
*/	*/

if (((*s_nouvel_etat_processus).s_arbre_variables =	copie_arbre_variables(s_etat_processus, s_nouvel_etat_processus);
copie_arbre_variables(s_etat_processus)) == NULL)
	if ((*s_nouvel_etat_processus).erreur_systeme != d_es)
{	{
return(NULL);	return(NULL);
}	}

// La pile des variables par niveau n'est pas copiée puisqu'il est
// impossible n'enlever dans un thread une variable créée dans le père.

(*s_etat_processus).l_liste_variables_par_niveau = NULL;

/*	/*
* Copie de la table des variables statiques	* Copie de la table des variables statiques
*/	*/
Line 3288 copie_etat_processus(struct_processus *s	Line 3275 copie_etat_processus(struct_processus *s
* Copie des différents contextes	* Copie des différents contextes
*/	*/

	(*s_nouvel_etat_processus).pointeur_signal_lecture = d_faux;
	(*s_nouvel_etat_processus).pointeur_signal_ecriture = d_faux;

(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;	(*s_nouvel_etat_processus).l_base_pile_contextes = NULL;
l_element_lecture = (*s_etat_processus).l_base_pile_contextes;	l_element_lecture = (*s_etat_processus).l_base_pile_contextes;

Line 3952 debug_fork()	Line 3942 debug_fork()
pthread_mutex_lock(&mutex_allocation);	pthread_mutex_lock(&mutex_allocation);
pid = fork();	pid = fork();

# ifdef OS2
if (pid == 0)	if (pid == 0)
{	{
sem_init(&semaphore_liste_threads, 0, 1);	liberation_queue_signaux(s_etat_processus);
sem_init(&semaphore_gestionnaires_signaux, 0, 0);	creation_queue_signaux(s_etat_processus);
sem_init(&semaphore_gestionnaires_signaux_atomique, 0, 1);
sem_init(&((*s_etat_processus).semaphore_fork), 0, 0);
}
# endif

if (pid == 0)
{
# ifdef _BROKEN_SIGINFO
liberation_fifos_signaux(s_etat_processus);
creation_fifos_signaux(s_etat_processus);
# endif

pthread_mutex_destroy(&mutex_allocation);	pthread_mutex_destroy(&mutex_allocation);
debug_memoire_initialisation();	debug_memoire_initialisation();

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.47
changed lines
	Added in v.1.69