ichthyo/LUMIERA.clone
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

REVERT tmpbuf implementation to the state of July.2010 (bc989dab)

Browse source 
The new implementation provides differentiated buffers,
but is still buggy and causes double free alarms on shutdown
See Ticket #683
This commit is contained in:
Fischlurch 2011-05-20 18:51:15 +02:00
parent 2dde33ec42
commit 36cfaaa14d
2 changed files with 21 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

48
src/lib/tmpbuf.c
View file

@ -29,18 +29,17 @@
#include <nobug.h>
/*!! WARNING
*!!
*!! this is the restored old version from bc989dab7a97fc69c (July 2010)
*!! (the improved version is still buggy as of 5/2011)
*/
struct lumiera_tmpbuf_struct
{
/* tiny buffers are not aligned, anything which is smaller than sizeof(void*) */
char tiny_buffers[LUMIERA_TMPBUF_NUM*(sizeof(void*)-1)];
unsigned tiny_idx;
/* first 16 static LUMIERA_TMPBUF_SMALL byte arrays */
char small_buffers[LUMIERA_TMPBUF_NUM][LUMIERA_TMPBUF_SMALL];
unsigned small_idx;
/* next 16 dynamic arrays for biggier buffers */
void* big_buffers[LUMIERA_TMPBUF_NUM];
size_t big_sizes[LUMIERA_TMPBUF_NUM];
unsigned big_idx;
void* buffers[64];
size_t sizes[64];
unsigned idx;
};
static pthread_once_t lumiera_tmpbuf_tls_once = PTHREAD_ONCE_INIT;
@ -74,7 +73,7 @@ lumiera_tmpbuf_freeall (void)
{
pthread_setspecific (lumiera_tmpbuf_tls_key, NULL);
for (int idx = 0; idx < LUMIERA_TMPBUF_NUM; ++idx)
lumiera_free (buf->big_buffers[idx]);
lumiera_free (buf->buffers[idx]);
lumiera_free (buf);
}
}
@ -90,28 +89,15 @@ lumiera_tmpbuf_provide (size_t size)
pthread_setspecific (lumiera_tmpbuf_tls_key,
buf = lumiera_calloc (1, sizeof (struct lumiera_tmpbuf_struct)));
if (size < sizeof(void*))
{
buf->tiny_idx = (buf->tiny_idx + size) & ~(LUMIERA_TMPBUF_NUM*sizeof(void*)-1);
return &buf->tiny_buffers[buf->tiny_idx-size];
}
else if (size <= LUMIERA_TMPBUF_SMALL)
{
buf->small_idx = (buf->small_idx + 1) % LUMIERA_TMPBUF_NUM;
return buf->small_buffers[buf->small_idx];
}
else
{
buf->big_idx = (buf->big_idx + 1) & ~(LUMIERA_TMPBUF_NUM-1);
buf->idx = (buf->idx + 1) & 0x3f;
if (buf->big_sizes[buf->big_idx] < size || buf->big_sizes[buf->big_idx] > 8*size)
{
lumiera_free (buf->big_buffers[buf->big_idx]);
buf->big_sizes[buf->big_idx] = (size + LUMIERA_TMPBUF_SMALL-1) & ~(LUMIERA_TMPBUF_SMALL-1);
buf->big_buffers[buf->big_idx] = lumiera_malloc (buf->big_sizes[buf->big_idx]);
}
return buf->big_buffers[buf->big_idx];
if (buf->sizes[buf->idx] < size || buf->sizes[buf->idx] > 8*size)
{
lumiera_free (buf->buffers[buf->idx]);
buf->sizes[buf->idx] = (size+4*sizeof(long)) & ~(4*sizeof(long)-1);
buf->buffers[buf->idx] = lumiera_malloc (buf->sizes[buf->idx]);
}
return buf->buffers[buf->idx];
}

11
src/lib/tmpbuf.h
View file

@ -29,10 +29,13 @@
* Round robin temporary buffers.
* This provides some buffers per thread which are round-robin recycled with each use.
* The idea is to have fast buffers for temporal data without need for explicit heap management.
*
* @warning this is the restored old version from bc989dab7a97fc69c (July 2010)
* (the improved version is still buggy as of 5/2011)
*/
/* following 2 values must be exponent of 2 */
/* following value must be exponent of 2 */
/**
* Number of buffers in the ring
* This also defines how many concurent buffers can be in use in one thread (including nested calls)
@ -40,12 +43,6 @@
*/
#define LUMIERA_TMPBUF_NUM 16
/**
* Size of a small block
* tmpbuf's knows small and big blocks, anything bigger than LUMIERA_TMPBUF_SMALL will be
* allocated dynamically as 'big' buffer while for anything smaller static buffers are allocated.
*/
#define LUMIERA_TMPBUF_SMALL 256
/**