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