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

- Implement DS_Value_Alloc_I(), DS_Value_Add(), DS_Alloc_I(), DS_DataStruct_Value_Print(), DS_DataStruct_Lock() & DS_DataStruct_Unlock(),

Browse Source 
- Debug with dsbench: ADD_VALUE & SHOW.
This commit is contained in:
Arnaud G. GIBERT 2024-04-29 12:08:11 +02:00
parent 6492980a9b
commit 813967de98
4 changed files with 250 additions and 173 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
include/datastr.h
View File

@ -183,9 +183,9 @@ typedef struct DST_RootDesc
# define DS_DataStruct_Traverse DS_DataStruct_Traverse_I # define DS_DataStruct_Traverse DS_DataStruct_Traverse_I
# define DS_DataStruct_Convert DS_DataStruct_Convert_I # define DS_DataStruct_Convert DS_DataStruct_Convert_I
# define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_I # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_I
# define DS_DataStruct_Value_Print DS_DataStruct_Value_Print_I
# define DS_DataStruct_Print DS_DataStruct_Print_I # define DS_DataStruct_Print DS_DataStruct_Print_I
# define DS_DataStruct_Check DS_DataStruct_Check_I # define DS_DataStruct_Check DS_DataStruct_Check_I
# define DS_DataStruct_Dump DS_DataStruct_Dump_I
# define DS_DataStruct_Lock DS_DataStruct_Lock_I # define DS_DataStruct_Lock DS_DataStruct_Lock_I
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_I # define DS_DataStruct_Unlock DS_DataStruct_Unlock_I
# define DS_Node_Root_Get DS_Node_Root_Get_I # define DS_Node_Root_Get DS_Node_Root_Get_I
@ -219,9 +219,9 @@ typedef struct DST_RootDesc
# define DS_DataStruct_Traverse DS_DataStruct_Traverse_L # define DS_DataStruct_Traverse DS_DataStruct_Traverse_L
# define DS_DataStruct_Convert DS_DataStruct_Convert_L # define DS_DataStruct_Convert DS_DataStruct_Convert_L
# define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_L # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_L
# define DS_DataStruct_Value_Print DS_DataStruct_Value_Print_L
# define DS_DataStruct_Print DS_DataStruct_Print_L # define DS_DataStruct_Print DS_DataStruct_Print_L
# define DS_DataStruct_Check DS_DataStruct_Check_L # define DS_DataStruct_Check DS_DataStruct_Check_L
# define DS_DataStruct_Dump DS_DataStruct_Dump_L
# define DS_DataStruct_Lock DS_DataStruct_Lock_L # define DS_DataStruct_Lock DS_DataStruct_Lock_L
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_L # define DS_DataStruct_Unlock DS_DataStruct_Unlock_L
# define DS_Node_Root_Get DS_Node_Root_Get_L # define DS_Node_Root_Get DS_Node_Root_Get_L
@ -255,9 +255,9 @@ typedef struct DST_RootDesc
# define DS_DataStruct_Traverse DS_DataStruct_Traverse_CL # define DS_DataStruct_Traverse DS_DataStruct_Traverse_CL
# define DS_DataStruct_Convert DS_DataStruct_Convert_CL # define DS_DataStruct_Convert DS_DataStruct_Convert_CL
# define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_CL # define DS_DataStruct_Info_Print DS_DataStruct_Info_Print_CL
# define DS_DataStruct_Value_Print DS_DataStruct_Value_Print_CL
# define DS_DataStruct_Print DS_DataStruct_Print_CL # define DS_DataStruct_Print DS_DataStruct_Print_CL
# define DS_DataStruct_Check DS_DataStruct_Check_CL # define DS_DataStruct_Check DS_DataStruct_Check_CL
# define DS_DataStruct_Dump DS_DataStruct_Dump_CL
# define DS_DataStruct_Lock DS_DataStruct_Lock_CL # define DS_DataStruct_Lock DS_DataStruct_Lock_CL
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_CL # define DS_DataStruct_Unlock DS_DataStruct_Unlock_CL
# define DS_Node_Root_Get DS_Node_Root_Get_CL # define DS_Node_Root_Get DS_Node_Root_Get_CL
@ -359,10 +359,10 @@ DSD_API DST_Status DS_DataStruct_Open_CL( const char *DS_Name, NDT_Root **Roo
/* (I) Lock_Mode : type de verrou à poser sur la structure */ /* (I) Lock_Mode : type de verrou à poser sur la structure */
/* (O) Locked : verrou effectif (TRUE ou FALSE) */ /* (O) Locked : verrou effectif (TRUE ou FALSE) */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_DataStruct_Lock_I( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); DSD_API DST_Status DS_DataStruct_Lock_I( NDT_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked);
DSD_API DST_Status DS_DataStruct_Lock_L( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); DSD_API DST_Status DS_DataStruct_Lock_L( NDT_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked);
DSD_API DST_Status DS_DataStruct_Lock_CL( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked); DSD_API DST_Status DS_DataStruct_Lock_CL( NDT_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked);
@ -371,10 +371,10 @@ DSD_API DST_Status DS_DataStruct_Lock_CL( NDT_Root * Root, DST_Flags Lock_Mode,
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure */ /* (I) Root : pointeur sur la racine de la structure */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_DataStruct_Unlock_I( NDT_Root * Root); DSD_API DST_Status DS_DataStruct_Unlock_I( NDT_Root *Root_Ptr);
DSD_API DST_Status DS_DataStruct_Unlock_L( NDT_Root * Root); DSD_API DST_Status DS_DataStruct_Unlock_L( NDT_Root *Root_Ptr);
DSD_API DST_Status DS_DataStruct_Unlock_CL( NDT_Root * Root); DSD_API DST_Status DS_DataStruct_Unlock_CL( NDT_Root *Root_Ptr);
@ -475,15 +475,19 @@ DSD_API DST_Status DS_DataStruct_Check_CL( NDT_Root * Root, int * Nb_Detected,
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Affichage de la structure de données */ /* Print all the data structure values */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure */ /* (I) Stream: Output stream */
/* (I) Out : flux de sortie */ /* (I) Root_Ptr: Data structure pointer */
/* (I) Recursive_Mode: Child or Parent */
/* (I) Recursive_Depth: Curent recursion depth */
/* (I) Recursive_Offset: Curent print out offset */
/* (I) ...: User args */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_DataStruct_Dump_I( NDT_Root * Root, FILE * Out); DSD_API DST_Status DS_DataStruct_Value_Print_I( FILE *Out_Ptr, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...);
DSD_API DST_Status DS_DataStruct_Dump_L( NDT_Root * Root, FILE * Out); DSD_API DST_Status DS_DataStruct_Value_Print_L( FILE *Out_Ptr, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...);
DSD_API DST_Status DS_DataStruct_Dump_CL( NDT_Root * Root, FILE * Out); DSD_API DST_Status DS_DataStruct_Value_Print_CL( FILE *Out_Ptr, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...);
@ -582,14 +586,14 @@ DSD_API DST_Status DS_Node_Find_CL( NDT_Root * Root, NDT_Node ** Node, void * V
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Allocation d'une valeur d'une structure de données */ /* Allocation d'une valeur d'une structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure de données */
/* (O) Value : adresse d'un pointeur sur la valeur à allouer */ /* (O) Value : adresse d'un pointeur sur la valeur à allouer */
/* (I) Root : pointeur sur la racine de la structure de données */
/* (I) ... : arguments relatifs à l'allocation de la valeur */ /* (I) ... : arguments relatifs à l'allocation de la valeur */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_Value_Alloc_I( NDT_Root * Root, void ** Value, ...); DSD_API DST_Status DS_Value_Alloc_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, ...);
DSD_API DST_Status DS_Value_Alloc_L( NDT_Root * Root, void ** Value, ...); DSD_API DST_Status DS_Value_Alloc_L( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, ...);
DSD_API DST_Status DS_Value_Alloc_CL( NDT_Root * Root, void ** Value, ...); DSD_API DST_Status DS_Value_Alloc_CL( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, ...);
@ -599,10 +603,10 @@ DSD_API DST_Status DS_Value_Alloc_CL( NDT_Root * Root, void ** Value, ...);
/* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Root : pointeur sur la racine de la structure de données */
/* (I) Value : pointeur sur la valeur à ajouter */ /* (I) Value : pointeur sur la valeur à ajouter */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_Value_Add_I( NDT_Root * Root, void * Value); DSD_API DST_Status DS_Value_Add_I( NDT_Root *Root_Ptr, void *Value_Ptr);
DSD_API DST_Status DS_Value_Add_L( NDT_Root * Root, void * Value); DSD_API DST_Status DS_Value_Add_L( NDT_Root *Root_Ptr, void *Value_Ptr);
DSD_API DST_Status DS_Value_Add_CL( NDT_Root * Root, void * Value); DSD_API DST_Status DS_Value_Add_CL( NDT_Root *Root_Ptr, void *Value_Ptr);
@ -636,14 +640,14 @@ DSD_API DST_Status DS_Value_Free_CL( NDT_Root * Root, void * Value);
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Allocation de mémoire pour une structure de données : */ /* Allocation de mémoire pour une structure de données : */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (O) Ptr : adresse du pointeur sur la zone de données allouée */
/* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Root : pointeur sur la racine de la structure de données */
/* (I) Size : taille mémoire à allouer */ /* (I) Size : taille mémoire à allouer */
/* (O) Ptr : adresse du pointeur sur la zone de données allouée */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_Alloc_I( NDT_Root * Root, size_t Size, void ** Ptr); DSD_API DST_Status DS_Alloc_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size);
DSD_API DST_Status DS_Alloc_L( NDT_Root * Root, size_t Size, void ** Ptr); DSD_API DST_Status DS_Alloc_L( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size);
DSD_API DST_Status DS_Alloc_CL( NDT_Root * Root, size_t Size, void ** Ptr); DSD_API DST_Status DS_Alloc_CL( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size);

248
lib/libdatastr.c
View File

@ -683,61 +683,76 @@ Strange: why end the heap here ?
/* (I) Lock_Mode : type de verrou à poser sur la structure */ /* (I) Lock_Mode : type de verrou à poser sur la structure */
/* (O) Locked : verrou effectif (TRUE ou FALSE) */ /* (O) Locked : verrou effectif (TRUE ou FALSE) */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DST_Status DS_DataStruct_Lock_I ( NDT_Root * Root, DST_Flags Lock_Mode, int * Locked ) DST_Status DS_DataStruct_Lock_I( NDT_Root *Root_Ptr, DST_Flags Lock_Mode, int *Locked )
{ {
DST_Status rc; char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name;
SMT_Heap * Heap;
char * Heap_Name = ((DST_RootDesc *)(Root->User))->Heap_Name;
SMT_Status sm_status;
SMT_Heap *heap_ptr;
/* Réouverture du heap sous-jacent (rafraîchissement des segments) + verrouillage */ /* Réouverture du heap sous-jacent (rafraîchissement des segments) + verrouillage */
/*
rc = SM_Heap_Open (Heap_Name, &Heap, 0, SMD_OPEN | Lock_Mode, Locked);
if (rc != SMS_OK)
{
sprintf (DS_Error_Msg, "Error DS_DataStruct_Lock : unable to reopen the data structure heap \"%s\" for %s",
Heap_Name, DSD_MSK_READ (Lock_Mode) ? "reading" : "writing");
DS_Error_Print ();
return rc; if( ( sm_status = SM_Heap_Open( Heap_Name, &heap_ptr, 0, ( SMD_OPEN | Lock_Mode), Locked)) != SMS_OK)
{
LG_LOG_ERROR_3( "Unable to reopen the data structure heap: [%s] for [%s], status: (%d)",
Heap_Name, (DSD_MSK_READ( Lock_Mode) ? "reading" : "writing"), sm_status);
return( DSS_KO);
} }
return DSS_OK; return( DSS_OK);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Déverrouillage d'une structure de données */ /* Déverrouillage d'une structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure */ /* (I) Root : pointeur sur la racine de la structure */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DST_Status DS_DataStruct_Unlock_I ( NDT_Root * Root ) DST_Status DS_DataStruct_Unlock_I( NDT_Root *Root_Ptr)
{ {
DST_Status rc; char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name;
SMT_Heap * Heap;
char * Heap_Name = ((DST_RootDesc *)(Root->User))->Heap_Name;
rc = SM_Heap_IsOpen (Heap_Name, &Heap); SMT_Status sm_status;
if (rc != SMS_YES) SMT_Heap *heap_ptr;
if( ( sm_status = SM_Heap_IsOpen( Heap_Name, &heap_ptr)) != SMS_OK)
{ {
sprintf (DS_Error_Msg, "Error DS_DataStruct_Unlock : the data structure heap \"%s\" is not open", Heap_Name); LG_LOG_ERROR_2( "Unable to check if heap: [%s] is open, status: (%d)", Heap_Name, sm_status);
DS_Error_Print ();
return( DSS_KO);
}
else
{
if( heap_ptr == NULL)
{
LG_LOG_ERROR_1( "Data structure heap: [%s] is not open", Heap_Name);
return rc; return( DSS_KO);
}
} }
rc = SM_Heap_Unlock (Heap); if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK)
if (rc != SMS_OK)
{ {
sprintf (DS_Error_Msg, "Error DS_DataStruct_Unlock : unable to unlock the data structure heap \"%s\"", Heap_Name); LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", Heap_Name, sm_status);
DS_Error_Print ();
return rc; return( DSS_KO);
} }
return DSS_OK; return( DSS_OK);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Fermeture d'une structure de données */ /* Fermeture d'une structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
@ -784,13 +799,14 @@ DST_Status DS_DataStruct_Close_I( NDT_Root *Root_Ptr, DST_Flags Close_Mode)
/* On supprime la structure proprement (toutes les valeurs sont supprimées les unes après les autres) */ /* On supprime la structure proprement (toutes les valeurs sont supprimées les unes après les autres) */
if( ( nd_status =ND_DataStruct_Close( Root_Ptr)) != NDS_OK) if( ( nd_status = ND_DataStruct_Close( Root_Ptr)) != NDS_OK)
{ {
LG_LOG_ERROR_2( "Unable to close the node structure of data structure: [%s], status: (%d)", ds_name, nd_status); LG_LOG_ERROR_2( "Unable to close the node structure of data structure: [%s], status: (%d)", ds_name, nd_status);
return( DSS_KO); return( DSS_KO);
} }
/* Suppression du sémaphore */ /* Suppression du sémaphore */
semctl( RootDesc_Ptr->OpenSemId, 0, IPC_RMID, sem_ctl); semctl( RootDesc_Ptr->OpenSemId, 0, IPC_RMID, sem_ctl);
@ -808,11 +824,11 @@ DST_Status DS_DataStruct_Close_I( NDT_Root *Root_Ptr, DST_Flags Close_Mode)
else else
{ {
/* /*
Dans le cas où la data structure n'est pas propriétaire du heap sous-jacent, Dans le cas où la data structure n'est pas propriétaire du heap sous-jacent,
on ne peut pas garantir qu'aucun autre processus ne l'a ouverte. on ne peut pas garantir qu'aucun autre processus ne l'a ouverte.
On la supprime donc sans contrôle. On la supprime donc sans contrôle.
*/ */
if( ( nd_status = ND_DataStruct_Close( Root_Ptr)) != NDS_OK) if( ( nd_status = ND_DataStruct_Close( Root_Ptr)) != NDS_OK)
{ {
@ -824,11 +840,9 @@ DST_Status DS_DataStruct_Close_I( NDT_Root *Root_Ptr, DST_Flags Close_Mode)
if( ( status = DS_DataStruct_Free( RootDesc_Ptr, (void *)RootDesc_Ptr)) != DSS_OK) if( ( status = DS_DataStruct_Free( RootDesc_Ptr, (void *)RootDesc_Ptr)) != DSS_OK)
{ {
LG_LOG_ERROR_2( "Unable to free data structure: [%s], status: (%d)", ds_name, status); LG_LOG_ERROR_2( "Unable to free data structure: [%s], status: (%d)", ds_name, status);
return( status);
} }
return( DSS_OK); return( status);
} }
} }
else /* Fermeture simple de la data structure */ else /* Fermeture simple de la data structure */
@ -1237,18 +1251,32 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_
return rc; return rc;
} }
/*----------------------------------------------------------------------------*/
/* Affiche la structure de données */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure */
/* (I) Out : flux de sortie */
/*----------------------------------------------------------------------------*/
/*
DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out )
{
DST_Status rc;
DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User);
/*----------------------------------------------------------------------------*/
/* Print all the data structure values */
/*----------------------------------------------------------------------------*/
/* (I) Stream: Output stream */
/* (I) Root_Ptr: Data structure pointer */
/* (I) Recursive_Mode: Child or Parent */
/* (I) Recursive_Depth: Curent recursion depth */
/* (I) Recursive_Offset: Curent print out offset */
/* (I) ...: User args */
/*----------------------------------------------------------------------------*/
DST_Status DS_DataStruct_Value_Print_I( FILE *Out_Ptr, NDT_Root *Root_Ptr, NDT_Recursive_Mode Recursive_Mode, NDT_Recursive_Depth Recursive_Depth, NDT_Recursive_Offset Recursive_Offset, ...)
{
DST_RootDesc *RootDesc_Ptr = (DST_RootDesc *)( Root_Ptr->User_Ptr);
DST_Status status;
NDT_Status nd_status;
va_list user_args;
va_start( user_args, Recursive_Offset);
/* On vérifie que la data structure est valide */ /* On vérifie que la data structure est valide */
/* /*
if (RootDesc->Valid == FALSE) if (RootDesc->Valid == FALSE)
@ -1267,21 +1295,30 @@ DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out )
return rc; return rc;
} }
} }
*/
/* Affichage de la node structure */ /* Affichage de la node structure */
/*
rc = ND_DataStruct_Dump (Root, Out); if( ( nd_status = ND_DataStruct_Value_Print_VI( Out_Ptr, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset, &user_args)) != NDS_OK)
if (rc != NDS_OK)
{ {
sprintf (DS_Error_Msg, "Error DS_DataStruct_Dump : unable to dump the node structure"); LG_LOG_ERROR_1( "Unable to dump the node structure: (%d)", nd_status);
DS_Error_Print ();
status = DSS_KO;
return rc;
} }
else
{
status = DSS_OK;
}
va_end( user_args);
return DSS_OK; return( status);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Récupération du premier noeud d'une structure */ /* Récupération du premier noeud d'une structure */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
@ -1589,49 +1626,70 @@ DST_Status DS_Node_Find_I ( NDT_Root * Root, NDT_Node ** Node, void * Value, voi
return rc; return rc;
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Allocation d'une valeur d'une structure de données */ /* Allocation d'une valeur d'une structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure de données */
/* (O) Value : adresse d'un pointeur sur la valeur à allouer */ /* (O) Value : adresse d'un pointeur sur la valeur à allouer */
/* (I) Root : pointeur sur la racine de la structure de données */
/* (I) ... : arguments relatifs à l'allocation de la valeur */ /* (I) ... : arguments relatifs à l'allocation de la valeur */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DST_Status DS_Value_Alloc_I ( NDT_Root * Root, void ** Value, ... ) DST_Status DS_Value_Alloc_I( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, ... )
{ {
DST_Status rc; DST_Status status;
va_list Args; NDT_Status nd_status;
va_list user_args;
/* Récupération des arguments pour l'allocation de la valeur */ /* Récupération des arguments pour l'allocation de la valeur */
/*
va_start (Args, Value);
va_start( user_args, Root_Ptr);
/* Appel du manager */ /* Appel du manager */
/*
rc = ND_Manager_Exec (Root->Manager, NDD_CMD_MAKE_VALUE, Root, Value, Args);
va_end (Args); if( ( nd_status = ND_Manager_Exec( Root_Ptr, NDD_INDEX_UNKNOWN, NULL, NDD_CMD_VALUE_ALLOC, Value_Ptr_Ptr, &user_args)) != NDS_OK)
{
LG_LOG_ERROR_1( "Unnable to alloc a new value: (%d)", nd_status);
return rc; status = DSS_KO;
}
else
{
status = DSS_OK;
}
va_end( user_args);
return( status);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Ajout d'une valeur à une structure de données */ /* Ajout d'une valeur à une structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Root : pointeur sur la racine de la structure de données */
/* (I) Value : pointeur sur la valeur à ajouter à la structure de données */ /* (I) Value : pointeur sur la valeur à ajouter à la structure de données */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/*
DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value )
{
DST_Status rc;
DST_RootDesc * RootDesc = (DST_RootDesc *)(Root->User);
DST_Status DS_Value_Add_I( NDT_Root *Root_Ptr, void *Value_Ptr)
{
DST_RootDesc *RootDesc_Ptr = (DST_RootDesc *)( Root_Ptr->User_Ptr);
DST_Status status;
NDT_Status nd_status;
/* On vérifie que la data structure est valide */ /* On vérifie que la data structure est valide */
/* /*
if (RootDesc->Valid == FALSE) if( RootDesc_Ptr->Valid == FALSE)
{ {
int Nb_Detected, Nb_Corrected; int Nb_Detected, Nb_Corrected;
/* On vérifie la structure */ /* On vérifie la structure */
/* /*
@ -1645,29 +1703,27 @@ DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value )
return rc; return rc;
} }
} }
*/
/* On rend la structure invalide le temps de l'ajout */ /* On rend la structure invalide le temps de l'ajout */
/*
RootDesc->Valid = FALSE; RootDesc_Ptr->Valid = FALSE;
/* Ajout de la valeur */ /* Ajout de la valeur */
/*
rc = ND_Value_Add (Root, Value); if( ( nd_status = ND_DataStruct_Value_Add( Root_Ptr, Value_Ptr)) != NDS_OK)
if (rc != NDS_OK)
{ {
sprintf (DS_Error_Msg, "Error DS_Value_Add : unable to add a value to the data structure"); LG_LOG_ERROR_1( "Unable to add a value to the data structure: (%d)", nd_status);
DS_Error_Print ();
if (!DS_ERROR(rc)) RootDesc->Valid = TRUE; // if (!DS_ERROR(rc)) RootDesc->Valid = TRUE;
return rc; return( DSS_KO);
} }
/* On rend la structure à nouveau valide */ /* On rend la structure à nouveau valide */
/*
RootDesc->Valid = TRUE;
return DSS_OK; RootDesc_Ptr->Valid = TRUE;
return( DSS_OK);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
@ -1738,21 +1794,27 @@ DST_Status DS_Value_Free_I ( NDT_Root * Root, void * Value )
return ND_Value_Free (Root, Value); return ND_Value_Free (Root, Value);
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Allocation de mémoire pour une structure de données : */ /* Allocation de mémoire pour une structure de données : */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* (O) Ptr : adresse du pointeur sur la zone de données allouée */
/* (I) Root : pointeur sur la racine de la structure de données */ /* (I) Root : pointeur sur la racine de la structure de données */
/* (I) Size : taille mémoire à allouer */ /* (I) Size : taille mémoire à allouer */
/* (O) Ptr : adresse du pointeur sur la zone de données allouée */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
DST_Status DS_Alloc_I( NDT_Root *Root, size_t Size, void **Ptr) DST_Status DS_Alloc_I( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size)
{ {
// return DS_DataStruct_Alloc (Size, Ptr, Root->User); return( DS_DataStruct_Alloc( Ptr_Ptr, Size, Root_Ptr->User_Ptr));
} }
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
/* Désallocation d'une ressource pour une structure de données : */ /* Désallocation d'une ressource pour une structure de données : */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/

2
lib/libdatastr.h
View File

@ -126,7 +126,7 @@ DST_Status DS_Semaphore_Operate (int, struct sembuf *, unsigned int);
/* Fonction d'allocation attachée à une structure de données : */ /* Fonction d'allocation attachée à une structure de données : */
/*----------------------------------------------------------------------------*/ /*----------------------------------------------------------------------------*/
DST_Status DS_DataStruct_Alloc ( void **Ptr, size_t Size, void *Data ); DST_Status DS_DataStruct_Alloc ( void **Ptr_Ptr, size_t Size, void *Data );

105
util/dsbench.c
View File

@ -96,11 +96,14 @@ typedef struct {
T_Cpt t_exec; T_Cpt t_exec;
/* Définition des valeurs attachées aux noeuds de la structure */ /* Définition des valeurs attachées aux noeuds de la structure */
typedef struct { typedef struct
int Id; {
char * Nom; int Id;
char Nom[ DSD_NAME_SIZE];
} T_Module; } T_Module;
@ -189,8 +192,8 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod
ND_VA_LIST_OPEN( user_args, *Args_Ptr); ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( Nom, user_args, char *);
ND_VA_ARG_GET( Id, user_args, int); ND_VA_ARG_GET( Id, user_args, int);
ND_VA_ARG_GET( Nom, user_args, char *);
ND_VA_LIST_CLOSE( user_args); ND_VA_LIST_CLOSE( user_args);
@ -199,22 +202,21 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod
LG_LOG_TRACE_0( LGD_LOG_LEVEL_DEFAULT, "CMD_VALUE_ALLOC called..."); LG_LOG_TRACE_0( LGD_LOG_LEVEL_DEFAULT, "CMD_VALUE_ALLOC called...");
/*
if( DS_Alloc( Root, sizeof( T_Module) + strlen( Nom) + 1, (void **)Module) == DSS_OK) if( DS_Alloc( (void **)Module_Ptr_Ptr, Root_Ptr, sizeof( T_Module)) != DSS_OK)
{
(* Module_Ptr_Ptr)->Id = Id;
(* Module_Ptr_Ptr)->Nom = (char *)((size_t)(*Module) + sizeof (T_Module));
strcpy( ( *Module)->Nom, Nom);
return( DSS_OK)
}
else
{ {
LG_LOG_ERROR_0( "Allocation error"); LG_LOG_ERROR_0( "Allocation error");
return( DSS_KO) return( DSS_KO);
}
else
{
( *Module_Ptr_Ptr)->Id = Id;
strncpy( ( *Module_Ptr_Ptr)->Nom, Nom, DSD_NAME_LEN);
( *Module_Ptr_Ptr)->Nom[ DSD_NAME_LEN] = '\0';
return( DSS_OK);
} }
*/
} }
case NDD_CMD_VALUE_FREE: case NDD_CMD_VALUE_FREE:
@ -368,10 +370,11 @@ NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Nod
ND_VA_LIST_CLOSE( lib_args); ND_VA_LIST_CLOSE( lib_args);
T_Module *Module_Ptr = (T_Module *)Node_Ptr->Value; T_Module *Module_Ptr = (T_Module *)Node_Ptr->Value;
Command_Name = "NDD_CMD_VALUE_PRINT"; Command_Name = "NDD_CMD_VALUE_PRINT";
fprintf( Out, "Id Module: (%d) Nom Module: [%s]", Module_Ptr->Id, Module_Ptr->Nom); LG_LOG_INFO_2( "Id Module: (%d) Nom Module: [%s]", Module_Ptr->Id, Module_Ptr->Nom);
return( NDS_OK); return( NDS_OK);
} }
@ -585,7 +588,7 @@ int main( int argc, char **argv)
NDT_Index_Type index_type = ( NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO); NDT_Index_Type index_type = ( NDD_INDEX_STATUS_OPENED | NDD_INDEX_TYPE_LIST | NDD_INDEX_SUBTYPE_FIFO);
char *tmp; char *tmp;
int n, m, i, j; int n, m, i, j;
int choice, Nb_Removed, Locked; int choice, nb_removed, locked;
int Nb_Detected, Nb_Corrected; int Nb_Detected, Nb_Corrected;
T_Module *Module, Ref_Module; T_Module *Module, Ref_Module;
NDT_Node *Node; NDT_Node *Node;
@ -624,6 +627,7 @@ int main( int argc, char **argv)
{ {
fprintf( stdout, "\nNom de la structure à créer ? "); fprintf( stdout, "\nNom de la structure à créer ? ");
fgets( DataStruct_Name, 100, stdin); fgets( DataStruct_Name, 100, stdin);
if( strlen( DataStruct_Name) < 2) if( strlen( DataStruct_Name) < 2)
{ {
fprintf( stdout, "Bad name!\n"); fprintf( stdout, "Bad name!\n");
@ -664,6 +668,7 @@ int main( int argc, char **argv)
{ {
fprintf (stdout, "\nNom de la structure à ouvrir ? "); fprintf (stdout, "\nNom de la structure à ouvrir ? ");
fgets( DataStruct_Name, 100, stdin); fgets( DataStruct_Name, 100, stdin);
if( strlen( DataStruct_Name) < 2) if( strlen( DataStruct_Name) < 2)
{ {
fprintf( stdout, "Bad name!\n"); fprintf( stdout, "Bad name!\n");
@ -742,20 +747,21 @@ int main( int argc, char **argv)
m - n + 1, t_exec.sec, (m - n + 1) / t_exec.sec); m - n + 1, t_exec.sec, (m - n + 1) / t_exec.sec);
break; break;
} }
*/
case ADD_VALUE: case ADD_VALUE:
{ {
fprintf (stdout, "\nPlage des valeurs à ajouter (?->?) : "); fprintf (stdout, "\nPlage des valeurs à ajouter (?-?) : ");
gets (buf); fgets( buf, 100, stdin);
tmp = strstr (buf, "->"); tmp = strstr( buf, "-");
if (tmp != NULL)
if( tmp != NULL)
{ {
* tmp = '\0'; *tmp = '\0';
n = atoi (buf); n = atoi( buf);
tmp++; tmp++;
tmp++; m = atoi( tmp);
m = atoi (tmp);
if (m < n) if( m < n)
{ {
printf ("\nEntrées non valides\n"); printf ("\nEntrées non valides\n");
break; break;
@ -763,47 +769,52 @@ int main( int argc, char **argv)
} }
else else
{ {
printf ("\nEntrées non valides\n"); printf( "\nEntrées non valides\n");
break; break;
} }
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked); DS_DataStruct_Lock( Root_Ptr, DSD_WRITE, &locked);
fprintf (stdout, "\nOrdre d'ajout (croissant=0 décroissant=1) ? "); fprintf (stdout, "\nOrdre d'ajout (croissant=0 décroissant=1) ? ");
gets (buf); fgets( buf, 100, stdin);
choice = atoi (buf); choice = atoi (buf);
if (choice == 0)
if( choice == 0)
{ {
i = n; i = n;
j = m + 1; j = m + 1;
t_start (t_exec); t_start (t_exec);
while (i < j)
while( i < j)
{ {
if (DS_Value_Alloc (Root, (void **)&Module, "x", i) == NDS_OK) DS_Value_Add (Root, Module); if( DS_Value_Alloc( (void **)&Module, Root_Ptr, i, "x") == NDS_OK) DS_Value_Add( Root_Ptr, Module);
i++; i++;
} }
t_stop (t_exec);
t_stop( t_exec);
} }
else else
{ {
i = m; i = m;
j = n - 1; j = n - 1;
t_start (t_exec); t_start( t_exec);
while (i > j)
while( i > j)
{ {
if (DS_Value_Alloc (Root, (void **)&Module, "x", i) == NDS_OK) DS_Value_Add (Root, Module); if( DS_Value_Alloc( (void **)&Module, Root_Ptr, i, "x") == NDS_OK) DS_Value_Add( Root_Ptr, Module);
i--; i--;
} }
t_stop (t_exec); t_stop (t_exec);
} }
DS_DataStruct_Unlock (Root); DS_DataStruct_Unlock( Root_Ptr);
fprintf (stdout, "\n%d valeur(s) ajoutée(s) en %.4f sec (%.2f ajouts/sec)\n", m - n + 1, \ fprintf( stdout, "\n%d valeur(s) ajoutée(s) en %.4f sec (%.2f ajouts/sec)\n", m - n + 1, \
t_exec.sec, (m - n + 1) / t_exec.sec); t_exec.sec, (m - n + 1) / t_exec.sec);
break; break;
} }
/*
case REMOVE_VALUE: case REMOVE_VALUE:
{ {
Nb_Removed = 0; Nb_Removed = 0;
@ -942,15 +953,15 @@ int main( int argc, char **argv)
// DS_DataStruct_Unlock (Root); // DS_DataStruct_Unlock (Root);
break; break;
} }
/*
case SHOW: case SHOW:
{ {
DS_DataStruct_Lock (Root, DSD_READ, &Locked); DS_DataStruct_Lock( Root_Ptr, DSD_READ, &locked);
DS_DataStruct_Dump (Root, stdout); DS_DataStruct_Value_Print( stdout, Root_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
DS_DataStruct_Unlock (Root); DS_DataStruct_Unlock( Root_Ptr);
break; break;
} }
/*
case CHECK: case CHECK:
{ {
Nb_Corrected = Nb_Detected = 0; Nb_Corrected = Nb_Detected = 0;