Memory (Jikes RVM API)

java.lang.Object
- org.jikesrvm.runtime.Memory

```
public class Memory
extends Object
```
Low level memory management functions.
Note that this class is "uninterruptible" - calling its methods will never cause the current thread to yield the CPU to another thread (one that might cause a GC, for example).

Field Summary

Fields
Modifier and Type	Field and Description
`private static int`	`BYTES_IN_COPY` Number of bytes used when copying larger chunks of memory.
`static int`	`MAP_ANONYMOUS`
`static int`	`MAP_FIXED`
`static int`	`MAP_PRIVATE`
`private static int`	`NATIVE_THRESHOLD` How many bytes is considered large enough to justify the transition to C code to use memcpy?
`private static int`	`pagesize`
`private static int`	`pagesizeLog`
`static int`	`PROT_EXEC`
`static int`	`PROT_NONE`
`static int`	`PROT_READ`
`static int`	`PROT_WRITE`
`private static int`	`UNKNOWN`
`private static boolean`	`USE_NATIVE` Allow the use of C based memcpy

Constructor Summary

Constructors
Constructor and Description

Memory()

Constructors
Constructor and Description
`Memory()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Address`	`alignDown(Address address, int alignment)`
`static int`	`alignDown(int address, int alignment)`
`static void`	`aligned16Copy(Address dstPtr, Address srcPtr, int copyBytes)` Low level copy of `copyBytes` bytes from `src[srcPos]` to `dst[dstPos]`.
`static void`	`aligned32Copy(Address dst, Address src, int copyBytes)` Copy copyBytes from src to dst.
`static void`	`aligned64Copy(Address dstPtr, Address srcPtr, int copyBytes)` Low level copy of `copyBytes` bytes from `src[srcPos]` to `dst[dstPos]`.
`static void`	`aligned8Copy(Address dstPtr, Address srcPtr, int copyBytes)` Low level copy of `copyBytes` bytes from `src[srcPos]` to `dst[dstPos]`.
`static void`	`alignedWordCopy(Address dst, Address src, int numBytes)` Copy numbytes from src to dst.
`static Address`	`alignUp(Address address, int alignment)`
`static int`	`alignUp(int address, int alignment)`
`static void`	`arraycopy16Bit(Object src, int srcPos, Object dst, int dstPos, int len)` Low level copy of len elements from src[srcPos] to dst[dstPos].
`static void`	`arraycopy32Bit(Object src, int srcIdx, Object dst, int dstIdx, int len)` Low level copy of `len` elements from `src[srcPos]` to `dst[dstPos]`.
`static void`	`arraycopy64Bit(Object src, int srcIdx, Object dst, int dstIdx, int len)` Low level copy of `len` elements from `src[srcPos]` to `dst[dstPos]`.
`static void`	`arraycopy8Bit(Object src, int srcPos, Object dst, int dstPos, int len)` Low level copy of len elements from src[srcPos] to dst[dstPos].
`private static void`	`copy1Bytes(Address dstPtr, Address srcPtr)`
`private static void`	`copy2Bytes(Address dstPtr, Address srcPtr)`
`private static void`	`copy4Bytes(Address dstPtr, Address srcPtr)`
`private static void`	`copy8Bytes(Address dstPtr, Address srcPtr)`
`static void`	`dumpMemory(Address start, int beforeBytes, int afterBytes)`
`static Address`	`dzmmap(Address address, Extent size)` Do mmap demand zero fixed address memory mapping call
`(package private) static int`	`getNativeThreshold()` For use in test cases only.
`static int`	`getPagesize()`
`static int`	`getPagesizeLog()`
`static byte`	`getPagesizeLogAsByte()`
`private static void`	`internalAlignedWordCopy(Address dst, Address src, int numBytes)` Copy `numbytes` from `src` to `dst`.
`static boolean`	`isPageAligned(Address addr)`
`static boolean`	`isPageMultiple(Extent val)`
`static boolean`	`isPageMultiple(int val)`
`static boolean`	`isPageMultiple(Offset val)`
`static void`	`memcopy(Address dst, Address src, Extent cnt)` Copies a region of memory.
`static void`	`memcopy(Address dst, Address src, int cnt)` Wrapper method for `memcopy(Address, Address, Extent)`.
`static Address`	`mmap(Address address, Extent size, int prot, int flags)` Do generic mmap non-file memory mapping call
`static boolean`	`mprotect(Address address, Extent size, int prot)` Do mprotect system call
`static void`	`setPageSize(Extent pageSizeFromBootRecord)` Sets the page size.
`static void`	`sync(Address address, int size)` Synchronize a region of memory: force data in dcache to be written out to main memory so that it will be seen by icache when instructions are fetched back.
`static void`	`zero(boolean useNT, Address start, Extent len)` Zero a region of memory.

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

- Field Detail
  - UNKNOWN
```
private static final int UNKNOWN
```
    See Also:
    
    Constant Field Values
  - NATIVE_THRESHOLD
```
private static final int NATIVE_THRESHOLD
```
    How many bytes is considered large enough to justify the transition to C code to use memcpy?
    
    See Also:
    
    Constant Field Values
  - USE_NATIVE
```
private static final boolean USE_NATIVE
```
    Allow the use of C based memcpy
    
    See Also:
    
    Constant Field Values
  - BYTES_IN_COPY
```
private static final int BYTES_IN_COPY
```
    Number of bytes used when copying larger chunks of memory. Normally 8 bytes except on x87 Intel
    
    See Also:
    
    Constant Field Values
  - PROT_NONE
```
public static final int PROT_NONE
```
    See Also:
    
    Constant Field Values
  - PROT_READ
```
public static final int PROT_READ
```
    See Also:
    
    Constant Field Values
  - PROT_WRITE
```
public static final int PROT_WRITE
```
    See Also:
    
    Constant Field Values
  - PROT_EXEC
```
public static final int PROT_EXEC
```
    See Also:
    
    Constant Field Values
  - MAP_PRIVATE
```
public static final int MAP_PRIVATE
```
    See Also:
    
    Constant Field Values
  - MAP_FIXED
```
public static final int MAP_FIXED
```
    See Also:
    
    Constant Field Values
  - MAP_ANONYMOUS
```
public static final int MAP_ANONYMOUS
```
    See Also:
    
    Constant Field Values
  - pagesize
```
private static int pagesize
```
  - pagesizeLog
```
private static int pagesizeLog
```
- Constructor Detail
  - Memory
```
public Memory()
```
- Method Detail
  - copy8Bytes
```
private static void copy8Bytes(Address dstPtr,
                               Address srcPtr)
```
  - copy4Bytes
```
private static void copy4Bytes(Address dstPtr,
                               Address srcPtr)
```
  - copy2Bytes
```
private static void copy2Bytes(Address dstPtr,
                               Address srcPtr)
```
  - copy1Bytes
```
private static void copy1Bytes(Address dstPtr,
                               Address srcPtr)
```
  - arraycopy8Bit
```
public static void arraycopy8Bit(Object src,
                                 int srcPos,
                                 Object dst,
                                 int dstPos,
                                 int len)
```
    Low level copy of len elements from src[srcPos] to dst[dstPos]. Assumptions: src != dst || (scrPos >= dstPos + 4) and src and dst are 8Bit arrays.
    
    Parameters:
    
    src - the source array
    
    srcPos - index in the source array to begin copy
    
    dst - the destination array
    
    dstPos - index in the destination array to being copy
    
    len - number of array elements to copy
  - aligned8Copy
```
public static void aligned8Copy(Address dstPtr,
                                Address srcPtr,
                                int copyBytes)
```
    Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos]. Assumption src != dst || (srcPos >= dstPos) and element size is 4 bytes.
    
    Parameters:
    
    dstPtr - The destination start address
    
    srcPtr - The source start address
    
    copyBytes - The number of bytes to be copied
  - arraycopy16Bit
```
public static void arraycopy16Bit(Object src,
                                  int srcPos,
                                  Object dst,
                                  int dstPos,
                                  int len)
```
    Low level copy of len elements from src[srcPos] to dst[dstPos].
    Assumption; src != dst || (srcPos >= dstPos + 2).
    
    Parameters:
    
    src - the source array
    
    srcPos - index in the source array to begin copy
    
    dst - the destination array
    
    dstPos - index in the destination array to being copy
    
    len - number of array elements to copy
  - aligned16Copy
```
public static void aligned16Copy(Address dstPtr,
                                 Address srcPtr,
                                 int copyBytes)
```
    Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos].
    Assumption: src != dst || (srcPos >= dstPos) and element size is 2 bytes.
    
    Parameters:
    
    dstPtr - The destination start address
    
    srcPtr - The source start address
    
    copyBytes - The number of bytes to be copied
  - arraycopy32Bit
```
public static void arraycopy32Bit(Object src,
                                  int srcIdx,
                                  Object dst,
                                  int dstIdx,
                                  int len)
```
    Low level copy of len elements from src[srcPos] to dst[dstPos].
    Assumption: src != dst || (srcPos >= dstPos) and element size is 4 bytes.
    
    Parameters:
    
    src - the source array
    
    srcIdx - index in the source array to begin copy
    
    dst - the destination array
    
    dstIdx - index in the destination array to being copy
    
    len - number of array elements to copy
  - arraycopy64Bit
```
public static void arraycopy64Bit(Object src,
                                  int srcIdx,
                                  Object dst,
                                  int dstIdx,
                                  int len)
```
    Low level copy of len elements from src[srcPos] to dst[dstPos].
    Assumption: src != dst || (srcPos >= dstPos) and element size is 8 bytes.
    
    Parameters:
    
    src - the source array
    
    srcIdx - index in the source array to begin copy
    
    dst - the destination array
    
    dstIdx - index in the destination array to being copy
    
    len - number of array elements to copy
  - aligned64Copy
```
public static void aligned64Copy(Address dstPtr,
                                 Address srcPtr,
                                 int copyBytes)
```
    Low level copy of copyBytes bytes from src[srcPos] to dst[dstPos]. Assumption src != dst || (srcPos >= dstPos) and element size is 8 bytes.
    
    Parameters:
    
    dstPtr - The destination start address
    
    srcPtr - The source start address
    
    copyBytes - The number of bytes to be copied
  - aligned32Copy
```
public static void aligned32Copy(Address dst,
                                 Address src,
                                 int copyBytes)
```
    Copy copyBytes from src to dst. Assumption: either the ranges are non overlapping, or src >= dst + 4. Also, src and dst are 4 byte aligned and numBytes is a multiple of 4.
    
    Parameters:
    
    dst - the destination addr
    
    src - the source addr
    
    copyBytes - the number of bytes top copy
  - alignedWordCopy
```
public static void alignedWordCopy(Address dst,
                                   Address src,
                                   int numBytes)
```
    Copy numbytes from src to dst. Assumption: either the ranges are non overlapping, or src >= dst + BYTES_IN_ADDRESS. Also, src and dst are word aligned and numBytes is a multiple of BYTES_IN_ADDRESS.
    
    Parameters:
    
    dst - the destination addr
    
    src - the source addr
    
    numBytes - the number of bytes top copy
  - internalAlignedWordCopy
```
private static void internalAlignedWordCopy(Address dst,
                                            Address src,
                                            int numBytes)
```
    Copy numbytes from src to dst. Assumption either the ranges are non overlapping, or src >= dst + BYTES_IN_ADDRESS.
    
    Parameters:
    
    dst - The destination addr
    
    src - The source addr
    
    numBytes - The number of bytes to copy
  - memcopy
```
public static void memcopy(Address dst,
                           Address src,
                           Extent cnt)
```
    Copies a region of memory.
    
    Parameters:
    
    dst - Destination address
    
    src - Source address
    
    cnt - Number of bytes to copy
  - memcopy
```
public static void memcopy(Address dst,
                           Address src,
                           int cnt)
```
    Wrapper method for memcopy(Address, Address, Extent).
    
    Parameters:
    
    dst - Destination address
    
    src - Source address
    
    cnt - Number of bytes to copy
  - zero
```
public static void zero(boolean useNT,
                        Address start,
                        Extent len)
```
    Zero a region of memory.
    
    Parameters:
    
    useNT - use non-temporal instructions (if available)
    
    start - of address range (inclusive)
    
    len - extent to zero.
  - sync
```
public static void sync(Address address,
                        int size)
```
    Synchronize a region of memory: force data in dcache to be written out to main memory so that it will be seen by icache when instructions are fetched back.
    
    Parameters:
    
    address - Start of address range
    
    size - Size of address range (bytes)
  - isPageMultiple
```
public static boolean isPageMultiple(int val)
```
  - isPageMultiple
```
public static boolean isPageMultiple(Extent val)
```
  - isPageMultiple
```
public static boolean isPageMultiple(Offset val)
```
  - isPageAligned
```
public static boolean isPageAligned(Address addr)
```
  - mmap
```
public static Address mmap(Address address,
                           Extent size,
                           int prot,
                           int flags)
```
    Do generic mmap non-file memory mapping call
    
    Parameters:
    
    address - Start of address range (Address)
    
    size - Size of address range
    
    prot - Protection (int)
    
    flags - (int)
    
    Returns:
    
    Address (of region) if successful; errno (1 to 127) otherwise
  - dzmmap
```
public static Address dzmmap(Address address,
                             Extent size)
```
    Do mmap demand zero fixed address memory mapping call
    
    Parameters:
    
    address - Start of address range
    
    size - Size of address range
    
    Returns:
    
    Address (of region) if successful; errno (1 to 127) otherwise
  - mprotect
```
public static boolean mprotect(Address address,
                               Extent size,
                               int prot)
```
    Do mprotect system call
    
    Parameters:
    
    address - Start of address range (Address)
    
    size - Size of address range
    
    prot - Protection (int)
    
    Returns:
    
    true iff success
  - setPageSize
```
public static void setPageSize(Extent pageSizeFromBootRecord)
```
    Sets the page size.
    Note: this method may only be called once, at boot time. Multithreading is not yet enabled at this point, so no synchronization is necessary.
    
    Parameters:
    
    pageSizeFromBootRecord - the page size
  - getPagesize
```
public static int getPagesize()
```
  - getPagesizeLog
```
public static int getPagesizeLog()
```
  - getPagesizeLogAsByte
```
public static byte getPagesizeLogAsByte()
```
  - dumpMemory
```
public static void dumpMemory(Address start,
                              int beforeBytes,
                              int afterBytes)
```
  - alignUp
```
public static Address alignUp(Address address,
                              int alignment)
```
  - alignDown
```
public static Address alignDown(Address address,
                                int alignment)
```
  - alignUp
```
public static int alignUp(int address,
                          int alignment)
```
  - alignDown
```
public static int alignDown(int address,
                            int alignment)
```
  - getNativeThreshold
```
static int getNativeThreshold()
```
    For use in test cases only.
    
    Returns:
    
    native threshold (number in bytes before copying uses C code)

Class Memory

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

UNKNOWN

NATIVE_THRESHOLD

USE_NATIVE

BYTES_IN_COPY

PROT_NONE

PROT_READ

PROT_WRITE

PROT_EXEC

MAP_PRIVATE

MAP_FIXED

MAP_ANONYMOUS

pagesize

pagesizeLog

Constructor Detail

Memory

Method Detail

copy8Bytes

copy4Bytes

copy2Bytes

copy1Bytes

arraycopy8Bit

aligned8Copy

arraycopy16Bit

aligned16Copy

arraycopy32Bit

arraycopy64Bit

aligned64Copy

aligned32Copy

alignedWordCopy

internalAlignedWordCopy

memcopy

memcopy

zero

sync

isPageMultiple

isPageMultiple

isPageMultiple

isPageAligned

mmap

dzmmap

mprotect

setPageSize

getPagesize

getPagesizeLog

getPagesizeLogAsByte

dumpMemory

alignUp

alignDown

alignUp

alignDown

getNativeThreshold