rpl/src/rpl.h - diff

Return to rpl.h CVS log

Up to [local] / rpl / src

Diff for /rpl/src/rpl.h between versions 1.218 and 1.239

version 1.218, 2013/03/26 11:06:14	version 1.239, 2014/04/23 13:43:01
Line 1	Line 1
/*	/*
================================================================================	================================================================================
RPL/2 (R) version 4.1.13	RPL/2 (R) version 4.1.17
Copyright (C) 1989-2013 Dr. BERTRAND Joël	Copyright (C) 1989-2014 Dr. BERTRAND Joël

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

Line 56	Line 56
# define sched_yield(arg)	# define sched_yield(arg)
#endif	#endif

	#ifdef CYGWIN
	# define SA_ONSTACK 0
	#endif


/*	/*
================================================================================	================================================================================
Line 73	Line 77
#include <errno.h>	#include <errno.h>
#include <stdarg.h>	#include <stdarg.h>
#include <poll.h>	#include <poll.h>
	#include <signal.h>

#ifndef RPLARGS	#ifndef RPLARGS
# include <sys/mman.h>	# include <sys/mman.h>
Line 105	Line 110
# include <sys/shm.h>	# include <sys/shm.h>
# endif	# endif

# ifndef IPCS_SYSV	# ifndef __RPLCAS
# include <semaphore.h>	# ifndef IPCS_SYSV
# else	# include <semaphore.h>
# include <sys/ipc.h>	# else
# include <sys/sem.h>	# include <sys/ipc.h>
	# include <sys/sem.h>
# ifdef OS2
# define INCL_DOSSEMAPHORES
# define INCL_DOSMEMMGR
# define INCL_DOSERRORS
# include <os2.h>

typedef struct _OS2SEM
{
HMTX hmtx;
HEV hev;
ULONG shared;
ULONG *cnt;
ULONG *nopened;
ULONG allocated;
} sem_t;
# else // IPCS_SYSV
typedef struct
{
int sem;
int alloue;
unsigned char *path;
pid_t pid;
pthread_t tid;
} sem_t;
# endif

# ifndef SEM_FAILED	# ifdef OS2
# define SEM_FAILED NULL	# define INCL_DOSSEMAPHORES
	# define INCL_DOSMEMMGR
	# define INCL_DOSERRORS
	# include <os2.h>

	typedef struct _OS2SEM
	{
	HMTX hmtx;
	HEV hev;
	ULONG shared;
	ULONG *cnt;
	ULONG *nopened;
	ULONG allocated;
	} sem_t;
	# else // IPCS_SYSV
	typedef struct
	{
	int sem;
	int alloue;
	unsigned char *path;
	pid_t pid;
	pthread_t tid;
	} sem_t;
	# endif

	# ifndef SEM_FAILED
	# define SEM_FAILED NULL
	# endif

	sem_t sem_open_SysV(const char nom, int oflag, ...);
	int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
	int sem_close_SysV(sem_t *sem);
	int sem_wait_SysV(sem_t *sem);
	int sem_trywait_SysV(sem_t *sem);
	int sem_timedwait_SysV(sem_t sem, struct timespec ts);
	int sem_post_SysV(sem_t *sem);
	int sem_getvalue_SysV(sem_t sem, int value);
	int sem_unlink_SysV(char *nom);
	int sem_destroy_SysV(sem_t *sem);
# endif	# endif

sem_t sem_open_SysV(const char nom, int oflag, ...);
int sem_init_SysV(sem_t *sem, int shared, unsigned int value);
int sem_close_SysV(sem_t *sem);
int sem_wait_SysV(sem_t *sem);
int sem_trywait_SysV(sem_t *sem);
int sem_timedwait_SysV(sem_t sem, struct timespec ts);
int sem_post_SysV(sem_t *sem);
int sem_getvalue_SysV(sem_t sem, int value);
int sem_unlink_SysV(char *nom);
int sem_destroy_SysV(sem_t *sem);
# endif	# endif

# include <setjmp.h>	# include <setjmp.h>
# include <signal.h>
# include <termios.h>	# include <termios.h>
# include <time.h>	# include <time.h>
# include <unistd.h>	# include <unistd.h>
Line 314 enum signaux_rpl	Line 320 enum signaux_rpl
#ifndef RPLARGS	#ifndef RPLARGS
typedef struct queue_signaux	typedef struct queue_signaux
{	{
# ifndef IPCS_SYSV
# ifndef SEMAPHORES_NOMMES
sem_t semaphore;
sem_t signalisation;
# endif
# else
sem_t semaphore;
sem_t signalisation;
# endif

volatile int pointeur_lecture;	volatile int pointeur_lecture;
volatile int pointeur_ecriture;	volatile int pointeur_ecriture;
pthread_t thread_signaux;
volatile logical1 requete_arret;	volatile logical1 requete_arret;

	pthread_t thread_signaux;

volatile struct	volatile struct
{	{
pid_t pid;	pid_t pid;
enum signaux_rpl signal;	enum signaux_rpl signal;
} queue[LONGUEUR_QUEUE_SIGNAUX];	} queue[LONGUEUR_QUEUE_SIGNAUX];

	# ifdef OS2
	sem_t semaphore;
	sem_t signalisation;
	sem_t arret_signalisation;
	# endif
} struct_queue_signaux;	} struct_queue_signaux;

__EXTERN__ struct_queue_signaux *s_queue_signaux;	__EXTERN__ struct_queue_signaux *s_queue_signaux;
__EXTERN__ int f_queue_signaux;	__EXTERN__ int f_queue_signaux;

# ifdef SEMAPHORES_NOMMES	# ifndef OS2
__EXTERN__ sem_t *semaphore_queue_signaux;	__EXTERN__ sem_t *semaphore_queue_signaux;
__EXTERN__ sem_t *semaphore_signalisation;	__EXTERN__ sem_t *semaphore_signalisation;
	__EXTERN__ sem_t *semaphore_arret_signalisation;
# endif	# endif
#endif	#endif

Line 473 union semun	Line 477 union semun

__EXTERN__ pid_t pid_processus_pere;	__EXTERN__ pid_t pid_processus_pere;

# ifdef SEMAPHORES_NOMMES
__EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__;
# endif

__EXTERN__ pthread_mutex_t mutex_liste_threads	__EXTERN__ pthread_mutex_t mutex_liste_threads
__STATIC_MUTEX_INITIALIZATION__;	__STATIC_MUTEX_INITIALIZATION__;
__EXTERN__ pthread_mutex_t mutex_gestionnaires_signaux_atomique
__STATIC_MUTEX_INITIALIZATION__;
__EXTERN__ pthread_mutex_t mutex_creation_variable_partagee	__EXTERN__ pthread_mutex_t mutex_creation_variable_partagee
__STATIC_MUTEX_INITIALIZATION__;	__STATIC_MUTEX_INITIALIZATION__;
__EXTERN__ pthread_mutex_t mutex_sections_critiques;	__EXTERN__ pthread_mutex_t mutex_sections_critiques;
__EXTERN__ pthread_mutex_t mutex_liste_variables_partagees;	__EXTERN__ pthread_mutex_t mutex_liste_variables_partagees;
	__EXTERN__ pthread_mutex_t mutex_sem __STATIC_MUTEX_INITIALIZATION__;

__EXTERN__ sem_t __PTR__ semaphore_gestionnaires_signaux;	__EXTERN__ sem_t __PTR__ semaphore_gestionnaires_signaux;

__EXTERN__ volatile int routine_recursive;	__EXTERN__ volatile int routine_recursive;
#endif	#endif

#ifdef SEMAPHORES_NOMMES	#define SEM_FORK 0
#define SEM_FORK 0	#define SEM_QUEUE 1
#define SEM_QUEUE 1	#define SEM_SIGNAUX 2
#define SEM_SIGNAUX 2	#define SEM_SIGNALISATION 3
#define SEM_SIGNALISATION 3	#define SEM_ARRET_SIGNALISATION 4
sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);	sem_t *sem_init2(unsigned int valeur, pid_t pid, int ordre);
sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);	sem_t *sem_init3(unsigned int valeur, pid_t pid, pthread_t tid, int ordre);
int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);	int sem_destroy2(sem_t *semaphore_p, pid_t pid, int ordre);
Line 507 sem_t *sem_open2(pid_t pid, int ordre);	Line 506 sem_t *sem_open2(pid_t pid, int ordre);
// de sem_getvalue() sur un système comme MacOS X qui ne possède pas	// de sem_getvalue() sur un système comme MacOS X qui ne possède pas
// cette fonction.	// cette fonction.

	#ifdef Darwin
#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)	#define sem_getvalue(semaphore, value) sem_getvalue2(semaphore, value)
#define sem_post(semaphore) \	#define sem_post(semaphore) \
({ int r; pthread_mutex_lock(&mutex_sem); \	({ int r; pthread_mutex_lock(&mutex_sem); \
Line 1460 typedef struct descripteur_thread	Line 1460 typedef struct descripteur_thread
int pipe_injections[2];	int pipe_injections[2];
int pipe_nombre_injections[2];	int pipe_nombre_injections[2];
int pipe_interruptions[2];	int pipe_interruptions[2];
int pipe_nombre_objets_attente[2];	// pipe_nombre_elements_attente == 0 => initialisation ou terminaison
int pipe_nombre_interruptions_attente[2];	// pipe_nombre_elements_attente == 1 => objet en attente
	// pipe_nombre_elements_attente == 2 => interruption en attente
	int pipe_nombre_elements_attente[2];
int pipe_acquittement[2];	int pipe_acquittement[2];

volatile integer8 nombre_objets_dans_pipe;	volatile integer8 nombre_objets_dans_pipe;
Line 1945 typedef struct processus	Line 1947 typedef struct processus
int pipe_injections;	int pipe_injections;
int pipe_nombre_injections;	int pipe_nombre_injections;
int pipe_interruptions;	int pipe_interruptions;
int pipe_nombre_objets_attente;	int pipe_nombre_elements_attente;
int pipe_nombre_interruptions_attente;
int nombre_objets_envoyes_non_lus;	int nombre_objets_envoyes_non_lus;
int nombre_objets_injectes;	int nombre_objets_injectes;

Line 2182 typedef struct processus	Line 2183 typedef struct processus
/* Traitement des erreurs */	/* Traitement des erreurs */

int erreur_compilation;	int erreur_compilation;
int erreur_execution;	volatile int erreur_execution;
int erreur_systeme;	volatile int erreur_systeme;

struct_objet *s_objet_errone;	struct_objet *s_objet_errone;
struct_objet *s_objet_erreur;	struct_objet *s_objet_erreur;
Line 2304 typedef struct processus	Line 2305 typedef struct processus
struct_liste_profilage2 *pile_profilage_fonctions;	struct_liste_profilage2 *pile_profilage_fonctions;
struct timeval horodatage_profilage;	struct timeval horodatage_profilage;

// Mutex spécifique au processus et donnant accès à la pile des processus
pthread_mutex_t mutex;
pthread_mutex_t mutex_allocation;	pthread_mutex_t mutex_allocation;
	pthread_mutex_t mutex_interruptions;
	pthread_mutex_t mutex_pile_processus;
	pthread_mutex_t mutex_signaux;

// Mutex autorisant les fork()	// Mutex autorisant les fork()
sem_t __PTR__ semaphore_fork;	sem_t __PTR__ semaphore_fork;
Line 2317 typedef struct processus	Line 2319 typedef struct processus
pthread_mutex_t protection_liste_mutexes;	pthread_mutex_t protection_liste_mutexes;
unsigned int sections_critiques;	unsigned int sections_critiques;

/* Drapeau nécessaire à RESTART */	/* Variable d'initialisation pour SCHED */

	logical1 initialisation_scheduler;

	/* Drapeau nécessaire à RESTART */

volatile logical1 requete_redemarrage;	volatile logical1 requete_redemarrage;

Line 2792 void instruction_return(struct_processus	Line 2798 void instruction_return(struct_processus
void instruction_revlist(struct_processus *s_etat_processus);	void instruction_revlist(struct_processus *s_etat_processus);
void instruction_rewind(struct_processus *s_etat_processus);	void instruction_rewind(struct_processus *s_etat_processus);
void instruction_rfuse(struct_processus *s_etat_processus);	void instruction_rfuse(struct_processus *s_etat_processus);
	void instruction_rgdl(struct_processus *s_etat_processus);
	void instruction_rgdr(struct_processus *s_etat_processus);
void instruction_rl(struct_processus *s_etat_processus);	void instruction_rl(struct_processus *s_etat_processus);
void instruction_rlb(struct_processus *s_etat_processus);	void instruction_rlb(struct_processus *s_etat_processus);
void instruction_rnd(struct_processus *s_etat_processus);	void instruction_rnd(struct_processus *s_etat_processus);

CVSweb interface <joel.bertrand@systella.fr>

Removed from v.1.218
changed lines
	Added in v.1.239