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         #define CHECK_MLOCKALL()(false)
  36         #define CHECK_MUNLOCKALL()(false)
  37 #else
  38         #include <sys/types.h>
  39         #include <sys/mman.h>
  40         #define CHECK_MLOCK(ptr, size) (mlock((ptr), (size)) == 0)
  41         #define CHECK_MUNLOCK(ptr, size) (munlock((ptr), (size)) == 0)
  42         #define CHECK_MLOCKALL() (mlockall(MCL_CURRENT | MCL_FUTURE) == 0)
  43         #define CHECK_MUNLOCKALL() (munlockall() == 0)
  44 #endif
  45
  46 namespace Jack
  47 {
  48
  49 void LockMemoryImp(void* ptr, size_t size);
  50 void UnlockMemoryImp(void* ptr, size_t size);
  51
  52 class JackMem
  53 {
  54         private:
  55
  56                 size_t fSize;
  57                 static size_t gSize;
  58
  59         public:
  60
  61         void* operator new(size_t size)
  62                 {
  63                         gSize = size;
  64                         return calloc(1, size);
  65                 }
  66
  67         void operator delete(void* ptr, size_t size)
  68                 {
  69                         free(ptr);
  70                 }
  71
  72         JackMem():fSize(gSize)
  73         {}
  74
  75         virtual ~JackMem()
  76         {
  77                         UnlockMemoryImp(this, fSize);
  78                 }
  79
  80                 void LockMemory()
  81                 {
  82                         LockMemoryImp(this, fSize);
  83                 }
  84
  85                 void UnlockMemory()
  86                 {
  87                         UnlockMemoryImp(this, fSize);
  88                 }
  89
  90 };
  91
  92 /*!
  93 \brief The base class for shared memory management.
  94
  95 A class which objects need to be allocated in shared memory derives from this class.
  96 */
  97
  98 class JackShmMem
  99 {
 100
 101     protected:
 102
 103         jack_shm_info_t fInfo;
 104         static unsigned long fSegmentNum;
 105         static unsigned long fSegmentCount;
 106         static jack_shm_info_t gInfo;
 107
 108     public:
 109
 110         void* operator new(size_t size);
 111         void operator delete(void* p, size_t size);
 112
 113         JackShmMem()
 114         {
 115             fInfo.index = gInfo.index;
 116                         fInfo.attached_at = gInfo.attached_at;
 117                         fInfo.size = gInfo.size;
 118                 }
 119
 120         virtual ~JackShmMem()
 121         {
 122                         UnlockMemoryImp(this, fInfo.size);
 123                 }
 124
 125         int GetShmIndex()
 126         {
 127             return fInfo.index;
 128         }
 129
 130         char* GetShmAddress()
 131         {
 132             return (char*)fInfo.attached_at;
 133         }
 134
 135                 void LockMemory()
 136                 {
 137                         LockMemoryImp(this, fInfo.size);
 138                 }
 139
 140                 void UnlockMemory()
 141                 {
 142                         UnlockMemoryImp(this, fInfo.size);
 143                 }
 144
 145 };
 146
 147 /*!
 148 \brief Pointer on shared memory segment in the client side.
 149 */
 150
 151 template <class T>
 152 class JackShmReadWritePtr
 153 {
 154
 155     private:
 156
 157         jack_shm_info_t fInfo;
 158
 159         void Init(int index)
 160         {
 161             if (fInfo.index < 0 && index >= 0) {
 162                 JackLog("JackShmReadWritePtr::Init %ld %ld\n", index, fInfo.index);
 163                 if (jack_initialize_shm_client() < 0)
 164                     throw - 1;
 165                 fInfo.index = index;
 166                 if (jack_attach_shm(&fInfo)) {
 167                     //jack_error("cannot attach shared memory segment", strerror(errno));
 168                     throw - 2;
 169                 }
 170             }
 171         }
 172
 173     public:
 174
 175         JackShmReadWritePtr()
 176         {
 177             fInfo.index = -1;
 178             fInfo.attached_at = NULL;
 179         }
 180
 181         JackShmReadWritePtr(int index)
 182         {
 183             Init(index);
 184         }
 185
 186         virtual ~JackShmReadWritePtr()
 187         {
 188             if (fInfo.index >= 0) {
 189                 JackLog("JackShmReadWritePtr::~JackShmReadWritePtr %ld\n", fInfo.index);
 190                 jack_release_shm(&fInfo);
 191                 fInfo.index = -1;
 192             }
 193         }
 194
 195         T* operator->() const
 196         {
 197             return (T*)fInfo.attached_at;
 198         }
 199
 200         operator T*() const
 201         {
 202             return (T*)fInfo.attached_at;
 203         }
 204
 205         JackShmReadWritePtr& operator=(int index)
 206         {
 207             Init(index);
 208             return *this;
 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)
 235         {
 236             if (fInfo.index < 0 && index >= 0) {
 237                 JackLog("JackShmReadWritePtr1::Init %ld %ld\n", index, fInfo.index);
 238                 if (jack_initialize_shm_client() < 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)
 263         {
 264             Init(index);
 265         }
 266
 267         virtual ~JackShmReadWritePtr1()
 268         {
 269             if (fInfo.index >= 0) {
 270                 JackLog("JackShmReadWritePtr1::~JackShmReadWritePtr1 %ld\n", 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         int GetShmIndex()
 293         {
 294             return fInfo.index;
 295         }
 296
 297         T* GetShmAddress()
 298         {
 299             return (T*)fInfo.attached_at;
 300         }
 301 };
 302
 303 /*!
 304 \brief Pointer on shared memory segment in the client side.
 305 */
 306
 307 template <class T>
 308 class JackShmReadPtr
 309 {
 310
 311     private:
 312
 313         jack_shm_info_t fInfo;
 314
 315         void Init(int index)
 316         {
 317             if (fInfo.index < 0 && index >= 0) {
 318                 JackLog("JackShmPtrRead::Init %ld %ld\n", index, fInfo.index);
 319                 if (jack_initialize_shm_client() < 0)
 320                     throw - 1;
 321                 fInfo.index = index;
 322                 if (jack_attach_shm_read(&fInfo)) {
 323                     //jack_error("cannot attach shared memory segment", strerror(errno));
 324                     throw - 2;
 325                 }
 326             }
 327         }
 328
 329     public:
 330
 331         JackShmReadPtr()
 332         {
 333             fInfo.index = -1;
 334             fInfo.attached_at = NULL;
 335         }
 336
 337         JackShmReadPtr(int index)
 338         {
 339             Init(index);
 340         }
 341
 342         virtual ~JackShmReadPtr()
 343         {
 344             if (fInfo.index >= 0) {
 345                 JackLog("JackShmPtrRead::~JackShmPtrRead %ld\n", fInfo.index);
 346                 jack_release_shm(&fInfo);
 347                 fInfo.index = -1;
 348             }
 349         }
 350
 351         T* operator->() const
 352         {
 353             return (T*)fInfo.attached_at;
 354         }
 355
 356         operator T*() const
 357         {
 358             return (T*)fInfo.attached_at;
 359         }
 360
 361         JackShmReadPtr& operator=(int index)
 362         {
 363             Init(index);
 364             return *this;
 365         }
 366
 367         int GetShmIndex()
 368         {
 369             return fInfo.index;
 370         }
 371
 372         T* GetShmAddress()
 373         {
 374             return (T*)fInfo.attached_at;
 375         }
 376
 377 };
 378
 379 } // end of namespace
 380
 381 #endif