296 lines
13 KiB
C
296 lines
13 KiB
C
/*---------------------------------------------------------------------------------*/
|
||
/* $RCSfile: libshmem.h,v $ */
|
||
/*---------------------------------------------------------------------------------*/
|
||
/* $Revision: 2.3 $ */
|
||
/* $Name: $ */
|
||
/* $Date: 2005/06/26 23:02:35 $ */
|
||
/* $Author: agibert $ */
|
||
/*---------------------------------------------------------------------------------*/
|
||
|
||
/*---------------------------------------------------------------------------------*/
|
||
/* This file is part of LibShMem */
|
||
/* */
|
||
/* LibShMem is free software; you can redistribute it and/or modify */
|
||
/* it under the terms of the GNU Lesser General Public Licence as published by */
|
||
/* the Free Software Foundation; either version 2.1 of the License, or */
|
||
/* (at your option) any later version. */
|
||
/* */
|
||
/* LibShMem is distributed in the hope that it will be useful, */
|
||
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
|
||
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
|
||
/* GNU Lesser General Public License for more details. */
|
||
/* */
|
||
/* You should have received a copy of the GNU Lesser General Public License */
|
||
/* along with LibShMem; if not, write to the Free Software */
|
||
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
|
||
/*---------------------------------------------------------------------------------*/
|
||
|
||
|
||
|
||
|
||
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <string.h>
|
||
#include <unistd.h>
|
||
#include <errno.h>
|
||
|
||
#include <sys/sem.h>
|
||
#include <sys/shm.h>
|
||
#include <sys/ipc.h>
|
||
|
||
#include <shmem.h>
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
|
||
/* Compteur d'ouverture de la librairie */
|
||
|
||
unsigned int SM_Open_Counter = 0;
|
||
|
||
|
||
/* Flux de sortie des messages d'erreur g<>n<EFBFBD>r<EFBFBD>s par la librairie */
|
||
|
||
FILE * SM_stderr;
|
||
|
||
extern char * strdup (const char *);
|
||
|
||
#define max(A,B) ((A < B) ? B : A)
|
||
|
||
|
||
/* Limite sup<75>rieure d'adressage */
|
||
|
||
#define MEM_LIMIT 1000000000
|
||
|
||
|
||
//#define SMD_CMD_VALUE_SUM (NDT_Command)65
|
||
#define NDD_CMD_VALUE_SUM (NDT_Command)NDD_CMD_USER_TRAVERSE
|
||
|
||
|
||
/* Taille d'un segment = 100 Ko par d<>faut */
|
||
|
||
#define K 1024
|
||
#define NB_BLOCS 100
|
||
#define SEGMENT_DEFAULT_SIZE NB_BLOCS * K
|
||
|
||
char Info_Msg [256];
|
||
|
||
|
||
/* Etats possibles pour un heap */
|
||
|
||
#define SMD_STATE_VALID 0
|
||
#define SMD_STATE_UNVALIDATED 1
|
||
#define SMD_STATE_CORRUPTED 2
|
||
|
||
/* R<>f<EFBFBD>rence sur le heap syst<73>me */
|
||
|
||
SMT_Heap * System_Heap;
|
||
|
||
/* Liste des heaps ouverts par le processus courant */
|
||
|
||
NDT_Root * Opened_Heap_List;
|
||
|
||
/*
|
||
Taille par d<>faut des chunks allou<6F>s dans le heap syst<73>me :
|
||
Cette taille est fix<69>e <20> la taille maximale des chunks pouvant
|
||
y <20>tre allou<6F> (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH)
|
||
*/
|
||
|
||
#define DEFAULT_CHUNK_SIZE max(max(sizeof(NDT_Root), sizeof(NDT_Node)), max(sizeof(SMT_MHH), sizeof(SMT_DSH)))
|
||
|
||
/*
|
||
Nombre de chunk libre minimum avant extension du heap syst<73>me par un
|
||
nouveau segment de donn<6E>es (fix<69> <20> 3 car l'ajout d'un nouveau segment
|
||
n<>cessite l'allocation de 2 chunks (un noeud et une ent<6E>te de segment).
|
||
*/
|
||
|
||
#define FREE_CHUNK_LIMIT 3
|
||
|
||
int SM_Instance;
|
||
char * SM_Context;
|
||
|
||
/* Contexte et instance d'utilisation de la librairie */
|
||
|
||
#define DEFAULT_INSTANCE 1000
|
||
#define INSTANCE_ENV_VAR "INSTANCE"
|
||
|
||
#define DEFAULT_CONTEXT "CTX"
|
||
#define CONTEXT_ENV_VAR "CONTEXT"
|
||
|
||
/*
|
||
Variable globale permettant d'indiquer que l'on est en train
|
||
d'<27>tendre le heap syst<73>me par ajout d'un nouveau segment.
|
||
*/
|
||
|
||
unsigned int Adding_Segment = FALSE;
|
||
|
||
SMT_Chunk * Tmp_Chunk;
|
||
SMT_MHH * Tmp_MHH;
|
||
|
||
/*
|
||
D<>finition des op<6F>rations de verouillage et de d<>verrouillage
|
||
NB : la valeur 1 d'un s<>maphore correspond <20> l'<27>tat non verrouill<6C>
|
||
*/
|
||
|
||
/* Pose d'un verrou en lecture : 2 op<6F>rations : ( -1 puis +2 ) */
|
||
|
||
struct sembuf SM_SemOp_SSL [2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} };
|
||
|
||
/* Lib<69>ration d'un verrou en lecture : 2 op<6F>rations ( -2 puis +1 ) */
|
||
|
||
struct sembuf SM_SemOp_RSL [2] = { {0, -2, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
||
|
||
/* Pose d'un verrou en <20>criture : 2 op<6F>rations ( -1 puis 0 ) */
|
||
|
||
struct sembuf SM_SemOp_SEL [2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} };
|
||
|
||
/* Lib<69>ration d'un verrou en <20>criture : 2 op<6F>rations ( 0 puis +1 ) */
|
||
|
||
struct sembuf SM_SemOp_REL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 1, SEM_UNDO|IPC_NOWAIT} };
|
||
|
||
/* Transformation d'un verrou en <20>criture en un verrou en lecture : 2 op<6F>rations ( 0 puis +2 ) */
|
||
|
||
struct sembuf SM_SemOp_TSL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 2, SEM_UNDO|IPC_NOWAIT} };
|
||
|
||
typedef union semun
|
||
{
|
||
int val;
|
||
struct semid_ds * buf;
|
||
unsigned short int * array;
|
||
} semun;
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Allocation de m<>moire dans la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_Base_Alloc( void **, size_t, void *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* D<>sallocation de m<>moire dans la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_Base_Free( void *, void *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Allocation de m<>moire dans le heap syst<73>me */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_System_Alloc( void **, size_t, void *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* D<>sallocation de m<>moire dans le heap syst<73>me */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_System_Free( void *, void *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Initialisation de la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_Init (void);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Terminaison de la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_End (void);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Ouverture de la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_Open (void);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fermeture de la base */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_Close (void);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Pose d'un verrou sur la base : */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_Lock (SMT_Flags);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Lib<69>ration d'un verrou sur la base : */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Base_Unlock (SMT_Flags);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fonction manager de la liste des heaps ouverts */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_Opened_Heap_List_Manager ( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fonction manager du MHR (Memory Heap Root) */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status MHR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Destruction d'un MHH (Memory Heap Header) */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_MHH_End (SMT_MHH *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fonction manager pour un DSR (Data Segment Root) */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_DSR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Ouverture d'un segment de donn<6E>es */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_DataSegment_Open (SMT_DSH *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fermeture d'un segment de donn<6E>es */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_DataSegment_Close (SMT_DSH *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Compression d'un segment de donn<6E>es */
|
||
/*------------------------------------------------------------------------------*/
|
||
size_t SM_DataSegment_Compress (SMT_DSH *, NDT_Root *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fonction manager pour un ACR (Allocated Chunk Root) */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_ACR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Fonction manager pour un FCR (Free Chunk Root) */
|
||
/*------------------------------------------------------------------------------*/
|
||
NDT_Status SM_FCR_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Pose d'un verrou sur un heap : */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Heap_Lock_Set (SMT_MHH *, SMT_Flags);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Changement d'un verrou sur un heap : */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Heap_Lock_Change (SMT_MHH *, SMT_Flags);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Lib<69>ration d'un verrou sur un heap : */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Heap_Lock_Release (SMT_MHH *, SMT_Flags);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Op<4F>ration sur un s<>maphore */
|
||
/*------------------------------------------------------------------------------*/
|
||
SMT_Status SM_Semaphore_Operate (int, struct sembuf *, unsigned int);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* R<>cup<75>re sous forme explicite l'<27>tat d'un verrou */
|
||
/*------------------------------------------------------------------------------*/
|
||
char * SM_Lock_Status_Get (const char *, void *);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Routine d'affichage d'un message d'erreur */
|
||
/*------------------------------------------------------------------------------*/
|
||
void SM_Error_Print (void);
|
||
|
||
/*------------------------------------------------------------------------------*/
|
||
/* Pour pr<70>fixer un nom de heap avec le nom de l'instance utilis<69>e */
|
||
/*------------------------------------------------------------------------------*/
|
||
static char * SM_Name_Prefix (const char *);
|