lib/base/object.h

   1 #ifndef __base_object_h
   2 #define __base_object_h
   3
   4 #include <assert.h>
   5 #include <lib/base/smartptr.h>
   6 #include <lib/base/elock.h>
   7
   8 //#define OBJECT_DEBUG
   9
  10 #include <lib/base/eerror.h>
  11
  12 typedef int RESULT;
  13
  14 class iObject
  15 {
  16 private:
  17                 /* we don't allow the default operator here, as it would break the refcount. */
  18         void operator=(const iObject &);
  19 protected:
  20         void operator delete(void *p) { ::operator delete(p); }
  21         virtual ~iObject() { }
  22 #ifdef SWIG
  23         virtual void AddRef()=0;
  24         virtual void Release()=0;
  25 #endif
  26 public:
  27 #ifndef SWIG
  28         virtual void AddRef()=0;
  29         virtual void Release()=0;
  30 #endif
  31 };
  32
  33 #ifndef SWIG
  34         struct oRefCount
  35         {
  36                 volatile int count;
  37                 oRefCount(): count(0) { }
  38                 operator volatile int&() { return count; }
  39                 ~oRefCount()
  40                 {
  41         #ifdef OBJECT_DEBUG
  42                         if (count)
  43                                 eDebug("OBJECT_DEBUG FATAL: %p has %d references!", this, count);
  44                         else
  45                                 eDebug("OBJECT_DEBUG refcount ok! (%p)", this);
  46         #endif
  47                 }
  48         };
  49
  50         #if defined(OBJECT_DEBUG)
  51                 extern int object_total_remaining;
  52                 #define DECLARE_REF(x)                  \
  53                         public: void AddRef();          \
  54                                         void Release();         \
  55                         private:oRefCount ref;          \
  56                                         eSingleLock ref_lock;
  57                 #define DEFINE_REF(c) \
  58                         void c::AddRef() \
  59                         { \
  60                                 eSingleLocker l(ref_lock); \
  61                                 ++object_total_remaining; \
  62                                 ++ref; \
  63                                 eDebug("OBJECT_DEBUG " #c "+%p now %d", this, (int)ref); \
  64                         } \
  65                         void c::Release() \
  66                         { \
  67                                 { \
  68                                         eSingleLocker l(ref_lock); \
  69                                         --object_total_remaining; \
  70                                         --ref; \
  71                                         eDebug("OBJECT_DEBUG " #c "-%p now %d", this, (int)ref); \
  72                                 } \
  73                                 if (!ref) \
  74                                         delete this; \
  75                         }
  76         #elif defined(__mips__)
  77                 #define DECLARE_REF(x)                  \
  78                         public: void AddRef();          \
  79                                         void Release();         \
  80                         private: oRefCount ref;
  81                 #define DEFINE_REF(c) \
  82                         void c::AddRef() \
  83                         { \
  84                                 unsigned long temp; \
  85                                 __asm__ __volatile__( \
  86                                 "               .set    mips3                                                                                   \n" \
  87                                 "1:             ll              %0, %1  # load counter                                                  \n" \
  88                                 "               .set    mips0                                                                                   \n" \
  89                                 "               addu    %0, 1   # increment                                                             \n" \
  90                                 "               .set    mips3                                                                                   \n" \
  91                                 "               sc              %0, %1  # try to store, checking for atomicity  \n" \
  92                                 "               .set    mips0                                                                                   \n" \
  93                                 "               beqz    %0, 1b  # if not atomic (0), try again                  \n" \
  94                                 : "=&r" (temp), "=m" (ref.count) \
  95                                 : "m" (ref.count) \
  96                                 : ); \
  97                         } \
  98                         void c::Release() \
  99                         { \
 100                                 unsigned long temp; \
 101                                 __asm__ __volatile__( \
 102                                 "               .set    mips3                           \n" \
 103                                 "1:             ll              %0, %1                          \n" \
 104                                 "               .set    mips0                           \n" \
 105                                 "               subu    %0, 1   # decrement     \n" \
 106                                 "               .set    mips3                           \n" \
 107                                 "               sc              %0, %1                          \n" \
 108                                 "               .set    mips0                           \n" \
 109                                 "               beqz    %0, 1b                          \n" \
 110                                 : "=&r" (temp), "=m" (ref.count) \
 111                                 : "m" (ref.count) \
 112                                 : ); \
 113                                 if (!ref) \
 114                                         delete this; \
 115                         }
 116         #elif defined(__ppc__) || defined(__powerpc__)
 117                 #define DECLARE_REF(x)                  \
 118                         public: void AddRef();          \
 119                                         void Release();         \
 120                         private: oRefCount ref;
 121                 #define DEFINE_REF(c) \
 122                         void c::AddRef() \
 123                         { \
 124                                 int temp; \
 125                                 __asm__ __volatile__( \
 126                                 "1:             lwarx   %0, 0, %3       \n" \
 127                                 "               add             %0, %2, %0      \n" \
 128                                 "               dcbt    0, %3           # workaround for PPC405CR Errata\n" \
 129                                 "               stwcx.  %0, 0, %3       \n" \
 130                                 "               bne-    1b                      \n" \
 131                                 : "=&r" (temp), "=m" (ref.count) \
 132                                 : "r" (1), "r" (&ref.count), "m" (ref.count) \
 133                                 : "cc"); \
 134                         } \
 135                         void c::Release() \
 136                         { \
 137                                 int temp; \
 138                                 __asm__ __volatile__( \
 139                                 "1:             lwarx   %0, 0, %3       \n" \
 140                                 "               subf    %0, %2, %0      \n" \
 141                                 "               dcbt    0, %3           # workaround for PPC405CR Errata\n" \
 142                                 "               stwcx.  %0, 0, %3       \n" \
 143                                 "               bne-    1b                      \n" \
 144                                 : "=&r" (temp), "=m" (ref.count) \
 145                                 : "r" (1), "r" (&ref.count), "m" (ref.count) \
 146                                 : "cc"); \
 147                                 if (!ref) \
 148                                         delete this; \
 149                         }
 150         #elif defined(__i386__) || defined(__x86_64__)
 151                 #define DECLARE_REF(x)                  \
 152                         public: void AddRef();          \
 153                                         void Release();         \
 154                         private: oRefCount ref;
 155                 #define DEFINE_REF(c) \
 156                         void c::AddRef() \
 157                         { \
 158                                 __asm__ __volatile__( \
 159                                 "               lock ; incl     %0      \n" \
 160                                 : "=m" (ref.count) \
 161                                 : "m" (ref.count)); \
 162                         } \
 163                         void c::Release() \
 164                         { \
 165                                 __asm__ __volatile__( \
 166                                 "               lock ; decl     %0      \n" \
 167                                 : "=m" (ref.count) \
 168                                 : "m" (ref.count)); \
 169                                 if (!ref) \
 170                                         delete this; \
 171                         }
 172         #else
 173                 #warning use non optimized implementation of refcounting.
 174                 #define DECLARE_REF(x)                  \
 175                         public: void AddRef();          \
 176                                         void Release();         \
 177                         private:oRefCount ref;  \
 178                                         eSingleLock ref_lock;
 179                 #define DEFINE_REF(c) \
 180                         void c::AddRef() \
 181                         { \
 182                                 eSingleLocker l(ref_lock); \
 183                                 ++ref; \
 184                         } \
 185                         void c::Release() \
 186                         { \
 187                                 { \
 188                                         eSingleLocker l(ref_lock); \
 189                                         --ref; \
 190                                 } \
 191                                 if (!ref) \
 192                                         delete this; \
 193                         }
 194         #endif
 195 #else  // SWIG
 196         #define DECLARE_REF(x) \
 197                 private: \
 198                         void AddRef(); \
 199                         void Release();
 200 #endif  // SWIG
 201
 202 #endif  // __base_object_h