VirtualMemoryUtil

Search an available range and allocate at least the requested amount of bytes. Do not confuse this method with allocate(long, int, int).

Allocate a memory range, filling gaps in between already allocated pages if needed. (The given range [address, address + size) may have already allocated pages. Those pages will not be re-allocated.) When the method returns, the range [address, address + size) is guaranteed to be allocated.

Facade factory method returning a concrete, private implementation of an efficient page-based virtual memory.

Dump a contiguous memory range of memory to a byte array. Illegal pages (non-allocated) are dumped as empty pages (all bytes are zero).

Dump a contiguous memory range of memory to a buffer. Illegal pages (non-allocated) are dumped as empty pages (all bytes are zero).

Dump a virtual memory to files in a folder. The files will be named [PREFIX][MEMORY_RANGE_START][SUFFIX].

Dump a virtual memory to files in a folder. The files will be named as the start of the memory range (in hex) they contain.

Search for an available memory range.

Search for a single byte of memory. Similar as memchr or memrchr (if `lastAddress` is less than `address`).

Search for bytes in memory, with an optional binary mask. The search can either be forward (default), in which case the resulting found address will be either -1 or ≥ the start address, or backward, in which case the resulting found address will be either -1 or ≤ the start address.

Create a copy-on-write shim of the provided virtual memory, if possible. The shim can be used to perform safe memory writes, that will not impact the underlying memory. Using a shim yields better performance than copying the entire source VM and working on the full copy.

Verify if a page was allocated (regardless of protection rights on the page).

Read a single byte and perform a zero-extension. This method does not raise MemoryException; on error, -1 is returned.

Read an integer (byte, short, int or long) and converts it to Long. Standard memory byte ordering is used for decoding.

Read a big-endian 32-bit integer.

Read a big-endian 64-bit integer.

Read a big-endian 16-bit integer.

Read an array of booleans from memory. Each entry occupies 1 byte of memory, the lower-significant bit of the byte indicates false(0) or true(1).

Read a byte safely (this method does not raise MemoryException).

Read an array of bytes from memory.

Safely read at most the requested amount of bytes.

Safely read at most the requested amount of bytes.

Read an array of chars from memory. Each entry occupies 2 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Read an array of doubles from memory. Each entry occupies 8 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Read an array of floats from memory. Each entry occupies 4 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Read a little-endian 32-bit integer using a specific byte ordering.

Read an array of ints from memory. Each entry occupies 4 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Read a little-endian 32-bit integer.

Read a little-endian 64-bit integer.

Read a little-endian 16-bit integer.

Read a little-endian 64-bit integer using a specific byte ordering.

Read an array of longs from memory. Each entry occupies 8 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Read from memory a series of ASCII characters, terminated by a null byte, and build the corresponding String. If no null-byte is found, the search stops at the provided maxSize.

This method does not raise MemoryException.

Read an array of bytes from memory (this method does not raise MemoryException).

Read a little-endian 16-bit integer using a specific byte ordering.

Read an array of shorts from memory. Each entry occupies 2 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Write an array of booleans to memory. Each entry occupies 1 byte whose value will be set to 0(false) or 1(true).

Write an 8-bit integer.

Write an array of bytes to memory.

Write an array of chars to memory. Each entry occupies 2 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Write an array of doubles to memory. Each entry occupies 8 bytes of memory. The encoding used is IEEE754. Byte ordering is determined from the virtual memory endianness setting.

Write an array of floats to memory. Each entry occupies 4 bytes of memory. The encoding used is IEEE754. Byte ordering is determined from the virtual memory endianness setting.

Write a little-endian 32-bit integer using a specific byte ordering.

Write an array of ints to memory. Each entry occupies 4 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Write a little-endian 32-bit integer.

Write a little-endian 64-bit integer.

Write a little-endian 16-bit integer.

Write a little-endian 64-bit integer using a specific byte ordering.

Write an array of longs to memory. Each entry occupies 8 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.

Write an array of bytes to memory (this method does not raise MemoryException).

Write a little-endian 16-bit integer using a specific byte ordering.

Write an array of shorts to memory. Each entry occupies 2 bytes of memory. Byte ordering is determined from the virtual memory endianness setting.