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