Hi, I will improve, about the 'cosmetic' - there was an acual mix in the comments on table allocations - using entry_id for the index of the entry within the table, but using table_id for the inter table index within the master and inter_table_id for the table index within the inter table … it's messy as entry_id was not to be changed I did what I did
but as said, I will improve regards On Thursday 16 May 2013 13:25, Tom Hacohen wrote : > Hey, > > Thanks for your efforts, but if possible please avoid such changes in > the future. > > 1. Don't mix cosmetic changes with actual code affecting changes. > 2. The cosmetic changes you've made are disputable, and anyhow just make > it very annoying to revert old patches, use git blame to find who > changed a line, and etc. > > -- > Tom. > > On 16/05/13 12:18, Jérémy Zurcher - Enlightenment Git wrote: > > jeyzu pushed a commit to branch master. > > > > commit a9e69d519cd5240320e278cdc4efa8b1723a5fa1 > > Author: Jérémy Zurcher <[email protected]> > > Date: Thu May 16 10:55:32 2013 +0200 > > > > eo ptr ind: mostly cosmetic > > > > - add and use SHIFT_* macros > > - rename queue into fifo > > - try to clarify the structure top table -> mid table -> table[entry] > > --- > > src/lib/eo/eo_ptr_indirection.c | 216 > > +++++++++++++++++++++------------------- > > 1 file changed, 111 insertions(+), 105 deletions(-) > > > > diff --git a/src/lib/eo/eo_ptr_indirection.c > > b/src/lib/eo/eo_ptr_indirection.c > > index 74a3926..47c5295 100644 > > --- a/src/lib/eo/eo_ptr_indirection.c > > +++ b/src/lib/eo/eo_ptr_indirection.c > > @@ -17,14 +17,16 @@ > > * the Eo object to supply a better memory management by preventing bad > > usage > > * of the pointers. > > * > > - * Eo * is no more a pointer but an index to an entry into a ids table. > > - * For a better memory usage, we don't allocate all the tables at the > > beginning, > > - * but only when needed (i.e no more empty entries in allocated tables. > > - * In addition, tables are composed of intermediate tables, this for memory > > - * optimizations. Finding the different table, intermediate table and > > relative > > - * entry is done by bits manipulation of the id: > > + * Eo * is no more a pointer but indexes to an entry into an ids table. > > + * For a better memory usage: > > + * - a tree structure is used, composed of a top level table pointing at > > + * mid tables pointing at tables composed of entries. > > + * - tables are allocated when needed (i.e no more empty entries in > > allocated tables. > > + * For now there is no mechanism to free empty tables. > > * > > - * id = Table | Inter_table | Entry | Generation > > + * An Eo id is contructed by bits manipulation of table indexes and a > > generation. > > + * > > + * id = Mid Table | Table | Entry | Generation > > * > > * Generation helps finding abuse of ids. When an entry is assigned to an > > * object, a generation is inserted into the id. If the developer uses > > this id > > @@ -32,69 +34,73 @@ > > * entry of the table, the generation will be different and an error will > > * occur when accessing with the old id. > > * > > - * Each table is composed of: > > - * - an index 'start' indicating which entry is the next one to use. > > - * - 2 indexes 'queue_head' and 'queue_tail' defining a queue (fifo), > > + * Each Table is composed of: > > + * - an index 'start' indicating which free entry is the next one to use. > > + * - 2 indexes 'fifo_head' and 'fifo_tail' defining a fifo, > > * that will help us to store the entries to be reused. It stores only > > the > > * entries that have been used at least one time. The entries that have > > * never been used are "pointed" by the start parameter. > > * - entries composed of: > > * - a pointer to the object > > + * - an index 'next_in_fifo' used to chain the free entries in the fifo > > * - a flag indicating if the entry is active > > * - a generation assigned to the object > > - * - an index 'next_in_queue' used to chain the entries in the queue > > * > > * When an entry is searched into a table, we first use one of the > > entries that > > - * has never been used. If there is none, we try to pop from the queue. > > + * has never been used. If there is none, we try to pop from the fifo. > > + * If a such entry doesn't exist, we pass to the next table. > > + * When an entry is found, we reserve it to the object pointer > > + * then contruct and return the related Eo id. > > + * > > * Assigning all the entries of a table before trying to reuse them from > > * the fifo ensures that we are not going to soon recycle a released > > entry, > > * thus minimize the risks of an aggressive del() then use() on a single > > entry. > > - * If a such entry doesn't exist, we pass to the next table. > > - * When an entry is found, we reserve it to the object pointer and create > > - * the id with the table id, the intermediate table id, the entry and a > > - * generation. > > + * > > * The indexes and a reference to the last table which served an entry is > > kept > > * and is reused prior to the others untill it is full. > > * When an object is freed, the entry into the table is released by > > appending > > - * it to the queue. > > + * it to the fifo. > > */ > > > > #if SIZEOF_UINTPTR_T == 4 > > /* 32 bits */ > > -# define BITS_FOR_IDS_TABLE 5 > > -# define BITS_FOR_IDS_INTER_TABLE 5 > > -# define BITS_FOR_ID_IN_TABLE 12 > > -# define BITS_FOR_GENERATION_COUNTER 10 > > +# define BITS_MID_TABLE_ID 5 > > +# define BITS_TABLE_ID 5 > > +# define BITS_ENTRY_ID 12 > > +# define BITS_GENERATION_COUNTER 10 > > typedef int16_t Table_Index; > > typedef uint16_t Generation_Counter; > > #else > > /* 64 bits */ > > -# define BITS_FOR_IDS_TABLE 11 > > -# define BITS_FOR_IDS_INTER_TABLE 11 > > -# define BITS_FOR_ID_IN_TABLE 12 > > -# define BITS_FOR_GENERATION_COUNTER 30 > > +# define BITS_MID_TABLE_ID 11 > > +# define BITS_TABLE_ID 11 > > +# define BITS_ENTRY_ID 12 > > +# define BITS_GENERATION_COUNTER 30 > > typedef int16_t Table_Index; > > typedef uint32_t Generation_Counter; > > #endif > > > > /* Shifts macros to manipulate the Eo id */ > > -#define SHIFT_FOR_IDS_TABLE \ > > - (BITS_FOR_IDS_INTER_TABLE + BITS_FOR_ID_IN_TABLE + > > BITS_FOR_GENERATION_COUNTER) > > - > > -#define SHIFT_FOR_IDS_INTER_TABLE \ > > - (BITS_FOR_ID_IN_TABLE + BITS_FOR_GENERATION_COUNTER) > > - > > -#define SHIFT_FOR_ID_IN_TABLE (BITS_FOR_GENERATION_COUNTER) > > +#define SHIFT_MID_TABLE_ID (BITS_TABLE_ID + \ > > + BITS_ENTRY_ID + BITS_GENERATION_COUNTER) > > +#define SHIFT_TABLE_ID (BITS_ENTRY_ID + BITS_GENERATION_COUNTER) > > +#define SHIFT_ENTRY_ID (BITS_GENERATION_COUNTER) > > > > /* Maximum ranges */ > > -#define MAX_IDS_TABLES (1 << BITS_FOR_IDS_TABLE) > > -#define MAX_IDS_INTER_TABLES (1 << BITS_FOR_IDS_INTER_TABLE) > > -#define MAX_IDS_PER_TABLE (1 << BITS_FOR_ID_IN_TABLE) > > -#define MAX_GENERATIONS (1 << BITS_FOR_GENERATION_COUNTER) > > +#define MAX_MID_TABLE_ID (1 << BITS_MID_TABLE_ID) > > +#define MAX_TABLE_ID (1 << BITS_TABLE_ID) > > +#define MAX_ENTRY_ID (1 << BITS_ENTRY_ID) > > +#define MAX_GENERATIONS (1 << BITS_GENERATION_COUNTER) > > + > > +/* Masks */ > > +#define MASK_MID_TABLE_ID (MAX_MID_TABLE_ID - 1) > > +#define MASK_TABLE_ID (MAX_TABLE_ID - 1) > > +#define MASK_ENTRY_ID (MAX_ENTRY_ID - 1) > > +#define MASK_GENERATIONS (MAX_GENERATIONS - 1) > > > > -#define MEM_HEADER_SIZE 16 > > -#define MEM_PAGE_SIZE 4096 > > -#define MEM_MAGIC 0x3f61ec8a > > +#define MEM_HEADER_SIZE 16 > > +#define MEM_PAGE_SIZE 4096 > > +#define MEM_MAGIC 0x3f61ec8a > > > > typedef struct _Mem_Header > > { > > @@ -159,26 +165,26 @@ typedef struct > > { > > /* Pointer to the object */ > > _Eo *ptr; > > + /* Indicates where to find the next entry to recycle */ > > + Table_Index next_in_fifo; > > /* Active flag */ > > unsigned int active : 1; > > /* Generation */ > > - unsigned int generation : BITS_FOR_GENERATION_COUNTER; > > - /* Indicates where to find the next entry to recycle */ > > - Table_Index next_in_queue; > > + unsigned int generation : BITS_GENERATION_COUNTER; > > > > } _Eo_Id_Entry; > > > > /* Table */ > > typedef struct > > { > > - /* Entries of the table holding real pointers and generations */ > > - _Eo_Id_Entry entries[MAX_IDS_PER_TABLE]; > > /* Indicates where start the "never used" entries */ > > Table_Index start; > > /* Indicates where to find the next entry to recycle */ > > - Table_Index queue_head; > > + Table_Index fifo_head; > > /* Indicates where to add an entry to recycle */ > > - Table_Index queue_tail; > > + Table_Index fifo_tail; > > + /* Entries of the table holding real pointers and generations */ > > + _Eo_Id_Entry entries[MAX_ENTRY_ID]; > > } _Eo_Ids_Table; > > > > /* Table Info */ > > @@ -186,14 +192,14 @@ typedef struct > > { > > /* Table pointer */ > > _Eo_Ids_Table *table; > > - /* Top table index */ > > + /* Index of mid table in top table */ > > + Table_Index mid_table_id; > > + /* Index of table in mid table */ > > Table_Index table_id; > > - /* Intermediate table index */ > > - Table_Index int_table_id; > > } _Eo_Table_Info; > > > > /* Tables handling pointers indirection */ > > -static _Eo_Ids_Table **_eo_ids_tables[MAX_IDS_TABLES] = { NULL }; > > +static _Eo_Ids_Table **_eo_ids_tables[MAX_MID_TABLE_ID] = { NULL }; > > > > /* Current table used for following allocations */ > > static _Eo_Table_Info current_table = { NULL, 0, 0 }; > > @@ -202,21 +208,21 @@ static _Eo_Table_Info current_table = { NULL, 0, 0 }; > > Generation_Counter _eo_generation_counter; > > > > /* Macro used to compose an Eo id */ > > -#define EO_COMPOSE_ID(TABLE, INTER_TABLE, ENTRY, GENERATION) > > \ > > - (((Eo_Id)(TABLE & (MAX_IDS_TABLES - 1)) << SHIFT_FOR_IDS_TABLE) > > | \ > > - ((Eo_Id)(INTER_TABLE & (MAX_IDS_INTER_TABLES - 1)) << > > SHIFT_FOR_IDS_INTER_TABLE) | \ > > - ((ENTRY & (MAX_IDS_PER_TABLE - 1)) << SHIFT_FOR_ID_IN_TABLE) > > | \ > > - (GENERATION & (MAX_GENERATIONS - 1) )) > > +#define EO_COMPOSE_ID(TABLE, INTER_TABLE, ENTRY, GENERATION) \ > > + (((Eo_Id)(TABLE & MASK_MID_TABLE_ID) << SHIFT_MID_TABLE_ID) | \ > > + ((Eo_Id)(INTER_TABLE & MASK_TABLE_ID) << SHIFT_TABLE_ID) | \ > > + ((ENTRY & MASK_ENTRY_ID) << SHIFT_ENTRY_ID) | \ > > + (GENERATION & MASK_GENERATIONS )) > > > > /* Macro to extract from an Eo id the indexes of the tables */ > > -#define EO_DECOMPOSE_ID(ID, TABLE, INTER_TABLE, ENTRY, GENERATION) > > \ > > - TABLE = (ID >> SHIFT_FOR_IDS_TABLE) & (MAX_IDS_TABLES - 1); > > \ > > - INTER_TABLE = (ID >> SHIFT_FOR_IDS_INTER_TABLE) & (MAX_IDS_INTER_TABLES > > - 1); \ > > - ENTRY = (ID >> SHIFT_FOR_ID_IN_TABLE) & (MAX_IDS_PER_TABLE - 1); > > \ > > - GENERATION = ID & (MAX_GENERATIONS - 1); > > \ > > +#define EO_DECOMPOSE_ID(ID, TABLE, INTER_TABLE, ENTRY, GENERATION) \ > > + TABLE = (ID >> SHIFT_MID_TABLE_ID) & MASK_MID_TABLE_ID; \ > > + INTER_TABLE = (ID >> SHIFT_TABLE_ID) & MASK_TABLE_ID; \ > > + ENTRY = (ID >> SHIFT_ENTRY_ID) & MASK_ENTRY_ID; \ > > + GENERATION = ID & MASK_GENERATIONS; > > > > /* Macro used for readability */ > > -#define ID_TABLE _eo_ids_tables[table_id][int_table_id] > > +#define TABLE_FROM_IDS _eo_ids_tables[mid_table_id][table_id] > > > > _Eo * > > _eo_obj_pointer_get(const Eo_Id obj_id) > > @@ -224,14 +230,14 @@ _eo_obj_pointer_get(const Eo_Id obj_id) > > #ifdef HAVE_EO_ID > > _Eo_Id_Entry *entry; > > Generation_Counter generation; > > - Table_Index table_id, int_table_id, entry_id; > > + Table_Index mid_table_id, table_id, entry_id; > > > > - EO_DECOMPOSE_ID(obj_id, table_id, int_table_id, entry_id, generation); > > + EO_DECOMPOSE_ID(obj_id, mid_table_id, table_id, entry_id, generation); > > > > /* Checking the validity of the entry */ > > - if (_eo_ids_tables[table_id] && ID_TABLE) > > + if (_eo_ids_tables[mid_table_id] && TABLE_FROM_IDS) > > { > > - entry = &(ID_TABLE->entries[entry_id]); > > + entry = &(TABLE_FROM_IDS->entries[entry_id]); > > if (entry && entry->active && (entry->generation == generation)) > > return entry->ptr; > > } > > @@ -250,20 +256,20 @@ _get_available_entry(_Eo_Ids_Table *table) > > { > > _Eo_Id_Entry *entry = NULL; > > > > - if (table->start != MAX_IDS_PER_TABLE) > > + if (table->start != MAX_ENTRY_ID) > > { > > /* Serve never used entries first */ > > entry = &(table->entries[table->start]); > > table->start++; > > } > > - else if (table->queue_head != -1) > > + else if (table->fifo_head != -1) > > { > > - /* Pop an unused entry from the queue */ > > - entry = &(table->entries[table->queue_head]); > > - if (entry->next_in_queue == -1) > > - table->queue_head = table->queue_tail = -1; > > + /* Pop a free entry from the fifo */ > > + entry = &(table->entries[table->fifo_head]); > > + if (entry->next_in_fifo == -1) > > + table->fifo_head = table->fifo_tail = -1; > > else > > - table->queue_head = entry->next_in_queue; > > + table->fifo_head = entry->next_in_fifo; > > } > > > > return entry; > > @@ -275,25 +281,25 @@ _search_tables() > > _Eo_Ids_Table *table; > > _Eo_Id_Entry *entry; > > > > - for (Table_Index table_id = 1; table_id < MAX_IDS_TABLES; table_id++) > > + for (Table_Index mid_table_id = 1; mid_table_id < MAX_MID_TABLE_ID; > > mid_table_id++) > > { > > - if (!_eo_ids_tables[table_id]) > > + if (!_eo_ids_tables[mid_table_id]) > > { > > /* Allocate a new intermediate table */ > > - _eo_ids_tables[table_id] = > > _eo_id_mem_calloc(MAX_IDS_INTER_TABLES, sizeof(_Eo_Ids_Table*)); > > + _eo_ids_tables[mid_table_id] = > > _eo_id_mem_calloc(MAX_TABLE_ID, sizeof(_Eo_Ids_Table*)); > > } > > > > - for (Table_Index int_table_id = 0; int_table_id < > > MAX_IDS_INTER_TABLES; int_table_id++) > > + for (Table_Index table_id = 0; table_id < MAX_TABLE_ID; table_id++) > > { > > - table = ID_TABLE; > > + table = TABLE_FROM_IDS; > > > > if (!table) > > { > > /* Allocate a new table and reserve the first entry */ > > table = _eo_id_mem_calloc(1, sizeof(_Eo_Ids_Table)); > > table->start = 1; > > - table->queue_head = table->queue_tail = -1; > > - ID_TABLE = table; > > + table->fifo_head = table->fifo_tail = -1; > > + TABLE_FROM_IDS = table; > > entry = &(table->entries[0]); > > } > > else > > @@ -303,8 +309,8 @@ _search_tables() > > { > > /* Store table info into current table */ > > current_table.table = table; > > + current_table.mid_table_id = mid_table_id; > > current_table.table_id = table_id; > > - current_table.int_table_id = int_table_id; > > return entry; > > } > > } > > @@ -337,8 +343,8 @@ _eo_id_allocate(const _Eo *obj) > > entry->generation = _eo_generation_counter; > > _eo_generation_counter++; > > _eo_generation_counter %= MAX_GENERATIONS; > > - return EO_COMPOSE_ID(current_table.table_id, > > - current_table.int_table_id, > > + return EO_COMPOSE_ID(current_table.mid_table_id, > > + current_table.table_id, > > (entry - current_table.table->entries), > > entry->generation); > > #else > > @@ -353,27 +359,27 @@ _eo_id_release(const Eo_Id obj_id) > > _Eo_Ids_Table *table; > > _Eo_Id_Entry *entry; > > Generation_Counter generation; > > - Table_Index table_id, int_table_id, entry_id; > > - EO_DECOMPOSE_ID(obj_id, table_id, int_table_id, entry_id, generation); > > + Table_Index mid_table_id, table_id, entry_id; > > + EO_DECOMPOSE_ID(obj_id, mid_table_id, table_id, entry_id, generation); > > > > /* Checking the validity of the entry */ > > - if (_eo_ids_tables[table_id] && (table = ID_TABLE)) > > + if (_eo_ids_tables[mid_table_id] && (table = TABLE_FROM_IDS)) > > { > > entry = &(table->entries[entry_id]); > > if (entry && entry->active && (entry->generation == generation)) > > { > > /* Disable the entry */ > > entry->active = 0; > > - entry->next_in_queue = -1; > > - /* Push the entry into the queue */ > > - if (table->queue_tail == -1) > > + entry->next_in_fifo = -1; > > + /* Push the entry into the fifo */ > > + if (table->fifo_tail == -1) > > { > > - table->queue_head = table->queue_tail = entry_id; > > + table->fifo_head = table->fifo_tail = entry_id; > > } > > else > > { > > - table->entries[table->queue_tail].next_in_queue = > > entry_id; > > - table->queue_tail = entry_id; > > + table->entries[table->fifo_tail].next_in_fifo = entry_id; > > + table->fifo_tail = entry_id; > > } > > return; > > } > > @@ -388,20 +394,20 @@ _eo_id_release(const Eo_Id obj_id) > > void > > _eo_free_ids_tables() > > { > > - for (Table_Index table_id = 0; table_id < MAX_IDS_TABLES; table_id++) > > + for (Table_Index mid_table_id = 0; mid_table_id < MAX_MID_TABLE_ID; > > mid_table_id++) > > { > > - if (_eo_ids_tables[table_id]) > > + if (_eo_ids_tables[mid_table_id]) > > { > > - for (Table_Index int_table_id = 0; int_table_id < > > MAX_IDS_INTER_TABLES; int_table_id++) > > + for (Table_Index table_id = 0; table_id < MAX_TABLE_ID; > > table_id++) > > { > > - if (ID_TABLE) > > + if (TABLE_FROM_IDS) > > { > > - _eo_id_mem_free(ID_TABLE); > > + _eo_id_mem_free(TABLE_FROM_IDS); > > } > > } > > - _eo_id_mem_free(_eo_ids_tables[table_id]); > > + _eo_id_mem_free(_eo_ids_tables[mid_table_id]); > > } > > - _eo_ids_tables[table_id] = NULL; > > + _eo_ids_tables[mid_table_id] = NULL; > > } > > current_table.table = NULL; > > } > > @@ -412,22 +418,22 @@ _eo_print() > > { > > _Eo_Id_Entry *entry; > > unsigned long obj_number = 0; > > - for (Table_Index table_id = 0; table_id < MAX_IDS_TABLES; table_id++) > > + for (Table_Index mid_table_id = 0; mid_table_id < MAX_MID_TABLE_ID; > > mid_table_id++) > > { > > - if (_eo_ids_tables[table_id]) > > + if (_eo_ids_tables[mid_table_id]) > > { > > - for (Table_Index int_table_id = 0; int_table_id < > > MAX_IDS_INTER_TABLES; int_table_id++) > > + for (Table_Index table_id = 0; table_id < MAX_TABLE_ID; > > table_id++) > > { > > - if (ID_TABLE) > > + if (TABLE_FROM_IDS) > > { > > - for (Table_Index entry_id = 0; entry_id < > > MAX_IDS_PER_TABLE; entry_id++) > > + for (Table_Index entry_id = 0; entry_id < > > MAX_ENTRY_ID; entry_id++) > > { > > - entry = &(ID_TABLE->entries[entry_id]); > > + entry = &(TABLE_FROM_IDS->entries[entry_id]); > > if (entry->active) > > { > > printf("%ld: %p -> (%p, %p, %p, %p)\n", > > obj_number++, > > entry->ptr, > > - (void *)table_id, (void > > *)int_table_id, (void *)entry_id, > > + (void *)mid_table_id, (void > > *)table_id, (void *)entry_id, > > (void *)entry->generation); > > } > > } > > > > > > ------------------------------------------------------------------------------ > AlienVault Unified Security Management (USM) platform delivers complete > security visibility with the essential security capabilities. Easily and > efficiently configure, manage, and operate all of your security controls > from a single console and one unified framework. Download a free trial. > http://p.sf.net/sfu/alienvault_d2d > _______________________________________________ > enlightenment-devel mailing list > [email protected] > https://lists.sourceforge.net/lists/listinfo/enlightenment-devel -- Jérémy Zurcher av General Guisan 49 1400 Yverdon-les-bains +41 (0) 79 599 84 27 ------------------------------------------------------------------------------ AlienVault Unified Security Management (USM) platform delivers complete security visibility with the essential security capabilities. Easily and efficiently configure, manage, and operate all of your security controls from a single console and one unified framework. Download a free trial. http://p.sf.net/sfu/alienvault_d2d _______________________________________________ enlightenment-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/enlightenment-devel
