Liste chainée de "Bloc pool"

Bonjour,
j'ai 2 fichiers header de définis :
- 1 qui gere des liste chainées d'elements "linked_list.h"
- 1 qui gere des "block pool" cad une gestion de la memoire en block (pour eviter de passer par des allocations de memoire dynamiques

Résumé de linked_list.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct linked_list_elem
{
	struct linked_list_head * head; ///< A pointer to the head of the list.
	struct linked_list_elem * prev; ///< A pointer to the previous element in the list.
	struct linked_list_elem * next; ///< A pointer to the next element in the list.
};
 
struct linked_list_head
{
	struct linked_list_elem * first; ///< A pointer to the first element in the list.
	struct linked_list_elem * last;  ///< A pointer to the last element in the list.
};
 
void 						linked_list_append ( struct linked_list_head * head, struct linked_list_elem * elem );
void 						linked_list_insert ( struct linked_list_head * head, struct linked_list_elem * elem );
void 						linked_list_unlink ( struct linked_list_elem * elem );
struct linked_list_elem * 	linked_list_pop_first ( struct linked_list_head * head );
struct linked_list_elem * 	linked_list_pop_last ( struct linked_list_head * head );

Résumé de block pool.h :

Code:

1
2
3
4
5
6
7
8
struct block_pool;
 
struct block_pool * 	block_pool_create ( unsigned int block_size, unsigned int page_size, unsigned int min_pages, unsigned int max_pages );
void 					block_pool_delete ( struct block_pool * block_pool );
int 					block_pool_is_empty ( struct block_pool * block_pool );
void * 					block_pool_alloc ( struct block_pool * block_pool );
void 					block_pool_free ( struct block_pool * block_pool, void * block );
unsigned int 			block_pool_size ( struct block_pool * block_pool );

Maintenant j'aimerais crée une liste chainée de blocks, donc une liste chainée de blocks allouées par un block pool.

j'ai donc pensé a créer des structure comme tels :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
struct block_list_head
{
	struct linked_list_head head;	///< Block list head are linked list head
};
 
struct block_list_elem
{
	struct linked_list_elem	list;	///< Block list elem are linked list elem
	unsigned int			size;	///< The element size
	unsigned int		   begin;	///< Offset to begin
	unsigned int			 end;	///< Offset to end
};

et 4 fonctions :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// retourne un pointer sur les données et le maximum disponible dans le
premier block, si il n'y a rien la fonction retourne NULL et *size = 0
 
void *
block_list_read_begin ( struct block_list * block_list, unsigned int *
size )
 
// libere 'size' octets dans le premier block, size pouvant etre
inferieur ou egal au size que l'on a obtenu avec la fonction precedente.
 
int
block_list_read_end ( struct block_list * block_list, unsigned int size )
 
// retourne un pointer sur les données et le maximum disponible dans le
dernier block, si le dernier block est plein, un nouveau block vide et crée
 
void *
block_list_write_begin ( struct block_list * block_list, unsigned int *
size )
 
 
// ajoute 'size' octets au dernier block, size pouvant etre inferieur ou
egal au size que l'on a obtenu avec la fonction precedente
 
int
block_list_write_end ( struct block_list * block_list, unsigned int size )

mais comment gerer la notion de block pool dans ce que j'ai commencé ?
merci d'avance car la je bloque pas mal