jemalloc

https://jemalloc.net
Admin
jemalloc is a general-purpose memory allocator that emphasizes fragmentation avoidance and scalable...
Tokens:700,330
Snippets:5,006
Trust Score:9.6
Update:2 months ago
Show doc for...
Tokens:
Raw
### Install Documentation Rule

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000278.html

Installs documentation files using make variables.

```makefile
install_doc_html install_doc_man

install:
	install_bin install_include install_lib install_doc
```

--------------------------------

### jemalloc Compilation and Installation

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-December/000536.html

This snippet shows the commands used to configure, compile, and install jemalloc with a custom prefix. It's relevant for users encountering issues during setup.

```bash
./configure --with-jemalloc-prefix=je_ && make && make install
```

--------------------------------

### Install HTML Documentation

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000278.html

Installs the generated HTML documentation files to the specified data directory, creating the necessary subdirectory.

```makefile
install_doc_html:
	install -d $(DATADIR)/doc/jemalloc$(install_suffix)
	@for d in $(DOCS_HTML); do \
	echo "install -m 644 $$d $(DATADIR)/doc/jemalloc$(install_suffix)"; \
	install -m 644 $$d $(DATADIR)/doc/jemalloc$(install_suffix); \
	done
```

--------------------------------

### Install HTML Documentation

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-May/000592.html

This command attempts to install the jemalloc HTML documentation. It fails if the 'doc/jemalloc.html' file is not found.

```shell
install -m 644 doc/jemalloc.html /usr/local/share/doc/jemalloc
```

--------------------------------

### Install Jemalloc Components (Excluding Docs)

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-May/000592.html

This command installs only the binary, include, and library files, skipping the documentation.

```shell
make install_bin install_include install_lib
```

--------------------------------

### Install Static Libraries

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000278.html

Installs both pic and non-pic static libraries to the target library directory.

```makefile
install_lib_static: $(DSOS) $(STATIC_LIBS)
	install -d $(LIBDIR)
	install -m 755 $(objroot)lib/libjemalloc$(install_suffix)_pic.a $(LIBDIR)
	install -m 755 $(objroot)lib/libjemalloc$(install_suffix).a $(LIBDIR)
```

--------------------------------

### Jemalloc Installation Steps and Error

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-November/001202.html

Demonstrates the sequence of commands leading to the 'make install' failure and the specific error message indicating a missing documentation file.

```bash
./configure --prefix=$HOME/jemalloc-bin/
make
make install
```

```text
install -m 644 doc/jemalloc.html /ccs/home/bzf/jemalloc-bin/share/doc/jemalloc
install: cannot stat `doc/jemalloc.html': No such file or directory
make: *** [install_doc_html] Error 1
```

--------------------------------

### Jemalloc Heap Profile v2 Format Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-February/001045.html

This is an example of a jemalloc heap profile file in the v2 format. It shows allocation statistics per thread type. Note the '@' symbol indicating the start of backtrace information, which in this case appears to be missing.

```text
heap_v2/524288
  t*: 217: 3029560 [0: 0]
  t0: 6: 1015808 [0: 0]
  t1: 0: 0 [0: 0]
  t2: 207: 1440312 [0: 0]
  t3: 0: 0 [0: 0]
  t4: 0: 0 [0: 0]
  t5: 0: 0 [0: 0]
  t6: 0: 0 [0: 0]
  t7: 4: 573440 [0: 0]
@
  t*: 217: 3029560 [0: 0]
  t0: 6: 1015808 [0: 0]
  t2: 207: 1440312 [0: 0]
  t7: 4: 573440 [0: 0]
```

--------------------------------

### Makefile Install Rule for Static Library (with objroot)

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000265.html

Installs the static library files. Uses 'objroot' to specify the source location of the library files.

```makefile
install_lib_static: $(DSOS) $(STATIC_LIBS)
 	install -d $(LIBDIR)
	install -m 755 @objroot at lib/libjemalloc at install_suffix@_pic.a $(LIBDIR)
	install -m 755 @objroot at lib/libjemalloc at install_suffix@.a $(LIBDIR)

```

--------------------------------

### Jemalloc JVM Integration Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2016-March/001278.html

This example demonstrates how to attempt to integrate jemalloc with the JVM using LD_PRELOAD and MALLOC_CONF. It highlights the expected error messages when profiling options are not correctly configured.

```shell
jgriffith at mydevbox.c1.:~/JEMALLOC$ echo $LD_PRELOAD
/usr/local/lib/libjemalloc.so
jgriffith at mydevbox.c1.:~/JEMALLOC$ echo $MALLOC_CONF
prof:true,lg_prof_interval:30,lg_prof_sample:17
jgriffith at mydevbox.c1.:~/JEMALLOC$ java -jar allocmemory.jar 
<jemalloc>: Invalid conf pair: prof:true
<jemalloc>: Invalid conf pair: lg_prof_interval:30
<jemalloc>: Invalid conf pair: lg_prof_sample:17
[...]
```

--------------------------------

### Jemalloc Heap Profile Format (Example)

Source: https://jemalloc.net/jemalloc.3.html

An example of the heap profile format used by jemalloc, including aggregate data and mapped libraries.

```text
heap_v2/524288
  t*: 28106: 56637512 [0: 0]
  [...]
  t3: 352: 16777344 [0: 0]
  [...]
  t99: 17754: 29341640 [0: 0]
  [...]
@ 0x5f86da8 0x5f5a1dc [...] 0x29e4d4e 0xa200316 0xabb2988 [...]
  t*: 13: 6688 [0: 0]
  t3: 12: 6496 [0: 0]
  t99: 1: 192 [0: 0]
[...]

MAPPED_LIBRARIES:
[...]
```

--------------------------------

### Makefile Install Rule for Shared Library (with objroot)

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000265.html

Installs the shared library files. Uses 'objroot' to specify the source location of the library files.

```makefile
install_lib_shared: $(DSOS)
 	install -d $(LIBDIR)
	install -m 755 @objroot at lib/libjemalloc at install_suffix@.$(SO).$(REV) $(LIBDIR)
	ln -sf libjemalloc at install_suffix@.$(SO).$(REV) $(LIBDIR)/libjemalloc at install_suffix@.$(SO)

```

--------------------------------

### Install Static Library with Suffix

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000282.html

Installs the static library with the appropriate suffix. This snippet is part of the installation process for shared and static libraries.

```makefile
	install -m 755 $(objroot)lib/$(LIBJEMALLOC).$(A) $(LIBDIR)
```

--------------------------------

### Install Shared Library

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000278.html

Installs the shared library files to the target library directory, creating necessary symbolic links.

```makefile
install_lib_shared: $(DSOS)
	install -d $(LIBDIR)
	install -m 755 $(objroot)lib/libjemalloc$(install_suffix).$(SO).$(REV) $(LIBDIR)
	ln -sf libjemalloc$(install_suffix).$(SO).$(REV) $(LIBDIR)/libjemalloc$(install_suffix).$(SO)
```

--------------------------------

### Jemalloc Build Configuration and Commands

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-September/000922.html

Commands used to configure, build, and install jemalloc. Manual doc build targets may be required for successful installation.

```bash
autoconf
./configure \
--enable-autogen \
--prefix=/usr/local/jemalloc \
--with-jemalloc-prefix=je_ \
--enable-stats \
--enable-prof \
--enable-prof-libunwind \
--with-static-libunwind=/usr/lib/x86_64-linux-gnu/libunwind-x86_64.a \
--enable-fill \
--enable-valgrind \
--enable-dss \
--enable-xmalloc \
--disable-lazy-lock

make
sudo make install
```

```bash
make build_doc_html
make build_doc_man
```

--------------------------------

### Jemalloc Debug Configuration Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-August/001131.html

This example shows the environment variables and build flags used by a user when encountering a jemalloc assertion failure. It includes enabling debug and fill options, and setting specific MALLOC_CONF parameters.

```bash
MALLOC_CONF=tcache:false,redzone:true,stats_print:true
jemalloc version is 3.6.0
--enable-debug
--enable-fill
```

--------------------------------

### Update INSTALL file for --enable-ivsalloc

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-December/000534.html

This snippet shows the additions to the INSTALL file to document the new --enable-ivsalloc configure option. It explains that this option enables pointer validation and incurs a performance hit.

```diff
--- a/INSTALL
+++ b/INSTALL
@@ -79,6 +79,12 @@
 any of the following arguments (not a definitive list) to 'configure':
 
 --enable-debug
-    Enable assertions and validation code.  This incurs a substantial
-    performance hit, but is very useful during application development.
+    Enable assertions and validation code.  This incurs a substantial
+    performance hit, but is very useful during application development.
+    Implies --enable-ivsalloc.
+
+--enable-ivsalloc
+    Enable validation code, which verifies that pointers reside within
+    jemalloc-owned chunks before dereferencing them. This incurs a substantial
+    performance hit.
 
 --disable-stats
     Disable statistics gathering functionality.  See the "opt.stats_print"

```

--------------------------------

### Jemalloc Profiling Example with opt.prof and opt.prof_accum

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-November/001211.html

This C code example demonstrates how jemalloc's profiling statistics are affected by opt.prof and opt.prof_accum settings, including manual dumps and resets using mallctl. It shows the expected output for current and cumulative stats at different dump points (A, B, C).

```c
void g(void *p);

void
f(void) {
unsigned i;

for (i = 0; i < (1U << 20); i++) {
void *p = malloc(1U << 30);
if (i == (1U << 19)) {
mallctl("prof.dump", NULL, NULL, NULL, 0); /* A */
mallctl("prof.reset", NULL, NULL, NULL, 0);
mallctl("prof.dump", NULL, NULL, NULL, 0); /* B */
}
if (p != NULL) {
g(p);
free(p);
}
}
mallctl("prof.dump", NULL, NULL, NULL, 0); /* C */
}
```

--------------------------------

### Jemalloc Heap_v2 Profile Data Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-February/001046.html

This is an example of the heap_v2 profile data generated by jemalloc. It shows allocation statistics per thread type, but lacks the expected hex addresses for backtraces, resulting in '0 B' information in 'pprof'.

```text
>_ heap_v2/524288
_>_   t*: 217: 3029560 [0: 0]
_>_   t0: 6: 1015808 [0: 0]
_>_   t1: 0: 0 [0: 0]
_>_   t2: 207: 1440312 [0: 0]
_>_   t3: 0: 0 [0: 0]
_>_   t4: 0: 0 [0: 0]
_>_   t5: 0: 0 [0: 0]
_>_   t6: 0: 0 [0: 0]
_>_   t7: 4: 573440 [0: 0]
_>_ @
_>_   t*: 217: 3029560 [0: 0]
_>_   t0: 6: 1015808 [0: 0]
_>_   t2: 207: 1440312 [0: 0]
_>_   t7: 4: 573440 [0: 0]
_>_
```

--------------------------------

### Pre-forking Process Strategy Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-July/000873.html

This example demonstrates a strategy for mitigating fork() latency by pre-forking processes and using inter-process communication. It is intended to be used early in application startup before memory usage becomes substantial.

```C++
#include "light-process.h"
#include "hphp/util/light-process.cpp"
```

--------------------------------

### Generate Distribution Archive

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-September/000923.html

Use 'make dist' before installing when building from non-tarball sources to ensure documentation is pre-built and included.

```bash
make dist
```

--------------------------------

### Environment Setup and Compilation Steps

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-October/000497.html

This snippet outlines the commands to set up the environment and configure jemalloc for compilation using Cygwin and Visual Studio's command prompt. It includes setting the PATH, enabling specific shell options, and running the configure script.

```bash
start cmd with vs10 shortcut
set PATH=%PATH%;C:\cygwin\bin
set SHELLOPTS=igncr
bash
echo $SHELLOPTS # check for igncr
cd jemalloc
CPPFLAGS=-Iinclude/msvc_compat ./configure
```

--------------------------------

### Implementing Jemalloc Chunk Hooks for Custom Memory Management

Source: https://jemalloc.net/mailman/jemalloc-discuss/2016-January/001247.html

This example demonstrates how to implement custom chunk hooks for jemalloc to manage memory allocation from a pre-allocated contiguous region. It involves creating a chunk provider and installing it for threads.

```c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "jemalloc/jemalloc.h"

// Assume a large contiguous memory region is available
#define HEAP_SIZE (1024 * 1024 * 100) // 100 MB
char memory_heap[HEAP_SIZE];

// Bitmap for tracking allocated chunks within the heap
unsigned char bitmap[HEAP_SIZE / 4096 / 8]; // Assuming 4KB chunks

// Function to align addresses and sizes
size_t align_up(size_t val, size_t align) {
    return (val + align - 1) & ~(align - 1);
}

// Chunk allocation hook
static void* chunk_alloc(size_t size, size_t alignment, bool* zero) {
    size_t chunk_size = align_up(size, 4096); // Jemalloc typically uses 4KB chunks
    size_t aligned_alignment = align_up(alignment, 4096);

    // Find a suitable free chunk in the bitmap
    for (size_t i = 0; i < HEAP_SIZE / 4096; ++i) {
        if (!((bitmap[i / 8] >> (i % 8)) & 1)) { // If chunk is free
            // Check if this chunk and subsequent ones are enough
            bool possible = true;
            for (size_t j = 0; j < chunk_size / 4096; ++j) {
                if (i + j >= HEAP_SIZE / 4096 || ((bitmap[(i + j) / 8] >> ((i + j) % 8)) & 1)) {
                    possible = false;
                    break;
                }
            }

            if (possible) {
                // Mark chunks as allocated
                for (size_t j = 0; j < chunk_size / 4096; ++j) {
                    bitmap[(i + j) / 8] |= (1 << ((i + j) % 8));
                }
                void* ptr = memory_heap + i * 4096;
                // Ensure alignment
                if ((uintptr_t)ptr % aligned_alignment != 0) {
                    // This simple bitmap approach might not guarantee alignment for arbitrary sizes
                    // A more sophisticated allocator would be needed for strict alignment
                    // For this example, we assume alignment is handled or not critical for the base chunk
                }
                *zero = true; // Indicate that the memory should be zeroed
                printf("Allocated chunk at %p, size %zu\n", ptr, chunk_size);
                return ptr;
            }
        }
    }
    return NULL; // No suitable chunk found
}

// Chunk deallocation hook
static void chunk_dealloc(void* ptr, size_t size) {
    if (ptr == NULL) return;

    size_t chunk_size = align_up(size, 4096);
    ptrdiff_t offset = (char*)ptr - memory_heap;

    if (offset < 0 || offset >= HEAP_SIZE) {
        // This pointer is not from our managed heap
        return;
    }

    size_t start_index = offset / 4096;
    size_t num_chunks = chunk_size / 4096;

    // Mark chunks as free
    for (size_t i = 0; i < num_chunks; ++i) {
        if (start_index + i < HEAP_SIZE / 4096) {
            bitmap[(start_index + i) / 8] &= ~(1 << ((start_index + i) % 8));
            printf("Deallocated chunk at %p, size %zu\n", ptr, chunk_size);
        }
    }
}

int main() {
    // Initialize the bitmap (all chunks are free initially)
    memset(bitmap, 0, sizeof(bitmap));

    // Install the chunk hooks
    // Note: In a real scenario, this would be done via jemalloc configuration or API calls
    // For demonstration, we'll simulate the hooks being used.
    // jemalloc_hooks_t hooks = {
    //     .chunk_alloc = chunk_alloc,
    //     .chunk_dealloc = chunk_dealloc
    // };
    // jemalloc_set_hooks(&hooks); // This API might not exist or work this way

    printf("Jemalloc chunk hooks setup (simulated).\n");
    printf("Attempting to allocate memory using jemalloc (which would use the hooks).\n");

    // Example usage (jemalloc would internally call chunk_alloc/chunk_dealloc)
    void* mem1 = malloc(10000); // Request 10KB
    if (mem1) {
        printf("malloc(10000) succeeded, got %p\n", mem1);
        // Use mem1...
        free(mem1);
    } else {
        printf("malloc(10000) failed.\n");
    }

    void* mem2 = malloc(50000); // Request 50KB
     if (mem2) {
        printf("malloc(50000) succeeded, got %p\n", mem2);
        // Use mem2...
        free(mem2);
    } else {
        printf("malloc(50000) failed.\n");
    }

    // In a real application, jemalloc would be initialized and used throughout.
    // The actual installation of hooks might require specific build flags or runtime configuration.

    return 0;
}

```

--------------------------------

### Custom Arena Initialization Issue

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-February/001042.html

This example illustrates the problem where setting a custom chunk allocator via mallctl triggers an early a0malloc() call before the custom allocator is fully installed, leading to unexpected memory allocation behavior.

```text
On Feb 10, 2015, at 8:29 PM, D'Alessandro, Luke K <ldalessa at indiana.edu> wrote:
>>_ On Feb 10, 2015, at 11:00 PM, D'Alessandro, Luke K <ldalessa at indiana.edu> wrote:
_>>>_ On Feb 10, 2015, at 10:52 PM, D'Alessandro, Luke K <ldalessa at indiana.edu> wrote:
_>>>_ We have an arena that we are using for a specific bit of memory that we are managing with a custom chunk allocator.
_>>>_ 
_>>>_ We’re seeing initial small allocations through this arena succeed without calling out to our custom chunk allocator. This behavior appears to be new since b617df8. While tracing this behavior, I’m seeing the initial allocations miss in the cache, and forward to arena_tcache_fill_small() which does some difficult-to-disect stuff including something to do with runs. After this call, the cache succeeds in supplying the allocation, without ever getting our chunk allocator involved.
_10aff3f3e1b8b3ac0348b259c439c9fe870a6b95 had a lot of a0-related changes in it, which may be related to the behavior change you're seeing.

>>>_ This causes us issues because the memory we’re getting back doesn’t seem to come from the place we’re expecting it to come from.
_>>>_ 
_>>>_ Is arena_tcache_fill_small() going somewhere special to find memory that was allocated with some other chunk allocator, previous to our initialization of our arena?
_>>>_ 
_>>_ Ah, actually, I see one call happening to the default chunk allocator for another arena during initialization.
_>>_ 
_>>_ We’re calling mallctl with opt.lg_chunk, and that triggers a really early a0malloc() inside of ctl_init(), which cascades into the chunk_alloc_default before we’ve had a chance to set our custom allocator on the default arena. I guess that arena_tcache_fill_small() uses this chunk to satisfy misses for small objects, which makes sense.
Is the problem that the region that is allocated from arena 0 ends up being freed back to the tcache, and you're depending on the tcache only containing regions from your custom arena?  In that case you could flush the tcache once you have the arena fully configured.

>>_ Is this early a0malloc() behavior new? 
_>>_ 
_>>_ I’ll will try and see if we can promote our custom allocator to be the default arena’s allocator before we do any other interaction with jemalloc.
_>>_ Let me know if there is any other way to bypass this issue,
_>
_> Okay, I’ve run into a wall here.
_>
_> In order to change the custom chunk allocator I am using the mallctl interface, which requires that I provide the arena id which I normally get through mallctl, but this triggers the a0malloc() that causes my problem.
_>
_> If I hard-code arena to be 0, which is correct, but feels brittle, I can skip that initial mallctl query, however I still need to use mallctl to set the chunk allocator which will trigger the bad a0malloc() before the allocator is installed.
_>
_> Is there a way around this? Could I set the allocator without passing through the mallctl interface as a workaround for now? Where would I look to do that? Can I have a0malloc() use the system malloc instead (we’re using jemalloc in prefixed form)?
_>
_> Any help would be appreciated as this is a blocker for us.
I'm a bit confused about what your code is trying to do, but maybe you're hitting one of these problems:

- You're trying to change the chunk allocator for one of the automatic arenas (arena 0?).  This is unlikely to ever work reliably for arena 0, though it would potentially be possible for other automatic arenas prior to launching any threads.
- You're calling the thread.arena mallctl to refer to a newly created arena before you've finished setting up the arena to use your chunk allocator.

I still have a bit of work to do on making sure that no metadata are allocated from non-auto arenas, so that they can be reset (see https://github.com/jemalloc/jemalloc/issues/146).  Is that related to what you're hitting?

Thanks,
Jason
```

--------------------------------

### Example Usage of Custom Prefixes

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-February/000116.html

Illustrates how to use different prefixes for jemalloc and libc functions, including the option to not exclude memalign and valloc.

```text
In some cases, it can be interesting to use different prefixes for the
"standard" libc malloc functions and for jemalloc specific functions. One such
case is to use the "__wrap_" prefix on libc malloc functions (for use with ld's
--wrap option) and no prefix or "je_" for jemalloc functions.

In such cases, it can also me interesting not to exclude memalign and valloc,
so this change also adds an option not to omit them when the prefix is set.
```

--------------------------------

### GCC Command Line Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-August/000912.html

Illustrates the specific GCC compilation flags that trigger the build failure on Fedora's i686 target.

```text
gcc -m32 -march=i686 -mtune=atom
```

--------------------------------

### JE_COMPILABLE() Program Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2011-April/000007.html

A proposed solution to test compilability of code during the configure process. This approach avoids issues with autoconf's search paths for header files.

```C
#define JE_COMPILABLE(program) \
  do { \
    printf("checking for %s... ", #program); \
    if (compile_test(program)) { \
      printf("yes\n"); \
    } else { \
      printf("no\n"); \
    } \
  } while (0)
```

--------------------------------

### Email Content Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-May/000375.html

An example of an email exchange from the jemalloc-discuss mailing list regarding the 3.0.0 release preparation.

```text
On Wed, May 02, 2012 at 03:04:52AM -0700, Jason Evans wrote:
>_ I'm doing a final round of testing in preparation for the 3.0.0
_>_ release, which I'm hoping to tag in the next 24-36 hours, assuming no
_>_ stability issues are uncovered.  My testing coverage is best on Linux
_>_ and FreeBSD; OS X is minimal, and I don't even have a Windows system.
_>_ If there are issues that need to be addressed before the release,
_>_ please let me know ASAP.
_ 
There is the "Check for VALGRIND_RESIZEINPLACE_BLOCK support" patch.
And I'm going to send one or two more patches today for other things.

Mike

```

--------------------------------

### Jemalloc Heap Profiling Configuration Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-January/000705.html

This configuration enables heap profiling, sets it to active, configures the sampling rate, enables accumulation of profiling data, and specifies a prefix for the output file.

```bash
MALLOC_CONF="prof:true,prof_active:true,lg_prof_sample:19,prof_accum:true,prof_prefix:jeprof.out”
```

--------------------------------

### Example smaps entry with high Private_Clean

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-May/000595.html

This is an example of a smaps entry showing a large Private_Clean size, which is a key observation in the analysis.

```text
7f41dc200000-7f437a400000 rw-p 00000000 00:00 0 
Size:            6785024 kB
Rss:             4037056 kB
Pss:             4037056 kB
Shared_Clean:          0 kB
Shared_Dirty:          0 kB
Private_Clean:   1499364 kB
Private_Dirty:   2537692 kB
Referenced:      2536428 kB
Swap:                  0 kB
KernelPageSize:        4 kB
MMUPageSize:           4 kB
```

--------------------------------

### Working GCC Command Line Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2014-August/000912.html

Shows the GCC compilation flags that work correctly for x86_64 and generic i386 targets, which do not encounter the build issue.

```text
gcc -march=i386 -mtune=generic
```

--------------------------------

### Static Linker Command Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-July/000619.html

This command demonstrates a typical linker line for statically linking an application with jemalloc and other libraries. Issues with symbol definition order can arise.

```bash
g++  -m64 -Wl,--eh-frame-hdr -o ./bin/xxxx ./obj/xxxx.o  .....   -static -pthread -lcrypto -lz -lbz2 -ldl  -ljemalloc -lunwind
-Wl,-Map=gccmaps/xxxx.map
```

--------------------------------

### Add --disable-zone-allocator Option to INSTALL

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-November/000527.html

This snippet shows the addition of the --disable-zone-allocator option to the INSTALL file, explaining its purpose for Darwin systems.

```diff
--- a/INSTALL
+++ b/INSTALL
@@ -141,6 +141,10 @@
 any of the following arguments (not a definitive list) to 'configure':
 --disable-experimental
     Disable support for the experimental API (*allocm()).
+
+--disable-zone-allocator
+    Disable zone allocator for Darwin. This means jemalloc won't be hooked as
+    the default allocator on OSX/iOS.
 
 --enable-utrace
     Enable utrace(2)-based allocation tracing.  This feature is not broadly

```

--------------------------------

### Makefile Install Rule for Static Library (without objroot)

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000265.html

Installs the static library files after the 'objroot' variable has been removed. The source location is now relative.

```makefile
install_lib_static: $(DSOS) $(STATIC_LIBS)
 	install -d $(LIBDIR)
	install -m 755 lib/libjemalloc at install_suffix@_pic.a $(LIBDIR)
	install -m 755 lib/libjemalloc at install_suffix@.a $(LIBDIR)

```

--------------------------------

### Build Jemalloc Documentation

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-May/000592.html

If building from a git checkout, run 'make dist' or 'make build_doc' before 'make install' to ensure documentation is generated.

```shell
make dist
```

```shell
make build_doc
```

--------------------------------

### Makefile Install Rule for Shared Library (without objroot)

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000265.html

Installs the shared library files after the 'objroot' variable has been removed. The source location is now relative.

```makefile
install_lib_shared: $(DSOS)
 	install -d $(LIBDIR)
	install -m 755 lib/libjemalloc at install_suffix@.$(SO).$(REV) $(LIBDIR)
	ln -sf libjemalloc at install_suffix@.$(SO).$(REV) $(LIBDIR)/libjemalloc at install_suffix@.$(SO)

```

--------------------------------

### Example Use Case for Semi-dual jemalloc

Source: https://jemalloc.net/mailman/jemalloc-discuss/2015-August/001153.html

Illustrates a scenario where jemalloc is LD_PRELOAD'ed for an executable that also uses a .so library statically linked with jemalloc. This highlights the potential for dual jemalloc instances.

```bash
LD_PRELOAD=...jemalloc... mysqld       # where msyqld uses TokuDB .so lib
and this lib has jemalloc statically linked.
```

--------------------------------

### Running GDB with jemalloc printers on Linux

Source: https://jemalloc.net/mailman/jemalloc-discuss/2011-November/000051.html

Example of launching GDB with jemalloc pretty printers loaded, attached to a running application (gedit in this case), and initiating the heap analysis.

```bash
env LD_PRELOAD=../libjemalloc.so.0 gdb7.2 -q -x /u/ezolt,spin/heap.py gedit
```

--------------------------------

### Jemalloc INSTALL File Modification

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-November/000517.html

This snippet shows the addition to the INSTALL file, explaining the new --without-export option and its use cases for static linking and OSX zone allocator.

```diff
diff --git a/INSTALL b/INSTALL
index e40a7ed..7c2ed68 100644
--- a/INSTALL
+++ b/INSTALL
@@ -55,6 +55,11 @@ any of the following arguments (not a definitive list) to 'configure':
     jemalloc overlays the default malloc zone, but makes no attempt to actually
     replace the "malloc", "calloc", etc. symbols.
 
+--without-export
+    Don't export public APIs. This can be useful when building jemalloc as a
+    static library, or to avoid exporting public APIs when using the zone
+    allocator on OSX.
+
 --with-private-namespace=<prefix>
     Prefix all library-private APIs with <prefix>.  For shared libraries,
     symbol visibility mechanisms prevent these symbols from being exported, but

```

--------------------------------

### Index Function Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-February/000563.html

An example of an index function that is part of a multithreaded application experiencing performance issues. This function is called by one thread while another thread runs a search function.

```c
void index()
{
}
```

--------------------------------

### Jemalloc Configuration Initialization for Windows

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-April/000317.html

This code block illustrates conditional compilation for configuration initialization, specifically excluding the POSIX symbolic link logic when `_WIN32` is defined. It ensures that the configuration process is adapted for Windows.

```c
#ifndef _WIN32
			int	linklen;
			const char	*linkname =
#ifdef JEMALLOC_PREFIX
			    JEMALLOC_PREFIX
#else
			    "/etc/malloc.conf"
#endif
			;
			char	buf[PATH_MAX];

			linklen = readlink(linkname, buf, sizeof(buf) - 1);
			if (linklen != -1) {
				/*
				 * The configuration file is a symbolic link.  We need to read
				 * the contents of the file that the link points to.
				 */
				buf[linklen] = '\0';
				opts = buf;
			} else {
#endif
#ifdef JEMALLOC_PREFIX
			/* No configuration specified. */
			buf[0] = '\0';
			opts = buf;
#endif
#ifndef _WIN32
			}
#endif
```

--------------------------------

### Successful Heap Profile Output on x86

Source: https://jemalloc.net/mailman/jemalloc-discuss/2016-June/001310.html

Example of a heap profile file generated by jemalloc on an x86 platform, showing call stack information.

```text
heap_v2/1
  t*: 10: 47112 [0: 0]
  t0: 10: 47112 [0: 0]
@ 0x7fa08cb98c2d 0x7fa08cb91a1d 0x7fa08cb5d171 0x7fa08cb5d3da 0x7fa08cb5d651 0x40054c 0x400573 0x7fa08c7b0ec5 0x400469
  t*: 10: 47112 [0: 0]
  t0: 10: 47112 [0: 0]
```

--------------------------------

### Search Function Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-February/000563.html

An example of a search function that is part of a multithreaded application experiencing performance issues. This function's performance is significantly degraded when another thread runs the index function.

```c
void search()
{
}
```

--------------------------------

### Conditional Mallopt Call Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2013-November/000678.html

This example demonstrates how to conditionally call mallopt() only when using glibc's allocator. This approach helps avoid issues when linking with alternative memory allocators like jemalloc.

```c
#if defined(__GLIBC__) && !defined(MALLOC_GLIBC) // Only use glibc's mallopt if we are using glibc's malloc
    mallopt(MALLOC_OPTIONS, ...);
#endif
```

--------------------------------

### Jemalloc Memory Profiling Output Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2012-December/000533.html

This is an example of a meaningless memory profiling dump received when attempting to use jemalloc's profiler on the SH4 architecture. It indicates a potential issue with unwinding or configuration.

```text
heap profile: 6: 49296 [0: 0] @ heap_v2/524288
6: 49296 [0: 0] @

MAPPED_LIBRARIES:
....
```

--------------------------------

### GDB 'heap' Command Output Example

Source: https://jemalloc.net/mailman/jemalloc-discuss/2011-November/000051.html

Example output from the 'heap' GDB command, showing a breakdown of memory usage by allocation size. This helps identify memory leaks or inefficient allocation patterns.

```text
(ugdb-amd64-7.2-02)help heap
Show heap utilization for user-space cores and processes (BETA)

       The code walks jemalloc heap datastructures to determine heap usage.

       It splits the memory usage into buckets by size.

       BETA: It is very memory intensive and can cause gdb to core.

       Example:
       (ugdb-amd64-7.2-02) heap

       FreeBSD Heap Analysis
       ---------------------
       Searching process virtual address space for 'chunks' of the heap... DONE.

       Calculating memory usage for 'chunks' in 5 heap arenas:
         Walking Arena  0 (0x898f78) with   2 'chunks'...  DONE.
         Walking Arena  1 (0x89a6f8) with   0 'chunks'...  DONE.
         Walking Arena  2 (0x89b278) with   0 'chunks'...  DONE.
         Walking Arena  3 (0x899b78) with  19 'chunks'...  DONE.
         Walking Arena  4 (0x89bdf8) with   0 'chunks'...  DONE.

         Heap allocation distribution (by size)
         =================================================
           2 bytes *         96 allocs ( 0%) =           192 bytes ( 0%)
           4 bytes *         84 allocs ( 0%) =           336 bytes ( 0%)
           8 bytes *       2544 allocs ( 1%) =         20352 bytes ( 0%)
          16 bytes *       9569 allocs ( 4%) =        153104 bytes ( 0%)
          32 bytes *      47567 allocs (20%) =       1522144 bytes ( 9%)
          ...
           ^                    ^        ^               ^            ^
           |                    |        |               |            |
          Bin Size       Num allocs    % all allocs  Total Bytes   % of total bytes


```
Tokens:
Raw