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
|
/*-
* Copyright (c) 2014-2016 MongoDB, Inc.
* Copyright (c) 2008-2014 WiredTiger, Inc.
* All rights reserved.
*
* See the file LICENSE for redistribution information.
*/
/*
* WT_DATA_HANDLE_CACHE --
* Per-session cache of handles to avoid synchronization when opening
* cursors.
*/
struct __wt_data_handle_cache {
WT_DATA_HANDLE *dhandle;
TAILQ_ENTRY(__wt_data_handle_cache) q;
TAILQ_ENTRY(__wt_data_handle_cache) hashq;
};
/*
* WT_HAZARD --
* A hazard pointer.
*/
struct __wt_hazard {
WT_REF *ref; /* Page reference */
#ifdef HAVE_DIAGNOSTIC
const char *file; /* File/line where hazard acquired */
int line;
#endif
};
/* Get the connection implementation for a session */
#define S2C(session) ((WT_CONNECTION_IMPL *)(session)->iface.connection)
/* Get the btree for a session */
#define S2BT(session) ((WT_BTREE *)(session)->dhandle->handle)
#define S2BT_SAFE(session) ((session)->dhandle == NULL ? NULL : S2BT(session))
/*
* WT_SESSION_IMPL --
* Implementation of WT_SESSION.
*/
struct __wt_session_impl {
WT_SESSION iface;
void *lang_private; /* Language specific private storage */
u_int active; /* Non-zero if the session is in-use */
const char *name; /* Name */
const char *lastop; /* Last operation */
uint32_t id; /* UID, offset in session array */
WT_EVENT_HANDLER *event_handler;/* Application's event handlers */
WT_DATA_HANDLE *dhandle; /* Current data handle */
/*
* Each session keeps a cache of data handles. The set of handles
* can grow quite large so we maintain both a simple list and a hash
* table of lists. The hash table key is based on a hash of the table
* URI. The hash table list is kept in allocated memory that lives
* across session close - so it is declared further down.
*/
/* Session handle reference list */
TAILQ_HEAD(__dhandles, __wt_data_handle_cache) dhandles;
time_t last_sweep; /* Last sweep for dead handles */
/* Cursors closed with the session */
TAILQ_HEAD(__cursors, __wt_cursor) cursors;
WT_CURSOR_BACKUP *bkp_cursor; /* Hot backup cursor */
WT_COMPACT_STATE *compact; /* Compaction information */
enum { WT_COMPACT_NONE=0,
WT_COMPACT_RUNNING, WT_COMPACT_SUCCESS } compact_state;
/*
* Lookaside table cursor, sweep and eviction worker threads only.
*/
WT_CURSOR *las_cursor; /* Lookaside table cursor */
WT_CURSOR *meta_cursor; /* Metadata file */
void *meta_track; /* Metadata operation tracking */
void *meta_track_next; /* Current position */
void *meta_track_sub; /* Child transaction / save point */
size_t meta_track_alloc; /* Currently allocated */
int meta_track_nest; /* Nesting level of meta transaction */
#define WT_META_TRACKING(session) ((session)->meta_track_next != NULL)
/*
* Each session keeps a cache of table handles. The set of handles
* can grow quite large so we maintain both a simple list and a hash
* table of lists. The hash table list is kept in allocated memory
* that lives across session close - so it is declared further down.
*/
TAILQ_HEAD(__tables, __wt_table) tables;
/* Current rwlock for callback. */
WT_RWLOCK *current_rwlock;
uint8_t current_rwticket;
WT_ITEM **scratch; /* Temporary memory for any function */
u_int scratch_alloc; /* Currently allocated */
size_t scratch_cached; /* Scratch bytes cached */
#ifdef HAVE_DIAGNOSTIC
/*
* It's hard to figure out from where a buffer was allocated after it's
* leaked, so in diagnostic mode we track them; DIAGNOSTIC can't simply
* add additional fields to WT_ITEM structures because they are visible
* to applications, create a parallel structure instead.
*/
struct __wt_scratch_track {
const char *file; /* Allocating file, line */
int line;
} *scratch_track;
#endif
WT_ITEM err; /* Error buffer */
WT_TXN_ISOLATION isolation;
WT_TXN txn; /* Transaction state */
WT_LSN bg_sync_lsn; /* Background sync operation LSN. */
u_int ncursors; /* Count of active file cursors. */
void *block_manager; /* Block-manager support */
int (*block_manager_cleanup)(WT_SESSION_IMPL *);
/* Checkpoint handles */
WT_DATA_HANDLE **ckpt_handle; /* Handle list */
u_int ckpt_handle_next; /* Next empty slot */
size_t ckpt_handle_allocated; /* Bytes allocated */
/*
* Operations acting on handles.
*
* The preferred pattern is to gather all of the required handles at
* the beginning of an operation, then drop any other locks, perform
* the operation, then release the handles. This cannot be easily
* merged with the list of checkpoint handles because some operations
* (such as compact) do checkpoints internally.
*/
WT_DATA_HANDLE **op_handle; /* Handle list */
u_int op_handle_next; /* Next empty slot */
size_t op_handle_allocated; /* Bytes allocated */
void *reconcile; /* Reconciliation support */
int (*reconcile_cleanup)(WT_SESSION_IMPL *);
/* Sessions have an associated statistics bucket based on its ID. */
u_int stat_bucket; /* Statistics bucket offset */
uint32_t flags;
/*
* All of the following fields live at the end of the structure so it's
* easier to clear everything but the fields that persist.
*/
#define WT_SESSION_CLEAR_SIZE (offsetof(WT_SESSION_IMPL, rnd))
/*
* The random number state persists past session close because we don't
* want to repeatedly use the same values for skiplist depth when the
* application isn't caching sessions.
*/
WT_RAND_STATE rnd; /* Random number generation state */
/* Hashed handle reference list array */
TAILQ_HEAD(__dhandles_hash, __wt_data_handle_cache) *dhhash;
/* Hashed table reference list array */
TAILQ_HEAD(__tables_hash, __wt_table) *tablehash;
/*
* Split stash memory persists past session close because it's accessed
* by threads of control other than the thread owning the session.
*
* Splits can "free" memory that may still be in use, and we use a
* split generation number to track it, that is, the session stores a
* reference to the memory and allocates a split generation; when no
* session is reading from that split generation, the memory can be
* freed for real.
*/
struct __wt_split_stash {
uint64_t split_gen; /* Split generation */
void *p; /* Memory, length */
size_t len;
} *split_stash; /* Split stash array */
size_t split_stash_cnt; /* Array entries */
size_t split_stash_alloc; /* Allocated bytes */
uint64_t split_gen; /* Reading split generation */
/*
* Hazard pointers.
*
* Hazard information persists past session close because it's accessed
* by threads of control other than the thread owning the session.
*
* Use the non-NULL state of the hazard field to know if the session has
* previously been initialized.
*/
#define WT_SESSION_FIRST_USE(s) \
((s)->hazard == NULL)
/*
* The hazard pointer array grows as necessary, initialize with 250
* slots.
*/
#define WT_SESSION_INITIAL_HAZARD_SLOTS 250
uint32_t hazard_size; /* Hazard pointer array slots */
uint32_t hazard_inuse; /* Hazard pointer array slots in-use */
uint32_t nhazard; /* Count of active hazard pointers */
WT_HAZARD *hazard; /* Hazard pointer array */
};
|
