00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00029 #ifndef _UCOMMON_MAPPED_H_
00030 #define _UCOMMON_MAPPED_H_
00031
00032 #ifndef _UCOMMON_LINKED_H_
00033 #include <ucommon/linked.h>
00034 #endif
00035
00036 #ifndef _UCOMMON_THREAD_H_
00037 #include <ucommon/thread.h>
00038 #endif
00039
00040 #ifndef _UCOMMON_STRING_H_
00041 #include <ucommon/string.h>
00042 #endif
00043
00044 #ifndef _MSWINDOWS_
00045 #include <signal.h>
00046 #endif
00047
00048 NAMESPACE_UCOMMON
00049
00058 class __EXPORT MappedMemory
00059 {
00060 private:
00061 size_t mapsize;
00062 caddr_t map;
00063 fd_t fd;
00064
00065 protected:
00066 size_t size, used;
00067
00068 MappedMemory();
00069
00076 void create(const char *name, size_t size = (size_t)0);
00077
00082 virtual void fault(void);
00083
00084 public:
00091 MappedMemory(const char *name, size_t size);
00092
00099 MappedMemory(const char *name);
00100
00104 virtual ~MappedMemory();
00105
00109 void release(void);
00110
00117 static void remove(const char *name);
00118
00123 inline operator bool() const
00124 {return (size != 0);};
00125
00130 inline bool operator!() const
00131 {return (size == 0);};
00132
00140 void *sbrk(size_t size);
00141
00147 void *offset(size_t offset);
00148
00153 inline size_t len(void)
00154 {return size;};
00155
00160 inline caddr_t getStart(void)
00161 {return map;};
00162
00170 static void disable(void);
00171 };
00172
00182 class __EXPORT MappedReuse : protected ReusableAllocator, protected MappedMemory
00183 {
00184 private:
00185 unsigned objsize;
00186 unsigned reading;
00187 mutex_t mutex;
00188
00189 protected:
00190 MappedReuse(size_t osize);
00191
00192 inline void create(const char *fname, unsigned count)
00193 {MappedMemory::create(fname, count * objsize);};
00194
00195 public:
00208 MappedReuse(const char *name, size_t size, unsigned count);
00209
00214 bool avail(void);
00215
00220 ReusableObject *request(void);
00221
00227 ReusableObject *get(void);
00228
00236 ReusableObject *getTimed(timeout_t timeout);
00237
00243 ReusableObject *getLocked(void);
00244
00250 void removeLocked(ReusableObject *object);
00251 };
00252
00259 template <class T>
00260 class mapped_array : public MappedMemory
00261 {
00262 protected:
00263 inline mapped_array() : MappedMemory() {};
00264
00265 inline void create(const char *fn, unsigned members)
00266 {MappedMemory::create(fn, members * sizeof(T));};
00267
00268 public:
00277 inline mapped_array(const char *name, unsigned number) :
00278 MappedMemory(name, number * sizeof(T)) {};
00279
00284 inline void initialize(void)
00285 {new((caddr_t)offset(0)) T[size / sizeof(T)];};
00286
00291 inline void *addLock(void)
00292 {return sbrk(sizeof(T));};
00293
00299 inline T *operator()(unsigned member)
00300 {return static_cast<T*>(offset(member * sizeof(T)));}
00301
00306 inline T *operator()(void)
00307 {return static_cast<T*>(sbrk(sizeof(T)));};
00308
00314 inline T& operator[](unsigned member)
00315 {return *(operator()(member));};
00316
00321 inline unsigned getSize(void)
00322 {return (unsigned)(size / sizeof(T));};
00323 };
00324
00332 template <class T>
00333 class mapped_reuse : public MappedReuse
00334 {
00335 protected:
00336 inline mapped_reuse() :
00337 MappedReuse(sizeof(T)) {};
00338
00339 public:
00347 inline mapped_reuse(const char *name, unsigned number) :
00348 MappedReuse(name, sizeof(T), number) {};
00349
00354 inline void initialize(void)
00355 {new((caddr_t)pos(0)) T[size / sizeof(T)];};
00356
00361 inline operator bool()
00362 {return MappedReuse::avail();};
00363
00368 inline bool operator!()
00369 {return !MappedReuse::avail();};
00370
00376 inline operator T*()
00377 {return mapped_reuse::get();};
00378
00384 inline T* operator*()
00385 {return mapped_reuse::get();};
00386
00392 inline T *pos(size_t member)
00393 {return static_cast<T*>(MappedReuse::offset(member * sizeof(T)));};
00394
00400 inline T *get(void)
00401 {return static_cast<T*>(MappedReuse::get());};
00402
00410 inline T *getTimed(timeout_t timeout)
00411 {return static_cast<T*>(MappedReuse::getTimed(timeout));};
00412
00418 inline T *request(void)
00419 {return static_cast<T*>(MappedReuse::request());};
00420
00426 inline void removeLocked(T *object)
00427 {MappedReuse::removeLocked(object);};
00428
00434 inline T *getLocked(void)
00435 {return static_cast<T*>(MappedReuse::getLocked());};
00436
00441 inline void release(T *object)
00442 {ReusableAllocator::release(object);};
00443 };
00444
00451 template <class T>
00452 class mapped_view : protected MappedMemory
00453 {
00454 public:
00460 inline mapped_view(const char *name) :
00461 MappedMemory(name) {};
00462
00468 inline volatile const T *operator()(unsigned member)
00469 {return static_cast<const T*>(offset(member * sizeof(T)));}
00470
00476 inline volatile const T &operator[](unsigned member)
00477 {return *(operator()(member));};
00478
00483 inline unsigned getCount(void)
00484 {return (unsigned)(size / sizeof(T));};
00485 };
00486
00487 END_NAMESPACE
00488
00489 #endif