/*****************************************************************************\
* Copyright (c) Athena Dev Teams - Licensed under GNU GPL *
* For more information, see LICENCE in the main folder *
* *
* Entry Reusage System
*
* *
* There are several root entry managers, each with a different entry size. *
* Each manager will keep track of how many instances have been 'created'. *
* They will only automatically destroy themselves after the last instance *
* is destroyed. *
* *
* Entries can be allocated from the managers. *
* If it has reusable entries (freed entry), it uses one. *
* So no assumption should be made about the data of the entry. *
* Entries should be freed in the manager they where allocated from. *
* Failure to do so can lead to unexpected behaviours. *
* *
* Advantages:
*
* - The same manager is used for entries of the same size. *
* So entries freed in one instance of the manager can be used by other *
* instances of the manager. *
* - Much less memory allocation/deallocation - program will be faster. *
* - Avoids memory fragmentaion - program will run better for longer. *
* *
* Disavantages:
*
* - Unused entries are almost inevitable - memory being wasted. *
* - A manager will only auto-destroy when all of its instances are *
* destroyed so memory will usually only be recovered near the end. *
* - Always wastes space for entries smaller than a pointer. *
* *
* WARNING: The system is not thread-safe at the moment. *
* *
* HISTORY: *
* 0.1 - Initial version *
* 1.0 - ERS Rework *
* *
* @version 1.0 - ERS Rework *
* @author GreenBox @ rAthena Project *
* @encoding US-ASCII *
* @see common#ers.h *
\*****************************************************************************/
#include
#include "../common/cbasetypes.h"
#include "../common/malloc.h" // CREATE, RECREATE, aMalloc, aFree
#include "../common/showmsg.h" // ShowMessage, ShowError, ShowFatalError, CL_BOLD, CL_NORMAL
#include "ers.h"
#ifndef DISABLE_ERS
#define ERS_ROOT_SIZE 256
#define ERS_BLOCK_ENTRIES 4096
typedef struct ers_instance_t;
struct ers_list
{
struct ers_list *Next;
};
typedef struct ers_cache
{
// Allocated object size, including ers_list size
unsigned int ObjectSize;
// Number of ers_instances referencing this
int ReferenceCount;
// Reuse linked list
struct ers_list *ReuseList;
// Memory blocks array
unsigned char **Blocks;
// Max number of blocks
unsigned int Max;
// Free objects count
unsigned int Free;
// Used objects count
unsigned int Used;
// Linked list
struct ers_cache *Next, *Prev;
} ers_cache_t;
typedef struct
{
// Interface to ERS
struct eri VTable;
// Name, used for debbuging purpouses
char *Name;
// Misc options
enum ERSOptions Options;
// Our cache
ers_cache_t *Cache;
// Count of objects in use, used for detecting memory leaks
unsigned int Count;
} ers_instance_t;
// Array containing a pointer for all ers_cache structures
static ers_cache_t *CacheList;
static ers_cache_t *ers_find_cache(unsigned int size)
{
ers_cache_t *cache;
for (cache = CacheList; cache; cache = cache->Next)
if (cache->ObjectSize == size)
return cache;
CREATE(cache, ers_cache_t, 1);
cache->ObjectSize = size;
cache->ReferenceCount = 0;
cache->ReuseList = NULL;
cache->Blocks = NULL;
cache->Free = 0;
cache->Used = 0;
cache->Max = 0;
if (CacheList == NULL)
{
CacheList = cache;
}
else
{
CacheList->Next = cache;
cache->Prev = CacheList;
}
return cache;
}
static void ers_free_cache(ers_cache_t *cache, bool remove)
{
unsigned int i;
for (i = 0; i < cache->Used; i++)
aFree(cache->Blocks[i]);
if (cache->Prev)
cache->Prev->Next = cache->Next;
if (cache->Next)
cache->Next->Prev = cache->Prev;
if (CacheList == cache)
CacheList = cache->Next;
aFree(cache->Blocks);
aFree(cache);
}
static void *ers_obj_alloc_entry(ERS self)
{
ers_instance_t *instance = (ers_instance_t *)self;
void *ret;
if (instance == NULL)
{
ShowError("ers_obj_alloc_entry: NULL object, aborting entry freeing.\n");
return NULL;
}
if (instance->Cache->ReuseList != NULL)
{
ret = (void *)((unsigned int)instance->Cache->ReuseList + sizeof(struct ers_list));
instance->Cache->ReuseList = instance->Cache->ReuseList->Next;
}
else if (instance->Cache->Free > 0)
{
instance->Cache->Free--;
ret = &instance->Cache->Blocks[instance->Cache->Used - 1][instance->Cache->Free * instance->Cache->ObjectSize + sizeof(struct ers_list)];
}
else
{
if (instance->Cache->Used == instance->Cache->Max)
{
instance->Cache->Max = (instance->Cache->Max * 4) + 3;
RECREATE(instance->Cache->Blocks, unsigned char *, instance->Cache->Max);
}
CREATE(instance->Cache->Blocks[instance->Cache->Used], unsigned char, instance->Cache->ObjectSize * ERS_BLOCK_ENTRIES);
instance->Cache->Used++;
instance->Cache->Free = ERS_BLOCK_ENTRIES -1;
ret = &instance->Cache->Blocks[instance->Cache->Used - 1][instance->Cache->Free * instance->Cache->ObjectSize + sizeof(struct ers_list)];
}
instance->Count++;
return ret;
}
static void ers_obj_free_entry(ERS self, void *entry)
{
ers_instance_t *instance = (ers_instance_t *)self;
struct ers_list *reuse = (struct ers_list *)((unsigned int)entry - sizeof(struct ers_list));
if (instance == NULL)
{
ShowError("ers_obj_free_entry: NULL object, aborting entry freeing.\n");
return;
}
else if (entry == NULL)
{
ShowError("ers_obj_free_entry: NULL entry, nothing to free.\n");
return;
}
reuse->Next = instance->Cache->ReuseList;
instance->Cache->ReuseList = reuse;
instance->Count--;
}
static size_t ers_obj_entry_size(ERS self)
{
ers_instance_t *instance = (ers_instance_t *)self;
if (instance == NULL)
{
ShowError("ers_obj_entry_size: NULL object, aborting entry freeing.\n");
return 0;
}
return instance->Cache->ObjectSize;
}
static void ers_obj_destroy(ERS self)
{
ers_instance_t *instance = (ers_instance_t *)self;
if (instance == NULL)
{
ShowError("ers_obj_destroy: NULL object, aborting entry freeing.\n");
return;
}
if (instance->Count > 0)
if (!(instance->Options & ERS_OPT_CLEAR))
ShowWarning("Memory leak detected at ERS '%s', %d objects not freed.\n", instance->Name, instance->Count);
if (--instance->Cache->ReferenceCount <= 0)
ers_free_cache(instance->Cache, true);
aFree(instance);
}
ERS ers_new(uint32 size, char *name, enum ERSOptions options)
{
ers_instance_t *instance;
CREATE(instance, ers_instance_t, 1);
size += sizeof(struct ers_list);
if (size % ERS_ALIGNED)
size += ERS_ALIGNED - size % ERS_ALIGNED;
instance->VTable.alloc = ers_obj_alloc_entry;
instance->VTable.free = ers_obj_free_entry;
instance->VTable.entry_size = ers_obj_entry_size;
instance->VTable.destroy = ers_obj_destroy;
instance->Name = name;
instance->Options = options;
instance->Cache = ers_find_cache(size);
instance->Cache->ReferenceCount++;
instance->Count = 0;
return &instance->VTable;
}
void ers_report(void)
{
// FIXME: Someone use this? Is it really needed?
}
void ers_force_destroy_all(void)
{
ers_cache_t *cache;
for (cache = CacheList; cache; cache = cache->Next)
ers_free_cache(cache, false);
}
#endif