コード例 #1
0
int palHeapAllocator::Create(palPageAllocator* page_allocator) {
    internal_ = create_mspace(0, page_allocator);
    if (internal_ == NULL) {
        return PAL_HEAP_ALLOCATOR_COULD_NOT_CREATE;
    }
    mspace_track_large_chunks(internal_, 1);
    return 0;
}
コード例 #2
0
ファイル: mem-dlmalloc.c プロジェクト: deniskin82/chapel
void chpl_mem_layerInit(void) {
  chpl_comm_desired_shared_heap(&saved_heap_start, &saved_heap_size);
  if (!saved_heap_start || !saved_heap_size) {
    chpl_dlmalloc_heap = create_mspace(0, 1);
  } else {
    chpl_dlmalloc_heap = create_mspace_with_base(saved_heap_start, saved_heap_size, 1);
  }
}
コード例 #3
0
ファイル: mempool.c プロジェクト: Garfield-Chen/openlibs
void
mempool_init()
{
	if (!mp_mspace__)
	{
		mp_mspace__ = create_mspace(0, 0);
		KeInitializeSpinLock(&mp_spinlock__);
	}
}
コード例 #4
0
ファイル: space.c プロジェクト: ademakov/MainMemory
static mm_mspace_t
mm_mspace_create(void)
{
    mm_mspace_t space;
    space.opaque = create_mspace(0, 0);
    if (space.opaque == NULL)
        mm_fatal(errno, "failed to create mspace");
    return space;
}
コード例 #5
0
ファイル: mem-dlmalloc.c プロジェクト: Improbus/CPEG614
void chpl_mem_layerInit(void) {
  void*  heap_base;
  size_t heap_size;

  chpl_comm_desired_shared_heap(&heap_base, &heap_size);
  if (heap_base == NULL || heap_size == 0)
    chpl_dlmalloc_heap = create_mspace(0, 1);
  else
    chpl_dlmalloc_heap = create_mspace_with_base(heap_base, heap_size, 1);
}
コード例 #6
0
ファイル: fm.c プロジェクト: jlsiug/harbour-core
static mspace hb_mspace( void )
{
   PHB_MSPACE pm = ( PHB_MSPACE ) hb_stackAllocator();

   if( pm )
      return pm->ms;

   if( ! s_gm )
      s_gm = create_mspace( 0, 1 );

   return s_gm;
}
コード例 #7
0
ファイル: alloc.c プロジェクト: celskeggs/libca
void new_default_arena_with_capacity(memory_arena *arena, ulen starting_capacity) {
	mspace space = create_mspace(starting_capacity, 0); // TODO: Should locked be 1 instead? That would help with threadsafety.
	if (space == NULL) {
		panic("OOM while building new dlmalloc mspace");
	}
	mspace_track_large_chunks(space, 1); // make sure that destroying an arena will always free all its memory
	new_custom_arena(arena, space);
	arena->alloc = mspace_malloc;
	arena->alloc_zeroed = dlmalloc_mspace_alloc_zeroed;
	arena->free = mspace_free;
	arena->realloc = mspace_realloc;
	arena->deallocate = dlmalloc_mspace_deallocate;
}
コード例 #8
0
ファイル: MemAllocHeap.cpp プロジェクト: MadFishTheOne/tundra
void HeapInit(MemAllocHeap* heap, size_t capacity, uint32_t flags)
{
#if ENABLED(USE_DLMALLOC)
  heap->m_MemSpace = create_mspace(capacity, 0);
  if (!heap->m_MemSpace)
    Croak("couldn't create memspace for new heap");
#else
  heap->m_MemSpace = nullptr;
#endif

  heap->m_Flags = flags;

  if (flags & HeapFlags::kThreadSafe)
  {
    MutexInit(&heap->m_Lock);
  }
}
コード例 #9
0
/**
 * Initialize segment in a private heap
 */
int
ssvm_master_init_private (ssvm_private_t * ssvm)
{
  ssvm_shared_header_t *sh;
  u32 pagesize = clib_mem_get_page_size ();
  u32 rnd_size = 0;
  u8 *heap;

  rnd_size = clib_max (ssvm->ssvm_size + (pagesize - 1), ssvm->ssvm_size);
  rnd_size &= ~(pagesize - 1);

#if USE_DLMALLOC == 0
  {
    mheap_t *heap_header;

    heap = mheap_alloc (0, rnd_size);
    if (heap == 0)
      {
	clib_unix_warning ("mheap alloc");
	return -1;
      }
    heap_header = mheap_header (heap);
    heap_header->flags |= MHEAP_FLAG_THREAD_SAFE;
  }
#else
  heap = create_mspace (rnd_size, 1 /* locked */ );
#endif

  ssvm->ssvm_size = rnd_size;
  ssvm->i_am_master = 1;
  ssvm->my_pid = getpid ();
  ssvm->requested_va = ~0;

  /* Allocate a [sic] shared memory header, in process memory... */
  sh = clib_mem_alloc_aligned (sizeof (*sh), CLIB_CACHE_LINE_BYTES);
  ssvm->sh = sh;

  clib_memset (sh, 0, sizeof (*sh));
  sh->heap = heap;
  sh->ssvm_va = pointer_to_uword (heap);
  sh->type = SSVM_SEGMENT_PRIVATE;

  return 0;
}
コード例 #10
0
ファイル: fm.c プロジェクト: jlsiug/harbour-core
static PHB_MSPACE hb_mspace_alloc( void )
{
   if( s_mspool[ 0 ].ms == NULL && s_gm )
   {
      s_mspool[ 0 ].count = 1;
      s_mspool[ 0 ].ms = s_gm;
      return &s_mspool[ 0 ];
   }
   else
   {
      int i, imin = 0;
      for( i = 1; i < HB_MSPACE_COUNT; ++i )
      {
         if( s_mspool[ i ].count < s_mspool[ imin ].count )
            imin = i;
      }
      if( s_mspool[ imin ].ms == NULL )
         s_mspool[ imin ].ms = create_mspace( 0, 1 );
      s_mspool[ imin ].count++;
      return &s_mspool[ imin ];
   }
}
コード例 #11
0
/*
	Abstract.
 */
malloc_zone_t *
malloc_create_zone(vm_size_t start_size, unsigned flags) {
	OSMemoryZone* osm = _OSGetFirstAvailableMemoryZone();

	/* mkay, get default impls */
	osm->basic_zone.calloc = (void*)Impl_malloc_zone_calloc;
	osm->basic_zone.free = (void*)Impl_malloc_zone_free;
	osm->basic_zone.malloc = (void*)Impl_malloc_zone_malloc;
	osm->basic_zone.valloc = (void*)Impl_malloc_zone_valloc;
	osm->basic_zone.memalign = (void*)Impl_malloc_zone_memalign;
	osm->basic_zone.realloc = (void*)Impl_malloc_zone_realloc;

	if (flags != 0xfee1dead) {
		/* make a mspace */
		osm->memory_space = create_mspace(start_size, FALSE);
	}

	OSLog("malloc_create_zone: created zone {size=%d, space=%p, addr=%p}",
		  start_size,
		  osm->memory_space,
		  osm);

	return (malloc_zone_t*)osm;
}
コード例 #12
0
ファイル: dwMalloc.cpp プロジェクト: jinhwang15/dwMalloc
 void inline initTheSpaces(){
   for(int i = 0; i < N_MSPACES; i++)
     mspaces[i] = create_mspace(0, 1);
 }
コード例 #13
0
OOBase::ArenaAllocator::ArenaAllocator(bool locked) : m_mspace(NULL)
{
	m_mspace = create_mspace(0,locked ? 1 : 0);
	if (!m_mspace)
		OOBase_CallCriticalFailure("Failed to create dl_malloc mspace");
}
コード例 #14
0
void DCU_initialize()
{
	if (DCU_STATE(DCU_INITIALIZED))
	{
		return;
	}

	if (DCU_STATE(DCU_MUTEX_INITED))
	{
		DCU_MutexScopedLock lock(DCU_mutex);
		if (DCU_STATE(DCU_INITIALIZED))
		{
			return;
		}
		else
		{
			fprintf(DCU_FALLBACK_STREAM, "DynamicCheckUp Concurrency error.\n");
			_exit(1);
		}
	}

	if (pthread_mutex_init(&DCU_mutex, 0) < 0)
	{
		fprintf(DCU_FALLBACK_STREAM, "DynamicCheckUp unable to initialize mutex\n");
		_exit(1);
	}
	else
	{
		DCU_SET_FLAG(DCU_MUTEX_INITED);
	}


	{
		DCU_MutexScopedLock lock(DCU_mutex);

		memory_space = create_mspace(0, 0);
		DCU_SET_FLAG(DCU_INITIALIZED);

		//
		// init backtrace so it wont recursively call malloc
		//
		DCU_Pointer stack[DCU_STACK_TRACE_SIZE];
		backtrace(stack, DCU_STACK_TRACE_SIZE);

		//
		// Init Tracing data
		//

		DCU_stream = DCU_FALLBACK_STREAM;
		memset(DCU_memory_stats, 0, sizeof(DCU_MemoryStats) * DCU_DYNAMIC_OPERATION_TYPES);
		memset(&DCU_memory_stats_new, 0, sizeof(DCU_MemoryStats));
		memset(&DCU_memory_stats_new_array, 0, sizeof(DCU_MemoryStats));
		memset(&DCU_memory_stats_c, 0, sizeof(DCU_MemoryStats));
		memset(DCU_null_stack, 0, sizeof(DCU_null_stack));

		//
		// Operations HashTable
		//
		DCU_memory = (DCU_OperationInfo**) DCU_malloc( DCU_HASH_TABLE_SIZE * sizeof(DCU_OperationInfo*) );
		memset(DCU_memory, 0, DCU_HASH_TABLE_SIZE * sizeof(DCU_OperationInfo*));

		//
		// Problems Linked-List
		//
		DCU_problems = 0;

		//
		// Open Log File
		//
		DCU_stream = fopen(DCU_OUTPUT_FILE, "w");
		if (DCU_stream < 0)
		{
			fprintf(DCU_FALLBACK_STREAM, "DynamicCheckUp: Unable to open %s: %m\n", DCU_OUTPUT_FILE);
			DCU_stream = DCU_FALLBACK_STREAM;
		}
		else
		{
			int flags = fcntl(fileno(DCU_stream), F_GETFD, 0);
			if (flags >= 0)
			{
				flags |= FD_CLOEXEC;
				fcntl(fileno(DCU_stream), F_SETFD, flags);
			}

			setvbuf(DCU_stream, stream_trace_buffer, _IOFBF, DCU_STREAM_BUFFER_SIZE);
		}

		DCU_SET_FLAG(DCU_TRACING);
	}

	DCU_write("DynamicCheckUp Started\n");
}