common/JackShmMem.h

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