inline FastSharedMemoryPool(SharedMemory* pool, bool delegate =
true) :
m_mem_block(NULL), m_raw_pool(pool), m_managed_self(
delegate)
{
m_mem_block = shm_malloc_init(pool->GetRawAddress(),
pool->GetMemorySize());
}
int main() {
shm_malloc_init();
run_test();
print_memory();
shm_malloc_clean();
return 0;
}
int shm_getmem(void)
{
#ifdef SHM_MMAP
int fd;
#else
struct shmid_ds shm_info;
#endif
#ifdef SHM_MMAP
if (shm_mempool && (shm_mempool!=(void*)-1)){
#else
if ((shm_shmid!=-1)||(shm_mempool!=(void*)-1)){
#endif
LM_CRIT("shm already initialized\n");
return -1;
}
#ifdef SHM_MMAP
#ifdef USE_ANON_MMAP
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1 ,0);
#else
fd=open("/dev/zero", O_RDWR);
if (fd==-1){
LM_CRIT("could not open /dev/zero: %s\n", strerror(errno));
return -1;
}
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd ,0);
/* close /dev/zero */
close(fd);
#endif /* USE_ANON_MMAP */
#else
shm_shmid=shmget(IPC_PRIVATE, /* SHM_MEM_SIZE */ shm_mem_size , 0700);
if (shm_shmid==-1){
LM_CRIT("could not allocate shared memory segment: %s\n",
strerror(errno));
return -1;
}
shm_mempool=shmat(shm_shmid, 0, 0);
#endif
if (shm_mempool==(void*)-1){
LM_CRIT("could not attach shared memory segment: %s\n",
strerror(errno));
/* destroy segment*/
shm_mem_destroy();
return -1;
}
return 0;
}
int shm_mem_init_mallocs(void* mempool, unsigned long pool_size)
{
/* init it for malloc*/
shm_block=shm_malloc_init(mempool, pool_size);
if (shm_block==0){
LM_CRIT("could not initialize shared malloc\n");
shm_mem_destroy();
return -1;
}
mem_lock=shm_malloc_unsafe(sizeof(gen_lock_t)); /* skip lock_alloc,
race cond*/
if (mem_lock==0){
LM_CRIT("could not allocate lock\n");
shm_mem_destroy();
return -1;
}
if (lock_init(mem_lock)==0){
LM_CRIT("could not initialize lock\n");
shm_mem_destroy();
return -1;
}
#ifdef STATISTICS
if (event_shm_threshold) {
event_shm_last=shm_malloc_unsafe(sizeof(long));
if (event_shm_last==0){
LM_CRIT("could not allocate shm last event indicator\n");
shm_mem_destroy();
return -1;
}
*event_shm_last=0;
event_shm_pending=shm_malloc_unsafe(sizeof(int));
if (event_shm_pending==0){
LM_CRIT("could not allocate shm peinding flags\n");
shm_mem_destroy();
return -1;
}
*event_shm_pending=0;
}
#endif /* STATISTICS */
LM_DBG("success\n");
return 0;
}
int shm_getmem(void)
{
#ifdef SHM_MMAP
int fd;
#else
struct shmid_ds shm_info;
#endif
#ifdef SHM_MMAP
if (shm_mempool && (shm_mempool!=(void*)-1)){
#else
if ((shm_shmid!=-1)||(shm_mempool!=(void*)-1)){
#endif
LM_CRIT("shm already initialized\n");
return -1;
}
#ifdef SHM_MMAP
#ifdef USE_ANON_MMAP
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1 ,0);
#else
fd=open("/dev/zero", O_RDWR);
if (fd==-1){
LM_CRIT("could not open /dev/zero: %s\n", strerror(errno));
return -1;
}
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd ,0);
/* close /dev/zero */
close(fd);
#endif /* USE_ANON_MMAP */
#else
shm_shmid=shmget(IPC_PRIVATE, /* SHM_MEM_SIZE */ shm_mem_size , 0700);
if (shm_shmid==-1){
LM_CRIT("could not allocate shared memory segment: %s\n",
strerror(errno));
return -1;
}
shm_mempool=shmat(shm_shmid, 0, 0);
#endif
if (shm_mempool==(void*)-1){
LM_CRIT("could not attach shared memory segment: %s\n",
strerror(errno));
/* destroy segment*/
shm_mem_destroy();
return -1;
}
return 0;
}
int shm_mem_init_mallocs(void* mempool, unsigned long pool_size)
{
#ifdef HP_MALLOC
int i;
#endif
/* init it for malloc*/
shm_block = shm_malloc_init(mempool, pool_size, "shm");
if (!shm_block){
LM_CRIT("could not initialize shared malloc\n");
shm_mem_destroy();
return -1;
}
#ifdef SHM_EXTRA_STATS
int size_prealoc, j, one_full_entry, groups;
char *start;
if(mem_free_idx != 1){
#ifndef SHM_SHOW_DEFAULT_GROUP
groups = mem_free_idx - 1;
#else
groups = mem_free_idx;
#endif
one_full_entry = 3 * (sizeof(stat_var) + sizeof(stat_val));
size_prealoc = groups * sizeof(struct module_info) + groups * one_full_entry;
#ifndef DBG_MALLOC
memory_mods_stats = MY_MALLOC_UNSAFE(shm_block, size_prealoc);
#else
memory_mods_stats = MY_MALLOC_UNSAFE(shm_block, size_prealoc, __FILE__, __FUNCTION__, __LINE__ );
#endif
if(!memory_mods_stats){
LM_CRIT("could not alloc shared memory");
return -1;
}
memset( (void*)memory_mods_stats, 0, size_prealoc);
start = (char*)memory_mods_stats + groups * sizeof(struct module_info);
for(j = 0; j < groups; j++){
memory_mods_stats[j].fragments = (stat_var *)(start + j * one_full_entry);
memory_mods_stats[j].memory_used = (stat_var *)(start + j * one_full_entry + sizeof(stat_var));
memory_mods_stats[j].real_used = (stat_var *)(start + j * one_full_entry + 2 * sizeof(stat_var));
memory_mods_stats[j].fragments->u.val = (stat_val*)(start + j * one_full_entry + 3 * sizeof(stat_var));
memory_mods_stats[j].memory_used->u.val = (stat_val*)(start + j * one_full_entry + 3 * sizeof(stat_var) + sizeof(stat_val));
memory_mods_stats[j].real_used->u.val = (stat_val*)(start + j * one_full_entry + 3 * sizeof(stat_var) + 2 * sizeof(stat_val));
}
#ifndef SHM_SHOW_DEFAULT_GROUP
if(core_index != 0){
update_stat(memory_mods_stats[core_index - 1].fragments, 1);
update_stat(memory_mods_stats[core_index - 1].memory_used, size_prealoc);
update_stat(memory_mods_stats[core_index - 1].real_used, size_prealoc + FRAG_OVERHEAD);
}
#else
update_stat(memory_mods_stats[core_index].fragments, 1);
update_stat(memory_mods_stats[core_index].memory_used, size_prealoc);
update_stat(memory_mods_stats[core_index].real_used, size_prealoc + FRAG_OVERHEAD);
#endif
}
#endif
#ifdef HP_MALLOC
/* lock_alloc cannot be used yet! */
mem_lock = shm_malloc_unsafe(HP_TOTAL_HASH_SIZE * sizeof *mem_lock);
if (!mem_lock) {
LM_CRIT("could not allocate the shm lock array\n");
shm_mem_destroy();
return -1;
}
for (i = 0; i < HP_TOTAL_HASH_SIZE; i++)
if (!lock_init(&mem_lock[i])) {
LM_CRIT("could not initialize lock\n");
shm_mem_destroy();
return -1;
}
mem_hash_usage = shm_malloc_unsafe(HP_TOTAL_HASH_SIZE * sizeof *mem_hash_usage);
if (!mem_hash_usage) {
LM_ERR("failed to allocate statistics array\n");
return -1;
}
memset(mem_hash_usage, 0, HP_TOTAL_HASH_SIZE * sizeof *mem_hash_usage);
#else
mem_lock = shm_malloc_unsafe(sizeof *mem_lock);
if (!mem_lock) {
LM_CRIT("could not allocate the shm lock\n");
shm_mem_destroy();
return -1;
}
if (!lock_init(mem_lock)) {
LM_CRIT("could not initialize lock\n");
shm_mem_destroy();
return -1;
}
#endif
#ifdef STATISTICS
if (event_shm_threshold) {
event_shm_last=shm_malloc_unsafe(sizeof(long));
if (event_shm_last==0){
LM_CRIT("could not allocate shm last event indicator\n");
shm_mem_destroy();
return -1;
}
*event_shm_last=0;
event_shm_pending=shm_malloc_unsafe(sizeof(int));
if (event_shm_pending==0){
LM_CRIT("could not allocate shm pending flags\n");
shm_mem_destroy();
return -1;
}
*event_shm_pending=0;
}
#endif /* STATISTICS */
LM_DBG("success\n");
return 0;
}
int shm_getmem()
{
#ifdef SHM_MMAP
#ifndef USE_ANON_MMAP
int fd;
#endif
#else
struct shmid_ds shm_info;
#endif
#ifdef SHM_MMAP
if (shm_mempool && (shm_mempool!=(void*)-1)){
#else
if ((shm_shmid!=-1)||(shm_mempool!=(void*)-1)){
#endif
LOG(L_CRIT, "BUG: shm_mem_init: shm already initialized\n");
return -1;
}
#ifdef SHM_MMAP
#ifdef USE_ANON_MMAP
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE,
MAP_ANON|MAP_SHARED, -1 ,0);
#else
fd=open("/dev/zero", O_RDWR);
if (fd==-1){
LOG(L_CRIT, "ERROR: shm_mem_init: could not open /dev/zero: %s\n",
strerror(errno));
return -1;
}
shm_mempool=mmap(0, shm_mem_size, PROT_READ|PROT_WRITE, MAP_SHARED, fd ,0);
/* close /dev/zero */
close(fd);
#endif /* USE_ANON_MMAP */
#else
shm_shmid=shmget(IPC_PRIVATE, /* SHM_MEM_SIZE */ shm_mem_size , 0700);
if (shm_shmid==-1){
LOG(L_CRIT, "ERROR: shm_mem_init: could not allocate shared memory"
" segment: %s\n", strerror(errno));
return -1;
}
shm_mempool=shmat(shm_shmid, 0, 0);
#endif
if (shm_mempool==(void*)-1){
LOG(L_CRIT, "ERROR: shm_mem_init: could not attach shared memory"
" segment: %s\n", strerror(errno));
/* destroy segment*/
shm_mem_destroy();
return -1;
}
return 0;
}
int shm_mem_init_mallocs(void* mempool, unsigned long pool_size)
{
/* init it for malloc*/
shm_block=shm_malloc_init(mempool, pool_size);
if (shm_block==0){
LOG(L_CRIT, "ERROR: shm_mem_init: could not initialize shared"
" malloc\n");
shm_mem_destroy();
return -1;
}
mem_lock=shm_malloc_unsafe(sizeof(gen_lock_t)); /* skip lock_alloc,
race cond*/
if (mem_lock==0){
LOG(L_CRIT, "ERROR: shm_mem_init: could not allocate lock\n");
shm_mem_destroy();
return -1;
}
if (lock_init(mem_lock)==0){
LOG(L_CRIT, "ERROR: shm_mem_init: could not initialize lock\n");
shm_mem_destroy();
return -1;
}
DBG("shm_mem_init: success\n");
return 0;
}