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
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
|
/*-
* Copyright (c) 2014-2016 MongoDB, Inc.
* Copyright (c) 2008-2014 WiredTiger, Inc.
* All rights reserved.
*
* See the file LICENSE for redistribution information.
*/
/*
* Quiet compiler warnings about unused function parameters and variables,
* and unused function return values.
*/
#define WT_UNUSED(var) (void)(var)
#define WT_IGNORE_RET(call) do { \
int __ignored_ret; \
__ignored_ret = (call); \
WT_UNUSED(__ignored_ret); \
} while (0)
#define WT_DIVIDER "=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-="
/* Basic constants. */
#define WT_THOUSAND (1000)
#define WT_MILLION (1000000)
#define WT_BILLION (1000000000)
#define WT_KILOBYTE (1024)
#define WT_MEGABYTE (1048576)
#define WT_GIGABYTE (1073741824)
#define WT_TERABYTE ((uint64_t)1099511627776)
#define WT_PETABYTE ((uint64_t)1125899906842624)
#define WT_EXABYTE ((uint64_t)1152921504606846976)
/*
* Sizes that cannot be larger than 2**32 are stored in uint32_t fields in
* common structures to save space. To minimize conversions from size_t to
* uint32_t through the code, we use the following macros.
*/
#define WT_STORE_SIZE(s) ((uint32_t)(s))
#define WT_PTRDIFF(end, begin) \
((size_t)((const uint8_t *)(end) - (const uint8_t *)(begin)))
#define WT_PTRDIFF32(end, begin) \
WT_STORE_SIZE(WT_PTRDIFF((end), (begin)))
#define WT_BLOCK_FITS(p, len, begin, maxlen) \
((const uint8_t *)(p) >= (const uint8_t *)(begin) && \
((const uint8_t *)(p) + (len) <= (const uint8_t *)(begin) + (maxlen)))
#define WT_PTR_IN_RANGE(p, begin, maxlen) \
WT_BLOCK_FITS((p), 1, (begin), (maxlen))
/*
* Align an unsigned value of any type to a specified power-of-2, including the
* offset result of a pointer subtraction; do the calculation using the largest
* unsigned integer type available.
*/
#define WT_ALIGN(n, v) \
((((uintmax_t)(n)) + ((v) - 1)) & ~(((uintmax_t)(v)) - 1))
#define WT_ALIGN_NEAREST(n, v) \
((((uintmax_t)(n)) + ((v) / 2)) & ~(((uintmax_t)(v)) - 1))
/* Min, max. */
#define WT_MIN(a, b) ((a) < (b) ? (a) : (b))
#define WT_MAX(a, b) ((a) < (b) ? (b) : (a))
/* Elements in an array. */
#define WT_ELEMENTS(a) (sizeof(a) / sizeof(a[0]))
/* 10 level skip lists, 1/4 have a link to the next element. */
#define WT_SKIP_MAXDEPTH 10
#define WT_SKIP_PROBABILITY (UINT32_MAX >> 2)
/*
* Encryption needs to know its original length before either the
* block or logging subsystems pad. Constant value.
*/
#define WT_ENCRYPT_LEN_SIZE sizeof(uint32_t)
/*
* __wt_calloc_def, __wt_calloc_one --
* Most calloc calls don't need separate count or sizeof arguments.
*/
#define __wt_calloc_def(session, number, addr) \
__wt_calloc(session, (size_t)(number), sizeof(**(addr)), addr)
#define __wt_calloc_one(session, addr) \
__wt_calloc(session, (size_t)1, sizeof(**(addr)), addr)
/*
* __wt_realloc_def --
* Common case allocate-and-grow function.
* Starts by allocating the requested number of items (at least 10), then
* doubles each time the list needs to grow.
*/
#define __wt_realloc_def(session, sizep, number, addr) \
(((number) * sizeof(**(addr)) <= *(sizep)) ? 0 : \
__wt_realloc(session, sizep, WT_MAX(*(sizep) * 2, \
WT_MAX(10, (number)) * sizeof(**(addr))), addr))
/*
* Our internal free function clears the underlying address atomically so there
* is a smaller chance of racing threads seeing intermediate results while a
* structure is being free'd. (That would be a bug, of course, but I'd rather
* not drop core, just the same.) That's a non-standard "free" API, and the
* resulting bug is a mother to find -- make sure we get it right, don't make
* the caller remember to put the & operator on the pointer.
*/
#define __wt_free(session, p) do { \
void *__p = &(p); \
if (*(void **)__p != NULL) \
__wt_free_int(session, __p); \
} while (0)
#ifdef HAVE_DIAGNOSTIC
#define __wt_overwrite_and_free(session, p) do { \
memset(p, WT_DEBUG_BYTE, sizeof(*(p))); \
__wt_free(session, p); \
} while (0)
#define __wt_overwrite_and_free_len(session, p, len) do { \
memset(p, WT_DEBUG_BYTE, len); \
__wt_free(session, p); \
} while (0)
#else
#define __wt_overwrite_and_free(session, p) __wt_free(session, p)
#define __wt_overwrite_and_free_len(session, p, len) __wt_free(session, p)
#endif
/*
* Flag set, clear and test.
*
* They come in 3 flavors: F_XXX (handles a field named "flags" in the structure
* referenced by its argument), LF_XXX (handles a local variable named "flags"),
* and FLD_XXX (handles any variable, anywhere).
*
* Flags are unsigned 32-bit values -- we cast to keep the compiler quiet (the
* hex constant might be a negative integer), and to ensure the hex constant is
* the correct size before applying the bitwise not operator.
*/
#define FLD_CLR(field, mask) ((void)((field) &= ~(uint32_t)(mask)))
#define FLD_MASK(field, mask) ((field) & (uint32_t)(mask))
#define FLD_ISSET(field, mask) (FLD_MASK(field, mask) != 0)
#define FLD64_ISSET(field, mask) (((field) & (uint64_t)(mask)) != 0)
#define FLD_SET(field, mask) ((void)((field) |= (uint32_t)(mask)))
#define F_CLR(p, mask) FLD_CLR((p)->flags, mask)
#define F_ISSET(p, mask) FLD_ISSET((p)->flags, mask)
#define F_MASK(p, mask) FLD_MASK((p)->flags, mask)
#define F_SET(p, mask) FLD_SET((p)->flags, mask)
#define LF_CLR(mask) FLD_CLR(flags, mask)
#define LF_ISSET(mask) FLD_ISSET(flags, mask)
#define LF_MASK(mask) FLD_MASK(flags, mask)
#define LF_SET(mask) FLD_SET(flags, mask)
/*
* Insertion sort, for sorting small sets of values.
*
* The "compare_lt" argument is a function or macro that returns true when
* its first argument is less than its second argument.
*/
#define WT_INSERTION_SORT(arrayp, n, value_type, compare_lt) do { \
value_type __v; \
int __i, __j, __n = (int)(n); \
if (__n == 2) { \
__v = (arrayp)[1]; \
if (compare_lt(__v, (arrayp)[0])) { \
(arrayp)[1] = (arrayp)[0]; \
(arrayp)[0] = __v; \
} \
} \
if (__n > 2) { \
for (__i = 1; __i < __n; ++__i) { \
__v = (arrayp)[__i]; \
for (__j = __i - 1; __j >= 0 && \
compare_lt(__v, (arrayp)[__j]); --__j) \
(arrayp)[__j + 1] = (arrayp)[__j]; \
(arrayp)[__j + 1] = __v; \
} \
} \
} while (0)
/*
* Binary search for an integer key.
*/
#define WT_BINARY_SEARCH(key, arrayp, n, found) do { \
uint32_t __base, __indx, __limit; \
found = false; \
for (__base = 0, __limit = (n); __limit != 0; __limit >>= 1) { \
__indx = __base + (__limit >> 1); \
if ((arrayp)[__indx] < key) { \
__base = __indx + 1; \
--__limit; \
} else if ((arrayp)[__indx] == key) { \
found = true; \
break; \
} \
} \
} while (0)
/* Verbose messages. */
#ifdef HAVE_VERBOSE
#define WT_VERBOSE_ISSET(session, f) \
(FLD_ISSET(S2C(session)->verbose, f))
#else
#define WT_VERBOSE_ISSET(session, f) 0
#endif
#define WT_CLEAR(s) \
memset(&(s), 0, sizeof(s))
/* Check if a string matches a prefix. */
#define WT_PREFIX_MATCH(str, pfx) \
(((const char *)(str))[0] == ((const char *)pfx)[0] && \
strncmp((str), (pfx), strlen(pfx)) == 0)
/* Check if a string matches a prefix, and move past it. */
#define WT_PREFIX_SKIP(str, pfx) \
(WT_PREFIX_MATCH(str, pfx) ? ((str) += strlen(pfx), 1) : 0)
/*
* Check if a variable string equals a constant string. Inline the common
* case for WiredTiger of a single byte string. This is required because not
* all compilers optimize this case in strcmp (e.g., clang).
*/
#define WT_STREQ(s, cs) \
(sizeof(cs) == 2 ? (s)[0] == (cs)[0] && (s)[1] == '\0' : \
strcmp(s, cs) == 0)
/* Check if a string matches a byte string of len bytes. */
#define WT_STRING_MATCH(str, bytes, len) \
(((const char *)str)[0] == ((const char *)bytes)[0] && \
strncmp(str, bytes, len) == 0 && (str)[(len)] == '\0')
/*
* Macro that produces a string literal that isn't wrapped in quotes, to avoid
* tripping up spell checkers.
*/
#define WT_UNCHECKED_STRING(str) #str
/* Function return value and scratch buffer declaration and initialization. */
#define WT_DECL_ITEM(i) WT_ITEM *i = NULL
#define WT_DECL_RET int ret = 0
/* If a WT_ITEM data field points somewhere in its allocated memory. */
#define WT_DATA_IN_ITEM(i) \
((i)->mem != NULL && (i)->data >= (i)->mem && \
WT_PTRDIFF((i)->data, (i)->mem) < (i)->memsize)
/* Copy the data and size fields of an item. */
#define WT_ITEM_SET(dst, src) do { \
(dst).data = (src).data; \
(dst).size = (src).size; \
} while (0)
/*
* In diagnostic mode we track the locations from which hazard pointers and
* scratch buffers were acquired.
*/
#ifdef HAVE_DIAGNOSTIC
#define __wt_scr_alloc(session, size, scratchp) \
__wt_scr_alloc_func(session, size, scratchp, __FILE__, __LINE__)
#define __wt_page_in(session, ref, flags) \
__wt_page_in_func(session, ref, flags, __FILE__, __LINE__)
#define __wt_page_swap(session, held, want, flags) \
__wt_page_swap_func(session, held, want, flags, __FILE__, __LINE__)
#else
#define __wt_scr_alloc(session, size, scratchp) \
__wt_scr_alloc_func(session, size, scratchp)
#define __wt_page_in(session, ref, flags) \
__wt_page_in_func(session, ref, flags)
#define __wt_page_swap(session, held, want, flags) \
__wt_page_swap_func(session, held, want, flags)
#endif
/* Random number generator state. */
union __wt_rand_state {
uint64_t v;
struct {
uint32_t w, z;
} x;
};
/* Shared array for converting to hex */
extern const u_char __wt_hex[];
|
