/*
** Initialize this module.
*/
static int sqlite3MemInit(void *NotUsed){
#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
int cpuCount;
size_t len;
if( _sqliteZone_ ){
return SQLITE_OK;
}
len = sizeof(cpuCount);
/* One usually wants to use hw.acctivecpu for MT decisions, but not here */
sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
if( cpuCount>1 ){
/* defer MT decisions to system malloc */
_sqliteZone_ = malloc_default_zone();
}else{
/* only 1 core, use our own zone to contention over global locks,
** e.g. we have our own dedicated locks */
bool success;
malloc_zone_t* newzone = malloc_create_zone(4096, 0);
malloc_set_zone_name(newzone, "Sqlite_Heap");
do{
success = OSAtomicCompareAndSwapPtrBarrier(NULL, newzone,
(void * volatile *)&_sqliteZone_);
}while(!_sqliteZone_);
if( !success ){
/* somebody registered a zone first */
malloc_destroy_zone(newzone);
}
}
#endif
UNUSED_PARAMETER(NotUsed);
return SQLITE_OK;
}
static void
_dispatch_malloc_init(void)
{
_dispatch_ccache_zone = malloc_create_zone(0, 0);
dispatch_assert(_dispatch_ccache_zone);
malloc_set_zone_name(_dispatch_ccache_zone, "DispatchContinuations");
}
void _OSInitializeMemoryZones(void) {
/* create the default memory zone */
if (default_zone != NULL) {
OSHalt("default_zone already present!");
}
/* 0xfee1dead is the magic that stops the create thing from creating a mspace */
default_zone = (OSMemoryZone*)malloc_create_zone(0, 0xfee1dead);
default_zone->global_zone = TRUE;
default_zone->basic_zone.zone_name = "DefaultMallocZone";
OSLog("_OSInitializeMemoryZones: all set, %d zones inited, default zone @ %p", MAX_ZONES, default_zone);
}
int
init__zone0(int should_set_errno)
{
if (__zone0) return (0);
__zone0 = malloc_create_zone(0, 0);
if (!__zone0) {
if (should_set_errno) {
errno = ENOMEM;
}
return (-1);
}
malloc_set_zone_name(__zone0, "environ");
return (0);
}
/*
** Initialize this module.
*/
static int sqlite3MemInit(void *NotUsed){
#if defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC)
int cpuCount;
size_t len;
if( _sqliteZone_ ){
return SQLITE_OK;
}
len = sizeof(cpuCount);
/* One usually wants to use hw.acctivecpu for MT decisions, but not here */
sysctlbyname("hw.ncpu", &cpuCount, &len, NULL, 0);
if( cpuCount>1 ){
/* defer MT decisions to system malloc */
_sqliteZone_ = malloc_default_zone();
}else{
/* only 1 core, use our own zone to contention over global locks,
** e.g. we have our own dedicated locks */
_sqliteZone_ = malloc_create_zone(4096, 0);
malloc_set_zone_name(_sqliteZone_, "Sqlite_Heap");
}
#endif /* defined(__APPLE__) && !defined(SQLITE_WITHOUT_ZONEMALLOC) */
UNUSED_PARAMETER(NotUsed);
return SQLITE_OK;
}
/* Creates the the worker threads. */
static void
incdep_init (struct floc *f)
{
unsigned i;
#if defined (HAVE_PTHREAD) && !defined (CONFIG_WITHOUT_THREADS)
int rc;
pthread_attr_t attr;
#elif defined (WINDOWS32)
unsigned tid;
uintptr_t hThread;
#elif defined (__OS2__)
int rc;
int tid;
#endif
(void)f;
/* heap hacks */
#ifdef __APPLE__
incdep_zone = malloc_create_zone (0, 0);
if (!incdep_zone)
incdep_zone = malloc_default_zone ();
#endif
/* create the mutex and two condition variables / event objects. */
#if defined (HAVE_PTHREAD) && !defined (CONFIG_WITHOUT_THREADS)
rc = pthread_mutex_init (&incdep_mtx, NULL);
if (rc)
fatal (f, _("pthread_mutex_init failed: err=%d"), rc);
rc = pthread_cond_init (&incdep_cond_todo, NULL);
if (rc)
fatal (f, _("pthread_cond_init failed: err=%d"), rc);
rc = pthread_cond_init (&incdep_cond_done, NULL);
if (rc)
fatal (f, _("pthread_cond_init failed: err=%d"), rc);
#elif defined (WINDOWS32)
InitializeCriticalSection (&incdep_mtx);
incdep_hev_todo = CreateEvent (NULL, TRUE /*bManualReset*/, FALSE /*bInitialState*/, NULL);
if (!incdep_hev_todo)
fatal (f, _("CreateEvent failed: err=%d"), GetLastError());
incdep_hev_done = CreateEvent (NULL, TRUE /*bManualReset*/, FALSE /*bInitialState*/, NULL);
if (!incdep_hev_done)
fatal (f, _("CreateEvent failed: err=%d"), GetLastError());
incdep_hev_todo_waiters = 0;
incdep_hev_done_waiters = 0;
#elif defined (__OS2__)
_fmutex_create (&incdep_mtx, 0);
rc = DosCreateEventSem (NULL, &incdep_hev_todo, 0, FALSE);
if (rc)
fatal (f, _("DosCreateEventSem failed: rc=%d"), rc);
rc = DosCreateEventSem (NULL, &incdep_hev_done, 0, FALSE);
if (rc)
fatal (f, _("DosCreateEventSem failed: rc=%d"), rc);
incdep_hev_todo_waiters = 0;
incdep_hev_done_waiters = 0;
#endif
/* create the worker threads and associated per thread data. */
incdep_terminate = 0;
if (incdep_are_threads_enabled())
{
incdep_num_threads = sizeof (incdep_threads) / sizeof (incdep_threads[0]);
if (incdep_num_threads + 1 > job_slots)
incdep_num_threads = job_slots <= 1 ? 1 : job_slots - 1;
for (i = 0; i < incdep_num_threads; i++)
{
/* init caches */
unsigned rec_size = sizeof (struct incdep_variable_in_set);
if (rec_size < sizeof (struct incdep_variable_def))
rec_size = sizeof (struct incdep_variable_def);
if (rec_size < sizeof (struct incdep_recorded_file))
rec_size = sizeof (struct incdep_recorded_file);
alloccache_init (&incdep_rec_caches[i], rec_size, "incdep rec",
incdep_cache_allocator, (void *)(size_t)i);
alloccache_init (&incdep_dep_caches[i], sizeof(struct dep), "incdep dep",
incdep_cache_allocator, (void *)(size_t)i);
strcache2_init (&incdep_dep_strcaches[i],
"incdep dep", /* name */
65536, /* hash size */
0, /* default segment size*/
#ifdef HAVE_CASE_INSENSITIVE_FS
1, /* case insensitive */
#else
0, /* case insensitive */
#endif
0); /* thread safe */
strcache2_init (&incdep_var_strcaches[i],
"incdep var", /* name */
32768, /* hash size */
0, /* default segment size*/
0, /* case insensitive */
0); /* thread safe */
/* create the thread. */
#if defined (HAVE_PTHREAD) && !defined (CONFIG_WITHOUT_THREADS)
rc = pthread_attr_init (&attr);
if (rc)
fatal (f, _("pthread_attr_init failed: err=%d"), rc);
/*rc = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_JOINABLE); */
rc = pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
if (rc)
fatal (f, _("pthread_attr_setdetachstate failed: err=%d"), rc);
rc = pthread_create(&incdep_threads[i], &attr,
incdep_worker_pthread, (void *)(size_t)i);
if (rc)
fatal (f, _("pthread_mutex_init failed: err=%d"), rc);
pthread_attr_destroy (&attr);
#elif defined (WINDOWS32)
tid = 0;
hThread = _beginthreadex (NULL, 128*1024, incdep_worker_windows,
(void *)i, 0, &tid);
if (hThread == 0 || hThread == ~(uintptr_t)0)
fatal (f, _("_beginthreadex failed: err=%d"), errno);
incdep_threads[i] = (HANDLE)hThread;
#elif defined (__OS2__)
tid = _beginthread (incdep_worker_os2, NULL, 128*1024, (void *)i);
if (tid <= 0)
fatal (f, _("_beginthread failed: err=%d"), errno);
incdep_threads[i] = tid;
#endif
}
}
else
incdep_num_threads = 0;
incdep_initialized = 1;
}
void
unexec_init_emacs_zone (void)
{
emacs_zone = malloc_create_zone (0, 0);
malloc_set_zone_name (emacs_zone, "EmacsZone");
}
FMacMallocZone::FMacMallocZone( uint64 const InitialSize )
: MemoryZone( malloc_create_zone( InitialSize, 0 ) )
{
}
int main() {
test_introspection(auto_zone_create("auto zone"), true);
test_introspection(malloc_default_zone(), false);
test_introspection(malloc_create_zone(8192, 0), false);
return 0;
}
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @MLBA_OPEN_LICENSE_HEADER_END@
*/
#include "internal.h"
malloc_zone_t *_dispatch_ccache_zone;
void
_dispatch_ccache_init(void *context DISPATCH_UNUSED)
{
_dispatch_ccache_zone = malloc_create_zone(0, 0);
dispatch_assert(_dispatch_ccache_zone);
malloc_set_zone_name(_dispatch_ccache_zone, "DispatchContinuations");
}
dispatch_continuation_t
_dispatch_continuation_alloc_from_heap(void)
{
static dispatch_once_t pred;
dispatch_continuation_t dc;
dispatch_once_f(&pred, NULL, _dispatch_ccache_init);
while (!(dc = (dispatch_continuation_t)(dispatch_continuation_t)fastpath(malloc_zone_calloc(_dispatch_ccache_zone, 1, ROUND_UP_TO_CACHELINE_SIZE(sizeof(*dc)))))) {
sleep(1);
}
