1  #include "buffer_manage.h"
       2  #include "buffer_entry.h"
       3  #include <stdio.h>
       4  #include <assert.h>
       5  #include <stdlib.h>
       6  struct __buffer_manage_t
       7  {
       8  	cmph_uint32 memory_avail;         // memory available
       9  	buffer_entry_t ** buffer_entries; // buffer entries to be managed
      10  	cmph_uint32 nentries;             // number of entries to be managed
      11  	cmph_uint32 *memory_avail_list;   // memory available list
      12  	int pos_avail_list;               // current position in memory available list
      13  };
      14  
      15  buffer_manage_t * buffer_manage_new(cmph_uint32 memory_avail, cmph_uint32 nentries)
      16  {
      17  	cmph_uint32 memory_avail_entry, i;
      18  	buffer_manage_t *buff_manage = (buffer_manage_t *)malloc(sizeof(buffer_manage_t));
      19  	assert(buff_manage);
      20  	buff_manage->memory_avail = memory_avail;
      21  	buff_manage->buffer_entries = (buffer_entry_t **)calloc((size_t)nentries, sizeof(buffer_entry_t *));
      22  	buff_manage->memory_avail_list = (cmph_uint32 *)calloc((size_t)nentries, sizeof(cmph_uint32));
      23  	buff_manage->pos_avail_list = -1;
      24  	buff_manage->nentries = nentries;
      25  	memory_avail_entry = buff_manage->memory_avail/buff_manage->nentries + 1;
      26  	for(i = 0; i < buff_manage->nentries; i++)
      27  	{
      28  		buff_manage->buffer_entries[i] = buffer_entry_new(memory_avail_entry);
      29  	}	
      30  	return buff_manage;
      31  }
      32  
      33  void buffer_manage_open(buffer_manage_t * buffer_manage, cmph_uint32 index, char * filename)
      34  {
      35  	buffer_entry_open(buffer_manage->buffer_entries[index], filename);
      36  }
      37  
      38  cmph_uint8 * buffer_manage_read_key(buffer_manage_t * buffer_manage, cmph_uint32 index)
      39  {
      40  	cmph_uint8 * key = NULL;
      41  	if (buffer_manage->pos_avail_list >= 0 ) // recovering memory
      42  	{
      43  		cmph_uint32 new_capacity = buffer_entry_get_capacity(buffer_manage->buffer_entries[index]) + buffer_manage->memory_avail_list[(buffer_manage->pos_avail_list)--];
      44  		buffer_entry_set_capacity(buffer_manage->buffer_entries[index], new_capacity);
      45  		//fprintf(stderr, "recovering memory\n");
      46  	}
      47  	key = buffer_entry_read_key(buffer_manage->buffer_entries[index]);
      48  	if (key == NULL) // storing memory to be recovered
      49  	{
      50  		buffer_manage->memory_avail_list[++(buffer_manage->pos_avail_list)] = buffer_entry_get_capacity(buffer_manage->buffer_entries[index]);
      51  		//fprintf(stderr, "storing memory to be recovered\n");
      52  	}
      53  	return key;
      54  }
      55  
      56  void buffer_manage_destroy(buffer_manage_t * buffer_manage)
      57  { 
      58  	cmph_uint32 i;
      59  	for(i = 0; i < buffer_manage->nentries; i++)
      60  	{
      61  		buffer_entry_destroy(buffer_manage->buffer_entries[i]);
      62  	}
      63  	free(buffer_manage->memory_avail_list);
      64  	free(buffer_manage->buffer_entries);
      65  	free(buffer_manage);
      66  }