artefaktur
software engineer &        architecture

 
 
 
 

namespace acdk::lang::sys

Modules   Namespace List   Class Hierarchy   Alphabetical List   Compound List   Namespace Members   Compound Members   Related Pages  

acdk::lang::sys Namespace Reference


Detailed Description

System internal classes to support basic Language Features.


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
 

 
Last modified 2005-05-08 18:32 by SYSTEM By Artefaktur, Ing. Bureau Kommer