2005/5/9

acdk::lang::sys Namespace Reference

Detailed Description

Compounds
class	AbstractAllocator
	The AbstractAllocator allocates for Object types a little bit memory, where the beginning of the allocated block a pointer to the Allocator can be found. More...
class	Allocator
	API: ACDK Heaps that manages memory An Allocator has a little overhead:. More...
struct	AllocatorElement
	contains information about a allocated memory More...
union	AllocatorElement::Mem
class	AllocatorInfo
class	AllocatorObjectsIterator
struct	AllocTypeInfo
class	BackTrace
class	BitmapPage
class	BitmapPagedAllocator
class	BitmapPagedHeap
class	BoehmGC
struct	BoehmGC::Functions
class	BoehmGCAllocator
class	BoehmGCHeapFrame
class	core_abstractmutex
class	core_atomicop
	This is the internal implementation of an atomic operation. More...
class	core_condition
struct	core_endline
class	core_fastmutex
	This mutex is a simple fast mutex to protect static code. More...
class	core_flathashmap
	very basic & specialized implementation of an hashmap hashmap. More...
struct	core_flathashmap::container
class	core_lock_guard
	provides a lock guard used to control lock()/unlock on the stack in exception save way More...
class	core_memcheck
	Class to Check Memory usage in a scope. More...
class	core_memtrace
struct	core_memtrace::MergedTrace
class	core_mutex
	This is the internal implementation of a recursiv mutex. More...
class	core_output
	used for output, if System::out/err is not available More...
struct	core_pair
	Duplicate of std::pair struct. More...
class	core_recursivemutex
class	core_semaphore
class	core_setbit_leave_scope
	set the bit when leaving scope More...
class	core_setbit_scope
class	core_sharedlib
class	core_specific
class	core_stack
	Basic stack based on core_vector. More...
class	core_stack_scope
	use core_vector stack as scope. More...
class	core_static_lock_guard
	Use this to lock a static defined mutex This implementation looks, if the lock would be tried outside of main() (than it would fail on some plattforms). More...
class	core_static_vector
	Static versoin (fixed number of elements) of a vector<T>. More...
class	core_string
	a 'very core' string More...
class	core_substring
	mainly used to operate on literal strings More...
class	core_system
	implements a basic system wrapper More...
class	core_thread_id
class	core_tick
struct	core_tracemem
class	core_unlock_guard
	provides a lock guard used to control unlock()/lock on the stack in exception save way More...
class	core_value_scope
	helper to wrap a basic type value into a scope More...
class	core_vector
	replacement for the std::vector class. More...
class	core_vector_reverse_iterator
	reverse iterator vor core_vector More...
class	core_winimage
struct	core_winimage::FallbackInfoResult
struct	core_winimage::SymbolResult
class	Garbage_Heap
	This heap does only Reference Counting without Garbage Collecting. More...
class	hashmap_iterator
class	HeapFrame
	HeapFrame declares just an abstrakt interface Please refer to class ObjectHeap for more detailed information. More...
struct	HeapLockMutex
	different to static_mutex it only locks/unlock if System::isInMain() is true More...
class	LocalGcHeap
	internal API More...
struct	LocalGcHeap::SharedOwnedValue
class	LockObjectHeap
struct	MemChunkHeader
	uses by Allocator More...
class	ObjectHeap
class	PagedAllocator
class	PagedAllocatorPage
class	PagedAllocatorPageSlot
class	PagedHeap
class	RawAllocator
	This is a thin wrapper to raw allocation used by RC_Heap. More...
class	RawPage
class	RC_GC_Heap
class	RC_Heap
	This heap does only Reference Counting without Garbage Collecting. More...
class	ReferedMap
struct	ReferedMapValue
class	Referer
class	specific
class	StackHeap
class	static_specific
	the static_specific represents a thread local pointer to T T must have a public constructor with no arguments if called in main and ACDK_SUPPORT_STATIC_THREADLOCAL is defined it uses a the fast implementation of static TLS Otherwise it uses slower specific<T> implementation if called outside main it uses just a normal instance More...
class	StaticObjectWrapper
	In case an Object has to be defined statically, this class helps to manage initialization and deinitialion order. More...
class	StaticObjectWrapper1
class	StaticObjectWrapper2
class	SysObject
	SysObject is the base of reference counted Sysobjects. More...
class	SysStaticMutexLockGuard
class	SysStaticMutexUnLockGuard
class	TracedRawAllocator
class	TracedRawAllocatorInfo
class	TracedRawAllocatorIterator
Typedefs
typedef core_vector< Object * >	ObjectPtrVector
typedef core_vector< RObject * >	ObjectRefPtrVector
typedef void(*	GC_finalization_proc )(void *obj, void *client_data)
typedef void(*	GC_warn_proc )(char *msg, unsigned long arg)
typedef core_fastmutex	static_mutex
typedef clock_t	tick_t
typedef short	PagedAllocatorPageSlotFlags
typedef core_fastmutex	PageMutex
Enumerations
enum	AllocatorTypeFlags {   StandardAllocatorType = 0x0000, StackObjectAllocatorType = 0x0001, SupportListObjectAllocatorType = 0x0004, NoSyncAllocatorType = 0x0008,   NoRefCountAllocatorType = 0x0010, ManualGcAllocatorType = 0x0020, AutoGcAllocatorType = 0x0040 }
	information about the given allocator More...
enum	MemTraceReportFlags {   MTRFRecursive = 0x0001, MTRFMergeSameBt = 0x0002, MTRFRootsOnly = 0x0004, MTRFUnfreed = 0x0008,   MTRFNoStatics = 0x0010 }
	used by core_memtrace to report objects More...
enum	ExecutionState { BeforeMain = 0, InMain = 1, AfterMain = 2, InSignalHandler = 3 }
	This class encapsulate some very basic initializations. More...
enum	HeapInfo {   HeapIsUnknown = 0, HeapIsGlobal = 0x00000001, HeapIsStatic = 0x00000002, HeapIsThread = 0x00000004,   HeapTraceObjects = 0x00000010, HeapHasRC = 0x00000020, HeapHasGC = 0x00000040, HeapIsConsGC = 0x00000100 }
enum	AllocatedType {   UnspecifiedMem = 0x0, RawMem = 0x1, ObjectMem = 0x2, InternalMem = 0x3,   ObjectRefArrayMem = 0x4, DumpBufferMem = 0x5, NoGcMem = 0x6, MaxAllocatedType = 0x5 }
enum	ListObjectsFlags { AllocatedTypeMask = 0x0F, ListObjectsRecursive = 0x10, ListRootsOnly = 0x20, ListGcAble = 0x40 }
	flags which be used in HeapFrame::listObjects More...
Functions
	ACDK_DECL_SYS_CLASS (Allocator)
	ACDK_DECL_SYS_CLASS (AbstractAllocator)
	ACDK_DECL_SYS_CLASS (RawAllocator)
bool	doGc (Allocator *allocator, AllocatorObjectsIterator *iterator, bool recursiv)
	do a mark sweep on objects.
void	markMemberObjects (AllocatorObjectsIterator *iterator)
	mark all members of the objects unmarked objects are root objects
void	unmarkAndUnvisitedAll (AllocatorObjectsIterator *iterator)
	reset mark and visited flags
void	markMembers (Object *obj)
	mark all members of this object
void	genericListObject (HeapFrame *frame, AllocatorObjectsIterator *iterator,::acdk::lang::ref::NotifyObjectEventListener *listener, int flags)
bool	_valid (const Object *o)
	ACDK_DECL_SYS_CLASS (BitmapPagedAllocator)
	ACDK_DECL_SYS_CLASS (BoehmGCAllocator)
template<class First, class Second> core_pair< First, Second >	core_make_pair (const First &f, const Second &s)
int ACDK_CORE_PUBLIC	core_get_next_prim (int num)
	get next greater int whis is prim implementation in core_system.cpp
bool ACDK_CORE_PUBLIC	core_is_prim (int num)
void ACDK_CORE_PUBLIC	core_vector_throw_out_of_index (int size, int idx)
template<typename T> core_vector< T >	make_core_vector (const T &t1, const T &t2, const T &t3)
template<typename T> core_vector< T >	make_core_vector (const T &t1, const T &t2)
template<typename T> core_vector< T >	make_core_vector (const T &t1)
	ACDK_DECL_SYS_CLASS (HeapFrame)
PageMutex &	_pageLock ()
	ACDK_DECL_SYS_CLASS (PagedAllocator)
	ACDK_DECL_SYS_CLASS (TracedRawAllocator)
Variables
bool	acdk_core_BoundStatic
ACDK_CORE_PUBLIC core_endline	eofl
ACDK_CORE_PUBLIC core_output	coreout
const int	_noMenLandSize = 8
const char	_noMenLandMask = 0xee

Typedef Documentation

typedef void(* acdk::lang::sys::GC_finalization_proc)(void* obj, void* client_data)

typedef void(* acdk::lang::sys::GC_warn_proc)(char *msg, unsigned long arg)

typedef core_vector<Object*> acdk::lang::sys::ObjectPtrVector

typedef core_vector<RObject*> acdk::lang::sys::ObjectRefPtrVector

typedef short acdk::lang::sys::PagedAllocatorPageSlotFlags

typedef core_fastmutex acdk::lang::sys::PageMutex

typedef core_fastmutex acdk::lang::sys::static_mutex

typedef clock_t acdk::lang::sys::tick_t

Enumeration Type Documentation

enum acdk::lang::sys::AllocatedType

Enumeration values: UnspecifiedMem  RawMem  ObjectMem  InternalMem  ObjectRefArrayMem  contains acdk::lang::Object[] DumpBufferMem  CharBuffer, contains no pointer to other objects. NoGcMem  don't garbage this memory MaxAllocatedType

enum acdk::lang::sys::AllocatorTypeFlags

information about the given allocator Enumeration values: StandardAllocatorType  StackObjectAllocatorType  if this is true, allocated Object should threaded as stack object. References to stack object aren't synchronized SupportListObjectAllocatorType  Allocator support listing objects. NoSyncAllocatorType  Allocator itself doesn't need synchronization. NoRefCountAllocatorType  Allocator doesn't rely on RefHolders reference counting. ManualGcAllocatorType  Allocator support / needs manual garbage collecting calling gc(). AutoGcAllocatorType  Automatic gc.

enum acdk::lang::sys::ExecutionState

This class encapsulate some very basic initializations. Enumeration values: BeforeMain  Executable is not finished initialized. Normally in this state, constructors of static classes are called. Only limited usage of synchronization and allocators can be used. InMain  The executable up and running. AfterMain  The exutable is finished. This state can be occured in destructors of static classes. InSignalHandler  A signal handler is currently be called.

enum acdk::lang::sys::HeapInfo

Enumeration values: HeapIsUnknown  HeapIsGlobal  HeapIsStatic  HeapIsThread  HeapTraceObjects  HeapHasRC  HeapHasGC  HeapIsConsGC

enum acdk::lang::sys::ListObjectsFlags

flags which be used in HeapFrame::listObjects Enumeration values: AllocatedTypeMask  ListObjectsRecursive  list objects from all heaps ListRootsOnly  list only root elements ListGcAble  list objects, which would be gc

enum acdk::lang::sys::MemTraceReportFlags

used by core_memtrace to report objects Enumeration values: MTRFRecursive  report from this core_memtrace and parent MTRFMergeSameBt  if core_tracemem has same backtrace merge them MTRFRootsOnly  report only root objects MTRFUnfreed  report only not freed objects MTRFNoStatics  ignore object held by references Only works in combination with MTRFRootsOnly

Function Documentation

PageMutex& _pageLock (   )

bool _valid (  const acdk::lang::Object *  o  )  [inline]

ACDK_DECL_SYS_CLASS (  TracedRawAllocator   )

ACDK_DECL_SYS_CLASS (  PagedAllocator   )

acdk::lang::sys::ACDK_DECL_SYS_CLASS (  HeapFrame   )

ACDK_DECL_SYS_CLASS (  BoehmGCAllocator   )

ACDK_DECL_SYS_CLASS (  BitmapPagedAllocator   )

ACDK_DECL_SYS_CLASS (  RawAllocator   )

ACDK_DECL_SYS_CLASS (  AbstractAllocator   )

ACDK_DECL_SYS_CLASS (  Allocator   )

int ACDK_CORE_PUBLIC core_get_next_prim (  int  num  )

get next greater int whis is prim implementation in core_system.cpp

bool ACDK_CORE_PUBLIC core_is_prim (  int  num  )

template<class First, class Second> core_pair<First, Second> core_make_pair (  const First &  f, const Second &  s )  [inline]

void ACDK_CORE_PUBLIC core_vector_throw_out_of_index (  int  size, int  idx )

bool doGc (  Allocator *  allocator, AllocatorObjectsIterator *  iterator, bool  recursiv )

do a mark sweep on objects.

void genericListObject (  HeapFrame *  frame, AllocatorObjectsIterator *  iterator, ::acdk::lang::ref::NotifyObjectEventListener *  listener, int  flags )

template<typename T> core_vector<T> make_core_vector (  const T &  t1  )  [inline]

template<typename T> core_vector<T> make_core_vector (  const T &  t1, const T &  t2 )  [inline]

template<typename T> core_vector<T> make_core_vector (  const T &  t1, const T &  t2, const T &  t3 )  [inline]

void markMemberObjects (  AllocatorObjectsIterator *  iterator  )

mark all members of the objects unmarked objects are root objects

void markMembers (  acdk::lang::Object *  obj  )

mark all members of this object

void unmarkAndUnvisitedAll (  AllocatorObjectsIterator *  iterator  )

reset mark and visited flags

Variable Documentation

const char acdk::lang::sys::_noMenLandMask = 0xee

const int acdk::lang::sys::_noMenLandSize = 8

bool acdk::lang::sys::acdk_core_BoundStatic

ACDK_CORE_PUBLIC core_output acdk::lang::sys::coreout

ACDK_CORE_PUBLIC core_endline acdk::lang::sys::eofl