Rx3/libdatastr
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity
2967341251
libdatastr/util/dsbench.c

966 lines
34 KiB
C
Raw Normal View History

- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*----------------------------------------------------------------------------*/
/* dsbench.c */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* This file is part of LibDataStr. */
/* */
/* LibDataStr is free software: you can redistribute it and/or modify it */
/* under the terms of the GNU General Public License as published by */
/* the Free Software Foundation, either version 3 of the License, or */
/* (at your option) any later version. */
/* */
/* LibDataStr 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 General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with LibDataStr. If not, see <https://www.gnu.org/licenses/>. */
/*----------------------------------------------------------------------------*/
/*----------------------------------------------------------------------------*/
/* Includes */
/*----------------------------------------------------------------------------*/
Première version
2000-07-28 17:30:55 +02:00
#define DS_MODE 2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
#include <stdarg.h>
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
#include <log.h>
Première version
2000-07-28 17:30:55 +02:00
#include <node.h>
#include <datastr.h>
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*----------------------------------------------------------------------------*/
/* Defines */
/*----------------------------------------------------------------------------*/
#define LGD_MODULE_NAME "dsb"
Première version
2000-07-28 17:30:55 +02:00
extern char * strdup ( const char *);
#define QUIT 0
#define CREATE_STRUCT 1
#define OPEN_STRUCT 2
#define CLOSE_STRUCT 3
#define DELETE_STRUCT 4
#define ADD_VALUE 5
#define REMOVE_VALUE 6
#define FIND_VALUE 7
#define CHG_LIST_TYPE 8
#define CONVERT_TO_TREE 9
#define CONVERT_TO_LIST 10
#define REORG 11
#define INFO 12
#define SHOW 13
#define CHECK 14
#define MANAGER_FILE_NAME "dsbench.so"
char DataStruct_Name [100];
char menu [1000];
char buf [100];
long int random ( void );
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*----------------------------------------------------------------------------*/
/* Prototype */
/*----------------------------------------------------------------------------*/
NDT_Status Module_Manager( NDT_Root *, NDT_Index_Id, NDT_Node *, NDT_Command, va_list *);
void Menu_Init ( NDT_Root *);
int Menu_Print ( NDT_Root *);
Première version
2000-07-28 17:30:55 +02:00
/* Mesure des temps d'ex<65>cution */
typedef struct {
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
double sec;
struct timeval start;
struct timeval stop;
Première version
2000-07-28 17:30:55 +02:00
} T_Cpt;
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
#define t_start(x) { gettimeofday (&(x.start), NULL);}
#define t_stop( x) { gettimeofday (&(x.stop), NULL); x.sec = (double)(x.stop.tv_sec) - (double)(x.start.tv_sec) + ((double)(x.stop.tv_usec) - (double)(x.start.tv_usec)) / 1000000;}
Première version
2000-07-28 17:30:55 +02:00
T_Cpt t_exec;
/* D<>finition des valeurs attach<63>es aux noeuds de la structure */
typedef struct {
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
int Id;
char * Nom;
Première version
2000-07-28 17:30:55 +02:00
} T_Module;
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*---------------------------------------------------------------------------------*/
/* Module_Manager */
/*---------------------------------------------------------------------------------*/
NDT_Status Module_Manager( NDT_Root *Root_Ptr, NDT_Index_Id Index_Id, NDT_Node *Node_Ptr, NDT_Command Command, va_list *Args_Ptr)
{
NDT_Command_Name Command_Name;
switch( Command)
{
case NDD_CMD_MANAGER_VERSION:
{
ND_VA_ARG_GET( Version_Name_Ptr, *Args_Ptr, NDT_Version_Name *);
Command_Name = "NDD_CMD_MANAGER_VERSION";
*Version_Name_Ptr = "$Revision: 2.13 $ $Name: libnode-2_2_0-1 $ $Date: 2010/06/06 21:26:31 $ $Author: agibert $";
return( NDS_OK);
}
case NDD_CMD_INDEX_GET:
{
/*
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
*/
ND_VA_ARG_GET( Reply_Index_Id_Ptr, *Args_Ptr, NDT_Index_Id *);
ND_VA_ARG_GET( Reply_Command_Ptr, *Args_Ptr, NDT_Command *);
ND_VA_ARG_GET( Cmd, *Args_Ptr, NDT_Command);
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
Command_Name = "NDD_CMD_INDEX_GET";
switch(Cmd)
{
/*
case NDT_CMD_SOME_USER_CMD:
{
*Reply_Index_Id_Ptr = 0;
*Reply_Command_Ptr = NDD_CMD_SOME_OTHER_CMD;
break;
}
...
*/
default:
{
*Reply_Index_Id_Ptr = Index_Id;
*Reply_Command_Ptr = Cmd;
break;
}
}
return( NDS_OK);
}
case NDD_CMD_VALUE_ALLOC:
{
/*
ND_VA_ARG_GET( Value_Ptr_Ptr, *Args_Ptr, void **);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Module_Ptr_Ptr, *Args_Ptr, T_Module **);
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_LIST_CLOSE( user_args);
Command_Name = "NDD_CMD_VALUE_ALLOC";
- Start Allocation support.
2024-04-23 17:10:37 +02:00
LG_LOG_TRACE_0( LGD_LOG_LEVEL_DEFAULT, "CMD_VALUE_ALLOC called...");
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*
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
{
LG_LOG_ERROR_0( "Allocation error");
return( DSS_KO)
}
*/
}
case NDD_CMD_VALUE_FREE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
Command_Name = "NDD_CMD_VALUE_FREE";
/*
DS_Free( Root_Ptr, Value_Ptr);
*/
return( NDS_OK);
}
case NDD_CMD_VALUE_COMP:
{
/*
ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, void *);
ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
ND_VA_ARG_GET( Value1_Ptr, *Args_Ptr, T_Module *);
ND_VA_ARG_GET( Value2_Ptr, *Args_Ptr, T_Module *);
Command_Name = "NDD_CMD_VALUE_COMP";
switch( Index_Id)
{
case 0:
{
if( Value1_Ptr->Id < Value2_Ptr->Id)
{
return(NDS_LOWER);
}
else
{
if( Value1_Ptr->Id > Value2_Ptr->Id)
{
return(NDS_GREATER);
}
else
{
return(NDS_EQUAL);
}
}
}
default:
{
printf( "Unknown COMP idx (%d) !\n", Index_Id);
return( NDS_KO);
}
}
return( NDS_OK);
}
case NDD_CMD_VALUE_ADD:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_ADD";
/*
return( NDS_OK);
*/
}
case NDD_CMD_VALUE_REMOVE:
{
/*
ND_VA_ARG_GET( Value_Ptr, *Args_Ptr, void *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
*/
Command_Name = "NDD_CMD_VALUE_REMOVE";
return( NDS_OK);
}
case NDD_CMD_VALUE_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
void *Value_Ptr = Node_Ptr->Value;
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
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);
return( NDS_OK);
}
case NDD_CMD_INFO_PRINT:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_OPEN( user_args, lib_args);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
ND_VA_LIST_CLOSE( lib_args);
*/
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( lib_args, *Args_Ptr);
ND_VA_ARG_GET( Out, lib_args, FILE *);
ND_VA_ARG_GET( Recursive_Mode, lib_args, NDT_Recursive_Mode);
ND_VA_ARG_GET( Recursive_Depth, lib_args, NDT_Recursive_Depth);
ND_VA_ARG_GET( Recursive_Offset, lib_args, NDT_Recursive_Offset);
ND_VA_LIST_CLOSE( lib_args);
char *Root_Type;
DST_RootDesc *RootDesc;
Command_Name = "NDD_CMD_INFO_PRINT";
/*
switch( (int)(Root_Ptr->Type & NDD_DS_MSK))
{
case NDD_DS_LIST:
{
switch ((int)(Root_Ptr->Type & NDD_MN_MSK))
{
case NDD_MN_ORDERED: Root_Type = strdup ("liste tri<72>e"); break;
case NDD_MN_FILO: Root_Type = strdup ("liste FILO"); break;
case NDD_MN_FIFO: Root_Type = strdup ("liste FIFO"); break;
default: Root_Type = strdup ("inconnu"); break;
}
break;
}
case NDD_DS_TREE :
{
switch( (int)(Root_Ptr->Type & NDD_MN_MSK))
{
case NDD_MN_AUTO_EQU: Root_Type = strdup ("arbre auto-<2D>quilibr<62>"); break;
default: Root_Type = strdup ("arbre non auto-<2D>quilibr<62>"); break;
}
break;
}
default: Root_Type = strdup ("inconnu"); break;
}
RootDesc = (DST_RootDesc *)(Root->User);
fprintf( Out, \
"\nStructure de type %s :\n\t- Nom = %s\n\t- Manager = %s\n\t- Nombre de modules = %ld\n", \
Root_Type, RootDesc->Heap_Name, RootDesc->Manager_FileName, Root_Ptr->Node_Number);
if( ( Root->Type & NDD_DS_MSK) == NDD_DS_TREE)
fprintf( Out, "\t- Profondeur maxi = %ld\n\t- Profondeur mini = %ld\n\t- Diff<66>rence maximale autoris<69>e = %ld\n\t- Nombre d'<27>quilibrages = %ld\n", \
Root_Ptr->Max_Depth, Root_Ptr->Min_Depth, Root_Ptr->Max_Dif, Root_Ptr->Nb_Equ);
if( Root_Type) free( Root_Type);
*/
return( NDS_OK);
}
case NDD_CMD_USER_TRAVERSE:
{
/*
ND_VA_ARG_GET( Next_Node_Ptr, *Args_Ptr, NDT_Node *);
ND_VA_LIST_OPEN( user_args, *Args_Ptr);
ND_VA_ARG_GET( user_data, user_args, user_type);
ND_VA_ARG_GET( ..., user_args, ...);
ND_VA_LIST_CLOSE( user_args);
void *Value_Ptr = Node_Ptr->Value;
*/
Command_Name = "NDD_CMD_USER_TRAVERSE";
/*
return( NDS_OK);
*/
}
default:
{
LG_LOG_ERROR_1( "Manager called with an undefined command: (%d)", Command);
return( NDS_ERRAPI);
}
}
LG_LOG_ERROR_2( "Manager internal error with command: (%d) name: [%s]", Command, Command_Name);
return( NDS_OK);
}
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*---------------------------------------------------------------------------------*/
/* Menu_Init */
/*---------------------------------------------------------------------------------*/
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
void Menu_Init( NDT_Root *Root )
{
sprintf (menu, "Menu :\n");
sprintf (buf, " - %d) %-30s\n", QUIT, "Quitter");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s", CREATE_STRUCT, "Cr<EFBFBD>ation de structure");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", OPEN_STRUCT, "Ouverture de structure");
strcat (menu, buf);
if (Root != NULL)
{
sprintf (buf, " - %d) %-30s", CLOSE_STRUCT, "Fermer la structure");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", DELETE_STRUCT, "D<EFBFBD>truire la structure");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s", ADD_VALUE, "Ajout de valeurs");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", REMOVE_VALUE, "Suppression de valeurs");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", FIND_VALUE, "Recherche de valeurs al<61>atoires");
strcat (menu, buf);
if( ND_INDEX_TYPE_LIST_IS( Root, NDD_INDEX_PRIMARY))
Première version
2000-07-28 17:30:55 +02:00
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
sprintf (buf, " - %d) %-30s", CHG_LIST_TYPE, "Changement de type de liste");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", CONVERT_TO_TREE, "Conversion en arbre");
strcat (menu, buf);
Première version
2000-07-28 17:30:55 +02:00
}
else
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
sprintf (buf, " - %d) %-30s", CONVERT_TO_LIST, "Conversion en liste tri<72>e");
strcat (menu, buf);
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
sprintf (buf, " - %d) %-30s\n", REORG, "R<EFBFBD>organisation");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s", INFO, "Informations sur la structure");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", SHOW, "Affichage de la structure");
strcat (menu, buf);
sprintf (buf, " - %d) %-30s\n", CHECK, "V<EFBFBD>rification de la structure");
strcat (menu, buf);
}
}
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*---------------------------------------------------------------------------------*/
/* Menu_Print */
/*---------------------------------------------------------------------------------*/
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
int Menu_Print( NDT_Root *Root )
{
Menu_Init (Root);
fprintf (stdout, "\n---------------------------------------------------------\n");
fprintf (stdout, menu);
buf [0] = '\0';
while (buf [0] == '\0')
{
printf ("\nChoice ? ");
fgets( buf, 100, stdin);
}
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
return atoi (buf);
}
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
/*---------------------------------------------------------------------------------*/
/* main */
/*---------------------------------------------------------------------------------*/
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
int main( int argc, char **argv)
{
- Start Allocation support.
2024-04-23 17:10:37 +02:00
DST_Status status;
LGT_Status lg_status;
int rc;
NDT_Root *Root_Ptr = NULL;
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 Nb_Detected, Nb_Corrected;
T_Module *Module, Ref_Module;
NDT_Node *Node;
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
if( ( lg_status = LG_Library_Open( LGD_LOG_WRITER_DEFAULT, true)) != LGS_OK)
{
fprintf( stderr, "Can't open LibLog library: (%d)\n", lg_status);
return( -1);
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
LG_LOG_INFO_0( "Start DSBench");
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
if( argc > 1 && !strcmp (argv[1], "-h"))
Première version
2000-07-28 17:30:55 +02:00
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
fprintf( stdout, "Usage : %s [-h] [instance [context]]\n", argv[0]);
rc = 0;
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
else
Première version
2000-07-28 17:30:55 +02:00
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
if( DS_Library_Open (0, NULL, DSD_DEBUG_ALL) != NDS_OK)
Première version
2000-07-28 17:30:55 +02:00
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
rc = -1;
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
else
Première version
2000-07-28 17:30:55 +02:00
{
- Start Allocation support.
2024-04-23 17:10:37 +02:00
choice = Menu_Print( Root_Ptr);
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
while (choice != QUIT)
{
switch (choice)
{
case CREATE_STRUCT:
{
fprintf( stdout, "\nNom de la structure <20> cr<63>er ? ");
fgets( DataStruct_Name, 100, stdin);
- Start Allocation support.
2024-04-23 17:10:37 +02:00
if( strlen( DataStruct_Name) < 2)
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
{
- Start Allocation support.
2024-04-23 17:10:37 +02:00
fprintf( stdout, "Bad name!\n");
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
}
else
{
- Start Allocation support.
2024-04-23 17:10:37 +02:00
DataStruct_Name[ strlen( DataStruct_Name) - 1] = 0;
if( ( status = DS_DataStruct_Open( &Root_Ptr, DataStruct_Name, 1, &index_type, MANAGER_FILE_NAME, 0, DSD_CREATE, TRUE)) != DSS_OK)
{
LG_LOG_ERROR_1( "Can't create data structure: (%d)", status);
}
else
{
// strcpy( Root->Manager, "Module_Manager");
LG_LOG_INFO_1( "Data structure: [%s] created", DataStruct_Name);
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
}
- Start Allocation support.
2024-04-23 17:10:37 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
break;
}
/*
case DELETE_STRUCT:
{
if (DS_DataStruct_Close (Root, DSD_DESTROY) == DSS_KO) printf ("\nNOK\n");
else
{
printf ("\nStructure d<>truite : OK\n");
Root = NULL;
}
break;
}
case OPEN_STRUCT:
{
fprintf (stdout, "\nNom de la structure <20> ouvrir ? ");
gets (DataStruct_Name);
if (DS_DataStruct_Open (DataStruct_Name, &Root, 0, NULL, 0, DSD_OPEN, TRUE) == NDS_KO)
printf ("\nNOK\n");
else
printf ("\nStructure ouverte : OK\n");
break;
}
case CLOSE_STRUCT:
{
if (DS_DataStruct_Close (Root, DSD_CLOSE) == DSS_KO) printf ("\nNOK\n");
else
{
printf ("\nStructure ferm<72>e : OK\n");
Root = NULL;
}
break;
}
case FIND_VALUE:
{
fprintf (stdout, "\nPlage de recherche (?->?) : ");
gets (buf);
tmp = strstr (buf, "->");
if (tmp != NULL)
{
* tmp = '\0';
n = atoi (buf);
tmp++;
tmp++;
m = atoi (tmp);
if (m < n)
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
}
else
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
DS_DataStruct_Lock (Root, DSD_READ, &Locked);
i = n;
j = m + 1;
t_start (t_exec);
while (i < j)
{
Module->Id = n + (random () % m);
DS_Node_Find (Root, &Node, Module, NULL);
i++;
}
t_stop (t_exec);
DS_DataStruct_Unlock (Root);
fprintf (stdout, "\n%d valeur(s) recherch<63>e(s) en %.4f sec (%.2f select/sec)\n", \
m - n + 1, t_exec.sec, (m - n + 1) / t_exec.sec);
break;
}
case ADD_VALUE:
{
fprintf (stdout, "\nPlage des valeurs <20> ajouter (?->?) : ");
gets (buf);
tmp = strstr (buf, "->");
if (tmp != NULL)
{
* tmp = '\0';
n = atoi (buf);
tmp++;
tmp++;
m = atoi (tmp);
if (m < n)
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
}
else
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
fprintf (stdout, "\nOrdre d'ajout (croissant=0 d<>croissant=1) ? ");
gets (buf);
choice = atoi (buf);
if (choice == 0)
{
i = n;
j = m + 1;
t_start (t_exec);
while (i < j)
{
if (DS_Value_Alloc (Root, (void **)&Module, "x", i) == NDS_OK) DS_Value_Add (Root, Module);
i++;
}
t_stop (t_exec);
}
else
{
i = m;
j = n - 1;
t_start (t_exec);
while (i > j)
{
if (DS_Value_Alloc (Root, (void **)&Module, "x", i) == NDS_OK) DS_Value_Add (Root, Module);
i--;
}
t_stop (t_exec);
}
DS_DataStruct_Unlock (Root);
fprintf (stdout, "\n%d valeur(s) ajout<75>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;
fprintf (stdout, "\nPlage des valeurs <20> supprimer (?->?) : ");
gets (buf);
tmp = strstr (buf, "->");
if (tmp != NULL)
{
* tmp = '\0';
n = atoi (buf);
tmp++;
tmp++;
m = atoi (tmp);
if (m < n)
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
}
else
{
printf ("\nEntr<EFBFBD>es non valides\n");
break;
}
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
fprintf (stdout, "\nOrdre de suppression (croissant=0 d<>croissant=1) ? ");
gets (buf);
choice = atoi (buf);
if (choice == 0)
{
i = n;
j = m + 1;
t_start (t_exec);
while (i < j)
{
Ref_Module.Id = i;
if (DS_Value_Remove (Root, &Ref_Module, (void **)&Module) == NDS_OK)
{
DS_Value_Free (Root, Module);
Nb_Removed++;
}
i++;
}
t_stop (t_exec);
}
else
{
i = m;
j = n - 1;
t_start (t_exec);
while (i > j)
{
Ref_Module.Id = i;
if (DS_Value_Remove (Root, &Ref_Module, (void **)&Module) == NDS_OK)
{
DS_Value_Free (Root, Module);
Nb_Removed++;
}
i--;
}
t_stop (t_exec);
}
DS_DataStruct_Unlock (Root);
fprintf (stdout, "\n%d valeur(s) supprim<69>e(s) en %.4f sec (%.2f suppressions/sec)\n",\
Nb_Removed, t_exec.sec, (m - n + 1) / t_exec.sec);
break;
}
case CHG_LIST_TYPE:
{
fprintf (stdout, "\nType de liste (FIFO=0 ; FILO=1 ; tri<72>e=2) ? ");
gets (buf);
choice = atoi (buf);
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
switch (choice)
{
case 0:
Root->Type = NDD_DS_LIST | NDD_MN_FIFO;
break;
case 1:
Root->Type = NDD_DS_LIST | NDD_MN_FILO;
break;
case 2:
Root->Type = NDD_DS_LIST | NDD_MN_ORDERED;
break;
default:
printf ("\nChoix non valide\n");
break;
}
DS_DataStruct_Unlock (Root);
break;
}
case REORG:
{
t_start (t_exec);
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
DS_DataStruct_Reorg (Root);
DS_DataStruct_Unlock (Root);
t_stop (t_exec);
fprintf (stdout, "\nR<EFBFBD>organisation de la structure en %.4f sec\n", t_exec.sec);
break;
}
case CONVERT_TO_LIST:
{
t_start (t_exec);
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
DS_DataStruct_Convert (Root, NDD_DS_LIST | NDD_MN_ORDERED);
DS_DataStruct_Unlock (Root);
t_stop (t_exec);
fprintf (stdout, "\nConversion arbre vers liste en %.4f sec\n", t_exec.sec);
break;
}
case CONVERT_TO_TREE:
{
t_start (t_exec);
DS_DataStruct_Lock (Root, DSD_WRITE, &Locked);
DS_DataStruct_Convert (Root, NDD_DS_TREE | NDD_MN_AUTO_EQU);
DS_DataStruct_Unlock (Root);
t_stop (t_exec);
fprintf (stdout, "\nConversion liste vers arbre en %.4f sec\n", t_exec.sec);
break;
}
case INFO:
{
DS_DataStruct_Lock (Root, DSD_READ, &Locked);
DS_DataStruct_Info_Print (Root, stdout);
DS_DataStruct_Unlock (Root);
break;
}
case SHOW:
{
DS_DataStruct_Lock (Root, DSD_READ, &Locked);
DS_DataStruct_Dump (Root, stdout);
DS_DataStruct_Unlock (Root);
break;
}
case CHECK:
{
Nb_Corrected = Nb_Detected = 0;
ND_DataStruct_Check (Root, &Nb_Detected, &Nb_Corrected, stderr);
break;
}
*/
default:
{
fprintf (stdout, "\nChoix %d non d<>fini\n", choice);
}
}
- Start Allocation support.
2024-04-23 17:10:37 +02:00
choice = Menu_Print( Root_Ptr);
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
}
DS_Library_Close();
rc = 0;
}
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
LG_LOG_INFO_0( "End DSBench");
Première version
2000-07-28 17:30:55 +02:00
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
if( ( lg_status = LG_Library_Close( true)) != LGS_OK)
Première version
2000-07-28 17:30:55 +02:00
{
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
fprintf( stderr, "Can't close LibLog library: (%d)\n", lg_status);
rc = -1;
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
return( rc);
Première version
2000-07-28 17:30:55 +02:00
}
- Update LibDataStr Open & Close, - Make compile dsbench...
2024-04-22 18:37:50 +02:00
Reference in New Issue Copy Permalink