30 #ifndef _UCOMMON_MAPPED_H_
31 #define _UCOMMON_MAPPED_H_
33 #ifndef _UCOMMON_LINKED_H_
37 #ifndef _UCOMMON_THREAD_H_
41 #ifndef _UCOMMON_STRING_H_
81 void create(
const char *name,
size_t size = (
size_t)0);
87 virtual void *invalid(
void)
const;
92 virtual void fault(
void)
const;
127 static void remove(
const char *name);
133 inline operator bool()
const
134 {
return (size != 0);}
141 {
return (size == 0);}
150 void *sbrk(
size_t size);
157 void *offset(
size_t offset)
const;
167 bool copy(
size_t offset,
void *buffer,
size_t size)
const;
173 inline size_t len(
void)
const
190 static void disable(
void);
212 inline void create(
const char *fname,
unsigned count)
228 MappedReuse(
const char *name,
size_t size,
unsigned count);
234 bool avail(
void)
const;
285 inline void create(
const char *fn,
unsigned members)
305 {
new((caddr_t)
offset(0)) T[size /
sizeof(T)];}
312 {
return sbrk(
sizeof(T));}
320 {
return static_cast<T*
>(
offset(member *
sizeof(T)));}
327 {
return static_cast<T*
>(
sbrk(
sizeof(T)));}
341 inline unsigned max(
void)
const
342 {
return (
unsigned)(size /
sizeof(T));}
375 {
new((caddr_t)
pos(0)) T[size /
sizeof(T)];}
381 inline operator bool()
const
412 inline T *
pos(
size_t member)
489 {
return static_cast<const T*
>(
offset(member *
sizeof(T)));}
499 inline volatile const T *
get(
unsigned member)
500 {
return static_cast<const T*
>(
offset(member *
sizeof(T)));}
502 inline void copy(
unsigned member, T& buffer)
510 {
return (
unsigned)(size /
sizeof(T));}
A common string class and character string support functions.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.
volatile const T * operator()(unsigned member)
Access typed member object in the mapped segment.
T * operator*()
Request a typed reusable object from the free list or mapped space by pointer reference.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
ReusableObject * get(void)
Request a reusable object from the free list or mapped space.
void release(ReusableObject *object)
Release resuable object.
Thread classes and sychronization objects.
T * request(void)
Request a typed reusable object from the free list or mapped space.
caddr_t addr(void)
Get starting address of mapped segment.
mapped_view(const char *name)
Map existing named memory segment.
void * sbrk(size_t size)
Extend size of managed heap on shared memory segment.
ObjectProtocol * copy(ObjectProtocol *object)
Convenience function to access object copy.
Template class to map typed reusable objects into shared memory heap.
Linked objects, lists, templates, and containers.
void initialize(void)
Initialize typed data in mapped array.
bool avail(void) const
Check whether there are objects available to be allocated.
bool operator!() const
Test if map is inactive.
Reusable objects for forming private heaps.
void * offset(size_t offset) const
Get memory from a specific offset within the mapped memory segment.
T * getTimed(timeout_t timeout)
Request a typed 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.
Generic non-recursive exclusive lock class.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
ReusableObject * getTimed(timeout_t timeout)
Request a reusable object from the free list or mapped space.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
void removeLocked(ReusableObject *object)
Used to return an object to the reuse pool when the mutex lock is already held.
Common namespace for all ucommon objects.
void create(const char *name, size_t size=(size_t) 0)
Supporting function to construct a new or access an existing shared memory segment.
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.
bool operator!() const
Check whether there are typed objects available to be allocated.
Class for resource bound memory pools between threads.
Template class to map typed vector into shared memory.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
unsigned count(void) const
Get count of typed member objects held in this map.
unsigned max(void) const
Get member size of typed objects that can be held in mapped vector.
Construct or access a named section of memory.
T * getLocked(void)
Used to get a typed object from the reuse pool when the mutex lock is already held.
T * get(void)
Request a typed reusable object from the free list or mapped space.
bool copy(size_t offset, void *buffer, size_t size) const
Copy memory from specific offset within the mapped memory segment.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
void * addLock(void)
Add mapped space while holding lock for one object.
volatile const T & operator[](unsigned member)
Reference typed member object in the mapped segment.
void initialize(void)
Initialize typed data in mapped array.
size_t len(void) const
Get size of mapped segment.
Map a reusable allocator over a named shared memory segment.
ReusableObject * request(void)
Request a reusable object from the free list or mapped space.
T * operator()(void)
Allocate mapped space for one object.
Class to access a named mapped segment published from another process.