Rx3/libshmem
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Initial support for LibNode 2.1.x.

Browse Source 
Not working version...
Update revision number to 2.0 !
This commit is contained in:
agibert 2005-01-24 22:57:06 +00:00
parent 626c9e80f1
commit bb73fb28cc
3 changed files with 1099 additions and 598 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
include/shmem.h
View File

@ -1,3 +1,34 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: shmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.0 $ */
/* $Name: $ */
/* $Date: 2005/01/24 22:57:06 $ */
/* $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 */
/*---------------------------------------------------------------------------------*/
#ifndef _LIBSM #ifndef _LIBSM
#define _LIBSM #define _LIBSM
@ -11,7 +42,7 @@ extern "C" {
/* Code retour des fonctions constituant l'API */ /* Code retour des fonctions constituant l'API */
typedef long SMT_Status; typedef long SMT_Status;
#define SMS_OK NDS_OK /* La fonction s'est correctement exécutée et a produit un résultat */ #define SMS_OK NDS_OK /* La fonction s'est correctement exécutée et a produit un résultat */
#define SMS_KO NDS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */ #define SMS_KO NDS_KO /* La fonction s'est correctement exécutée mais n'a pas produit de résultat */
@ -28,7 +59,7 @@ typedef long SMT_Status;
#define SM_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */ #define SM_ERROR(s) ((s) < 0) /* Tous les codes retour négatifs correspondent à des erreurs */
typedef int SMT_Flags; typedef int SMT_Flags;
#define SMD_UNDEF 0 #define SMD_UNDEF 0
@ -59,12 +90,12 @@ typedef int SMT_Flags;
/* Différentes types de configuration d'un heap */ /* Différentes types de configuration d'un heap */
typedef int SMT_Config; typedef int SMT_Config;
#define SMD_SEGMENT_SIZE 1 /* Définir la taille des segments */ #define SMD_SEGMENT_SIZE 1 /* Définir la taille des segments */
#define SMD_HEAP_LIMIT 2 /* Définir la taille maximale */ #define SMD_HEAP_LIMIT 2 /* Définir la taille maximale */
#define SMD_AUTO_COMPRESS 3 /* Définir la taille d'un FCR à partir de laquelle #define SMD_AUTO_COMPRESS 3 /* Définir la taille d'un FCR à partir de laquelle
la compression du heap est autmatiquement activée */ la compression du heap est autmatiquement activée */
#define SMD_DEFAULT_COMPRESS 1000 /* si + de 1000 chunks libres, alors compression du heap */ #define SMD_DEFAULT_COMPRESS 1000 /* si + de 1000 chunks libres, alors compression du heap */
@ -85,7 +116,7 @@ typedef int SMT_Config;
#define TRUE 1 #define TRUE 1
#endif #endif
char SM_Error_Msg [512]; char SM_Error_Msg [512];
#ifndef SM_MODE #ifndef SM_MODE
#define SM_MODE 0 #define SM_MODE 0
@ -143,70 +174,70 @@ char SM_Error_Msg [512];
/* Structure de la base de heaps */ /* Structure de la base de heaps */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
typedef struct { typedef struct {
int SysMemID; /* ID de la 1ère zone de mémoire partagée de la base */ int SysMemID; /* ID de la 1ère zone de mémoire partagée de la base */
int DataMemID; /* ID de la 2ème zone de mémoire partagée de la base */ int DataMemID; /* ID de la 2ème zone de mémoire partagée de la base */
size_t Size; /* Taille de la zone de mémoire partagée */ size_t Size; /* Taille de la zone de mémoire partagée */
int SemID; /* ID du sémaphore pour la gestion des verrous */ int SemID; /* ID du sémaphore pour la gestion des verrous */
NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */ NDT_Root * MHR; /* Memory Heap Root : racine de la liste de heap */
pid_t Creator; /* ID du processus créateur de la base */ pid_t Creator; /* ID du processus créateur de la base */
pid_t Writer; /* ID du dernier processus ayant accédé en écriture à la base */ pid_t Writer; /* ID du dernier processus ayant accédé en écriture à la base */
void * Free; /* Pointeur sur la première zone libre de la base */ void * Free; /* Pointeur sur la première zone libre de la base */
void * Attach; /* Adresse du dernier attachement */ void * Attach; /* Adresse du dernier attachement */
size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */ size_t Segment_Size; /* Taille par défaut des segments qui composeront les heaps */
} SMT_Base; } SMT_Base;
/* Référence sur la base de heaps */ /* Référence sur la base de heaps */
SMT_Base * SM_Base; SMT_Base * SM_Base;
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Structure d'un MHH (Memory Heap Header) */ /* Structure d'un MHH (Memory Heap Header) */
/* Rappel : un MHH est une valeur attachée à un MHN (Memory Heap Node) */ /* Rappel : un MHH est une valeur attachée à un MHN (Memory Heap Node) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
typedef struct { typedef struct {
char Name [256]; /* Nom du heap */ char Name [256]; /* Nom du heap */
int SemID; /* ID du sémaphore pour la gestion des verrous */ int SemID; /* ID du sémaphore pour la gestion des verrous */
NDT_Root * DSR; /* Data Segment Root */ NDT_Root * DSR; /* Data Segment Root */
NDT_Root * ACR; /* Allocated Chunks Root */ NDT_Root * ACR; /* Allocated Chunks Root */
NDT_Root * FCR; /* Free Chunks Root */ NDT_Root * FCR; /* Free Chunks Root */
pid_t Writer; /* ID du processus ayant accédé en dernier au MHH en écriture */ pid_t Writer; /* ID du processus ayant accédé en dernier au MHH en écriture */
int State; /* Etat d'un heap (valide, non validé ou corrompu) */ int State; /* Etat d'un heap (valide, non validé ou corrompu) */
size_t Segment_Size; /* Taille des segments de mémoire composant le heap */ size_t Segment_Size; /* Taille des segments de mémoire composant le heap */
size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */ size_t Limit_Size; /* Taille limite du heap (par défaut : pas de limite) */
int Auto_Compress; /* Nombre de chunks libres à partir duquel le heap est automatiquement compressé */ int Auto_Compress; /* Nombre de chunks libres à partir duquel le heap est automatiquement compressé */
} SMT_MHH; } SMT_MHH;
/* Heap ouvert */ /* Heap ouvert */
typedef struct { typedef struct {
char * Name; char * Name;
SMT_MHH * MHH; SMT_MHH * MHH;
SMT_Flags Lock_Mode; /* Mode dans lequel le heap est verrouillé */ SMT_Flags Lock_Mode; /* Mode dans lequel le heap est verrouillé */
int Nb_Seg; /* Nombre de segments du heap lors de son ouverture */ int Nb_Seg; /* Nombre de segments du heap lors de son ouverture */
} SMT_Heap; } SMT_Heap;
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Structure d'un DSH (Data Segment Header) */ /* Structure d'un DSH (Data Segment Header) */
/* Rappel : un DSH est une valeur attachée à un DSN (noeud de DSR) */ /* Rappel : un DSH est une valeur attachée à un DSN (noeud de DSR) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
typedef struct { typedef struct {
int MemID; /* ID de la zone de mémoire partagée */ int MemID; /* ID de la zone de mémoire partagée */
size_t Size; /* Taille de la zone de mémoire partagée */ size_t Size; /* Taille de la zone de mémoire partagée */
void * Start; /* Adresse de début de la zone de mémoire partagée */ void * Start; /* Adresse de début de la zone de mémoire partagée */
} SMT_DSH; } SMT_DSH;
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Structure d'un chunk */ /* Structure d'un chunk */
/* Rappel : un chunk est la valeur attachée à un noeud de ACR ou FCR */ /* Rappel : un chunk est la valeur attachée à un noeud de ACR ou FCR */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
typedef struct { typedef struct {
size_t Size; /* Taille allouée au chunk */ size_t Size; /* Taille allouée au chunk */
void * Data; /* Adresse de la zone de données du chunk */ void * Data; /* Adresse de la zone de données du chunk */
} SMT_Chunk; } SMT_Chunk;
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Ouverture d'une instance de la librairie */ /* Ouverture d'une instance de la librairie */
@ -215,68 +246,68 @@ typedef struct {
/* (I) Context : nom du nouveau contexte */ /* (I) Context : nom du nouveau contexte */
/* (I) Flags : indicateur création/ouverture + mode d'affichage des erreurs */ /* (I) Flags : indicateur création/ouverture + mode d'affichage des erreurs */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Open_I ( int Instance, const char * Context, SMT_Flags Flags ); SMT_Status SM_Library_Open_I ( int Instance, const char * Context, SMT_Flags Flags );
SMT_Status SM_Library_Open_C ( int Instance, const char * Context, SMT_Flags Flags ); SMT_Status SM_Library_Open_C ( int Instance, const char * Context, SMT_Flags Flags );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Récupération du numéro de l'instance utilisée */ /* Récupération du numéro de l'instance utilisée */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (O) Instance : adresse du numéro de l'instance utilisée */ /* (O) Instance : adresse du numéro de l'instance utilisée */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Instance_Get_I ( int * Instance); SMT_Status SM_Library_Instance_Get_I ( int * Instance);
SMT_Status SM_Library_Instance_Get_C ( int * Instance); SMT_Status SM_Library_Instance_Get_C ( int * Instance);
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Changement de contexte d'utilisation de la librairie */ /* Changement de contexte d'utilisation de la librairie */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Context : nom du nouveau contexte */ /* (I) Context : nom du nouveau contexte */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Context_Set_I ( const char * Context ); SMT_Status SM_Library_Context_Set_I ( const char * Context );
SMT_Status SM_Library_Context_Set_C ( const char * Context ); SMT_Status SM_Library_Context_Set_C ( const char * Context );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Récupération du nom du contexte utilisé */ /* Récupération du nom du contexte utilisé */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (O) Context : adresse du nom du contexte utilisé */ /* (O) Context : adresse du nom du contexte utilisé */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Context_Get_I ( char ** Context ); SMT_Status SM_Library_Context_Get_I ( char ** Context );
SMT_Status SM_Library_Context_Get_C ( char ** Context ); SMT_Status SM_Library_Context_Get_C ( char ** Context );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Fermeture de l'instance de la librairie */ /* Fermeture de l'instance de la librairie */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Flags : mode de fermeture (destruction ou fermeture simple) */ /* (I) Flags : mode de fermeture (destruction ou fermeture simple) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Close_I ( SMT_Flags Flags ); SMT_Status SM_Library_Close_I ( SMT_Flags Flags );
SMT_Status SM_Library_Close_C ( SMT_Flags Flags ); SMT_Status SM_Library_Close_C ( SMT_Flags Flags );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Affichage des informations de la base de mémoires partagées */ /* Affichage des informations de la base de mémoires partagées */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Out : pointeur sur le flux de sortie */ /* (I) Out : pointeur sur le flux de sortie */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Dump_I ( FILE * Out ); SMT_Status SM_Library_Dump_I ( FILE * Out );
SMT_Status SM_Library_Dump_C ( FILE * Out ); SMT_Status SM_Library_Dump_C ( FILE * Out );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Libération de tous les verrous (base, heap) */ /* Libération de tous les verrous (base, heap) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Unlock_I ( void ); SMT_Status SM_Library_Unlock_I ( void );
SMT_Status SM_Library_Unlock_C ( void ); SMT_Status SM_Library_Unlock_C ( void );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Définition de la sortie standard des messages d'erreur de la librairie */ /* Définition de la sortie standard des messages d'erreur de la librairie */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Library_Stderr_Set_I ( FILE * Out ); SMT_Status SM_Library_Stderr_Set_I ( FILE * Out );
SMT_Status SM_Library_Stderr_Set_C ( FILE * Out ); SMT_Status SM_Library_Stderr_Set_C ( FILE * Out );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Test d'existence d'un heap */ /* Test d'existence d'un heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Heap_Name : nom du heap */ /* (I) Heap_Name : nom du heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Exist_I ( const char * Heap_Name ); SMT_Status SM_Heap_Exist_I ( const char * Heap_Name );
SMT_Status SM_Heap_Exist_C ( const char * Heap_Name ); SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Ouverture/création d'un heap */ /* Ouverture/création d'un heap */
@ -287,8 +318,8 @@ SMT_Status SM_Heap_Exist_C ( const char * Heap_Name );
/* (I) Flags : mode d'ouverture du heap */ /* (I) Flags : mode d'ouverture du heap */
/* (O) Locked : verrou effectif (TRUE ou FALSE) */ /* (O) Locked : verrou effectif (TRUE ou FALSE) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Open_I ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked ); SMT_Status SM_Heap_Open_I ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked ); SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg_Size, SMT_Flags Flags, int * Locked );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Teste si un heap a déjà été ouvert par le processus courant */ /* Teste si un heap a déjà été ouvert par le processus courant */
@ -296,24 +327,24 @@ SMT_Status SM_Heap_Open_C ( const char * Heap_Name, SMT_Heap ** Heap, size_t Seg
/* (I) Heap_Name : nom du heap */ /* (I) Heap_Name : nom du heap */
/* (O) Heap : adresse du pointeur sur le heap ouvert */ /* (O) Heap : adresse du pointeur sur le heap ouvert */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_IsOpen_I ( const char * Heap_Name, SMT_Heap ** Heap ); SMT_Status SM_Heap_IsOpen_I ( const char * Heap_Name, SMT_Heap ** Heap );
SMT_Status SM_Heap_IsOpen_C ( const char * Heap_Name, SMT_Heap ** Heap ); SMT_Status SM_Heap_IsOpen_C ( const char * Heap_Name, SMT_Heap ** Heap );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Fermeture d'un heap */ /* Fermeture d'un heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Heap : pointeur sur un heap ouvert */ /* (I) Heap : pointeur sur un heap ouvert */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Close_I ( SMT_Heap * Heap ); SMT_Status SM_Heap_Close_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Close_C ( SMT_Heap * Heap ); SMT_Status SM_Heap_Close_C ( SMT_Heap * Heap );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Destruction d'un heap */ /* Destruction d'un heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Heap_Name : nom du heap */ /* (I) Heap_Name : nom du heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_End_I ( const char * Heap_Name ); SMT_Status SM_Heap_End_I ( const char * Heap_Name );
SMT_Status SM_Heap_End_C ( const char * Heap_Name ); SMT_Status SM_Heap_End_C ( const char * Heap_Name );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Compression d'un heap */ /* Compression d'un heap */
@ -321,8 +352,8 @@ SMT_Status SM_Heap_End_C ( const char * Heap_Name );
/* (I) Heap : pointeur sur un heap ouvert */ /* (I) Heap : pointeur sur un heap ouvert */
/* (O) Compress : pointeur sur la taille mémoire gagnée */ /* (O) Compress : pointeur sur la taille mémoire gagnée */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Compress_I ( SMT_Heap * Heap, size_t * Compress ); SMT_Status SM_Heap_Compress_I ( SMT_Heap * Heap, size_t * Compress );
SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress ); SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Configuration d'un heap */ /* Configuration d'un heap */
@ -330,8 +361,8 @@ SMT_Status SM_Heap_Compress_C ( SMT_Heap * Heap, size_t * Compress );
/* (I) Heap : pointeur sur un heap ouvert */ /* (I) Heap : pointeur sur un heap ouvert */
/* (I) Tag : type de configuration */ /* (I) Tag : type de configuration */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... ); SMT_Status SM_Heap_Config_I ( SMT_Heap * Heap, SMT_Config Tag, ... );
SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... ); SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Vérification/correction des structures d'un heap : */ /* Vérification/correction des structures d'un heap : */
@ -341,8 +372,8 @@ SMT_Status SM_Heap_Config_C ( SMT_Heap * Heap, SMT_Config Tag, ... );
/* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */ /* (O) Nb_Corrected : pointeur sur le nombre d'erreurs corrigées */
/* (I) Out : pointeur sur le flux de sortie du rapport */ /* (I) Out : pointeur sur le flux de sortie du rapport */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Check_I ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out); SMT_Status SM_Heap_Check_I ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out); SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Corrected, FILE * Out);
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Pose d'un verrou sur un heap */ /* Pose d'un verrou sur un heap */
@ -351,16 +382,16 @@ SMT_Status SM_Heap_Check_C ( SMT_Heap * Heap, int * Nb_Detected, int * Nb_Correc
/* (I) Flags : mode de verrouillage (SMD_READ ou SMD_WRITE) */ /* (I) Flags : mode de verrouillage (SMD_READ ou SMD_WRITE) */
/* (O) Locked : verrouillage effectué (TRUE ou FALSE) */ /* (O) Locked : verrouillage effectué (TRUE ou FALSE) */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Lock_I ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked ); SMT_Status SM_Heap_Lock_I ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
SMT_Status SM_Heap_Lock_C ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked ); SMT_Status SM_Heap_Lock_C ( SMT_Heap * Heap, SMT_Flags Flags, int * Locked );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Libération d'un verrou sur un heap */ /* Libération d'un verrou sur un heap */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* (I) Heap : pointeur sur un heap ouvert */ /* (I) Heap : pointeur sur un heap ouvert */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Heap_Unlock_I ( SMT_Heap * Heap ); SMT_Status SM_Heap_Unlock_I ( SMT_Heap * Heap );
SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap ); SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Allocation d'un chunk dans un heap */ /* Allocation d'un chunk dans un heap */
@ -369,8 +400,8 @@ SMT_Status SM_Heap_Unlock_C ( SMT_Heap * Heap );
/* (I) Size : taille du chunk */ /* (I) Size : taille du chunk */
/* (O) Ptr : pointeur sur la zone de données allouée */ /* (O) Ptr : pointeur sur la zone de données allouée */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Chunk_Alloc_I ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr ); SMT_Status SM_Chunk_Alloc_I ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr ); SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
/* Désallocation d'un chunk */ /* Désallocation d'un chunk */
@ -378,8 +409,8 @@ SMT_Status SM_Chunk_Alloc_C ( SMT_Heap * Heap, size_t Alloc_Size, void ** Ptr );
/* (I) Heap : pointeur sur un heap ouvert */ /* (I) Heap : pointeur sur un heap ouvert */
/* (I) Ptr : adresse de la zone de données du chunk à désallouer */ /* (I) Ptr : adresse de la zone de données du chunk à désallouer */
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/
SMT_Status SM_Chunk_Free_I ( SMT_Heap * Heap, void * Ptr ); SMT_Status SM_Chunk_Free_I ( SMT_Heap * Heap, void * Ptr );
SMT_Status SM_Chunk_Free_C ( SMT_Heap * Heap, void * Ptr ); SMT_Status SM_Chunk_Free_C ( SMT_Heap * Heap, void * Ptr );
#ifdef __cplusplus #ifdef __cplusplus
} }

1418
lib/libshmem.c
View File

File diff suppressed because it is too large Load Diff

78
lib/libshmem.h
View File

@ -1,19 +1,59 @@
/*---------------------------------------------------------------------------------*/
/* $RCSfile: libshmem.h,v $ */
/*---------------------------------------------------------------------------------*/
/* $Revision: 2.0 $ */
/* $Name: $ */
/* $Date: 2005/01/24 22:57:06 $ */
/* $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 <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdarg.h>
#include <string.h> #include <string.h>
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
#include <stdarg.h>
#include <sys/sem.h> #include <sys/sem.h>
#include <sys/shm.h> #include <sys/shm.h>
#include <sys/ipc.h> #include <sys/ipc.h>
#include <ver.h>
#include <shmem.h> #include <shmem.h>
/* Compteur d'ouverture de la librairie */ /* Compteur d'ouverture de la librairie */
unsigned int SM_Open_Counter = 0; unsigned int SM_Open_Counter = 0;
/* Flux de sortie des messages d'erreur générés par la librairie */ /* Flux de sortie des messages d'erreur générés par la librairie */
FILE * SM_stderr; FILE * SM_stderr;
@ -22,10 +62,15 @@ extern char * strdup (const char *);
#define max(A,B) ((A < B) ? B : A) #define max(A,B) ((A < B) ? B : A)
/* Limite supérieure d'adressage */ /* Limite supérieure d'adressage */
#define MEM_LIMIT 1000000000 #define MEM_LIMIT 1000000000
#define SMD_CMD_VALUE_SUM (NDT_Command)65
/* Taille d'un segment = 100 Ko par défaut */ /* Taille d'un segment = 100 Ko par défaut */
#define K 1024 #define K 1024
@ -34,10 +79,11 @@ extern char * strdup (const char *);
char Info_Msg [256]; char Info_Msg [256];
/* Etats possibles pour un heap */ /* Etats possibles pour un heap */
#define SMD_STATE_VALID 0 #define SMD_STATE_VALID 0
#define SMD_STATE_UNVALIDATED 1 #define SMD_STATE_UNVALIDATED 1
#define SMD_STATE_CORRUPTED 2 #define SMD_STATE_CORRUPTED 2
/* Référence sur le heap système */ /* Référence sur le heap système */
@ -49,17 +95,17 @@ SMT_Heap * System_Heap;
NDT_Root * Opened_Heap_List; NDT_Root * Opened_Heap_List;
/* /*
Taille par défaut des chunks alloués dans le heap système : Taille par défaut des chunks alloués dans le heap système :
Cette taille est fixée à la taille maximale des chunks pouvant Cette taille est fixée à la taille maximale des chunks pouvant
y être alloué (de type NDT_Node, NDT_Root, SMT_MHH ou SMT_DSH) y être alloué (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))) #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ème par un Nombre de chunk libre minimum avant extension du heap système par un
nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment nouveau segment de données (fixé à 3 car l'ajout d'un nouveau segment
nécessite l'allocation de 2 chunks (un noeud et une entête de segment). nécessite l'allocation de 2 chunks (un noeud et une entête de segment).
*/ */
#define FREE_CHUNK_LIMIT 3 #define FREE_CHUNK_LIMIT 3
@ -76,8 +122,8 @@ char * SM_Context;
#define CONTEXT_ENV_VAR "CONTEXT" #define CONTEXT_ENV_VAR "CONTEXT"
/* /*
Variable globale permettant d'indiquer que l'on est en train Variable globale permettant d'indiquer que l'on est en train
d'étendre le heap système par ajout d'un nouveau segment. d'étendre le heap système par ajout d'un nouveau segment.
*/ */
unsigned int Adding_Segment = FALSE; unsigned int Adding_Segment = FALSE;
@ -86,8 +132,8 @@ SMT_Chunk * Tmp_Chunk;
SMT_MHH * Tmp_MHH; SMT_MHH * Tmp_MHH;
/* /*
Définition des opérations de verouillage et de déverrouillage Définition des opérations de verouillage et de déverrouillage
NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé NB : la valeur 1 d'un sémaphore correspond à l'état non verrouillé
*/ */
/* Pose d'un verrou en lecture : 2 opérations : ( -1 puis +2 ) */ /* Pose d'un verrou en lecture : 2 opérations : ( -1 puis +2 ) */
@ -112,9 +158,9 @@ struct sembuf SM_SemOp_TSL [2] = { {0, 0, SEM_UNDO|IPC_NOWAIT}, {0, 2, SEM_UNDO
typedef union semun typedef union semun
{ {
int val; int val;
struct semid_ds * buf; struct semid_ds * buf;
unsigned short int * array; unsigned short int * array;
} semun; } semun;
/*------------------------------------------------------------------------------*/ /*------------------------------------------------------------------------------*/