Class RPMallocConfig

  • All Implemented Interfaces:
    java.lang.AutoCloseable, org.lwjgl.system.NativeResource, org.lwjgl.system.Pointer

    public class RPMallocConfig
    extends org.lwjgl.system.Struct
    implements org.lwjgl.system.NativeResource
    This struct enables configuration of a memory mapper providing map/unmap of memory pages. Defaults to VirtualAlloc/mmap if none provided. This allows rpmalloc to be used in contexts where memory is provided by internal means.

    Page size may be set explicitly in initialization. This allows the allocator to be used as a sub-allocator where the page granularity should be lower to reduce risk of wasting unused memory ranges.

    If rpmalloc is built with ENABLE_GUARDS, memory_overwrite may be set to detect writes before or after allocated memory blocks. This is not enabled in the default LWJGL build.

    Layout

    
     struct rpmalloc_config_t {
         void * (*memory_map) (size_t size, size_t *offset);
         void (*memory_unmap) (void *address, size_t size, size_t offset, int release);
         void (*error_callback) (char const *message);
         int (*map_fail_callback) (size_t size);
         size_t page_size();
         size_t span_size();
         size_t span_map_count();
         int enable_huge_pages();
         char[4];
     }
    • Field Detail

      • SIZEOF

        The struct size in bytes.
      • ALIGNOF

        The struct alignment in bytes.
      • MEMORY_MAP, MEMORY_UNMAP, ERROR_CALLBACK, MAP_FAIL_CALLBACK, PAGE_SIZE, SPAN_SIZE, SPAN_MAP_COUNT, ENABLE_HUGE_PAGES

        The struct member offsets.
    • Constructor Detail

      • RPMallocConfig

        public RPMallocConfig​(java.nio.ByteBuffer container)
        Creates a RPMallocConfig instance at the current position of the specified ByteBuffer container. Changes to the buffer's content will be visible to the struct instance and vice versa.

        The created instance holds a strong reference to the container object.

    • Method Detail

      • sizeof

        public int sizeof()
        Specified by:
        sizeof in class org.lwjgl.system.Struct
      • memory_map

        @Nullable
        public RPMemoryMapCallback memory_map()
        the memory map callback function
      • memory_unmap

        @Nullable
        public RPMemoryUnmapCallback memory_unmap()
        the memory unmap callback function
      • error_callback

        @Nullable
        public RPErrorCallback error_callback()
        the error callback function
      • map_fail_callback

        @Nullable
        public RPMapFailCallback map_fail_callback()
        the map fail callback function
      • page_size

        public long page_size()
        the size of memory pages.

        The page size MUST be a power of two in [512,16384] range (29 to 214) unless 0 - set to 0 to use system page size. All memory mapping requests to memory_map will be made with size set to a multiple of the page size.

        Used if RPMALLOC_CONFIGURABLE is defined to 1, otherwise system page size is used.

      • span_size

        public long span_size()
        size of a span of memory blocks.

        MUST be a power of two, and in [4096,262144] range (unless 0 - set to 0 to use the default span size).

        Used if RPMALLOC_CONFIGURABLE is defined to 1.

      • span_map_count

        public long span_map_count()
        number of spans to map at each request to map new virtual memory blocks.

        This can be used to minimize the system call overhead at the cost of virtual memory address space. The extra mapped pages will not be written until actually used, so physical committed memory should not be affected in the default implementation.

        Will be aligned to a multiple of spans that match memory page size in case of huge pages.

      • enable_huge_pages

        public boolean enable_huge_pages()
        enable use of large/huge pages.

        If this flag is set to non-zero and page size is zero, the allocator will try to enable huge pages and auto detect the configuration. If this is set to non-zero and page_size is also non-zero, the allocator will assume huge pages have been configured and enabled prior to initializing the allocator.

        For Windows, see large-page-support. For Linux, see hugetlbpage.txt.

      • set

        public RPMallocConfig set​(RPMallocConfig src)
        Copies the specified struct data to this struct.
        Parameters:
        src - the source struct
        Returns:
        this struct
      • malloc

        public static RPMallocConfig malloc()
        Returns a new RPMallocConfig instance allocated with memAlloc. The instance must be explicitly freed.
      • calloc

        public static RPMallocConfig calloc()
        Returns a new RPMallocConfig instance allocated with memCalloc. The instance must be explicitly freed.
      • create

        public static RPMallocConfig create()
        Returns a new RPMallocConfig instance allocated with BufferUtils.
      • create

        public static RPMallocConfig create​(long address)
        Returns a new RPMallocConfig instance for the specified memory address.
      • createSafe

        @Nullable
        public static RPMallocConfig createSafe​(long address)
        Like create, but returns null if address is NULL.
      • mallocStack

        @Deprecated
        public static RPMallocConfig mallocStack​(org.lwjgl.system.MemoryStack stack)
        Deprecated.
        Deprecated for removal in 3.4.0. Use malloc(MemoryStack) instead.
      • callocStack

        @Deprecated
        public static RPMallocConfig callocStack​(org.lwjgl.system.MemoryStack stack)
        Deprecated.
        Deprecated for removal in 3.4.0. Use calloc(MemoryStack) instead.
      • malloc

        public static RPMallocConfig malloc​(org.lwjgl.system.MemoryStack stack)
        Returns a new RPMallocConfig instance allocated on the specified MemoryStack.
        Parameters:
        stack - the stack from which to allocate
      • calloc

        public static RPMallocConfig calloc​(org.lwjgl.system.MemoryStack stack)
        Returns a new RPMallocConfig instance allocated on the specified MemoryStack and initializes all its bits to zero.
        Parameters:
        stack - the stack from which to allocate
      • npage_size

        public static long npage_size​(long struct)
        Unsafe version of page_size().
      • nspan_size

        public static long nspan_size​(long struct)
        Unsafe version of span_size().
      • nspan_map_count

        public static long nspan_map_count​(long struct)
        Unsafe version of span_map_count().
      • nenable_huge_pages

        public static int nenable_huge_pages​(long struct)
        Unsafe version of enable_huge_pages().
      • npage_size

        public static void npage_size​(long struct,
                                      long value)
        Unsafe version of page_size.
      • nspan_size

        public static void nspan_size​(long struct,
                                      long value)
        Unsafe version of span_size.
      • nspan_map_count

        public static void nspan_map_count​(long struct,
                                           long value)
        Unsafe version of span_map_count.
      • nenable_huge_pages

        public static void nenable_huge_pages​(long struct,
                                              int value)
        Unsafe version of enable_huge_pages.