rpl/src/gestion_threads.c - diff

Return to gestion_threads.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_threads.c between versions 1.53 and 1.76

version 1.53, 2011/09/20 14:36:29	version 1.76, 2013/03/26 09:04:32
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.3	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2011 Dr. BERTRAND Joël	Copyright (C) 1989-2013 Dr. BERTRAND Joël

This file is part of RPL/2.	This file is part of RPL/2.

Line 38	Line 38
void *	void *
lancement_thread(void *argument)	lancement_thread(void *argument)
{	{
int status;	int status;

pid_t ppid;	pid_t ppid;

pthread_t tid_final;	pthread_t tid_final;

sig_atomic_t registre_stop;	sig_atomic_t registre_stop;

ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;

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

struct_objet *s_objet_temporaire;	struct_liste_variables_statiques *l_element_statique_courant;
	struct_liste_variables_statiques *l_element_statique_suivant;

struct_processus *s_etat_processus;	struct_objet *s_objet_temporaire;

struct sigaction action;	struct_processus *s_etat_processus;
struct sigaction registre;

struct timespec attente;	struct sigaction action;
	struct sigaction registre;

unsigned char *message;	struct timespec attente;

unsigned int erreur;	unsigned char *message;

unsigned long i;	unsigned int erreur;

	integer8 i;

attente.tv_sec = 0;	attente.tv_sec = 0;
attente.tv_nsec = GRANULARITE_us * 1000;	attente.tv_nsec = GRANULARITE_us * 1000;

s_argument_thread = (struct_descripteur_thread *) argument;	s_argument_thread = (struct_descripteur_thread *) argument;
s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;	s_etat_processus = (*s_argument_thread).s_nouvel_etat_processus;
(*s_argument_thread).tid = pthread_self();
(*s_argument_thread).thread_actif = d_vrai;

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

	(*s_argument_thread).tid = pthread_self();
insertion_thread(s_etat_processus, d_faux);	insertion_thread(s_etat_processus, d_faux);
	(*s_argument_thread).thread_actif = d_vrai;

// Envoi d'une donnée pour signaler le démarrage du thread au thread	// Envoi d'une donnée pour signaler le démarrage du thread au thread
// de surveillance.	// de surveillance.
Line 92 lancement_thread(void *argument)	Line 106 lancement_thread(void *argument)

(*s_argument_thread).thread_actif = d_faux;	(*s_argument_thread).thread_actif = d_faux;

tid_final = -2;	tid_final = (pthread_t) -2;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_interruptions_attente[1],
Line 174 lancement_thread(void *argument)	Line 188 lancement_thread(void *argument)
}	}
else	else
{	{
if (((*s_etat_processus).var_volatile_alarme == 0)	if (((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).arret_depuis_abort == 0)
&& ((*s_etat_processus).at_exit != NULL))	&& ((*s_etat_processus).at_exit != NULL))
{	{
(*s_etat_processus).var_volatile_requete_arret = 0;	(*s_etat_processus).var_volatile_requete_arret = 0;
(*s_etat_processus).var_volatile_traitement_retarde_stop =	(*s_etat_processus).var_volatile_alarme = 0;
-1;

if (evaluation(s_etat_processus,	if (evaluation(s_etat_processus,
(*s_etat_processus).at_exit, 'E') == d_erreur)	(*s_etat_processus).at_exit, 'E') == d_erreur)
Line 207 lancement_thread(void *argument)	Line 219 lancement_thread(void *argument)
pthread_cancel((*s_etat_processus).thread_fusible);	pthread_cancel((*s_etat_processus).thread_fusible);
}	}

tid_final = -2;	tid_final = (pthread_t) -2;

while((longueur_ecriture = write_atomic(s_etat_processus,	while((longueur_ecriture = write_atomic(s_etat_processus,
(*s_argument_thread).pipe_nombre_interruptions_attente[1],	(*s_argument_thread).pipe_nombre_interruptions_attente[1],
Line 563 lancement_thread(void *argument)	Line 575 lancement_thread(void *argument)
.var_volatile_traitement_retarde_stop;	.var_volatile_traitement_retarde_stop;
(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;	(*s_etat_processus).var_volatile_traitement_retarde_stop = 1;

for(i = 0; i < (unsigned long) ((((struct_processus_fils *)	for(i = 0; i < ((((struct_processus_fils *)
((l_element_courant).donnee).objet)).thread)	((l_element_courant).donnee).objet)).thread)
.nombre_objets_dans_pipe; i++)	.nombre_objets_dans_pipe; i++)
{	{
Line 801 lancement_thread(void *argument)	Line 813 lancement_thread(void *argument)
liberation_arbre_variables(s_etat_processus,	liberation_arbre_variables(s_etat_processus,
(*s_etat_processus).s_arbre_variables, d_faux);	(*s_etat_processus).s_arbre_variables, d_faux);

for(i = 0; i < (*s_etat_processus).nombre_variables_statiques; i++)	l_element_statique_courant = (*s_etat_processus)
	.l_liste_variables_statiques;

	while(l_element_statique_courant != NULL)
{	{
liberation(s_etat_processus,	l_element_statique_suivant = (*l_element_statique_courant).suivant;
(*s_etat_processus).s_liste_variables_statiques[i].objet);	free(l_element_statique_courant);
free((*s_etat_processus).s_liste_variables_statiques[i].nom);	l_element_statique_courant = l_element_statique_suivant;
}	}

free((*s_etat_processus).s_liste_variables_statiques);

l_element_courant = (*s_etat_processus).l_base_pile;	l_element_courant = (*s_etat_processus).l_base_pile;
while(l_element_courant != NULL)	while(l_element_courant != NULL)
{	{
Line 987 lancement_thread(void *argument)	Line 1000 lancement_thread(void *argument)
# ifndef SEMAPHORES_NOMMES	# ifndef SEMAPHORES_NOMMES
sem_destroy(&((*s_etat_processus).semaphore_fork));	sem_destroy(&((*s_etat_processus).semaphore_fork));
# else	# else
sem_destroy2((*s_etat_processus).semaphore_fork, getpid());	sem_destroy3((*s_etat_processus).semaphore_fork, getpid(),
	pthread_self(), SEM_FORK);
# endif	# endif

liberation_contexte_cas(s_etat_processus);	liberation_contexte_cas(s_etat_processus);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.53
changed lines
	Added in v.1.76