de.ruedigermoeller.heapoff.structs

Class FSTStructAllocator

java.lang.Object

de.ruedigermoeller.heapoff.structs.FSTStructAllocator

Direct Known Subclasses:

FSTTypedStructAllocator

public class FSTStructAllocator
extends Object

Copyright (c) 2012, Ruediger Moeller. All rights reserved.

This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

Date: 04.10.13 Time: 20:51 To change this template use File | Settings | File Templates.

Field Summary

Fields

Modifier and Type	Field and Description
protected Bytez	chunk
protected int	chunkIndex
protected int	chunkSize

Constructor Summary

Constructors

Modifier	Constructor and Description
protected	FSTStructAllocator()
	FSTStructAllocator(int chunkSizeBytes) Create a Heap-Byte Array Structallocator with given chunk size in bytes.
	FSTStructAllocator(int chunkSizeBytes, BytezAllocator allocator) optionally uses another allocator (e.g. for Real Off Heap with MallocBytez) Warning: Currently there is not automatic free for OffHeap Bytez, so only use for statically allocated structures.

Method Summary

Methods

Modifier and Type	Method and Description
protected static <C extends FSTStruct> Object	allocInstance(Class<C> clazz)
static FSTStruct	createStructPointer(Bytez b, int index)
void	free() frees associated offheap memory, in case making objects created INVALID (Access violation!).
protected FSTStructFactory	getFactory()
static FSTStruct	getVolatileStructPointer(Bytez b, int index)
<X extends FSTStruct> StructArray<X>	newArray(int size, X templ) create a new struct array of same type as template
<X extends FSTStruct> StructArray<X>	newArray(int size, X templ, BytezAllocator alloc) create a new struct array of same type as template
<K extends FSTStruct,V extends FSTStruct> StructMap<K,V>	newMap(int size, K keyTemplate, V valueTemplate) create a fixed size struct hashmap.
static <C extends FSTStruct> C	newPointer(Class<C> clazz)
<S extends FSTStruct> S	newStruct(S aTemplate) allocate a Struct instance from an arbitrary template instance.
<S extends FSTStruct> S	newStruct(S aTemplate, BytezAllocator alloc)
static <T extends FSTStruct> T	toStruct(T onHeapTemplate)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

chunkSize

protected int chunkSize

chunk

protected Bytez chunk

chunkIndex

protected int chunkIndex

Constructor Detail

FSTStructAllocator

protected FSTStructAllocator()

FSTStructAllocator

public FSTStructAllocator(int chunkSizeBytes)

Create a Heap-Byte Array Structallocator with given chunk size in bytes. If allocated structs are larger than the given size, a new bytearray is created for the allocation.

Parameters:

chunkSizeBytes -

FSTStructAllocator

public FSTStructAllocator(int chunkSizeBytes,
                  BytezAllocator allocator)

optionally uses another allocator (e.g. for Real Off Heap with MallocBytez) Warning: Currently there is not automatic free for OffHeap Bytez, so only use for statically allocated structures. You can call free() to release all offheap structures allocated by this instance, however you'll get crashes if there are still references from y

Parameters:

chunkSizeBytes - - set to a reasonable size, memory is allocated in thes chunk sizes. If very small, each struct alloc will result in its individual chunk being allocated.

allocator -

Method Detail

createStructPointer

public static FSTStruct createStructPointer(Bytez b,
                            int index)

Parameters:

b -

index -

Returns:

a new allocated pointer matching struct type stored in b[]

toStruct

public static <T extends FSTStruct> T toStruct(T onHeapTemplate)

Type Parameters:

T -

Parameters:

onHeapTemplate -

Returns:

return a byte array based struct instance for given on-heap template. Allocates a new byte[] with each call

getVolatileStructPointer

public static FSTStruct getVolatileStructPointer(Bytez b,
                                 int index)

Parameters:

b -

index -

Returns:

a pointer matching struct type stored in b[] from the thread local cache

newPointer

public static <C extends FSTStruct> C newPointer(Class<C> clazz)

Type Parameters:

C -

Parameters:

clazz -

Returns:

a newly allocated pointer matching. use baseOn to point it to a meaningful location

allocInstance

protected static <C extends FSTStruct> Object allocInstance(Class<C> clazz)
                               throws Exception

Throws:

Exception

newArray

public <X extends FSTStruct> StructArray<X> newArray(int size,
                                            X templ)

create a new struct array of same type as template

Parameters:

size -

Returns:

newArray

public <X extends FSTStruct> StructArray<X> newArray(int size,
                                            X templ,
                                            BytezAllocator alloc)

create a new struct array of same type as template

Parameters:

size -

Returns:

free

public void free()

frees associated offheap memory, in case making objects created INVALID (Access violation!). is a noop for on heap byte array allocator

newMap

public <K extends FSTStruct,V extends FSTStruct> StructMap<K,V> newMap(int size,
                                                              K keyTemplate,
                                                              V valueTemplate)

create a fixed size struct hashmap. Note it should be of fixed types for keys and values, as the space for those is allocated directly. Additionally keys and values are stored 'in-place' without references. (for allocation if templateless cosntructore has been used)

Type Parameters:

K -

Parameters:

size -

keyTemplate -

Returns:

newStruct

public <S extends FSTStruct> S newStruct(S aTemplate)

allocate a Struct instance from an arbitrary template instance.

Type Parameters:

S -

Parameters:

aTemplate -

Returns:

newStruct

public <S extends FSTStruct> S newStruct(S aTemplate,
                                BytezAllocator alloc)

getFactory

protected FSTStructFactory getFactory()