1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
|
/**************************************************************************/
/* */
/* OCaml */
/* */
/* KC Sivaramakrishnan, Indian Institute of Technology, Madras */
/* Stephen Dolan, University of Cambridge */
/* */
/* Copyright 2016 Indian Institute of Technology, Madras */
/* Copyright 2016 University of Cambridge */
/* */
/* All rights reserved. This file is distributed under the terms of */
/* the GNU Lesser General Public License version 2.1, with the */
/* special exception on linking described in the file LICENSE. */
/* */
/**************************************************************************/
#ifndef CAML_PLAT_THREADS_H
#define CAML_PLAT_THREADS_H
/* Platform-specific concurrency and memory primitives */
#ifdef CAML_INTERNALS
#include <pthread.h>
#include <errno.h>
#include <string.h>
#include "config.h"
#include "mlvalues.h"
#include "sys.h"
#if defined(MAP_ANON) && !defined(MAP_ANONYMOUS)
#define MAP_ANONYMOUS MAP_ANON
#endif
/* Hint for busy-waiting loops */
Caml_inline void cpu_relax(void) {
#ifdef __GNUC__
#if defined(__x86_64__) || defined(__i386__)
__asm__ volatile("pause" ::: "memory");
#elif defined(__aarch64__)
__asm__ volatile ("yield" ::: "memory");
#elif defined(__riscv)
/* Encoding of the pause instruction */
__asm__ volatile (".4byte 0x100000F");
#else
/* Just a compiler barrier */
__asm__ volatile ("" ::: "memory");
#endif
#endif
}
/* Loads and stores with acquire and release semantics respectively */
Caml_inline uintnat atomic_load_acq(atomic_uintnat* p)
{
return atomic_load_explicit(p, memory_order_acquire);
}
Caml_inline uintnat atomic_load_relaxed(atomic_uintnat* p)
{
return atomic_load_explicit(p, memory_order_relaxed);
}
Caml_inline void atomic_store_rel(atomic_uintnat* p, uintnat v)
{
atomic_store_explicit(p, v, memory_order_release);
}
Caml_inline void atomic_store_relaxed(atomic_uintnat* p, uintnat v)
{
atomic_store_explicit(p, v, memory_order_relaxed);
}
/* Spin-wait loops */
#define Max_spins 1000
CAMLextern unsigned caml_plat_spin_wait(unsigned spins,
const char* file, int line,
const char* function);
#define GENSYM_3(name, l) name##l
#define GENSYM_2(name, l) GENSYM_3(name, l)
#define GENSYM(name) GENSYM_2(name, __LINE__)
#define SPIN_WAIT \
unsigned GENSYM(caml__spins) = 0; \
for (; 1; cpu_relax(), \
GENSYM(caml__spins) = \
CAMLlikely(GENSYM(caml__spins) < Max_spins) ? \
GENSYM(caml__spins) + 1 : \
caml_plat_spin_wait(GENSYM(caml__spins), \
__FILE__, __LINE__, __func__))
Caml_inline uintnat atomic_load_wait_nonzero(atomic_uintnat* p) {
SPIN_WAIT {
uintnat v = atomic_load_acq(p);
if (v) return v;
}
}
/* Atomic read-modify-write instructions, with full fences */
Caml_inline uintnat atomic_fetch_add_verify_ge0(atomic_uintnat* p, uintnat v) {
uintnat result = atomic_fetch_add(p,v);
CAMLassert ((intnat)result > 0);
return result;
}
typedef pthread_mutex_t caml_plat_mutex;
#define CAML_PLAT_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
void caml_plat_mutex_init(caml_plat_mutex*);
Caml_inline void caml_plat_lock(caml_plat_mutex*);
Caml_inline int caml_plat_try_lock(caml_plat_mutex*);
void caml_plat_assert_locked(caml_plat_mutex*);
void caml_plat_assert_all_locks_unlocked(void);
Caml_inline void caml_plat_unlock(caml_plat_mutex*);
void caml_plat_mutex_free(caml_plat_mutex*);
typedef struct { pthread_cond_t cond; caml_plat_mutex* mutex; } caml_plat_cond;
#define CAML_PLAT_COND_INITIALIZER(m) { PTHREAD_COND_INITIALIZER, m }
void caml_plat_cond_init(caml_plat_cond*, caml_plat_mutex*);
void caml_plat_wait(caml_plat_cond*);
/* like caml_plat_wait, but if nanoseconds surpasses the second parameter
without a signal, then this function returns 1. */
void caml_plat_broadcast(caml_plat_cond*);
void caml_plat_signal(caml_plat_cond*);
void caml_plat_cond_free(caml_plat_cond*);
/* Memory management primitives (mmap) */
uintnat caml_mem_round_up_pages(uintnat size);
/* The size given to caml_mem_map and caml_mem_commit must be a multiple of
caml_plat_pagesize. The size given to caml_mem_unmap and caml_mem_decommit
must match the size given to caml_mem_map/caml_mem_commit for mem.
The Windows and Cygwin implementations do not support arbitrary alignment
and will fail for alignment values greater than caml_plat_mmap_alignment.
Luckily, this value is rather large on those platforms: 64KiB. This is enough
for all alignments used in the runtime system so far, the larger being the
major heap pools aligned on 32KiB boundaries. */
void* caml_mem_map(uintnat size, uintnat alignment, int reserve_only);
void* caml_mem_commit(void* mem, uintnat size);
void caml_mem_decommit(void* mem, uintnat size);
void caml_mem_unmap(void* mem, uintnat size);
CAMLnoreturn_start
void caml_plat_fatal_error(const char * action, int err)
CAMLnoreturn_end;
Caml_inline void check_err(const char* action, int err)
{
if (err) caml_plat_fatal_error(action, err);
}
#ifdef DEBUG
static __thread int lockdepth;
#define DEBUG_LOCK(m) (lockdepth++)
#define DEBUG_UNLOCK(m) (lockdepth--)
#else
#define DEBUG_LOCK(m)
#define DEBUG_UNLOCK(m)
#endif
Caml_inline void caml_plat_lock(caml_plat_mutex* m)
{
check_err("lock", pthread_mutex_lock(m));
DEBUG_LOCK(m);
}
Caml_inline int caml_plat_try_lock(caml_plat_mutex* m)
{
int r = pthread_mutex_trylock(m);
if (r == EBUSY) {
return 0;
} else {
check_err("try_lock", r);
DEBUG_LOCK(m);
return 1;
}
}
Caml_inline void caml_plat_unlock(caml_plat_mutex* m)
{
DEBUG_UNLOCK(m);
check_err("unlock", pthread_mutex_unlock(m));
}
extern intnat caml_plat_pagesize;
extern intnat caml_plat_mmap_alignment;
#endif /* CAML_INTERNALS */
#endif /* CAML_PLATFORM_H */
|
