ArenaAllocator

java.lang.Object
- one.nio.mem.ArenaAllocator

All Implemented Interfaces:

Allocator
```
public class ArenaAllocator
extends java.lang.Object
implements Allocator
```
Fast arena-based allocator that does not suffer from fragmentation. Individual objects cannot be released; arena is disposed all at once.

Nested Class Summary

Nested Classes
Modifier and Type Class Description

(package private) static class ArenaAllocator.Arena

Field Summary

Fields
Modifier and Type Field Description

private long accumulatedBytes

private ArenaAllocator.Arena current

private static long MIN_ARENA_SIZE

Constructor Summary

Constructors
Constructor Description

ArenaAllocator()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`long`	`calloc(int size)`
`void`	`free(long address)`
`long`	`getAllocatedBytes()`
`protected long`	`getMemoryFromSystem(long size)`
`private ArenaAllocator.Arena`	`getNextArena(ArenaAllocator.Arena current, long size)`
`long`	`getReservedBytes()`
`long`	`malloc(int size)`
`void`	`release()`
`protected void`	`releaseMemoryToSystem(long addr, long size)`
`void`	`verify()`	Verify the layout of the heap.

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

Field Detail

MIN_ARENA_SIZE
```
private static final long MIN_ARENA_SIZE
```
See Also:

Constant Field Values

current

private volatile ArenaAllocator.Arena current

accumulatedBytes
```
private long accumulatedBytes
```

Constructor Detail
- ArenaAllocator
```
public ArenaAllocator()
```

Method Detail

release
```
public void release()
```

malloc
```
public long malloc(int size)
```
Specified by:

malloc in interface Allocator

calloc
```
public long calloc(int size)
```
Specified by:

calloc in interface Allocator

free
```
public void free(long address)
```
Specified by:

free in interface Allocator

verify
```
public void verify()
```
Description copied from interface: Allocator

Verify the layout of the heap. Expensive operation, used only for debugging purposes.

Specified by:

verify in interface Allocator

getNextArena

private ArenaAllocator.Arena getNextArena(ArenaAllocator.Arena current,
                                          long size)

getMemoryFromSystem

protected long getMemoryFromSystem(long size)

releaseMemoryToSystem

protected void releaseMemoryToSystem(long addr,
                                     long size)

getAllocatedBytes
```
public long getAllocatedBytes()
```

getReservedBytes
```
public long getReservedBytes()
```