mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-11-03 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

increase default mempool size, make mempool_slot an abstract struct because the only fields it defined where actually unused

Browse source 
git-svn-id: file:///home/lennart/svn/public/pulseaudio/branches/glitch-free@2431 fefdeb5f-60dc-0310-8127-8f9354f1896f
This commit is contained in:
Lennart Poettering 2008-05-15 20:39:46 +00:00
parent 70c5967806
commit f96a8adb0c
2 changed files with 23 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/pulsecore/memblock.c
View file

@ -46,8 +46,12 @@
#include "memblock.h" #include "memblock.h"
#define PA_MEMPOOL_SLOTS_MAX 512 /* We can allocate 64*1024*1024 bytes at maximum. That's 64MB. Please
#define PA_MEMPOOL_SLOT_SIZE (32*1024) * note that the footprint is usually much smaller, since the data is
* stored in SHM and our OS does not commit the memory before we use
* it for the first time. */
#define PA_MEMPOOL_SLOTS_MAX 1024
#define PA_MEMPOOL_SLOT_SIZE (64*1024)
#define PA_MEMEXPORT_SLOTS_MAX 128 #define PA_MEMEXPORT_SLOTS_MAX 128
@ -127,11 +131,6 @@ struct pa_memexport {
PA_LLIST_FIELDS(pa_memexport); PA_LLIST_FIELDS(pa_memexport);
}; };
struct mempool_slot {
PA_LLIST_FIELDS(struct mempool_slot);
/* the actual data follows immediately hereafter */
};
struct pa_mempool { struct pa_mempool {
pa_semaphore *semaphore; pa_semaphore *semaphore;
pa_mutex *mutex; pa_mutex *mutex;
@ -204,9 +203,7 @@ pa_memblock *pa_memblock_new(pa_mempool *p, size_t length) {
pa_memblock *b; pa_memblock *b;
pa_assert(p); pa_assert(p);
pa_assert(length);
if (length <= 0)
length = pa_mempool_block_size_max(p);
if (!(b = pa_memblock_new_pool(p, length))) if (!(b = pa_memblock_new_pool(p, length)))
b = memblock_new_appended(p, length); b = memblock_new_appended(p, length);
@ -219,12 +216,12 @@ static pa_memblock *memblock_new_appended(pa_mempool *p, size_t length) {
pa_memblock *b; pa_memblock *b;
pa_assert(p); pa_assert(p);
pa_assert(length > 0); pa_assert(length);
/* If -1 is passed as length we choose the size for the caller. */ /* If -1 is passed as length we choose the size for the caller. */
if (length == (size_t) -1) if (length == (size_t) -1)
length = p->block_size - PA_ALIGN(sizeof(struct mempool_slot)) - PA_ALIGN(sizeof(pa_memblock)); length = p->block_size - PA_ALIGN(sizeof(pa_memblock));
b = pa_xmalloc(PA_ALIGN(sizeof(pa_memblock)) + length); b = pa_xmalloc(PA_ALIGN(sizeof(pa_memblock)) + length);
PA_REFCNT_INIT(b); PA_REFCNT_INIT(b);
@ -265,11 +262,9 @@ static struct mempool_slot* mempool_allocate_slot(pa_mempool *p) {
return slot; return slot;
} }
/* No lock necessary */ /* No lock necessary, totally redundant anyway */
static void* mempool_slot_data(struct mempool_slot *slot) { static inline void* mempool_slot_data(struct mempool_slot *slot) {
pa_assert(slot); return slot;
return (uint8_t*) slot + PA_ALIGN(sizeof(struct mempool_slot));
} }
/* No lock necessary */ /* No lock necessary */
@ -298,7 +293,7 @@ pa_memblock *pa_memblock_new_pool(pa_mempool *p, size_t length) {
struct mempool_slot *slot; struct mempool_slot *slot;
pa_assert(p); pa_assert(p);
pa_assert(length > 0); pa_assert(length);
/* If -1 is passed as length we choose the size for the caller: we /* If -1 is passed as length we choose the size for the caller: we
* take the largest size that fits in one of our slots. */ * take the largest size that fits in one of our slots. */
@ -306,7 +301,7 @@ pa_memblock *pa_memblock_new_pool(pa_mempool *p, size_t length) {
if (length == (size_t) -1) if (length == (size_t) -1)
length = pa_mempool_block_size_max(p); length = pa_mempool_block_size_max(p);
if (p->block_size - PA_ALIGN(sizeof(struct mempool_slot)) >= PA_ALIGN(sizeof(pa_memblock)) + length) { if (p->block_size >= PA_ALIGN(sizeof(pa_memblock)) + length) {
if (!(slot = mempool_allocate_slot(p))) if (!(slot = mempool_allocate_slot(p)))
return NULL; return NULL;
@ -315,7 +310,7 @@ pa_memblock *pa_memblock_new_pool(pa_mempool *p, size_t length) {
b->type = PA_MEMBLOCK_POOL; b->type = PA_MEMBLOCK_POOL;
pa_atomic_ptr_store(&b->data, (uint8_t*) b + PA_ALIGN(sizeof(pa_memblock))); pa_atomic_ptr_store(&b->data, (uint8_t*) b + PA_ALIGN(sizeof(pa_memblock)));
} else if (p->block_size - PA_ALIGN(sizeof(struct mempool_slot)) >= length) { } else if (p->block_size >= length) {
if (!(slot = mempool_allocate_slot(p))) if (!(slot = mempool_allocate_slot(p)))
return NULL; return NULL;
@ -327,7 +322,7 @@ pa_memblock *pa_memblock_new_pool(pa_mempool *p, size_t length) {
pa_atomic_ptr_store(&b->data, mempool_slot_data(slot)); pa_atomic_ptr_store(&b->data, mempool_slot_data(slot));
} else { } else {
pa_log_debug("Memory block too large for pool: %lu > %lu", (unsigned long) length, (unsigned long) (p->block_size - PA_ALIGN(sizeof(struct mempool_slot)))); pa_log_debug("Memory block too large for pool: %lu > %lu", (unsigned long) length, (unsigned long) p->block_size);
pa_atomic_inc(&p->stat.n_too_large_for_pool); pa_atomic_inc(&p->stat.n_too_large_for_pool);
return NULL; return NULL;
} }
@ -350,7 +345,7 @@ pa_memblock *pa_memblock_new_fixed(pa_mempool *p, void *d, size_t length, pa_boo
pa_assert(p); pa_assert(p);
pa_assert(d); pa_assert(d);
pa_assert(length != (size_t) -1); pa_assert(length != (size_t) -1);
pa_assert(length > 0); pa_assert(length);
if (!(b = pa_flist_pop(PA_STATIC_FLIST_GET(unused_memblocks)))) if (!(b = pa_flist_pop(PA_STATIC_FLIST_GET(unused_memblocks))))
b = pa_xnew(pa_memblock, 1); b = pa_xnew(pa_memblock, 1);
@ -374,7 +369,7 @@ pa_memblock *pa_memblock_new_user(pa_mempool *p, void *d, size_t length, pa_free
pa_assert(p); pa_assert(p);
pa_assert(d); pa_assert(d);
pa_assert(length > 0); pa_assert(length);
pa_assert(length != (size_t) -1); pa_assert(length != (size_t) -1);
pa_assert(free_cb); pa_assert(free_cb);
@ -423,7 +418,6 @@ void pa_memblock_set_is_silence(pa_memblock *b, pa_bool_t v) {
/* No lock necessary */ /* No lock necessary */
pa_bool_t pa_memblock_ref_is_one(pa_memblock *b) { pa_bool_t pa_memblock_ref_is_one(pa_memblock *b) {
int r; int r;
pa_assert(b); pa_assert(b);
pa_assert_se((r = PA_REFCNT_VALUE(b)) > 0); pa_assert_se((r = PA_REFCNT_VALUE(b)) > 0);
@ -588,7 +582,7 @@ static void memblock_make_local(pa_memblock *b) {
pa_atomic_dec(&b->pool->stat.n_allocated_by_type[b->type]); pa_atomic_dec(&b->pool->stat.n_allocated_by_type[b->type]);
if (b->length <= b->pool->block_size - PA_ALIGN(sizeof(struct mempool_slot))) { if (b->length <= b->pool->block_size) {
struct mempool_slot *slot; struct mempool_slot *slot;
if ((slot = mempool_allocate_slot(b->pool))) { if ((slot = mempool_allocate_slot(b->pool))) {
@ -676,7 +670,7 @@ static void memblock_replace_import(pa_memblock *b) {
pa_mutex_unlock(seg->import->mutex); pa_mutex_unlock(seg->import->mutex);
} }
pa_mempool* pa_mempool_new(int shared) { pa_mempool* pa_mempool_new(pa_bool_t shared) {
pa_mempool *p; pa_mempool *p;
p = pa_xnew(pa_mempool, 1); p = pa_xnew(pa_mempool, 1);
@ -690,8 +684,6 @@ pa_mempool* pa_mempool_new(int shared) {
p->n_blocks = PA_MEMPOOL_SLOTS_MAX; p->n_blocks = PA_MEMPOOL_SLOTS_MAX;
pa_assert(p->block_size > PA_ALIGN(sizeof(struct mempool_slot)));
if (pa_shm_create_rw(&p->memory, p->n_blocks * p->block_size, shared, 0700) < 0) { if (pa_shm_create_rw(&p->memory, p->n_blocks * p->block_size, shared, 0700) < 0) {
pa_xfree(p); pa_xfree(p);
return NULL; return NULL;
@ -747,7 +739,7 @@ const pa_mempool_stat* pa_mempool_get_stat(pa_mempool *p) {
size_t pa_mempool_block_size_max(pa_mempool *p) { size_t pa_mempool_block_size_max(pa_mempool *p) {
pa_assert(p); pa_assert(p);
return p->block_size - PA_ALIGN(sizeof(struct mempool_slot)) - PA_ALIGN(sizeof(pa_memblock)); return p->block_size - PA_ALIGN(sizeof(pa_memblock));
} }
/* No lock necessary */ /* No lock necessary */
@ -764,9 +756,7 @@ void pa_mempool_vacuum(pa_mempool *p) {
; ;
while ((slot = pa_flist_pop(list))) { while ((slot = pa_flist_pop(list))) {
pa_shm_punch(&p->memory, pa_shm_punch(&p->memory, (uint8_t*) slot - (uint8_t*) p->memory.ptr, p->block_size);
(uint8_t*) slot - (uint8_t*) p->memory.ptr + PA_ALIGN(sizeof(struct mempool_slot)),
p->block_size - PA_ALIGN(sizeof(struct mempool_slot)));
while (pa_flist_push(p->free_slots, slot)) while (pa_flist_push(p->free_slots, slot))
; ;

2
src/pulsecore/memblock.h
View file

@ -119,7 +119,7 @@ pa_mempool * pa_memblock_get_pool(pa_memblock *b);
pa_memblock *pa_memblock_will_need(pa_memblock *b); pa_memblock *pa_memblock_will_need(pa_memblock *b);
/* The memory block manager */ /* The memory block manager */
pa_mempool* pa_mempool_new(int shared); pa_mempool* pa_mempool_new(pa_bool_t shared);
void pa_mempool_free(pa_mempool *p); void pa_mempool_free(pa_mempool *p);
const pa_mempool_stat* pa_mempool_get_stat(pa_mempool *p); const pa_mempool_stat* pa_mempool_get_stat(pa_mempool *p);
void pa_mempool_vacuum(pa_mempool *p); void pa_mempool_vacuum(pa_mempool *p);