common/JackShmMem.h

   1 /*
   2  Copyright (C) 2004-2008 Grame
   3
   4  This program is free software; you can redistribute it and/or modify
   5  it under the terms of the GNU Lesser General Public License as published by
   6  the Free Software Foundation; either version 2.1 of the License, or
   7  (at your option) any later version.
   8
   9  This program is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  GNU Lesser General Public License for more details.
  13
  14  You should have received a copy of the GNU Lesser General Public License
  15  along with this program; if not, write to the Free Software
  16  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18  */
  19
  20 #ifndef __JackShmMem__
  21 #define __JackShmMem__
  22
  23 #include "shm.h"
  24 #include "JackError.h"
  25 #include "JackCompilerDeps.h"
  26
  27 #include <new>  // GCC 4.0
  28 #include <errno.h>
  29 #include <stdlib.h>
  30
  31 #include "JackShmMem_os.h"
  32
  33 namespace Jack
  34 {
  35
  36 void LockMemoryImp(void* ptr, size_t size);
  37 void InitLockMemoryImp(void* ptr, size_t size);
  38 void UnlockMemoryImp(void* ptr, size_t size);
  39 void LockAllMemory();
  40 void UnlockAllMemory();
  41
  42 /*!
  43 \brief
  44
  45 A class which objects possibly want to be allocated in shared memory derives from this class.
  46 */
  47
  48 class JackShmMemAble
  49 {
  50     protected:
  51
  52         jack_shm_info_t fInfo;
  53
  54     public:
  55
  56         void Init();
  57
  58         int GetShmIndex()
  59         {
  60             return fInfo.index;
  61         }
  62
  63         char* GetShmAddress()
  64         {
  65             return (char*)fInfo.ptr.attached_at;
  66         }
  67
  68         void LockMemory()
  69         {
  70             LockMemoryImp(this, fInfo.size);
  71         }
  72
  73         void UnlockMemory()
  74         {
  75             UnlockMemoryImp(this, fInfo.size);
  76         }
  77
  78 };
  79
  80 /*!
  81 \brief The base class for shared memory management.
  82
  83 A class which objects need to be allocated in shared memory derives from this class.
  84 */
  85
  86 class SERVER_EXPORT JackShmMem : public JackShmMemAble
  87 {
  88
  89      protected:
  90
  91         JackShmMem();
  92         ~JackShmMem();
  93
  94     public:
  95
  96         void* operator new(size_t size);
  97         void* operator new(size_t size, void* memory);
  98
  99         void operator delete(void* p, size_t size);
 100                 void operator delete(void* p);
 101
 102 };
 103
 104 /*!
 105 \brief Pointer on shared memory segment in the client side.
 106 */
 107
 108 template <class T>
 109 class JackShmReadWritePtr
 110 {
 111
 112     private:
 113
 114         jack_shm_info_t fInfo;
 115         bool fInitDone;
 116
 117         void Init(int index, const char* server_name = JACK_DEFAULT_SERVER_NAME)
 118         {
 119             if (fInfo.index < 0 && index >= 0) {
 120                 jack_log("JackShmReadWritePtr::Init %ld %d", index, fInfo.index);
 121                 if (jack_initialize_shm(server_name) < 0) {
 122                     throw std::bad_alloc();
 123                 }
 124                 fInfo.index = index;
 125                 if (jack_attach_lib_shm(&fInfo)) {
 126                     throw std::bad_alloc();
 127                 }
 128                 GetShmAddress()->LockMemory();
 129                 fInitDone = true;
 130             }
 131         }
 132
 133     public:
 134
 135         JackShmReadWritePtr()
 136         {
 137             fInfo.index = -1;
 138             fInitDone = false;
 139             fInfo.ptr.attached_at = (char*)NULL;
 140         }
 141
 142         JackShmReadWritePtr(int index, const char* server_name)
 143         {
 144             Init(index, server_name);
 145         }
 146
 147         ~JackShmReadWritePtr()
 148         {
 149             if (!fInitDone) {
 150                jack_error("JackShmReadWritePtr::~JackShmReadWritePtr - Init not done for %d, skipping unlock", fInfo.index);
 151                return;
 152             }
 153             if (fInfo.index >= 0) {
 154                 jack_log("JackShmReadWritePtr::~JackShmReadWritePtr %d", fInfo.index);
 155                 GetShmAddress()->UnlockMemory();
 156                 jack_release_lib_shm(&fInfo);
 157                 fInfo.index = -1;
 158              }
 159         }
 160
 161         T* operator->() const
 162         {
 163             return (T*)fInfo.ptr.attached_at;
 164         }
 165
 166         operator T*() const
 167         {
 168             return (T*)fInfo.ptr.attached_at;
 169         }
 170
 171         JackShmReadWritePtr& operator=(int index)
 172         {
 173             Init(index);
 174             return *this;
 175         }
 176
 177         void SetShmIndex(int index, const char* server_name)
 178         {
 179             Init(index, server_name);
 180         }
 181
 182         int GetShmIndex()
 183         {
 184             return fInfo.index;
 185         }
 186
 187         T* GetShmAddress()
 188         {
 189             return (T*)fInfo.ptr.attached_at;
 190         }
 191 };
 192
 193 /*!
 194 \brief Pointer on shared memory segment in the client side: destroy the segment (used client control)
 195 */
 196
 197 template <class T>
 198 class JackShmReadWritePtr1
 199 {
 200
 201     private:
 202
 203         jack_shm_info_t fInfo;
 204         bool fInitDone;
 205
 206         void Init(int index, const char* server_name = JACK_DEFAULT_SERVER_NAME)
 207         {
 208             if (fInfo.index < 0 && index >= 0) {
 209                 jack_log("JackShmReadWritePtr1::Init %ld %d", index, fInfo.index);
 210                 if (jack_initialize_shm(server_name) < 0) {
 211                     throw std::bad_alloc();
 212                 }
 213                 fInfo.index = index;
 214                 if (jack_attach_lib_shm(&fInfo)) {
 215                     throw std::bad_alloc();
 216                 }
 217                 GetShmAddress()->LockMemory();
 218                 fInitDone = true;
 219                 /*
 220                 nobody else needs to access this shared memory any more, so
 221                 destroy it. because we have our own attachment to it, it won't
 222                 vanish till we exit (and release it).
 223                 */
 224                 jack_destroy_shm(&fInfo);
 225             }
 226         }
 227
 228     public:
 229
 230         JackShmReadWritePtr1()
 231         {
 232             fInfo.index = -1;
 233             fInitDone = false;
 234             fInfo.ptr.attached_at = NULL;
 235         }
 236
 237         JackShmReadWritePtr1(int index, const char* server_name)
 238         {
 239             Init(index, server_name);
 240         }
 241
 242         ~JackShmReadWritePtr1()
 243         {
 244             if (!fInitDone) {
 245                jack_error("JackShmReadWritePtr1::~JackShmReadWritePtr1 - Init not done for %d, skipping unlock", fInfo.index);
 246                return;
 247             }
 248             if (fInfo.index >= 0) {
 249                 jack_log("JackShmReadWritePtr1::~JackShmReadWritePtr1 %d", fInfo.index);
 250                 GetShmAddress()->UnlockMemory();
 251                 jack_release_lib_shm(&fInfo);
 252                 fInfo.index = -1;
 253             }
 254         }
 255
 256         T* operator->() const
 257         {
 258             return (T*)fInfo.ptr.attached_at;
 259         }
 260
 261         operator T*() const
 262         {
 263             return (T*)fInfo.ptr.attached_at;
 264         }
 265
 266         JackShmReadWritePtr1& operator=(int index)
 267         {
 268             Init(index);
 269             return *this;
 270         }
 271
 272         void SetShmIndex(int index, const char* server_name)
 273         {
 274             Init(index, server_name);
 275         }
 276
 277         int GetShmIndex()
 278         {
 279             return fInfo.index;
 280         }
 281
 282         T* GetShmAddress()
 283         {
 284             return (T*)fInfo.ptr.attached_at;
 285         }
 286 };
 287
 288 /*!
 289 \brief Pointer on shared memory segment in the client side.
 290 */
 291
 292 template <class T>
 293 class JackShmReadPtr
 294 {
 295
 296     private:
 297
 298         jack_shm_info_t fInfo;
 299         bool fInitDone;
 300
 301         void Init(int index, const char* server_name = JACK_DEFAULT_SERVER_NAME)
 302         {
 303             if (fInfo.index < 0 && index >= 0) {
 304                 jack_log("JackShmPtrRead::Init %ld %d", index, fInfo.index);
 305                 if (jack_initialize_shm(server_name) < 0) {
 306                     throw std::bad_alloc();
 307                 }
 308                 fInfo.index = index;
 309                 if (jack_attach_lib_shm_read(&fInfo)) {
 310                     throw std::bad_alloc();
 311                 }
 312                 GetShmAddress()->LockMemory();
 313                 fInitDone = true;
 314             }
 315         }
 316
 317     public:
 318
 319         JackShmReadPtr()
 320         {
 321             fInfo.index = -1;
 322             fInitDone = false;
 323             fInfo.ptr.attached_at = NULL;
 324         }
 325
 326         JackShmReadPtr(int index, const char* server_name)
 327         {
 328             Init(index, server_name);
 329         }
 330
 331         ~JackShmReadPtr()
 332         {
 333             if (!fInitDone) {
 334                jack_error("JackShmReadPtr::~JackShmReadPtr - Init not done for %ld, skipping unlock", fInfo.index);
 335                return;
 336             }
 337             if (fInfo.index >= 0) {
 338                 jack_log("JackShmPtrRead::~JackShmPtrRead %ld", fInfo.index);
 339                 GetShmAddress()->UnlockMemory();
 340                 jack_release_lib_shm(&fInfo);
 341                 fInfo.index = -1;
 342             }
 343         }
 344
 345         T* operator->() const
 346         {
 347             return (T*)fInfo.ptr.attached_at;
 348         }
 349
 350         operator T*() const
 351         {
 352             return (T*)fInfo.ptr.attached_at;
 353         }
 354
 355         JackShmReadPtr& operator=(int index)
 356         {
 357             Init(index);
 358             return *this;
 359         }
 360
 361         void SetShmIndex(int index, const char* server_name)
 362         {
 363             Init(index, server_name);
 364         }
 365
 366         int GetShmIndex()
 367         {
 368             return fInfo.index;
 369         }
 370
 371         T* GetShmAddress()
 372         {
 373             return (T*)fInfo.ptr.attached_at;
 374         }
 375
 376 };
 377
 378 } // end of namespace
 379
 380 #endif