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-semaphore.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         MonoCoopSem *entry_sem;
  46 };
  47
  48 /*
  49  * Lock word format:
  50  *
  51  * The least significant bit stores whether a hash for the object is computed
  52  * which is stored either in the lock word or in the MonoThreadsSync structure
  53  * that the lock word points to.
  54  *
  55  * The second bit stores whether the lock word is inflated, containing an
  56  * address to the MonoThreadsSync structure.
  57  *
  58  * If both bits are 0, either the lock word is free (entire lock word is 0)
  59  * or it is a thin/flat lock.
  60  *
  61  * 32-bit
  62  *            LOCK_WORD_FLAT:    [owner:22 | nest:8 | status:2]
  63  *       LOCK_WORD_THIN_HASH:    [hash:30 | status:2]
  64  *        LOCK_WORD_INFLATED:    [sync:30 | status:2]
  65  *        LOCK_WORD_FAT_HASH:    [sync:30 | status:2]
  66  *
  67  * 64-bit
  68  *            LOCK_WORD_FLAT:    [unused:22 | owner:32 | nest:8 | status:2]
  69  *       LOCK_WORD_THIN_HASH:    [hash:62 | status:2]
  70  *        LOCK_WORD_INFLATED:    [sync:62 | status:2]
  71  *        LOCK_WORD_FAT_HASH:    [sync:62 | status:2]
  72  *
  73  * In order to save processing time and to have one additional value, the nest
  74  * count starts from 0 for the lock word (just valid thread ID in the lock word
  75  * means that the thread holds the lock once, although nest is 0).
  76  * FIXME Have the same convention on inflated locks
  77  */
  78
  79 typedef union {
  80 #if SIZEOF_REGISTER == 8
  81         guint64 lock_word;
  82 #elif SIZEOF_REGISTER == 4
  83         guint32 lock_word;
  84 #endif
  85         MonoThreadsSync *sync;
  86 } LockWord;
  87
  88
  89 enum {
  90         LOCK_WORD_FLAT = 0,
  91         LOCK_WORD_HAS_HASH = 1,
  92         LOCK_WORD_INFLATED = 2,
  93
  94         LOCK_WORD_STATUS_BITS = 2,
  95         LOCK_WORD_NEST_BITS = 8,
  96
  97         LOCK_WORD_STATUS_MASK = (1 << LOCK_WORD_STATUS_BITS) - 1,
  98         LOCK_WORD_NEST_MASK = ((1 << LOCK_WORD_NEST_BITS) - 1) << LOCK_WORD_STATUS_BITS,
  99
 100         LOCK_WORD_HASH_SHIFT = LOCK_WORD_STATUS_BITS,
 101         LOCK_WORD_NEST_SHIFT = LOCK_WORD_STATUS_BITS,
 102         LOCK_WORD_OWNER_SHIFT = LOCK_WORD_STATUS_BITS + LOCK_WORD_NEST_BITS
 103 };
 104
 105 MONO_API void mono_locks_dump (gboolean include_untaken);
 106
 107 void mono_monitor_init (void);
 108 void mono_monitor_cleanup (void);
 109
 110 MonoBoolean mono_monitor_enter_internal (MonoObject *obj);
 111 void mono_monitor_enter_v4_internal (MonoObject *obj, MonoBoolean *lock_taken);
 112
 113 guint32 mono_monitor_enter_fast (MonoObject *obj);
 114 guint32 mono_monitor_enter_v4_fast (MonoObject *obj, MonoBoolean *lock_taken);
 115
 116 guint32 mono_monitor_get_object_monitor_gchandle (MonoObject *object);
 117
 118 void mono_monitor_threads_sync_members_offset (int *status_offset, int *nest_offset);
 119 #define MONO_THREADS_SYNC_MEMBER_OFFSET(o)      ((o)>>8)
 120 #define MONO_THREADS_SYNC_MEMBER_SIZE(o)        ((o)&0xff)
 121
 122 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_owner(MonoObject *obj);
 123 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_test_synchronised(MonoObject *obj);
 124 extern void ves_icall_System_Threading_Monitor_Monitor_pulse(MonoObject *obj);
 125 extern void ves_icall_System_Threading_Monitor_Monitor_pulse_all(MonoObject *obj);
 126 extern MonoBoolean ves_icall_System_Threading_Monitor_Monitor_wait(MonoObject *obj, guint32 ms);
 127 extern void ves_icall_System_Threading_Monitor_Monitor_try_enter_with_atomic_var (MonoObject *obj, guint32 ms, MonoBoolean *lockTaken);
 128
 129 G_END_DECLS
 130
 131 #endif /* _MONO_METADATA_MONITOR_H_ */