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 UnlockMemoryImp(void* ptr, size_t size);
  39
  40 class JackMem
  41 {
  42     private:
  43
  44         size_t fSize;
  45         static size_t gSize;
  46
  47     protected:
  48
  49         JackMem(): fSize(gSize)
  50         {}
  51         ~JackMem()
  52         {}
  53
  54     public:
  55
  56         void* operator new(size_t size)
  57         {
  58             gSize = size;
  59             return calloc(1, size);
  60         }
  61
  62         void operator delete(void* ptr, size_t size)
  63         {
  64             free(ptr);
  65         }
  66
  67         void LockMemory()
  68         {
  69             LockMemoryImp(this, fSize);
  70         }
  71
  72         void UnlockMemory()
  73         {
  74             UnlockMemoryImp(this, fSize);
  75         }
  76
  77 };
  78
  79 /*!
  80 \brief
  81
  82 A class which objects possibly want to be allocated in shared memory derives from this class.
  83 */
  84
  85 class JackShmMemAble
  86 {
  87     protected:
  88
  89         jack_shm_info_t fInfo;
  90
  91     public:
  92
  93         void Init();
  94
  95         int GetShmIndex()
  96         {
  97             return fInfo.index;
  98         }
  99
 100         char* GetShmAddress()
 101         {
 102             return (char*)fInfo.attached_at;
 103         }
 104
 105         void LockMemory()
 106         {
 107             LockMemoryImp(this, fInfo.size);
 108         }
 109
 110         void UnlockMemory()
 111         {
 112             UnlockMemoryImp(this, fInfo.size);
 113         }
 114
 115 };
 116
 117 /*!
 118 \brief The base class for shared memory management.
 119
 120 A class which objects need to be allocated in shared memory derives from this class.
 121 */
 122
 123 class SERVER_EXPORT JackShmMem : public JackShmMemAble
 124 {
 125
 126      protected:
 127
 128         JackShmMem();
 129         ~JackShmMem()
 130         {}
 131
 132     public:
 133
 134         void* operator new(size_t size);
 135         void* operator new(size_t size, void* memory);
 136
 137         void operator delete(void* p, size_t size);
 138                 void operator delete(void* p);
 139
 140 };
 141
 142 /*!
 143 \brief Pointer on shared memory segment in the client side.
 144 */
 145
 146 template <class T>
 147 class JackShmReadWritePtr
 148 {
 149
 150     private:
 151
 152         jack_shm_info_t fInfo;
 153
 154         void Init(int index, const char* server_name = "default")
 155         {
 156             if (fInfo.index < 0 && index >= 0) {
 157                 jack_log("JackShmReadWritePtr::Init %ld %ld", index, fInfo.index);
 158                 if (jack_initialize_shm(server_name) < 0)
 159                     throw - 1;
 160                 fInfo.index = index;
 161                 if (jack_attach_shm(&fInfo)) {
 162                     //jack_error("cannot attach shared memory segment", strerror(errno));
 163                     throw - 2;
 164                 }
 165             }
 166         }
 167
 168     public:
 169
 170         JackShmReadWritePtr()
 171         {
 172             fInfo.index = -1;
 173             fInfo.attached_at = NULL;
 174         }
 175
 176         JackShmReadWritePtr(int index, const char* server_name)
 177         {
 178             Init(index, server_name);
 179         }
 180
 181         ~JackShmReadWritePtr()
 182         {
 183             if (fInfo.index >= 0) {
 184                 jack_log("JackShmReadWritePtr::~JackShmReadWritePtr %ld", fInfo.index);
 185                 jack_release_shm(&fInfo);
 186                 fInfo.index = -1;
 187             }
 188         }
 189
 190         T* operator->() const
 191         {
 192             return (T*)fInfo.attached_at;
 193         }
 194
 195         operator T*() const
 196         {
 197             return (T*)fInfo.attached_at;
 198         }
 199
 200         JackShmReadWritePtr& operator=(int index)
 201         {
 202             Init(index);
 203             return *this;
 204         }
 205
 206         void SetShmIndex(int index, const char* server_name)
 207         {
 208             Init(index, server_name);
 209         }
 210
 211         int GetShmIndex()
 212         {
 213             return fInfo.index;
 214         }
 215
 216         T* GetShmAddress()
 217         {
 218             return (T*)fInfo.attached_at;
 219         }
 220 };
 221
 222 /*!
 223 \brief Pointer on shared memory segment in the client side: destroy the segment (used client control)
 224 */
 225
 226 template <class T>
 227 class JackShmReadWritePtr1
 228 {
 229
 230     private:
 231
 232         jack_shm_info_t fInfo;
 233
 234         void Init(int index, const char* server_name = "default")
 235         {
 236             if (fInfo.index < 0 && index >= 0) {
 237                 jack_log("JackShmReadWritePtr1::Init %ld %ld", index, fInfo.index);
 238                 if (jack_initialize_shm(server_name) < 0)
 239                     throw - 1;
 240                 fInfo.index = index;
 241                 if (jack_attach_shm(&fInfo)) {
 242                     //jack_error("cannot attach shared memory segment", strerror(errno));
 243                     throw - 2;
 244                 }
 245                 /*
 246                             nobody else needs to access this shared memory any more, so
 247                             destroy it. because we have our own attachment to it, it won't
 248                             vanish till we exit (and release it).
 249                             */
 250                 jack_destroy_shm(&fInfo);
 251             }
 252         }
 253
 254     public:
 255
 256         JackShmReadWritePtr1()
 257         {
 258             fInfo.index = -1;
 259             fInfo.attached_at = NULL;
 260         }
 261
 262         JackShmReadWritePtr1(int index, const char* server_name)
 263         {
 264             Init(index, server_name);
 265         }
 266
 267         ~JackShmReadWritePtr1()
 268         {
 269             if (fInfo.index >= 0) {
 270                 jack_log("JackShmReadWritePtr1::~JackShmReadWritePtr1 %ld", fInfo.index);
 271                 jack_release_shm(&fInfo);
 272                 fInfo.index = -1;
 273             }
 274         }
 275
 276         T* operator->() const
 277         {
 278             return (T*)fInfo.attached_at;
 279         }
 280
 281         operator T*() const
 282         {
 283             return (T*)fInfo.attached_at;
 284         }
 285
 286         JackShmReadWritePtr1& operator=(int index)
 287         {
 288             Init(index);
 289             return *this;
 290         }
 291
 292         void SetShmIndex(int index, const char* server_name)
 293         {
 294             Init(index, server_name);
 295         }
 296
 297         int GetShmIndex()
 298         {
 299             return fInfo.index;
 300         }
 301
 302         T* GetShmAddress()
 303         {
 304             return (T*)fInfo.attached_at;
 305         }
 306 };
 307
 308 /*!
 309 \brief Pointer on shared memory segment in the client side.
 310 */
 311
 312 template <class T>
 313 class JackShmReadPtr
 314 {
 315
 316     private:
 317
 318         jack_shm_info_t fInfo;
 319
 320         void Init(int index, const char* server_name = "default")
 321         {
 322             if (fInfo.index < 0 && index >= 0) {
 323                 jack_log("JackShmPtrRead::Init %ld %ld", index, fInfo.index);
 324                 if (jack_initialize_shm(server_name) < 0)
 325                     throw - 1;
 326                 fInfo.index = index;
 327                 if (jack_attach_shm_read(&fInfo)) {
 328                     //jack_error("cannot attach shared memory segment", strerror(errno));
 329                     throw - 2;
 330                 }
 331             }
 332         }
 333
 334     public:
 335
 336         JackShmReadPtr()
 337         {
 338             fInfo.index = -1;
 339             fInfo.attached_at = NULL;
 340         }
 341
 342         JackShmReadPtr(int index, const char* server_name)
 343         {
 344             Init(index, server_name);
 345         }
 346
 347         ~JackShmReadPtr()
 348         {
 349             if (fInfo.index >= 0) {
 350                 jack_log("JackShmPtrRead::~JackShmPtrRead %ld", fInfo.index);
 351                 jack_release_shm(&fInfo);
 352                 fInfo.index = -1;
 353             }
 354         }
 355
 356         T* operator->() const
 357         {
 358             return (T*)fInfo.attached_at;
 359         }
 360
 361         operator T*() const
 362         {
 363             return (T*)fInfo.attached_at;
 364         }
 365
 366         JackShmReadPtr& operator=(int index)
 367         {
 368             Init(index);
 369             return *this;
 370         }
 371
 372         void SetShmIndex(int index, const char* server_name)
 373         {
 374             Init(index, server_name);
 375         }
 376
 377         int GetShmIndex()
 378         {
 379             return fInfo.index;
 380         }
 381
 382         T* GetShmAddress()
 383         {
 384             return (T*)fInfo.attached_at;
 385         }
 386
 387 };
 388
 389 } // end of namespace
 390
 391 #endif