common/JackShmMem.h

   1 /*
   2 Copyright (C) 2001 Paul Davis
   3 Copyright (C) 2004-2009 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     public:
 135
 136         void* operator new(size_t size);
 137         void* operator new(size_t size, void* memory);
 138
 139         void operator delete(void* p, size_t size);
 140                 void operator delete(void* p);
 141
 142 };
 143
 144 /*!
 145 \brief Pointer on shared memory segment in the client side.
 146 */
 147
 148 template <class T>
 149 class JackShmReadWritePtr
 150 {
 151
 152     private:
 153
 154         jack_shm_info_t fInfo;
 155
 156         void Init(int index, const char* server_name = "default")
 157         {
 158             if (fInfo.index < 0 && index >= 0) {
 159                 jack_log("JackShmReadWritePtr::Init %ld %ld", index, fInfo.index);
 160                 if (jack_initialize_shm(server_name) < 0)
 161                     throw - 1;
 162                 fInfo.index = index;
 163                 if (jack_attach_shm(&fInfo)) {
 164                     throw - 2;
 165                 }
 166                 GetShmAddress()->LockMemory();
 167             }
 168         }
 169
 170     public:
 171
 172         JackShmReadWritePtr()
 173         {
 174             fInfo.index = -1;
 175             fInfo.ptr.attached_at = (char*)NULL;
 176         }
 177
 178         JackShmReadWritePtr(int index, const char* server_name)
 179         {
 180             Init(index, server_name);
 181         }
 182
 183         ~JackShmReadWritePtr()
 184         {
 185             if (fInfo.index >= 0) {
 186                 jack_log("JackShmReadWritePtr::~JackShmReadWritePtr %ld", fInfo.index);
 187                 GetShmAddress()->UnlockMemory();
 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                     throw - 2;
 246                 }
 247                 /*
 248                 nobody else needs to access this shared memory any more, so
 249                 destroy it. because we have our own attachment to it, it won't
 250                 vanish till we exit (and release it).
 251                 */
 252                 jack_destroy_shm(&fInfo);
 253                 GetShmAddress()->LockMemory();
 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                 GetShmAddress()->UnlockMemory();
 275                 jack_release_shm(&fInfo);
 276                 fInfo.index = -1;
 277             }
 278         }
 279
 280         T* operator->() const
 281         {
 282             return (T*)fInfo.ptr.attached_at;
 283         }
 284
 285         operator T*() const
 286         {
 287             return (T*)fInfo.ptr.attached_at;
 288         }
 289
 290         JackShmReadWritePtr1& operator=(int index)
 291         {
 292             Init(index);
 293             return *this;
 294         }
 295
 296         void SetShmIndex(int index, const char* server_name)
 297         {
 298             Init(index, server_name);
 299         }
 300
 301         int GetShmIndex()
 302         {
 303             return fInfo.index;
 304         }
 305
 306         T* GetShmAddress()
 307         {
 308             return (T*)fInfo.ptr.attached_at;
 309         }
 310 };
 311
 312 /*!
 313 \brief Pointer on shared memory segment in the client side.
 314 */
 315
 316 template <class T>
 317 class JackShmReadPtr
 318 {
 319
 320     private:
 321
 322         jack_shm_info_t fInfo;
 323
 324         void Init(int index, const char* server_name = "default")
 325         {
 326             if (fInfo.index < 0 && index >= 0) {
 327                 jack_log("JackShmPtrRead::Init %ld %ld", index, fInfo.index);
 328                 if (jack_initialize_shm(server_name) < 0)
 329                     throw - 1;
 330                 fInfo.index = index;
 331                 if (jack_attach_shm_read(&fInfo)) {
 332                     throw - 2;
 333                 }
 334                 GetShmAddress()->LockMemory();
 335             }
 336         }
 337
 338     public:
 339
 340         JackShmReadPtr()
 341         {
 342             fInfo.index = -1;
 343             fInfo.ptr.attached_at = NULL;
 344         }
 345
 346         JackShmReadPtr(int index, const char* server_name)
 347         {
 348             Init(index, server_name);
 349         }
 350
 351         ~JackShmReadPtr()
 352         {
 353             if (fInfo.index >= 0) {
 354                 jack_log("JackShmPtrRead::~JackShmPtrRead %ld", fInfo.index);
 355                 GetShmAddress()->UnlockMemory();
 356                 jack_release_shm(&fInfo);
 357                 fInfo.index = -1;
 358             }
 359         }
 360
 361         T* operator->() const
 362         {
 363             return (T*)fInfo.ptr.attached_at;
 364         }
 365
 366         operator T*() const
 367         {
 368             return (T*)fInfo.ptr.attached_at;
 369         }
 370
 371         JackShmReadPtr& operator=(int index)
 372         {
 373             Init(index);
 374             return *this;
 375         }
 376
 377         void SetShmIndex(int index, const char* server_name)
 378         {
 379             Init(index, server_name);
 380         }
 381
 382         int GetShmIndex()
 383         {
 384             return fInfo.index;
 385         }
 386
 387         T* GetShmAddress()
 388         {
 389             return (T*)fInfo.ptr.attached_at;
 390         }
 391
 392 };
 393
 394 } // end of namespace
 395
 396 #endif