rpl/src/gestion_processus.c - diff

Return to gestion_processus.c CVS log

Up to [local] / rpl / src

Diff for /rpl/src/gestion_processus.c between versions 1.53 and 1.64

version 1.53, 2012/04/13 14:12:49	version 1.64, 2013/03/21 16:34:08
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.8	RPL/2 (R) version 4.1.13
Copyright (C) 1989-2012 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 40	Line 40
void *	void *
surveillance_processus(void *argument)	surveillance_processus(void *argument)
{	{
int iostat;
int status;	int status;

integer8 nombre_donnees;	integer8 nombre_donnees;
Line 57 surveillance_processus(void *argument)	Line 56 surveillance_processus(void *argument)

pthread_t tid_candidat;	pthread_t tid_candidat;

	ssize_t iostat;
ssize_t longueur_ecriture;	ssize_t longueur_ecriture;

struct_descripteur_thread *s_argument_thread;	struct_descripteur_thread *s_argument_thread;
Line 70 surveillance_processus(void *argument)	Line 70 surveillance_processus(void *argument)

unsigned char caractere;	unsigned char caractere;

unsigned int tampon_erreur_execution;	int tampon_erreur_execution;
unsigned int tampon_erreur_systeme;	int tampon_erreur_systeme;

	sigset_t set;

	sigfillset(&set);
	pthread_sigmask(SIG_BLOCK, &set, NULL);

s_argument_thread = argument;	s_argument_thread = argument;
s_etat_processus = (*s_argument_thread).s_etat_processus;	s_etat_processus = (*s_argument_thread).s_etat_processus;
Line 1855 ecriture_pipe(struct_processus *s_etat_p	Line 1860 ecriture_pipe(struct_processus *s_etat_p

struct timespec attente;	struct timespec attente;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;

size_t longueur;	size_t longueur;
ssize_t longueur_ecriture;	ssize_t longueur_ecriture;
Line 1986 ecriture_pipe(struct_processus *s_etat_p	Line 1991 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2039 ecriture_pipe(struct_processus *s_etat_p	Line 2044 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2092 ecriture_pipe(struct_processus *s_etat_p	Line 2097 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_vecteur ) (*s_objet).objet))	&((((struct_vecteur ) (*s_objet).objet))
.taille), sizeof(unsigned long))) != sizeof(unsigned long))	.taille), sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2145 ecriture_pipe(struct_processus *s_etat_p	Line 2150 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2161 ecriture_pipe(struct_processus *s_etat_p	Line 2166 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2220 ecriture_pipe(struct_processus *s_etat_p	Line 2225 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2236 ecriture_pipe(struct_processus *s_etat_p	Line 2241 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2295 ecriture_pipe(struct_processus *s_etat_p	Line 2300 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),	&((((struct_matrice ) (*s_objet).objet)).nombre_lignes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2311 ecriture_pipe(struct_processus *s_etat_p	Line 2316 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),	&((((struct_matrice ) (*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2505 ecriture_pipe(struct_processus *s_etat_p	Line 2510 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_fonction ) (*s_objet).objet)).nombre_arguments),	&((((struct_fonction ) (*s_objet).objet)).nombre_arguments),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2647 ecriture_pipe(struct_processus *s_etat_p	Line 2652 ecriture_pipe(struct_processus *s_etat_p

while((longueur_ecriture = write_atomic(s_etat_processus, pipe,	while((longueur_ecriture = write_atomic(s_etat_processus, pipe,
&((((struct_tableau ) (*s_objet).objet)).nombre_elements),	&((((struct_tableau ) (*s_objet).objet)).nombre_elements),
sizeof(unsigned long))) != sizeof(unsigned long))	sizeof(integer8))) != sizeof(integer8))
{	{
if (longueur_ecriture == -1)	if (longueur_ecriture == -1)
{	{
Line 2703 lecture_pipe(struct_processus *s_etat_pr	Line 2708 lecture_pipe(struct_processus *s_etat_pr

struct timespec attente;	struct timespec attente;

unsigned long i;	integer8 i;
unsigned long j;	integer8 j;

if ((s_objet = allocation(s_etat_processus, NON)) == NULL)	if ((s_objet = allocation(s_etat_processus, NON)) == NULL)
{	{
Line 2791 lecture_pipe(struct_processus *s_etat_pr	Line 2796 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(integer8))) == NULL)	.taille) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2835 lecture_pipe(struct_processus *s_etat_pr	Line 2840 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(real8))) == NULL)	.taille) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2879 lecture_pipe(struct_processus *s_etat_pr	Line 2884 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )	while(read_atomic(s_etat_processus, pipe, &((((struct_vecteur )
(*s_objet).objet)).taille),	(*s_objet).objet)).taille),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_vecteur ) (*s_objet).objet)).tableau =	if (((((struct_vecteur ) (*s_objet).objet)).tableau =
malloc((((struct_vecteur ) (s_objet).objet)).taille	malloc(((size_t) (((struct_vecteur ) (*s_objet).objet))
sizeof(complex16))) == NULL)	.taille) * sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2923 lecture_pipe(struct_processus *s_etat_pr	Line 2928 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 2934 lecture_pipe(struct_processus *s_etat_pr	Line 2939 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(integer8 *))) == NULL)	.nombre_lignes) * sizeof(integer8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2952 lecture_pipe(struct_processus *s_etat_pr	Line 2957 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(integer8))) == NULL)	.nombre_colonnes) * sizeof(integer8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 2991 lecture_pipe(struct_processus *s_etat_pr	Line 2996 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3002 lecture_pipe(struct_processus *s_etat_pr	Line 3007 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(real8 *))) == NULL)	.nombre_lignes) * sizeof(real8 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3020 lecture_pipe(struct_processus *s_etat_pr	Line 3025 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(real8))) == NULL)	.nombre_colonnes) * sizeof(real8))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3059 lecture_pipe(struct_processus *s_etat_pr	Line 3064 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_lignes),	(*s_objet).objet)).nombre_lignes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3070 lecture_pipe(struct_processus *s_etat_pr	Line 3075 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )	while(read_atomic(s_etat_processus, pipe, &((((struct_matrice )
(*s_objet).objet)).nombre_colonnes),	(*s_objet).objet)).nombre_colonnes),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_matrice ) (*s_objet).objet)).tableau =	if (((((struct_matrice ) (*s_objet).objet)).tableau =
malloc((((struct_matrice ) (s_objet).objet)).nombre_lignes	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
sizeof(complex16 *))) == NULL)	.nombre_lignes) * sizeof(complex16 *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3088 lecture_pipe(struct_processus *s_etat_pr	Line 3093 lecture_pipe(struct_processus *s_etat_pr
(*s_objet).objet)).nombre_lignes; i++)	(*s_objet).objet)).nombre_lignes; i++)
{	{
if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =	if ((((((struct_matrice ) (*s_objet).objet)).tableau)[i] =
malloc((((struct_matrice ) (*s_objet).objet))	malloc(((size_t) (((struct_matrice ) (*s_objet).objet))
.nombre_colonnes * sizeof(complex16))) == NULL)	.nombre_colonnes) * sizeof(complex16))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);
Line 3217 lecture_pipe(struct_processus *s_etat_pr	Line 3222 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe,	while(read_atomic(s_etat_processus, pipe,
&((((struct_fonction ) (*s_objet).objet))	&((((struct_fonction ) (*s_objet).objet))
.nombre_arguments), sizeof(unsigned long)) !=	.nombre_arguments), sizeof(integer8)) !=
sizeof(unsigned long))	sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
Line 3338 lecture_pipe(struct_processus *s_etat_pr	Line 3343 lecture_pipe(struct_processus *s_etat_pr

while(read_atomic(s_etat_processus, pipe, &((((struct_tableau )	while(read_atomic(s_etat_processus, pipe, &((((struct_tableau )
(*s_objet).objet)).nombre_elements),	(*s_objet).objet)).nombre_elements),
sizeof(unsigned long)) != sizeof(unsigned long))	sizeof(integer8)) != sizeof(integer8))
{	{
nanosleep(&attente, NULL);	nanosleep(&attente, NULL);
INCR_GRANULARITE(attente.tv_nsec);	INCR_GRANULARITE(attente.tv_nsec);
}	}

if (((((struct_tableau ) (*s_objet).objet)).elements = malloc(	if (((((struct_tableau ) (*s_objet).objet)).elements = malloc(
(((struct_tableau ) (s_objet).objet)).nombre_elements	((size_t) (((struct_tableau ) (*s_objet).objet))
sizeof(struct_objet *))) == NULL)	.nombre_elements) * sizeof(struct_objet *))) == NULL)
{	{
(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;	(*s_etat_processus).erreur_systeme = d_es_allocation_memoire;
return(NULL);	return(NULL);

CVSweb interface <joel.bertrand@systella.fr>

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