99#include <stdio.h>
1010#include <stdlib.h>
1111#include <string.h>
12- #include <sys/mman.h>
13-
14- #include <jemalloc/jemalloc.h>
1512
1613#include "base_alloc_global.h"
1714#include "utils_common.h"
2219#include <umf/memory_pool_ops.h>
2320#include <umf/pools/pool_jemalloc.h>
2421
22+ #include <jemalloc/jemalloc.h>
23+
24+ // The Windows version of jemalloc uses API with je_ prefix,
25+ // while the Linux one does not.
26+ #ifndef _WIN32
27+ #define je_mallocx mallocx
28+ #define je_dallocx dallocx
29+ #define je_rallocx rallocx
30+ #define je_mallctl mallctl
31+ #define je_malloc_usable_size malloc_usable_size
32+ #endif
33+
2534#define MALLOCX_ARENA_MAX (MALLCTL_ARENAS_ALL - 1)
2635
2736typedef struct jemalloc_memory_pool_t {
@@ -279,13 +288,13 @@ static extent_hooks_t arena_extent_hooks = {
279288 .merge = arena_extent_merge ,
280289};
281290
282- static void * je_malloc (void * pool , size_t size ) {
291+ static void * op_malloc (void * pool , size_t size ) {
283292 assert (pool );
284293 jemalloc_memory_pool_t * je_pool = (jemalloc_memory_pool_t * )pool ;
285294 // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
286295 // the tcache, so we wouldn't be able to guarantee isolation of different providers.
287296 int flags = MALLOCX_ARENA (je_pool -> arena_index ) | MALLOCX_TCACHE_NONE ;
288- void * ptr = mallocx (size , flags );
297+ void * ptr = je_mallocx (size , flags );
289298 if (ptr == NULL ) {
290299 TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY ;
291300 return NULL ;
@@ -296,24 +305,24 @@ static void *je_malloc(void *pool, size_t size) {
296305 return ptr ;
297306}
298307
299- static umf_result_t je_free (void * pool , void * ptr ) {
308+ static umf_result_t op_free (void * pool , void * ptr ) {
300309 (void )pool ; // unused
301310 assert (pool );
302311
303312 if (ptr != NULL ) {
304313 VALGRIND_DO_MEMPOOL_FREE (pool , ptr );
305- dallocx (ptr , MALLOCX_TCACHE_NONE );
314+ je_dallocx (ptr , MALLOCX_TCACHE_NONE );
306315 }
307316
308317 return UMF_RESULT_SUCCESS ;
309318}
310319
311- static void * je_calloc (void * pool , size_t num , size_t size ) {
320+ static void * op_calloc (void * pool , size_t num , size_t size ) {
312321 assert (pool );
313322 size_t csize = num * size ;
314- void * ptr = je_malloc (pool , csize );
323+ void * ptr = op_malloc (pool , csize );
315324 if (ptr == NULL ) {
316- // TLS_last_allocation_error is set by je_malloc ()
325+ // TLS_last_allocation_error is set by op_malloc ()
317326 return NULL ;
318327 }
319328
@@ -323,22 +332,22 @@ static void *je_calloc(void *pool, size_t num, size_t size) {
323332 return ptr ;
324333}
325334
326- static void * je_realloc (void * pool , void * ptr , size_t size ) {
335+ static void * op_realloc (void * pool , void * ptr , size_t size ) {
327336 assert (pool );
328337 if (size == 0 && ptr != NULL ) {
329- dallocx (ptr , MALLOCX_TCACHE_NONE );
338+ je_dallocx (ptr , MALLOCX_TCACHE_NONE );
330339 TLS_last_allocation_error = UMF_RESULT_SUCCESS ;
331340 VALGRIND_DO_MEMPOOL_FREE (pool , ptr );
332341 return NULL ;
333342 } else if (ptr == NULL ) {
334- return je_malloc (pool , size );
343+ return op_malloc (pool , size );
335344 }
336345
337346 jemalloc_memory_pool_t * je_pool = (jemalloc_memory_pool_t * )pool ;
338347 // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
339348 // the tcache, so we wouldn't be able to guarantee isolation of different providers.
340349 int flags = MALLOCX_ARENA (je_pool -> arena_index ) | MALLOCX_TCACHE_NONE ;
341- void * new_ptr = rallocx (ptr , size , flags );
350+ void * new_ptr = je_rallocx (ptr , size , flags );
342351 if (new_ptr == NULL ) {
343352 TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY ;
344353 return NULL ;
@@ -355,15 +364,15 @@ static void *je_realloc(void *pool, void *ptr, size_t size) {
355364 return new_ptr ;
356365}
357366
358- static void * je_aligned_alloc (void * pool , size_t size , size_t alignment ) {
367+ static void * op_aligned_alloc (void * pool , size_t size , size_t alignment ) {
359368 assert (pool );
360369 jemalloc_memory_pool_t * je_pool = (jemalloc_memory_pool_t * )pool ;
361370 unsigned arena = je_pool -> arena_index ;
362371 // MALLOCX_TCACHE_NONE is set, because jemalloc can mix objects from different arenas inside
363372 // the tcache, so we wouldn't be able to guarantee isolation of different providers.
364373 int flags =
365374 MALLOCX_ALIGN (alignment ) | MALLOCX_ARENA (arena ) | MALLOCX_TCACHE_NONE ;
366- void * ptr = mallocx (size , flags );
375+ void * ptr = je_mallocx (size , flags );
367376 if (ptr == NULL ) {
368377 TLS_last_allocation_error = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY ;
369378 return NULL ;
@@ -374,7 +383,7 @@ static void *je_aligned_alloc(void *pool, size_t size, size_t alignment) {
374383 return ptr ;
375384}
376385
377- static umf_result_t je_initialize (umf_memory_provider_handle_t provider ,
386+ static umf_result_t op_initialize (umf_memory_provider_handle_t provider ,
378387 void * params , void * * out_pool ) {
379388 assert (provider );
380389 assert (out_pool );
@@ -393,8 +402,8 @@ static umf_result_t je_initialize(umf_memory_provider_handle_t provider,
393402 pool -> provider = provider ;
394403
395404 unsigned arena_index ;
396- err =
397- mallctl ( "arenas.create" , ( void * ) & arena_index , & unsigned_size , NULL , 0 );
405+ err = je_mallctl ( "arenas.create" , ( void * ) & arena_index , & unsigned_size ,
406+ NULL , 0 );
398407 if (err ) {
399408 fprintf (stderr , "Could not create arena.\n" );
400409 goto err_free_pool ;
@@ -403,10 +412,10 @@ static umf_result_t je_initialize(umf_memory_provider_handle_t provider,
403412 // setup extent_hooks for newly created arena
404413 char cmd [64 ];
405414 snprintf (cmd , sizeof (cmd ), "arena.%u.extent_hooks" , arena_index );
406- err = mallctl (cmd , NULL , NULL , (void * )& pHooks , sizeof (void * ));
415+ err = je_mallctl (cmd , NULL , NULL , (void * )& pHooks , sizeof (void * ));
407416 if (err ) {
408417 snprintf (cmd , sizeof (cmd ), "arena.%u.destroy" , arena_index );
409- mallctl (cmd , NULL , 0 , NULL , 0 );
418+ je_mallctl (cmd , NULL , 0 , NULL , 0 );
410419 fprintf (stderr ,
411420 "Could not setup extent_hooks for newly created arena.\n" );
412421 goto err_free_pool ;
@@ -426,39 +435,39 @@ static umf_result_t je_initialize(umf_memory_provider_handle_t provider,
426435 return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC ;
427436}
428437
429- static void je_finalize (void * pool ) {
438+ static void op_finalize (void * pool ) {
430439 assert (pool );
431440 jemalloc_memory_pool_t * je_pool = (jemalloc_memory_pool_t * )pool ;
432441 char cmd [64 ];
433442 snprintf (cmd , sizeof (cmd ), "arena.%u.destroy" , je_pool -> arena_index );
434- mallctl (cmd , NULL , 0 , NULL , 0 );
443+ je_mallctl (cmd , NULL , 0 , NULL , 0 );
435444 pool_by_arena_index [je_pool -> arena_index ] = NULL ;
436445 umf_ba_global_free (je_pool );
437446
438447 VALGRIND_DO_DESTROY_MEMPOOL (pool );
439448}
440449
441- static size_t je_malloc_usable_size (void * pool , void * ptr ) {
450+ static size_t op_malloc_usable_size (void * pool , void * ptr ) {
442451 (void )pool ; // not used
443- return malloc_usable_size (ptr );
452+ return je_malloc_usable_size (ptr );
444453}
445454
446- static umf_result_t je_get_last_allocation_error (void * pool ) {
455+ static umf_result_t op_get_last_allocation_error (void * pool ) {
447456 (void )pool ; // not used
448457 return TLS_last_allocation_error ;
449458}
450459
451460static umf_memory_pool_ops_t UMF_JEMALLOC_POOL_OPS = {
452461 .version = UMF_VERSION_CURRENT ,
453- .initialize = je_initialize ,
454- .finalize = je_finalize ,
455- .malloc = je_malloc ,
456- .calloc = je_calloc ,
457- .realloc = je_realloc ,
458- .aligned_malloc = je_aligned_alloc ,
459- .malloc_usable_size = je_malloc_usable_size ,
460- .free = je_free ,
461- .get_last_allocation_error = je_get_last_allocation_error ,
462+ .initialize = op_initialize ,
463+ .finalize = op_finalize ,
464+ .malloc = op_malloc ,
465+ .calloc = op_calloc ,
466+ .realloc = op_realloc ,
467+ .aligned_malloc = op_aligned_alloc ,
468+ .malloc_usable_size = op_malloc_usable_size ,
469+ .free = op_free ,
470+ .get_last_allocation_error = op_get_last_allocation_error ,
462471};
463472
464473umf_memory_pool_ops_t * umfJemallocPoolOps (void ) {
0 commit comments