mono/metadata/monitor.h

   1 /**
   2  * \file
   3  * Monitor locking functions
   4  *
   5  * Author:
   6  *      Dick Porter (dick@ximian.com)
   7  *
   8  * (C) 2003 Ximian, Inc
   9  */
  10
  11 #ifndef _MONO_METADATA_MONITOR_H_
  12 #define _MONO_METADATA_MONITOR_H_
  13
  14 #include <glib.h>
  15 #include <mono/metadata/object.h>
  16 #include <mono/utils/mono-compiler.h>
  17 #include <mono/utils/mono-coop-mutex.h>
  18
  19 G_BEGIN_DECLS
  20
  21 #define OWNER_MASK              0x0000ffff
  22 #define ENTRY_COUNT_MASK        0xffff0000
  23 #define ENTRY_COUNT_WAITERS     0x80000000
  24 #define ENTRY_COUNT_ZERO        0x7fff0000
  25 #define ENTRY_COUNT_SHIFT       16
  26
  27 struct _MonoThreadsSync
  28 {
  29         /*
  30          * The entry count field can be negative, which would mean that the entry_sem is
  31          * signaled and nobody is waiting to acquire it. This can happen when the thread
  32          * that was waiting is either interrupted or timeouts, and the owner releases
  33          * the lock before the forementioned thread updates the entry count.
  34          *
  35          * The 0 entry_count value is encoded as ENTRY_COUNT_ZERO, positive numbers being
  36          * greater than it and negative numbers smaller than it.
  37          */
  38         guint32 status;                 /* entry_count (16) | owner_id (16) */
  39         guint32 nest;
  40 #ifdef HAVE_MOVING_COLLECTOR
  41         gint32 hash_code;
  42 #endif
  43         GSList *wait_list;
  44         void *data;
  45         MonoCoopMutex *entry_mutex;
  46         MonoCoopCond *entry_cond;
  47 };
  48
  49 /*
  50  * Lock word format:
  51  *
  52  * The least significant bit stores whether a hash for the object is computed
  53  * which is stored either in the lock word or in the MonoThreadsSync structure
  54  * that the lock word points to.
  55  *
  56  * The second bit stores whether the lock word is inflated, containing an
  57  * address to the MonoThreadsSync structure.
  58  *
  59  * If both bits are 0, either the lock word is free (entire lock word is 0)
  60  * or it is a thin/flat lock.
  61  *
  62  * 32-bit
  63  *            LOCK_WORD_FLAT:    [owner:22 | nest:8 | status:2]
  64  *       LOCK_WORD_THIN_HASH:    [hash:30 | status:2]
  65  *        LOCK_WORD_INFLATED:    [sync:30 | status:2]
  66  *        LOCK_WORD_FAT_HASH:    [sync:30 | status:2]
  67  *
  68  * 64-bit
  69  *            LOCK_WORD_FLAT:    [unused:22 | owner:32 | nest:8 | status:2]
  70  *       LOCK_WORD_THIN_HASH:    [hash:62 | status:2]
  71  *        LOCK_WORD_INFLATED:    [sync:62 | status:2]
  72  *        LOCK_WORD_FAT_HASH:    [sync:62 | status:2]
  73  *
  74  * In order to save processing time and to have one additional value, the nest
  75  * count starts from 0 for the lock word (just valid thread ID in the lock word
  76  * means that the thread holds the lock once, although nest is 0).
  77  * FIXME Have the same convention on inflated locks
  78  */
  79
  80 typedef union {
  81 #if SIZEOF_REGISTER == 8
  82         guint64 lock_word;
  83 #elif SIZEOF_REGISTER == 4
  84         guint32 lock_word;
  85 #endif
  86         MonoThreadsSync *sync;
  87 } LockWord;
  88
  89
  90 enum {
  91         LOCK_WORD_FLAT = 0,
  92         LOCK_WORD_HAS_HASH = 1,
  93         LOCK_WORD_INFLATED = 2,
  94
  95         LOCK_WORD_STATUS_BITS = 2,
  96         LOCK_WORD_NEST_BITS = 8,
  97
  98         LOCK_WORD_STATUS_MASK = (1 << LOCK_WORD_STATUS_BITS) - 1,
  99         LOCK_WORD_NEST_MASK = ((1 << LOCK_WORD_NEST_BITS) - 1) << LOCK_WORD_STATUS_BITS,
 100
 101         LOCK_WORD_HASH_SHIFT = LOCK_WORD_STATUS_BITS,
 102         LOCK_WORD_NEST_SHIFT = LOCK_WORD_STATUS_BITS,
 103         LOCK_WORD_OWNER_SHIFT = LOCK_WORD_STATUS_BITS + LOCK_WORD_NEST_BITS
 104 };
 105
 106 MONO_API void mono_locks_dump (gboolean include_untaken);
 107
 108 void mono_monitor_init (void);
 109 void mono_monitor_cleanup (void);
 110
 111 MonoBoolean mono_monitor_enter_internal (MonoObject *obj);
 112 void mono_monitor_enter_v4_internal (MonoObject *obj, MonoBoolean *lock_taken);
 113
 114 guint32 mono_monitor_enter_fast (MonoObject *obj);
 115 guint32 mono_monitor_enter_v4_fast (MonoObject *obj, MonoBoolean *lock_taken);
 116
 117 guint32 mono_monitor_get_object_monitor_gchandle (MonoObject *object);
 118
 119 void mono_monitor_threads_sync_members_offset (int *status_offset, int *nest_offset);
 120 #define MONO_THREADS_SYNC_MEMBER_OFFSET(o)      ((o)>>8)
 121 #define MONO_THREADS_SYNC_MEMBER_SIZE(o)        ((o)&0xff)
 122
 123 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj);
 124 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj);
 125 extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj);
 126 extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj);
 127 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms);
 128 extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, MonoBoolean *lockTaken);
 129 extern void ves_icall_System_Threading_Monitor_Monitor_Enter (MonoObject *obj);
 130 G_END_DECLS
 131
 132 #endif /* _MONO_METADATA_MONITOR_H_ */