common/JackShmMem.h

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2008 Grame
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18
  19 */
  20
  21 #ifndef __JackShmMem__
  22 #define __JackShmMem__
  23
  24 #include "shm.h"
  25 #include "JackError.h"
  26 #include "JackCompilerDeps.h"
  27
  28 #include <new>  // GCC 4.0
  29 #include <errno.h>
  30 #include <stdlib.h>
  31
  32 #include "JackShmMem_os.h"
  33
  34 namespace Jack
  35 {
  36
  37 SERVER_EXPORT void LockMemoryImp(void* ptr, size_t size);
  38 SERVER_EXPORT void InitLockMemoryImp(void* ptr, size_t size);
  39 SERVER_EXPORT void UnlockMemoryImp(void* ptr, size_t size);
  40 SERVER_EXPORT void LockAllMemory();
  41 SERVER_EXPORT void UnlockAllMemory();
  42
  43 class JackMem
  44 {
  45     private:
  46
  47         size_t fSize;
  48         static size_t gSize;
  49
  50     protected:
  51
  52         JackMem(): fSize(gSize)
  53         {}
  54         ~JackMem()
  55         {}
  56
  57     public:
  58
  59         void* operator new(size_t size)
  60         {
  61             gSize = size;
  62             return calloc(1, size);
  63         }
  64
  65         void operator delete(void* ptr, size_t size)
  66         {
  67             free(ptr);
  68         }
  69
  70         void LockMemory()
  71         {
  72             LockMemoryImp(this, fSize);
  73         }
  74
  75         void UnlockMemory()
  76         {
  77             UnlockMemoryImp(this, fSize);
  78         }
  79
  80 };
  81
  82 /*!
  83 \brief
  84
  85 A class which objects possibly want to be allocated in shared memory derives from this class.
  86 */
  87
  88 class JackShmMemAble
  89 {
  90     protected:
  91
  92         jack_shm_info_t fInfo;
  93
  94     public:
  95
  96         void Init();
  97
  98         int GetShmIndex()
  99         {
 100             return fInfo.index;
 101         }
 102
 103         char* GetShmAddress()
 104         {
 105             return (char*)fInfo.ptr.attached_at;
 106         }
 107
 108         void LockMemory()
 109         {
 110             LockMemoryImp(this, fInfo.size);
 111         }
 112
 113         void UnlockMemory()
 114         {
 115             UnlockMemoryImp(this, fInfo.size);
 116         }
 117
 118 };
 119
 120 /*!
 121 \brief The base class for shared memory management.
 122
 123 A class which objects need to be allocated in shared memory derives from this class.
 124 */
 125
 126 class SERVER_EXPORT JackShmMem : public JackShmMemAble
 127 {
 128
 129      protected:
 130
 131         JackShmMem();
 132         ~JackShmMem()
 133         {}
 134
 135     public:
 136
 137         void* operator new(size_t size);
 138         void* operator new(size_t size, void* memory);
 139
 140         void operator delete(void* p, size_t size);
 141                 void operator delete(void* p);
 142
 143 };
 144
 145 /*!
 146 \brief Pointer on shared memory segment in the client side.
 147 */
 148
 149 template <class T>
 150 class JackShmReadWritePtr
 151 {
 152
 153     private:
 154
 155         jack_shm_info_t fInfo;
 156
 157         void Init(int index, const char* server_name = "default")
 158         {
 159             if (fInfo.index < 0 && index >= 0) {
 160                 jack_log("JackShmReadWritePtr::Init %ld %ld", index, fInfo.index);
 161                 if (jack_initialize_shm(server_name) < 0)
 162                     throw - 1;
 163                 fInfo.index = index;
 164                 if (jack_attach_shm(&fInfo)) {
 165                     //jack_error("cannot attach shared memory segment", strerror(errno));
 166                     throw - 2;
 167                 }
 168             }
 169         }
 170
 171     public:
 172
 173         JackShmReadWritePtr()
 174         {
 175             fInfo.index = -1;
 176             fInfo.ptr.attached_at = (char*)NULL;
 177         }
 178
 179         JackShmReadWritePtr(int index, const char* server_name)
 180         {
 181             Init(index, server_name);
 182         }
 183
 184         ~JackShmReadWritePtr()
 185         {
 186             if (fInfo.index >= 0) {
 187                 jack_log("JackShmReadWritePtr::~JackShmReadWritePtr %ld", fInfo.index);
 188                 jack_release_shm(&fInfo);
 189                 fInfo.index = -1;
 190             }
 191         }
 192
 193         T* operator->() const
 194         {
 195             return (T*)fInfo.ptr.attached_at;
 196         }
 197
 198         operator T*() const
 199         {
 200             return (T*)fInfo.ptr.attached_at;
 201         }
 202
 203         JackShmReadWritePtr& operator=(int index)
 204         {
 205             Init(index);
 206             return *this;
 207         }
 208
 209         void SetShmIndex(int index, const char* server_name)
 210         {
 211             Init(index, server_name);
 212         }
 213
 214         int GetShmIndex()
 215         {
 216             return fInfo.index;
 217         }
 218
 219         T* GetShmAddress()
 220         {
 221             return (T*)fInfo.ptr.attached_at;
 222         }
 223 };
 224
 225 /*!
 226 \brief Pointer on shared memory segment in the client side: destroy the segment (used client control)
 227 */
 228
 229 template <class T>
 230 class JackShmReadWritePtr1
 231 {
 232
 233     private:
 234
 235         jack_shm_info_t fInfo;
 236
 237         void Init(int index, const char* server_name = "default")
 238         {
 239             if (fInfo.index < 0 && index >= 0) {
 240                 jack_log("JackShmReadWritePtr1::Init %ld %ld", index, fInfo.index);
 241                 if (jack_initialize_shm(server_name) < 0)
 242                     throw - 1;
 243                 fInfo.index = index;
 244                 if (jack_attach_shm(&fInfo)) {
 245                     //jack_error("cannot attach shared memory segment", strerror(errno));
 246                     throw - 2;
 247                 }
 248                 /*
 249                             nobody else needs to access this shared memory any more, so
 250                             destroy it. because we have our own attachment to it, it won't
 251                             vanish till we exit (and release it).
 252                             */
 253                 jack_destroy_shm(&fInfo);
 254             }
 255         }
 256
 257     public:
 258
 259         JackShmReadWritePtr1()
 260         {
 261             fInfo.index = -1;
 262             fInfo.ptr.attached_at = NULL;
 263         }
 264
 265         JackShmReadWritePtr1(int index, const char* server_name)
 266         {
 267             Init(index, server_name);
 268         }
 269
 270         ~JackShmReadWritePtr1()
 271         {
 272             if (fInfo.index >= 0) {
 273                 jack_log("JackShmReadWritePtr1::~JackShmReadWritePtr1 %ld", fInfo.index);
 274                 jack_release_shm(&fInfo);
 275                 fInfo.index = -1;
 276             }
 277         }
 278
 279         T* operator->() const
 280         {
 281             return (T*)fInfo.ptr.attached_at;
 282         }
 283
 284         operator T*() const
 285         {
 286             return (T*)fInfo.ptr.attached_at;
 287         }
 288
 289         JackShmReadWritePtr1& operator=(int index)
 290         {
 291             Init(index);
 292             return *this;
 293         }
 294
 295         void SetShmIndex(int index, const char* server_name)
 296         {
 297             Init(index, server_name);
 298         }
 299
 300         int GetShmIndex()
 301         {
 302             return fInfo.index;
 303         }
 304
 305         T* GetShmAddress()
 306         {
 307             return (T*)fInfo.ptr.attached_at;
 308         }
 309 };
 310
 311 /*!
 312 \brief Pointer on shared memory segment in the client side.
 313 */
 314
 315 template <class T>
 316 class JackShmReadPtr
 317 {
 318
 319     private:
 320
 321         jack_shm_info_t fInfo;
 322
 323         void Init(int index, const char* server_name = "default")
 324         {
 325             if (fInfo.index < 0 && index >= 0) {
 326                 jack_log("JackShmPtrRead::Init %ld %ld", index, fInfo.index);
 327                 if (jack_initialize_shm(server_name) < 0)
 328                     throw - 1;
 329                 fInfo.index = index;
 330                 if (jack_attach_shm_read(&fInfo)) {
 331                     //jack_error("cannot attach shared memory segment", strerror(errno));
 332                     throw - 2;
 333                 }
 334             }
 335         }
 336
 337     public:
 338
 339         JackShmReadPtr()
 340         {
 341             fInfo.index = -1;
 342             fInfo.ptr.attached_at = NULL;
 343         }
 344
 345         JackShmReadPtr(int index, const char* server_name)
 346         {
 347             Init(index, server_name);
 348         }
 349
 350         ~JackShmReadPtr()
 351         {
 352             if (fInfo.index >= 0) {
 353                 jack_log("JackShmPtrRead::~JackShmPtrRead %ld", fInfo.index);
 354                 jack_release_shm(&fInfo);
 355                 fInfo.index = -1;
 356             }
 357         }
 358
 359         T* operator->() const
 360         {
 361             return (T*)fInfo.ptr.attached_at;
 362         }
 363
 364         operator T*() const
 365         {
 366             return (T*)fInfo.ptr.attached_at;
 367         }
 368
 369         JackShmReadPtr& operator=(int index)
 370         {
 371             Init(index);
 372             return *this;
 373         }
 374
 375         void SetShmIndex(int index, const char* server_name)
 376         {
 377             Init(index, server_name);
 378         }
 379
 380         int GetShmIndex()
 381         {
 382             return fInfo.index;
 383         }
 384
 385         T* GetShmAddress()
 386         {
 387             return (T*)fInfo.ptr.attached_at;
 388         }
 389
 390 };
 391
 392 } // end of namespace
 393
 394 #endif