libphobos/libdruntime/rt/monitor_.d

   1 /**
   2  * Contains the implementation for object monitors.
   3  *
   4  * Copyright: Copyright Digital Mars 2000 - 2015.
   5  * License:   $(HTTP www.boost.org/LICENSE_1_0.txt, Boost License 1.0).
   6  * Authors:   Walter Bright, Sean Kelly, Martin Nowak
   7  * Source: $(DRUNTIMESRC rt/_monitor_.d)
   8  */
   9
  10 /* NOTE: This file has been patched from the original DMD distribution to
  11  * work with the GDC compiler.
  12  */
  13 module rt.monitor_;
  14
  15 import core.atomic, core.stdc.stdlib, core.stdc.string;
  16
  17 // NOTE: The dtor callback feature is only supported for monitors that are not
  18 //       supplied by the user.  The assumption is that any object with a user-
  19 //       supplied monitor may have special storage or lifetime requirements and
  20 //       that as a result, storing references to local objects within Monitor
  21 //       may not be safe or desirable.  Thus, devt is only valid if impl is
  22 //       null.
  23
  24 extern (C) void _d_setSameMutex(shared Object ownee, shared Object owner) nothrow
  25 in
  26 {
  27     assert(ownee.__monitor is null);
  28 }
  29 do
  30 {
  31     auto m = ensureMonitor(cast(Object) owner);
  32     if (m.impl is null)
  33     {
  34         atomicOp!("+=")(m.refs, cast(size_t) 1);
  35     }
  36     // Assume the monitor is garbage collected and simply copy the reference.
  37     ownee.__monitor = owner.__monitor;
  38 }
  39
  40 extern (C) void _d_monitordelete(Object h, bool det)
  41 {
  42     auto m = getMonitor(h);
  43     if (m is null)
  44         return;
  45
  46     if (m.impl)
  47     {
  48         // let the GC collect the monitor
  49         setMonitor(h, null);
  50     }
  51     else if (!atomicOp!("-=")(m.refs, cast(size_t) 1))
  52     {
  53         // refcount == 0 means unshared => no synchronization required
  54         disposeEvent(cast(Monitor*) m, h);
  55         deleteMonitor(cast(Monitor*) m);
  56         setMonitor(h, null);
  57     }
  58 }
  59
  60 // does not call dispose events, for internal use only
  61 extern (C) void _d_monitordelete_nogc(Object h) @nogc
  62 {
  63     auto m = getMonitor(h);
  64     if (m is null)
  65         return;
  66
  67     if (m.impl)
  68     {
  69         // let the GC collect the monitor
  70         setMonitor(h, null);
  71     }
  72     else if (!atomicOp!("-=")(m.refs, cast(size_t) 1))
  73     {
  74         // refcount == 0 means unshared => no synchronization required
  75         deleteMonitor(cast(Monitor*) m);
  76         setMonitor(h, null);
  77     }
  78 }
  79
  80 extern (C) void _d_monitorenter(Object h)
  81 in
  82 {
  83     assert(h !is null, "Synchronized object must not be null.");
  84 }
  85 do
  86 {
  87     auto m = cast(Monitor*) ensureMonitor(h);
  88     auto i = m.impl;
  89     if (i is null)
  90         lockMutex(&m.mtx);
  91     else
  92         i.lock();
  93 }
  94
  95 extern (C) void _d_monitorexit(Object h)
  96 {
  97     auto m = cast(Monitor*) getMonitor(h);
  98     auto i = m.impl;
  99     if (i is null)
 100         unlockMutex(&m.mtx);
 101     else
 102         i.unlock();
 103 }
 104
 105 extern (C) void rt_attachDisposeEvent(Object h, DEvent e)
 106 {
 107     synchronized (h)
 108     {
 109         auto m = cast(Monitor*) getMonitor(h);
 110         assert(m.impl is null);
 111
 112         foreach (ref v; m.devt)
 113         {
 114             if (v is null || v == e)
 115             {
 116                 v = e;
 117                 return;
 118             }
 119         }
 120
 121         auto len = m.devt.length + 4; // grow by 4 elements
 122         auto pos = m.devt.length; // insert position
 123         auto p = realloc(m.devt.ptr, DEvent.sizeof * len);
 124         import core.exception : onOutOfMemoryError;
 125
 126         if (!p)
 127             onOutOfMemoryError();
 128         m.devt = (cast(DEvent*) p)[0 .. len];
 129         m.devt[pos + 1 .. len] = null;
 130         m.devt[pos] = e;
 131     }
 132 }
 133
 134 extern (C) void rt_detachDisposeEvent(Object h, DEvent e)
 135 {
 136     synchronized (h)
 137     {
 138         auto m = cast(Monitor*) getMonitor(h);
 139         assert(m.impl is null);
 140
 141         foreach (p, v; m.devt)
 142         {
 143             if (v == e)
 144             {
 145                 memmove(&m.devt[p], &m.devt[p + 1], (m.devt.length - p - 1) * DEvent.sizeof);
 146                 m.devt[$ - 1] = null;
 147                 return;
 148             }
 149         }
 150     }
 151 }
 152
 153 nothrow:
 154
 155 extern (C) void _d_monitor_staticctor()
 156 {
 157     version (Posix)
 158     {
 159         pthread_mutexattr_init(&gattr);
 160         pthread_mutexattr_settype(&gattr, PTHREAD_MUTEX_RECURSIVE);
 161     }
 162     initMutex(&gmtx);
 163 }
 164
 165 extern (C) void _d_monitor_staticdtor()
 166 {
 167     destroyMutex(&gmtx);
 168     version (Posix)
 169         pthread_mutexattr_destroy(&gattr);
 170 }
 171
 172 package:
 173
 174 // This is what the monitor reference in Object points to
 175 alias IMonitor = Object.Monitor;
 176 alias DEvent = void delegate(Object);
 177
 178 version (GNU)
 179 {
 180     import gcc.config;
 181     static if (GNU_Thread_Model == ThreadModel.Single)
 182         version = SingleThreaded;
 183     // Ignore ThreadModel, we don't want posix threads on windows and
 184     // will always use native threading instead.
 185 }
 186
 187 version (SingleThreaded)
 188 {
 189 @nogc:
 190     alias Mutex = int;
 191
 192     void initMutex(Mutex* mtx)
 193     {
 194     }
 195
 196     void destroyMutex(Mutex* mtx)
 197     {
 198     }
 199
 200     void lockMutex(Mutex* mtx)
 201     {
 202     }
 203
 204     void unlockMutex(Mutex* mtx)
 205     {
 206     }
 207 }
 208 else version (Windows)
 209 {
 210     version (CRuntime_DigitalMars)
 211     {
 212         pragma(lib, "snn.lib");
 213     }
 214     import core.sys.windows.winbase /+: CRITICAL_SECTION, DeleteCriticalSection,
 215         EnterCriticalSection, InitializeCriticalSection, LeaveCriticalSection+/;
 216
 217     alias Mutex = CRITICAL_SECTION;
 218
 219     alias initMutex = InitializeCriticalSection;
 220     alias destroyMutex = DeleteCriticalSection;
 221     alias lockMutex = EnterCriticalSection;
 222     alias unlockMutex = LeaveCriticalSection;
 223 }
 224 else version (Posix)
 225 {
 226     import core.sys.posix.pthread;
 227
 228 @nogc:
 229     alias Mutex = pthread_mutex_t;
 230     __gshared pthread_mutexattr_t gattr;
 231
 232     void initMutex(pthread_mutex_t* mtx)
 233     {
 234         pthread_mutex_init(mtx, &gattr) && assert(0);
 235     }
 236
 237     void destroyMutex(pthread_mutex_t* mtx)
 238     {
 239         pthread_mutex_destroy(mtx) && assert(0);
 240     }
 241
 242     void lockMutex(pthread_mutex_t* mtx)
 243     {
 244         pthread_mutex_lock(mtx) && assert(0);
 245     }
 246
 247     void unlockMutex(pthread_mutex_t* mtx)
 248     {
 249         pthread_mutex_unlock(mtx) && assert(0);
 250     }
 251 }
 252 else
 253 {
 254     static assert(0, "Unsupported platform");
 255 }
 256
 257 struct Monitor
 258 {
 259     IMonitor impl; // for user-level monitors
 260     DEvent[] devt; // for internal monitors
 261     size_t refs; // reference count
 262     Mutex mtx;
 263 }
 264
 265 private:
 266
 267 @property ref shared(Monitor*) monitor(return scope Object h) pure nothrow @nogc
 268 {
 269     return *cast(shared Monitor**)&h.__monitor;
 270 }
 271
 272 private shared(Monitor)* getMonitor(Object h) pure @nogc
 273 {
 274     return atomicLoad!(MemoryOrder.acq)(h.monitor);
 275 }
 276
 277 void setMonitor(Object h, shared(Monitor)* m) pure @nogc
 278 {
 279     atomicStore!(MemoryOrder.rel)(h.monitor, m);
 280 }
 281
 282 __gshared Mutex gmtx;
 283
 284 shared(Monitor)* ensureMonitor(Object h)
 285 {
 286     if (auto m = getMonitor(h))
 287         return m;
 288
 289     auto m = cast(Monitor*) calloc(Monitor.sizeof, 1);
 290     assert(m);
 291     initMutex(&m.mtx);
 292
 293     bool success;
 294     lockMutex(&gmtx);
 295     if (getMonitor(h) is null)
 296     {
 297         m.refs = 1;
 298         setMonitor(h, cast(shared) m);
 299         success = true;
 300     }
 301     unlockMutex(&gmtx);
 302
 303     if (success)
 304     {
 305         // Set the finalize bit so that the monitor gets collected (Bugzilla 14573)
 306         import core.memory : GC;
 307
 308         if (!(typeid(h).m_flags & TypeInfo_Class.ClassFlags.hasDtor))
 309             GC.setAttr(cast(void*) h, GC.BlkAttr.FINALIZE);
 310         return cast(shared(Monitor)*) m;
 311     }
 312     else // another thread succeeded instead
 313     {
 314         deleteMonitor(m);
 315         return getMonitor(h);
 316     }
 317 }
 318
 319 void deleteMonitor(Monitor* m) @nogc
 320 {
 321     destroyMutex(&m.mtx);
 322     free(m);
 323 }
 324
 325 void disposeEvent(Monitor* m, Object h)
 326 {
 327     foreach (v; m.devt)
 328     {
 329         if (v)
 330             v(h);
 331     }
 332     if (m.devt.ptr)
 333         free(m.devt.ptr);
 334 }
 335
 336 // Bugzilla 14573
 337 unittest
 338 {
 339     import core.memory : GC;
 340
 341     auto obj = new Object;
 342     assert(!(GC.getAttr(cast(void*) obj) & GC.BlkAttr.FINALIZE));
 343     ensureMonitor(obj);
 344     assert(getMonitor(obj) !is null);
 345     assert(GC.getAttr(cast(void*) obj) & GC.BlkAttr.FINALIZE);
 346 }