Go to the documentation of this file.
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_
59 class __EXPORT MappedMemory
66 __DELETE_COPY(MappedMemory);
81 void create(
const char *name,
size_t size = (
size_t)0);
90 MappedMemory(
const char *name,
size_t size);
98 MappedMemory(
const char *name);
103 virtual ~MappedMemory();
116 static void remove(
const char *name);
122 inline operator bool()
const
123 {
return (size != 0);}
129 inline bool operator!()
const
130 {
return (size == 0);}
139 void *sbrk(
size_t size);
146 void *offset(
size_t offset)
const;
156 bool copy(
size_t offset,
void *buffer,
size_t size)
const;
162 inline size_t len(
void)
const
169 inline caddr_t
addr(
void)
179 static void disable(
void);
191 class __EXPORT MappedReuse :
protected ReusableAllocator,
protected MappedMemory
198 __DELETE_DEFAULTS(MappedReuse);
201 MappedReuse(
size_t osize);
203 inline void create(
const char *fname,
unsigned count)
204 {MappedMemory::create(fname, count * objsize);}
219 MappedReuse(
const char *name,
size_t size,
unsigned count);
225 bool avail(
void)
const;
231 ReusableObject *request(
void);
238 ReusableObject *get(
void);
247 ReusableObject *getTimed(timeout_t timeout);
254 ReusableObject *getLocked(
void);
261 void removeLocked(ReusableObject *
object);
279 inline void create(
const char *fn,
unsigned members)
280 {MappedMemory::create(fn, members *
sizeof(T));}
292 MappedMemory(name, number * sizeof(T)) {}
299 {
new((caddr_t)offset(0)) T[size /
sizeof(T)];}
306 {
return sbrk(
sizeof(T));}
314 {
return static_cast<T*
>(offset(member *
sizeof(T)));}
321 {
return static_cast<T*
>(sbrk(
sizeof(T)));}
335 inline unsigned max(
void)
const
336 {
return (
unsigned)(size /
sizeof(T));}
354 MappedReuse(
sizeof(T)) {}
365 MappedReuse(name, sizeof(T), number) {}
372 {
new((caddr_t)
pos(0)) T[size /
sizeof(T)];}
378 inline operator bool()
const
379 {
return MappedReuse::avail();}
386 {
return !MappedReuse::avail();}
409 inline T *
pos(
size_t member)
410 {
return static_cast<T*
>(MappedReuse::offset(member *
sizeof(T)));}
418 {
return static_cast<T*
>(MappedReuse::get());}
428 {
return static_cast<T*
>(MappedReuse::getTimed(timeout));}
436 {
return static_cast<T*
>(MappedReuse::request());}
444 {MappedReuse::removeLocked(
object);}
452 {
return static_cast<T*
>(MappedReuse::getLocked());}
459 {ReusableAllocator::release(
object);}
481 MappedMemory(name) {}
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));}
void initialize(void)
Initialize typed data in mapped array.
const volatile T & operator[](unsigned member)
Reference typed member object in the mapped segment.
const volatile T * operator()(unsigned member)
Access typed member object in the mapped segment.
T * getTimed(timeout_t timeout)
Request a typed reusable object from the free list or mapped space.
T * request(void)
Request a typed reusable object from the free list or mapped space.
mapped_reuse(const char *name, unsigned number)
Construct mapped reuse array of typed objects.
T & operator[](unsigned member)
Reference typed object of vector in mapped segment.
Common namespace for all ucommon objects.
Class to access a named mapped segment published from another process.
mapped_array(const char *name, unsigned number)
Construct mapped vector array of typed objects.
T * operator()(void)
Allocate mapped space for one object.
Mutex mutex_t
Convenience type for using exclusive mutex locks.
Map a reusable allocator over a named shared memory segment.
unsigned count(void) const
Get count of typed member objects held in this map.
void removeLocked(T *object)
Used to return a typed object to the reuse pool when the mutex lock is already held.
const struct sockaddr * addr(Socket::address &address)
A convenience function to convert a socket address list into a socket address.
Linked objects, lists, templates, and containers.
T copy(const T &src)
Convenience function to copy objects.
A common string class and character string support functions.
mapped_view(const char *name)
Map existing named memory segment.
T * pos(size_t member)
Get typed object from a specific member offset within the mapped segment.
bool operator!() const
Check whether there are typed objects available to be allocated.
void * addLock(void)
Add mapped space while holding lock for one object.
void initialize(void)
Initialize typed data in mapped array.
T * operator*()
Request a typed reusable object from the free list or mapped space by pointer reference.
T * operator()(unsigned member)
Get typed pointer to member object of vector in mapped segment.
Thread classes and sychronization objects.
void release(T *object)
Used to release a typed object back to the reuse typed object pool.
unsigned max(void) const
Get member size of typed objects that can be held in mapped vector.
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.
Template class to map typed reusable objects into shared memory heap.