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_Convert DS_DataStruct_Convert_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_Check DS_DataStruct_Check_I
# define DS_DataStruct_Dump DS_DataStruct_Dump_I
# define DS_DataStruct_Lock DS_DataStruct_Lock_I
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_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_Convert DS_DataStruct_Convert_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_Check DS_DataStruct_Check_L
# define DS_DataStruct_Dump DS_DataStruct_Dump_L
# define DS_DataStruct_Lock DS_DataStruct_Lock_L
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_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_Convert DS_DataStruct_Convert_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_Check DS_DataStruct_Check_CL
# define DS_DataStruct_Dump DS_DataStruct_Dump_CL
# define DS_DataStruct_Lock DS_DataStruct_Lock_CL
# define DS_DataStruct_Unlock DS_DataStruct_Unlock_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 */
/* (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_L( NDT_Root * Root, 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_I( NDT_Root *Root_Ptr, 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_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 */
/*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_DataStruct_Unlock_I( NDT_Root * Root);
DSD_API DST_Status DS_DataStruct_Unlock_L( NDT_Root * Root);
DSD_API DST_Status DS_DataStruct_Unlock_CL( 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_Ptr);
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) Out : flux de sortie */
/* (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 */
/*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_DataStruct_Dump_I( NDT_Root * Root, FILE * Out);
DSD_API DST_Status DS_DataStruct_Dump_L( NDT_Root * Root, FILE * Out);
DSD_API DST_Status DS_DataStruct_Dump_CL( 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_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_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 */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de la structure de données */
/* (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 */
/*----------------------------------------------------------------------------*/
/*
DSD_API DST_Status DS_Value_Alloc_I( NDT_Root * Root, void ** Value, ...);
DSD_API DST_Status DS_Value_Alloc_L( NDT_Root * Root, void ** Value, ...);
DSD_API DST_Status DS_Value_Alloc_CL( 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( void **Value_Ptr_Ptr, NDT_Root *Root_Ptr, ...);
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) 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_L( NDT_Root * Root, void * Value);
DSD_API DST_Status DS_Value_Add_CL( 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_Ptr, void *Value_Ptr);
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 : */
/*----------------------------------------------------------------------------*/
/* (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) 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_L( NDT_Root * Root, size_t Size, void ** Ptr);
DSD_API DST_Status DS_Alloc_CL( 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( void **Ptr_Ptr, NDT_Root *Root_Ptr, size_t Size);
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 */
/* (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;
SMT_Heap * Heap;
char * Heap_Name = ((DST_RootDesc *)(Root->User))->Heap_Name;
char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name;
SMT_Status sm_status;
SMT_Heap *heap_ptr;
/* 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 */
/*----------------------------------------------------------------------------*/
/* (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;
SMT_Heap * Heap;
char * Heap_Name = ((DST_RootDesc *)(Root->User))->Heap_Name;
char *Heap_Name = ( (DST_RootDesc *)( Root_Ptr->User_Ptr))->Heap_Name;
rc = SM_Heap_IsOpen (Heap_Name, &Heap);
if (rc != SMS_YES)
SMT_Status sm_status;
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);
DS_Error_Print ();
LG_LOG_ERROR_2( "Unable to check if heap: [%s] is open, status: (%d)", Heap_Name, sm_status);
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 (rc != SMS_OK)
if( ( sm_status = SM_Heap_Unlock( heap_ptr)) != SMS_OK)
{
sprintf (DS_Error_Msg, "Error DS_DataStruct_Unlock : unable to unlock the data structure heap \"%s\"", Heap_Name);
DS_Error_Print ();
LG_LOG_ERROR_2( "Unable to unlock the data structure heap: [%s], status: (%d)", Heap_Name, sm_status);
return rc;
return( DSS_KO);
}
return DSS_OK;
return( DSS_OK);
}
/*----------------------------------------------------------------------------*/
/* 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) */
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);
return( DSS_KO);
}
/* Suppression du sémaphore */
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
{
/*
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 la supprime donc sans contrôle.
*/
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 la supprime donc sans contrôle.
*/
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)
{
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 */
@ -1237,18 +1251,32 @@ DST_Status DS_DataStruct_Check_I ( NDT_Root * Root, int * Nb_Detected, int * Nb_
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 */
/*
if (RootDesc->Valid == FALSE)
@ -1267,21 +1295,30 @@ DST_Status DS_DataStruct_Dump_I ( NDT_Root * Root, FILE * Out )
return rc;
}
}
*/
/* Affichage de la node structure */
/*
rc = ND_DataStruct_Dump (Root, Out);
if (rc != NDS_OK)
if( ( nd_status = ND_DataStruct_Value_Print_VI( Out_Ptr, Root_Ptr, Recursive_Mode, Recursive_Depth, Recursive_Offset, &user_args)) != NDS_OK)
{
sprintf (DS_Error_Msg, "Error DS_DataStruct_Dump : unable to dump the node structure");
DS_Error_Print ();
return rc;
LG_LOG_ERROR_1( "Unable to dump the node structure: (%d)", nd_status);
status = DSS_KO;
}
else
{
status = DSS_OK;
}
va_end( user_args);
return DSS_OK;
return( status);
}
/*----------------------------------------------------------------------------*/
/* 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;
}
/*----------------------------------------------------------------------------*/
/* 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 */
/* (I) Root : pointeur sur la racine de la structure de données */
/* (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;
va_list Args;
DST_Status status;
NDT_Status nd_status;
va_list user_args;
/* Récupération des arguments pour l'allocation de la valeur */
/*
va_start (Args, Value);
va_start( user_args, Root_Ptr);
/* 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 */
/*----------------------------------------------------------------------------*/
/* (I) Root : pointeur sur la racine de 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 */
/*
if (RootDesc->Valid == FALSE)
if( RootDesc_Ptr->Valid == FALSE)
{
int Nb_Detected, Nb_Corrected;
int Nb_Detected, Nb_Corrected;
/* On vérifie la structure */
/*
@ -1645,29 +1703,27 @@ DST_Status DS_Value_Add_I ( NDT_Root * Root, void * Value )
return rc;
}
}
*/
/* On rend la structure invalide le temps de l'ajout */
/*
RootDesc->Valid = FALSE;
RootDesc_Ptr->Valid = FALSE;
/* Ajout de la valeur */
/*
rc = ND_Value_Add (Root, Value);
if (rc != NDS_OK)
if( ( nd_status = ND_DataStruct_Value_Add( Root_Ptr, Value_Ptr)) != NDS_OK)
{
sprintf (DS_Error_Msg, "Error DS_Value_Add : unable to add a value to the data structure");
DS_Error_Print ();
LG_LOG_ERROR_1( "Unable to add a value to the data structure: (%d)", nd_status);
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 */
/*
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);
}
/*----------------------------------------------------------------------------*/
/* 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) 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 : */
/*----------------------------------------------------------------------------*/

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 : */
/*----------------------------------------------------------------------------*/
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;
/* Définition des valeurs attachées aux noeuds de la structure */
typedef struct {
int Id;
char * Nom;
typedef struct
{
int Id;
char Nom[ DSD_NAME_SIZE];
} 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_ARG_GET( Nom, user_args, char *);
ND_VA_ARG_GET( Id, user_args, int);
ND_VA_ARG_GET( Nom, user_args, char *);
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...");
/*
if( DS_Alloc( Root, sizeof( T_Module) + strlen( Nom) + 1, (void **)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
if( DS_Alloc( (void **)Module_Ptr_Ptr, Root_Ptr, sizeof( T_Module)) != DSS_OK)
{
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:
@ -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);
T_Module *Module_Ptr = (T_Module *)Node_Ptr->Value;
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);
}
@ -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);
char *tmp;
int n, m, i, j;
int choice, Nb_Removed, Locked;
int choice, nb_removed, locked;
int Nb_Detected, Nb_Corrected;
T_Module *Module, Ref_Module;
NDT_Node *Node;
@ -624,6 +627,7 @@ int main( int argc, char **argv)
{
fprintf( stdout, "\nNom de la structure à créer ? ");
fgets( DataStruct_Name, 100, stdin);
if( strlen( DataStruct_Name) < 2)
{
fprintf( stdout, "Bad name!\n");
@ -664,6 +668,7 @@ int main( int argc, char **argv)
{
fprintf (stdout, "\nNom de la structure à ouvrir ? ");
fgets( DataStruct_Name, 100, stdin);
if( strlen( DataStruct_Name) < 2)
{
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);
break;
}
*/
case ADD_VALUE:
{
fprintf (stdout, "\nPlage des valeurs à ajouter (?->?) : ");
gets (buf);
tmp = strstr (buf, "->");
if (tmp != NULL)
fprintf (stdout, "\nPlage des valeurs à ajouter (?-?) : ");
fgets( buf, 100, stdin);
tmp = strstr( buf, "-");
if( tmp != NULL)
{
* tmp = '\0';
n = atoi (buf);
*tmp = '\0';
n = atoi( buf);
tmp++;
tmp++;
m = atoi (tmp);
if (m < n)
m = atoi( tmp);
if( m < n)
{
printf ("\nEntrées non valides\n");
break;
@ -763,47 +769,52 @@ int main( int argc, char **argv)
}
else
{
printf ("\nEntrées non valides\n");
printf( "\nEntrées non valides\n");
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) ? ");
gets (buf);
fgets( buf, 100, stdin);
choice = atoi (buf);
if (choice == 0)
if( choice == 0)
{
i = n;
j = m + 1;
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++;
}
t_stop (t_exec);
t_stop( t_exec);
}
else
{
i = m;
j = n - 1;
t_start (t_exec);
while (i > j)
t_start( t_exec);
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--;
}
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);
break;
}
/*
case REMOVE_VALUE:
{
Nb_Removed = 0;
@ -942,15 +953,15 @@ int main( int argc, char **argv)
// DS_DataStruct_Unlock (Root);
break;
}
/*
case SHOW:
{
DS_DataStruct_Lock (Root, DSD_READ, &Locked);
DS_DataStruct_Dump (Root, stdout);
DS_DataStruct_Unlock (Root);
DS_DataStruct_Lock( Root_Ptr, DSD_READ, &locked);
DS_DataStruct_Value_Print( stdout, Root_Ptr, NDD_RECURSIVE_MODE_PARENT_CHILD, 0, 0);
DS_DataStruct_Unlock( Root_Ptr);
break;
}
/*
case CHECK:
{
Nb_Corrected = Nb_Detected = 0;