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
|
/*-
* Copyright (c) 2014-2015 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)
/* Basic constants. */
#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)((uint8_t *)(end) - (uint8_t *)(begin)))
#define WT_PTRDIFF32(end, begin) \
WT_STORE_SIZE(WT_PTRDIFF((end), (begin)))
#define WT_BLOCK_FITS(p, len, begin, maxlen) \
((uint8_t *)(p) >= (uint8_t *)(begin) && \
((uint8_t *)(p) + (len) <= (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))
/* 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)
/*
* __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 { \
if ((p) != NULL) \
__wt_free_int(session, (void *)&(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 F_CLR(p, mask) ((p)->flags &= ~((uint32_t)(mask)))
#define F_ISSET(p, mask) ((p)->flags & ((uint32_t)(mask)))
#define F_SET(p, mask) ((p)->flags |= ((uint32_t)(mask)))
#define LF_CLR(mask) ((flags) &= ~((uint32_t)(mask)))
#define LF_ISSET(mask) ((flags) & ((uint32_t)(mask)))
#define LF_SET(mask) ((flags) |= ((uint32_t)(mask)))
#define FLD_CLR(field, mask) ((field) &= ~((uint32_t)(mask)))
#define FLD_ISSET(field, mask) ((field) & ((uint32_t)(mask)))
#define FLD_SET(field, mask) ((field) |= ((uint32_t)(mask)))
/* 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
/*
* Clear a structure, two flavors: inline when we want to guarantee there's
* no function call or setup/tear-down of a loop, and the default where the
* compiler presumably chooses. Gcc 4.3 is supposed to get this right, but
* we've seen problems when calling memset to clear structures in performance
* critical paths.
*/
#define WT_CLEAR_INLINE(type, s) do { \
static const type __clear; \
s = __clear; \
} while (0)
#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 non-nul-terminated string matches a prefix. */
#define WT_PREFIX_MATCH_LEN(str, len, pfx) \
((len) >= strlen(pfx) && WT_PREFIX_MATCH(str, pfx))
/* 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
|
