java.lang.Object
- org.lwjgl.system.jemalloc.JEmalloc

```
public class JEmalloc
extends java.lang.Object
```
Native bindings to jemalloc.
jemalloc is a general purpose malloc implementation that emphasizes fragmentation avoidance and scalable concurrency support. jemalloc first came into use as the FreeBSD libc allocator in 2005, and since then it has found its way into numerous applications that rely on its predictable behavior. In 2010 jemalloc development efforts broadened to include developer support features such as heap profiling, Valgrind integration, and extensive monitoring/tuning hooks. Modern jemalloc releases continue to be integrated back into FreeBSD, and therefore versatility remains critical. Ongoing development efforts trend toward making jemalloc among the best allocators for a broad range of demanding applications, and eliminating/mitigating weaknesses that have practical repercussions for real world applications.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class JEmalloc.Functions
Contains the function pointers loaded from the jemalloc SharedLibrary.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static SharedLibrary`	`getLibrary()` Returns the jemalloc `SharedLibrary`.
`static java.nio.ByteBuffer`	`je_aligned_alloc(long alignment, long size)` Allocates `size` bytes of memory such that the allocation's base address is an even multiple of `alignment`.
`static java.nio.ByteBuffer`	`je_calloc(long num, long size)` Allocates space for `num` objects, each `size` bytes in length.
`static void`	`je_dallocx(java.nio.ByteBuffer ptr, int flags)` Causes the memory referenced by `ptr` to be made available for future allocations.
`static void`	`je_dallocx(double[] ptr, int flags)` double[] version of: `dallocx`
`static void`	`je_dallocx(java.nio.DoubleBuffer ptr, int flags)` DoubleBuffer version of: `dallocx`
`static void`	`je_dallocx(float[] ptr, int flags)` float[] version of: `dallocx`
`static void`	`je_dallocx(java.nio.FloatBuffer ptr, int flags)` FloatBuffer version of: `dallocx`
`static void`	`je_dallocx(int[] ptr, int flags)` int[] version of: `dallocx`
`static void`	`je_dallocx(java.nio.IntBuffer ptr, int flags)` IntBuffer version of: `dallocx`
`static void`	`je_dallocx(long[] ptr, int flags)` long[] version of: `dallocx`
`static void`	`je_dallocx(java.nio.LongBuffer ptr, int flags)` LongBuffer version of: `dallocx`
`static void`	`je_dallocx(PointerBuffer ptr, int flags)` PointerBuffer version of: `dallocx`
`static void`	`je_dallocx(short[] ptr, int flags)` short[] version of: `dallocx`
`static void`	`je_dallocx(java.nio.ShortBuffer ptr, int flags)` ShortBuffer version of: `dallocx`
`static void`	`je_free(java.nio.ByteBuffer ptr)` Causes the allocated memory referenced by `ptr` to be made available for future allocations.
`static void`	`je_free(double[] ptr)` double[] version of: `free`
`static void`	`je_free(java.nio.DoubleBuffer ptr)` DoubleBuffer version of: `free`
`static void`	`je_free(float[] ptr)` float[] version of: `free`
`static void`	`je_free(java.nio.FloatBuffer ptr)` FloatBuffer version of: `free`
`static void`	`je_free(int[] ptr)` int[] version of: `free`
`static void`	`je_free(java.nio.IntBuffer ptr)` IntBuffer version of: `free`
`static void`	`je_free(long[] ptr)` long[] version of: `free`
`static void`	`je_free(java.nio.LongBuffer ptr)` LongBuffer version of: `free`
`static void`	`je_free(PointerBuffer ptr)` PointerBuffer version of: `free`
`static void`	`je_free(short[] ptr)` short[] version of: `free`
`static void`	`je_free(java.nio.ShortBuffer ptr)` ShortBuffer version of: `free`
`static int`	`je_mallctl(java.nio.ByteBuffer name, java.nio.ByteBuffer oldp, PointerBuffer oldlenp, java.nio.ByteBuffer newp)` Provides a general interface for introspecting the memory allocator, as well as setting modifiable parameters and triggering actions.
`static int`	`je_mallctl(java.lang.CharSequence name, java.nio.ByteBuffer oldp, PointerBuffer oldlenp, java.nio.ByteBuffer newp)` Provides a general interface for introspecting the memory allocator, as well as setting modifiable parameters and triggering actions.
`static int`	`je_mallctlbymib(PointerBuffer mib, java.nio.ByteBuffer oldp, PointerBuffer oldlenp, java.nio.ByteBuffer newp)` Similar to `mallctl`, but uses MIBs instead of names.
`static int`	`je_mallctlnametomib(java.nio.ByteBuffer name, PointerBuffer mibp, PointerBuffer miblenp)` Provides a way to avoid repeated name lookups for applications that repeatedly query the same portion of the namespace, by translating a name to a “Management Information Base” (MIB) that can be passed repeatedly to `mallctlbymib`.
`static int`	`je_mallctlnametomib(java.lang.CharSequence name, PointerBuffer mibp, PointerBuffer miblenp)` Provides a way to avoid repeated name lookups for applications that repeatedly query the same portion of the namespace, by translating a name to a “Management Information Base” (MIB) that can be passed repeatedly to `mallctlbymib`.
`static PointerBuffer`	`je_malloc_message()` Returns the `je_malloc_message` variable.
`static void`	`je_malloc_stats_print(MallocMessageCallbackI write_cb, java.nio.ByteBuffer je_cbopaque, java.nio.ByteBuffer opts)` Writes human-readable summary statistics via the `write_cb` callback function pointer and `cbopaque` data passed to `write_cb`, or `malloc_message()` if `write_cb` is `NULL`.
`static void`	`je_malloc_stats_print(MallocMessageCallbackI write_cb, java.nio.ByteBuffer je_cbopaque, java.lang.CharSequence opts)` Writes human-readable summary statistics via the `write_cb` callback function pointer and `cbopaque` data passed to `write_cb`, or `malloc_message()` if `write_cb` is `NULL`.
`static long`	`je_malloc_usable_size(java.nio.ByteBuffer ptr)` Returns the usable size of the allocation pointed to by `ptr`.
`static java.nio.ByteBuffer`	`je_malloc(long size)` Allocates `size` bytes of uninitialized memory.
`static java.nio.ByteBuffer`	`je_mallocx(long size, int flags)` Allocates at least `size` bytes of memory, and returns a pointer to the base address of the allocation.
`static java.nio.ByteBuffer`	`je_nallocx(long size, int flags)` Allocates no memory, but it performs the same size computation as the `mallocx` function, and returns the real size of the allocation that would result from the equivalent `mallocx()` function call.
`static int`	`je_posix_memalign(PointerBuffer memptr, long alignment, long size)` Allocates `size` bytes of memory such that the allocation's base address is an even multiple of `alignment`, and returns the allocation in the value pointed to by `memptr`.
`static java.nio.ByteBuffer`	`je_rallocx(java.nio.ByteBuffer ptr, long size, int flags)` Resizes the allocation at `ptr` to be at least `size` bytes, and returns a pointer to the base address of the resulting allocation, which may or may not have moved from its original location.
`static java.nio.ByteBuffer`	`je_realloc(java.nio.ByteBuffer ptr, long size)` Changes the size of the previously allocated memory referenced by `ptr` to `size` bytes.
`static long`	`je_sallocx(java.nio.ByteBuffer ptr, int flags)` Returns the real size of the allocation at `ptr`.
`static void`	`je_sdallocx(java.nio.ByteBuffer ptr, int flags)` Sized version of `dallocx`.
`static void`	`je_sdallocx(double[] ptr, int flags)` double[] version of: `sdallocx`
`static void`	`je_sdallocx(java.nio.DoubleBuffer ptr, int flags)` DoubleBuffer version of: `sdallocx`
`static void`	`je_sdallocx(float[] ptr, int flags)` float[] version of: `sdallocx`
`static void`	`je_sdallocx(java.nio.FloatBuffer ptr, int flags)` FloatBuffer version of: `sdallocx`
`static void`	`je_sdallocx(int[] ptr, int flags)` int[] version of: `sdallocx`
`static void`	`je_sdallocx(java.nio.IntBuffer ptr, int flags)` IntBuffer version of: `sdallocx`
`static void`	`je_sdallocx(long[] ptr, int flags)` long[] version of: `sdallocx`
`static void`	`je_sdallocx(java.nio.LongBuffer ptr, int flags)` LongBuffer version of: `sdallocx`
`static void`	`je_sdallocx(PointerBuffer ptr, int flags)` PointerBuffer version of: `sdallocx`
`static void`	`je_sdallocx(short[] ptr, int flags)` short[] version of: `sdallocx`
`static void`	`je_sdallocx(java.nio.ShortBuffer ptr, int flags)` ShortBuffer version of: `sdallocx`
`static long`	`je_xallocx(java.nio.ByteBuffer ptr, long size, long extra, int flags)` Resizes the allocation at `ptr` in place to be at least size bytes, and returns the real size of the allocation.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getLibrary
```
public static SharedLibrary getLibrary()
```
    Returns the jemalloc SharedLibrary.
  - je_malloc_message
```
public static PointerBuffer je_malloc_message()
```
    Returns the je_malloc_message variable.
  - je_malloc
```
public static java.nio.ByteBuffer je_malloc(long size)
```
    Allocates size bytes of uninitialized memory. The allocated space is suitably aligned (after possible pointer coercion) for storage of any type of object.
    
    Parameters:
    
    size - the number of bytes to allocate
  - je_calloc
```
public static java.nio.ByteBuffer je_calloc(long num,
                                            long size)
```
    Allocates space for num objects, each size bytes in length. The result is identical to calling malloc with an argument of num * size, with the exception that the allocated memory is explicitly initialized to zero bytes.
    
    Parameters:
    
    num - the number of objects to allocate
    
    size - the size of each object, in bytes
  - je_posix_memalign
```
public static int je_posix_memalign(PointerBuffer memptr,
                                    long alignment,
                                    long size)
```
    Allocates size bytes of memory such that the allocation's base address is an even multiple of alignment, and returns the allocation in the value pointed to by memptr. The requested alignment must be a power of 2 at least as large as sizeof(void *).
    
    Parameters:
    
    memptr - returns the allocated memory
    
    alignment - the allocation alignment, in bytes
    
    size - the number of bytes to allocate
  - je_aligned_alloc
```
public static java.nio.ByteBuffer je_aligned_alloc(long alignment,
                                                   long size)
```
    Allocates size bytes of memory such that the allocation's base address is an even multiple of alignment. The requested alignment must be a power of 2. Behavior is undefined if size is not an integral multiple of alignment.
    
    Parameters:
    
    alignment - the allocation alignment, in bytes
    
    size - the number of bytes to allocate
  - je_realloc
```
public static java.nio.ByteBuffer je_realloc(java.nio.ByteBuffer ptr,
                                             long size)
```
    Changes the size of the previously allocated memory referenced by ptr to size bytes. The contents of the memory are unchanged up to the lesser of the new and old sizes. If the new size is larger, the contents of the newly allocated portion of the memory are undefined. Upon success, the memory referenced by ptr is freed and a pointer to the newly allocated memory is returned. Note that realloc() may move the memory allocation, resulting in a different return value than ptr. If ptr is NULL, the realloc() function behaves identically to malloc() for the specified size.
    
    Parameters:
    
    ptr - the previously allocated memory or NULL
    
    size - the number of bytes to allocate
  - je_free
```
public static void je_free(java.nio.ByteBuffer ptr)
```
    Causes the allocated memory referenced by ptr to be made available for future allocations. If ptr is NULL, no action occurs.
    
    Parameters:
    
    ptr - the allocated memory to free
  - je_free
```
public static void je_free(java.nio.ShortBuffer ptr)
```
    ShortBuffer version of: free
  - je_free
```
public static void je_free(java.nio.IntBuffer ptr)
```
    IntBuffer version of: free
  - je_free
```
public static void je_free(java.nio.LongBuffer ptr)
```
    LongBuffer version of: free
  - je_free
```
public static void je_free(java.nio.FloatBuffer ptr)
```
    FloatBuffer version of: free
  - je_free
```
public static void je_free(java.nio.DoubleBuffer ptr)
```
    DoubleBuffer version of: free
  - je_free
```
public static void je_free(PointerBuffer ptr)
```
    PointerBuffer version of: free
  - je_mallocx
```
public static java.nio.ByteBuffer je_mallocx(long size,
                                             int flags)
```
    Allocates at least size bytes of memory, and returns a pointer to the base address of the allocation. Behavior is undefined if size is 0, or if request size overflows due to size class and/or alignment constraints.
    
    Parameters:
    
    size - the number of bytes to allocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_rallocx
```
public static java.nio.ByteBuffer je_rallocx(java.nio.ByteBuffer ptr,
                                             long size,
                                             int flags)
```
    Resizes the allocation at ptr to be at least size bytes, and returns a pointer to the base address of the resulting allocation, which may or may not have moved from its original location. Behavior is undefined if size is 0, or if request size overflows due to size class and/or alignment constraints.
    
    Parameters:
    
    ptr - the previously allocated memory or NULL
    
    size - the number of bytes to allocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_xallocx
```
public static long je_xallocx(java.nio.ByteBuffer ptr,
                              long size,
                              long extra,
                              int flags)
```
    Resizes the allocation at ptr in place to be at least size bytes, and returns the real size of the allocation. If extra is non-zero, an attempt is made to resize the allocation to be at least (size + extra) bytes, though inability to allocate the extra byte(s) will not by itself result in failure to resize. Behavior is undefined if size is 0, or if (size + extra > SIZE_T_MAX).
    
    Parameters:
    
    ptr - the previously allocated memory or NULL
    
    size - the number of bytes to allocate
    
    extra - the number of extra bytes to allocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_sallocx
```
public static long je_sallocx(java.nio.ByteBuffer ptr,
                              int flags)
```
    Returns the real size of the allocation at ptr.
    
    Parameters:
    
    ptr - the allocated memory to query
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_dallocx
```
public static void je_dallocx(java.nio.ByteBuffer ptr,
                              int flags)
```
    Causes the memory referenced by ptr to be made available for future allocations.
    
    Parameters:
    
    ptr - the allocated memory to deallocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_dallocx
```
public static void je_dallocx(java.nio.ShortBuffer ptr,
                              int flags)
```
    ShortBuffer version of: dallocx
  - je_dallocx
```
public static void je_dallocx(java.nio.IntBuffer ptr,
                              int flags)
```
    IntBuffer version of: dallocx
  - je_dallocx
```
public static void je_dallocx(java.nio.LongBuffer ptr,
                              int flags)
```
    LongBuffer version of: dallocx
  - je_dallocx
```
public static void je_dallocx(java.nio.FloatBuffer ptr,
                              int flags)
```
    FloatBuffer version of: dallocx
  - je_dallocx
```
public static void je_dallocx(java.nio.DoubleBuffer ptr,
                              int flags)
```
    DoubleBuffer version of: dallocx
  - je_dallocx
```
public static void je_dallocx(PointerBuffer ptr,
                              int flags)
```
    PointerBuffer version of: dallocx
  - je_sdallocx
```
public static void je_sdallocx(java.nio.ByteBuffer ptr,
                               int flags)
```
    Sized version of dallocx. The primary optimization over dallocx() is the removal of a metadata read, which often suffers an L1 cache miss.
    
    Parameters:
    
    ptr - the allocated memory to deallocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_sdallocx
```
public static void je_sdallocx(java.nio.ShortBuffer ptr,
                               int flags)
```
    ShortBuffer version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(java.nio.IntBuffer ptr,
                               int flags)
```
    IntBuffer version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(java.nio.LongBuffer ptr,
                               int flags)
```
    LongBuffer version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(java.nio.FloatBuffer ptr,
                               int flags)
```
    FloatBuffer version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(java.nio.DoubleBuffer ptr,
                               int flags)
```
    DoubleBuffer version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(PointerBuffer ptr,
                               int flags)
```
    PointerBuffer version of: sdallocx
  - je_nallocx
```
public static java.nio.ByteBuffer je_nallocx(long size,
                                             int flags)
```
    Allocates no memory, but it performs the same size computation as the mallocx function, and returns the real size of the allocation that would result from the equivalent mallocx() function call. Behavior is undefined if size is 0, or if request size overflows due to size class and/or alignment constraints.
    
    Parameters:
    
    size - the number of bytes to allocate
    
    flags - a bitfield of zero or more of the MALLOCX macros in JEmacros
  - je_mallctl
```
public static int je_mallctl(java.nio.ByteBuffer name,
                             java.nio.ByteBuffer oldp,
                             PointerBuffer oldlenp,
                             java.nio.ByteBuffer newp)
```
    Provides a general interface for introspecting the memory allocator, as well as setting modifiable parameters and triggering actions. The period-separated name argument specifies a location in a tree-structured namespace; see the MALLCTL NAMESPACE section for documentation on the tree contents. To read a value, pass a pointer via oldp to adequate space to contain the value, and a pointer to its length via oldlenp; otherwise pass NULL and NULL. Similarly, to write a value, pass a pointer to the value via newp, and its length via newlen; otherwise pass NULL and 0.
    
    Parameters:
    
    name - the namespace location
    
    oldp - returns a value
    
    oldlenp - returns the value length
    
    newp - the new value
  - je_mallctl
```
public static int je_mallctl(java.lang.CharSequence name,
                             java.nio.ByteBuffer oldp,
                             PointerBuffer oldlenp,
                             java.nio.ByteBuffer newp)
```
    Provides a general interface for introspecting the memory allocator, as well as setting modifiable parameters and triggering actions. The period-separated name argument specifies a location in a tree-structured namespace; see the MALLCTL NAMESPACE section for documentation on the tree contents. To read a value, pass a pointer via oldp to adequate space to contain the value, and a pointer to its length via oldlenp; otherwise pass NULL and NULL. Similarly, to write a value, pass a pointer to the value via newp, and its length via newlen; otherwise pass NULL and 0.
    
    Parameters:
    
    name - the namespace location
    
    oldp - returns a value
    
    oldlenp - returns the value length
    
    newp - the new value
  - je_mallctlnametomib
```
public static int je_mallctlnametomib(java.nio.ByteBuffer name,
                                      PointerBuffer mibp,
                                      PointerBuffer miblenp)
```
    Provides a way to avoid repeated name lookups for applications that repeatedly query the same portion of the namespace, by translating a name to a “Management Information Base” (MIB) that can be passed repeatedly to mallctlbymib. Upon successful return from mallctlnametomib(), mibp contains an array of *miblenp integers, where *miblenp is the lesser of the number of components in name and the input value of *miblenp. Thus it is possible to pass a *miblenp that is smaller than the number of period-separated name components, which results in a partial MIB that can be used as the basis for constructing a complete MIB. For name components that are integers (e.g. the 2 in "arenas.bin.2.size"), the corresponding MIB component will always be that integer. Therefore, it is legitimate to construct code like the following:
    unsigned nbins, i; size_t mib[4]; size_t len, miblen; len = sizeof(nbins); mallctl("arenas.nbins", &nbins, &len, NULL, 0); miblen = 4; mallctlnametomib("arenas.bin.0.size", mib, &miblen); for (i = 0; i < nbins; i++) { size_t bin_size; mib[2] = i; len = sizeof(bin_size); mallctlbymib(mib, miblen, &bin_size, &len, NULL, 0); // Do something with bin_size... }
    Parameters:
    
    name - the namespace location
    
    mibp - an array of integers
    
    miblenp - the number of components in mibp
  - je_mallctlnametomib
```
public static int je_mallctlnametomib(java.lang.CharSequence name,
                                      PointerBuffer mibp,
                                      PointerBuffer miblenp)
```
    Provides a way to avoid repeated name lookups for applications that repeatedly query the same portion of the namespace, by translating a name to a “Management Information Base” (MIB) that can be passed repeatedly to mallctlbymib. Upon successful return from mallctlnametomib(), mibp contains an array of *miblenp integers, where *miblenp is the lesser of the number of components in name and the input value of *miblenp. Thus it is possible to pass a *miblenp that is smaller than the number of period-separated name components, which results in a partial MIB that can be used as the basis for constructing a complete MIB. For name components that are integers (e.g. the 2 in "arenas.bin.2.size"), the corresponding MIB component will always be that integer. Therefore, it is legitimate to construct code like the following:
    unsigned nbins, i; size_t mib[4]; size_t len, miblen; len = sizeof(nbins); mallctl("arenas.nbins", &nbins, &len, NULL, 0); miblen = 4; mallctlnametomib("arenas.bin.0.size", mib, &miblen); for (i = 0; i < nbins; i++) { size_t bin_size; mib[2] = i; len = sizeof(bin_size); mallctlbymib(mib, miblen, &bin_size, &len, NULL, 0); // Do something with bin_size... }
    Parameters:
    
    name - the namespace location
    
    mibp - an array of integers
    
    miblenp - the number of components in mibp
  - je_mallctlbymib
```
public static int je_mallctlbymib(PointerBuffer mib,
                                  java.nio.ByteBuffer oldp,
                                  PointerBuffer oldlenp,
                                  java.nio.ByteBuffer newp)
```
    Similar to mallctl, but uses MIBs instead of names. See mallctlnametomib for details.
    
    Parameters:
    
    mib - a MIB
    
    oldp - returns a value
    
    oldlenp - returns the value length
    
    newp - the new value
  - je_malloc_stats_print
```
public static void je_malloc_stats_print(MallocMessageCallbackI write_cb,
                                         java.nio.ByteBuffer je_cbopaque,
                                         java.nio.ByteBuffer opts)
```
    Writes human-readable summary statistics via the write_cb callback function pointer and cbopaque data passed to write_cb, or malloc_message() if write_cb is NULL. This function can be called repeatedly. General information that never changes during execution can be omitted by specifying "g" as a character within the opts string. Note that malloc_message() uses the mallctl*() functions internally, so inconsistent statistics can be reported if multiple threads use these functions simultaneously. If --enable-stats is specified during configuration, “m” and “a” can be specified to omit merged arena and per arena statistics, respectively; “b” and “l” can be specified to omit per size class statistics for bins and large objects, respectively. Unrecognized characters are silently ignored. Note that thread caching may prevent some statistics from being completely up to date, since extra locking would be required to merge counters that track thread cache operations.
    
    Parameters:
    
    write_cb - the print callback, or NULL to use malloc_message()
    
    je_cbopaque - an opaque pointer that will be passed to write_cb
    
    opts - an options string
  - je_malloc_stats_print
```
public static void je_malloc_stats_print(MallocMessageCallbackI write_cb,
                                         java.nio.ByteBuffer je_cbopaque,
                                         java.lang.CharSequence opts)
```
    Writes human-readable summary statistics via the write_cb callback function pointer and cbopaque data passed to write_cb, or malloc_message() if write_cb is NULL. This function can be called repeatedly. General information that never changes during execution can be omitted by specifying "g" as a character within the opts string. Note that malloc_message() uses the mallctl*() functions internally, so inconsistent statistics can be reported if multiple threads use these functions simultaneously. If --enable-stats is specified during configuration, “m” and “a” can be specified to omit merged arena and per arena statistics, respectively; “b” and “l” can be specified to omit per size class statistics for bins and large objects, respectively. Unrecognized characters are silently ignored. Note that thread caching may prevent some statistics from being completely up to date, since extra locking would be required to merge counters that track thread cache operations.
    
    Parameters:
    
    write_cb - the print callback, or NULL to use malloc_message()
    
    je_cbopaque - an opaque pointer that will be passed to write_cb
    
    opts - an options string
  - je_malloc_usable_size
```
public static long je_malloc_usable_size(java.nio.ByteBuffer ptr)
```
    Returns the usable size of the allocation pointed to by ptr. The return value may be larger than the size that was requested during allocation. The malloc_usable_size() function is not a mechanism for in-place realloc; rather it is provided solely as a tool for introspection purposes. Any discrepancy between the requested allocation size and the size reported by malloc_usable_size() should not be depended on, since such behavior is entirely implementation-dependent.
    
    Parameters:
    
    ptr - the allocated memory to query
  - je_free
```
public static void je_free(short[] ptr)
```
    short[] version of: free
  - je_free
```
public static void je_free(int[] ptr)
```
    int[] version of: free
  - je_free
```
public static void je_free(long[] ptr)
```
    long[] version of: free
  - je_free
```
public static void je_free(float[] ptr)
```
    float[] version of: free
  - je_free
```
public static void je_free(double[] ptr)
```
    double[] version of: free
  - je_dallocx
```
public static void je_dallocx(short[] ptr,
                              int flags)
```
    short[] version of: dallocx
  - je_dallocx
```
public static void je_dallocx(int[] ptr,
                              int flags)
```
    int[] version of: dallocx
  - je_dallocx
```
public static void je_dallocx(long[] ptr,
                              int flags)
```
    long[] version of: dallocx
  - je_dallocx
```
public static void je_dallocx(float[] ptr,
                              int flags)
```
    float[] version of: dallocx
  - je_dallocx
```
public static void je_dallocx(double[] ptr,
                              int flags)
```
    double[] version of: dallocx
  - je_sdallocx
```
public static void je_sdallocx(short[] ptr,
                               int flags)
```
    short[] version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(int[] ptr,
                               int flags)
```
    int[] version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(long[] ptr,
                               int flags)
```
    long[] version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(float[] ptr,
                               int flags)
```
    float[] version of: sdallocx
  - je_sdallocx
```
public static void je_sdallocx(double[] ptr,
                               int flags)
```
    double[] version of: sdallocx

Class JEmalloc

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getLibrary

je_malloc_message

je_malloc

je_calloc

je_posix_memalign

je_aligned_alloc

je_realloc

je_free

je_free

je_free

je_free

je_free

je_free

je_free

je_mallocx

je_rallocx

je_xallocx

je_sallocx

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_nallocx

je_mallctl

je_mallctl

je_mallctlnametomib

je_mallctlnametomib

je_mallctlbymib

je_malloc_stats_print

je_malloc_stats_print

je_malloc_usable_size

je_free

je_free

je_free

je_free

je_free

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_dallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx

je_sdallocx