|
T * | get (void) |
| Request a typed reusable object from the free list or mapped space.
|
|
T * | getLocked (void) |
| Used to get a typed object from the reuse pool when the mutex lock is already held.
|
|
T * | getTimed (timeout_t timeout) |
| Request a typed reusable object from the free list or mapped space.
|
|
void | initialize (void) |
| Initialize typed data in mapped array.
|
|
| mapped_reuse (const char *name, unsigned number) |
| Construct mapped reuse array of typed objects.
|
|
| operator bool () const |
| Check whether there are typed objects available to be allocated.
|
|
| operator T* () |
| Request a typed reusable object from the free list or mapped space.
|
|
bool | operator! () const |
| Check whether there are typed objects available to be allocated.
|
|
T * | operator* () |
| Request a typed reusable object from the free list or mapped space by pointer reference.
|
|
T * | pos (size_t member) |
| Get typed object from a specific member offset within the mapped segment.
|
|
void | release (T *object) |
| Used to release a typed object back to the reuse typed object pool.
|
|
void | removeLocked (T *object) |
| Used to return a typed object to the reuse pool when the mutex lock is already held.
|
|
T * | request (void) |
| Request a typed reusable object from the free list or mapped space.
|
|
bool | avail (void) const |
| Check whether there are objects available to be allocated.
|
|
ReusableObject * | get (void) |
| Request a reusable object from the free list or mapped space.
|
|
ReusableObject * | getLocked (void) |
| Used to get an object from the reuse pool when the mutex lock is already held.
|
|
ReusableObject * | getTimed (timeout_t timeout) |
| Request a reusable object from the free list or mapped space.
|
|
| MappedReuse (const char *name, size_t size, unsigned count) |
| Construct a named memory segment for use with managed fixed size reusable objects.
|
|
void | removeLocked (ReusableObject *object) |
| Used to return an object to the reuse pool when the mutex lock is already held.
|
|
ReusableObject * | request (void) |
| Request a reusable object from the free list or mapped space.
|
|
|
void | create (const char *fname, unsigned count) |
|
| MappedReuse (size_t osize) |
|
ReusableObject * | next (ReusableObject *object) |
| Get next reusable object in the pool.
|
|
void | release (ReusableObject *object) |
| Release resuable object.
|
|
| ReusableAllocator () |
| Initialize reusable allocator through a conditional.
|
|
void | broadcast (void) |
| Signal the conditional to release all waiting threads.
|
|
| Conditional () |
| Initialize and construct conditional.
|
|
void | signal (void) |
| Signal the conditional to release one waiting thread.
|
|
bool | wait (struct timespec *timeout) |
| Conditional wait for signal on timespec timeout.
|
|
bool | wait (timeout_t timeout) |
| Conditional wait for signal on millisecond timeout.
|
|
void | wait (void) |
| Wait (block) until signalled.
|
|
| ~Conditional () |
| Destroy conditional, release any blocked threads.
|
|
| ConditionMutex () |
| Initialize and construct conditional.
|
|
void | lock (void) |
| Lock the conditional's supporting mutex.
|
|
void | unlock (void) |
| Unlock the conditional's supporting mutex.
|
|
| ~ConditionMutex () |
| Destroy conditional, release any blocked threads.
|
|
void | create (const char *name, size_t size=(size_t) 0) |
| Supporting function to construct a new or access an existing shared memory segment.
|
|
caddr_t | addr (void) |
| Get starting address of mapped segment.
|
|
bool | copy (size_t offset, void *buffer, size_t size) const |
| Copy memory from specific offset within the mapped memory segment.
|
|
size_t | len (void) const |
| Get size of mapped segment.
|
|
| MappedMemory (const char *name) |
| Provide read-only mapped access to an existing named shared memory segment.
|
|
| MappedMemory (const char *name, size_t size) |
| Construct a read/write access mapped shared segment of memory of a known size.
|
|
void * | offset (size_t offset) const |
| Get memory from a specific offset within the mapped memory segment.
|
|
| operator bool () const |
| Test if map active.
|
|
bool | operator! () const |
| Test if map is inactive.
|
|
void | release (void) |
| Unmap memory segment.
|
|
void * | sbrk (size_t size) |
| Extend size of managed heap on shared memory segment.
|
|
virtual | ~MappedMemory () |
| Unmap memory segment.
|
|
static pthread_condattr_t * | initializer (void) |
| Support function for getting conditional attributes for realtime scheduling.
|
|
static void | set (struct timespec *hires, timeout_t timeout) |
| Convert a millisecond timeout into use for high resolution conditional timers.
|
|
static void | disable (void) |
| An API that allows "disabling" of publishing shared memory maps.
|
|
static void | remove (const char *name) |
| Destroy a previously existing memory segment under the specified name.
|
|
ReusableObject * | freelist |
|
unsigned | waiting |
|
pthread_cond_t | cond |
|
pthread_mutex_t | mutex |
|
bool | erase |
|
char | idname [65] |
|
size_t | size |
|
size_t | used |
|
static attribute | attr |
|
template<class T>
class ucommon::mapped_reuse< T >
Template class to map typed reusable objects into shared memory heap.
This is used to construct a read/write heap of objects that are held in a named shared memory segment. Member objects are allocated from a reusable heap but are stored in the shared memory segment as a vector.
- Author
- David Sugar dyfet.nosp@m.@gnu.nosp@m.telep.nosp@m.hony.nosp@m..org
Definition at line 347 of file mapped.h.