ft-ops.cc 267 KB
Newer Older
1 2
/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
Bradley C. Kuszmaul's avatar
Bradley C. Kuszmaul committed
3
#ident "$Id$"
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
/*
COPYING CONDITIONS NOTICE:

  This program is free software; you can redistribute it and/or modify
  it under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation, and provided that the
  following conditions are met:

      * Redistributions of source code must retain this COPYING
        CONDITIONS NOTICE, the COPYRIGHT NOTICE (below), the
        DISCLAIMER (below), the UNIVERSITY PATENT NOTICE (below), the
        PATENT MARKING NOTICE (below), and the PATENT RIGHTS
        GRANT (below).

      * Redistributions in binary form must reproduce this COPYING
        CONDITIONS NOTICE, the COPYRIGHT NOTICE (below), the
        DISCLAIMER (below), the UNIVERSITY PATENT NOTICE (below), the
        PATENT MARKING NOTICE (below), and the PATENT RIGHTS
        GRANT (below) in the documentation and/or other materials
        provided with the distribution.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301, USA.

COPYRIGHT NOTICE:

  TokuDB, Tokutek Fractal Tree Indexing Library.
  Copyright (C) 2007-2013 Tokutek, Inc.

DISCLAIMER:

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

UNIVERSITY PATENT NOTICE:

  The technology is licensed by the Massachusetts Institute of
  Technology, Rutgers State University of New Jersey, and the Research
  Foundation of State University of New York at Stony Brook under
  United States of America Serial No. 11/760379 and to the patents
  and/or patent applications resulting from it.

PATENT MARKING NOTICE:

  This software is covered by US Patent No. 8,185,551.
53
  This software is covered by US Patent No. 8,489,638.
54 55 56

PATENT RIGHTS GRANT:

57
  "THIS IMPLEMENTATION" means the copyrightable works distributed by
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
  Tokutek as part of the Fractal Tree project.

  "PATENT CLAIMS" means the claims of patents that are owned or
  licensable by Tokutek, both currently or in the future; and that in
  the absence of this license would be infringed by THIS
  IMPLEMENTATION or by using or running THIS IMPLEMENTATION.

  "PATENT CHALLENGE" shall mean a challenge to the validity,
  patentability, enforceability and/or non-infringement of any of the
  PATENT CLAIMS or otherwise opposing any of the PATENT CLAIMS.

  Tokutek hereby grants to you, for the term and geographical scope of
  the PATENT CLAIMS, a non-exclusive, no-charge, royalty-free,
  irrevocable (except as stated in this section) patent license to
  make, have made, use, offer to sell, sell, import, transfer, and
  otherwise run, modify, and propagate the contents of THIS
  IMPLEMENTATION, where such license applies only to the PATENT
  CLAIMS.  This grant does not include claims that would be infringed
  only as a consequence of further modifications of THIS
  IMPLEMENTATION.  If you or your agent or licensee institute or order
  or agree to the institution of patent litigation against any entity
  (including a cross-claim or counterclaim in a lawsuit) alleging that
  THIS IMPLEMENTATION constitutes direct or contributory patent
  infringement, or inducement of patent infringement, then any rights
  granted to you under this License shall terminate as of the date
  such litigation is filed.  If you or your agent or exclusive
  licensee institute or order or agree to the institution of a PATENT
  CHALLENGE, then Tokutek may terminate any rights granted to you
  under this License.
*/

89
#ident "Copyright (c) 2007-2013 Tokutek Inc.  All rights reserved."
90
#ident "The technology is licensed by the Massachusetts Institute of Technology, Rutgers State University of New Jersey, and the Research Foundation of State University of New York at Stony Brook under United States of America Serial No. 11/760379 and to the patents and/or patent applications resulting from it."
91

92 93
/*

94
Managing the tree shape:  How insertion, deletion, and querying work
95

96
When we insert a message into the FT_HANDLE, here's what happens.
97

98
to insert a message at the root
99

100 101 102 103
    - find the root node
    - capture the next msn of the root node and assign it to the message
    - split the root if it needs to be split
    - insert the message into the root buffer
John Esmet's avatar
John Esmet committed
104
    - if the root is too full, then toku_ft_flush_some_child() of the root on a flusher thread
105

106
flusher functions use an advice struct with provides some functions to
107
call that tell it what to do based on the context of the flush. see ft-flusher.h
108 109 110 111 112

to flush some child, given a parent and some advice
    - pick the child using advice->pick_child()
    - remove that childs buffer from the parent
    - flush the buffer to the child
113
    - if the child has stable reactivity and
114
      advice->should_recursively_flush() is true, then
John Esmet's avatar
John Esmet committed
115
      toku_ft_flush_some_child() of the child
116 117 118
    - otherwise split the child if it needs to be split
    - otherwise maybe merge the child if it needs to be merged

119
flusher threads:
120

121 122 123 124 125 126 127 128 129 130 131 132 133 134
    flusher threads are created on demand as the result of internal nodes
    becoming gorged by insertions. this allows flushing to be done somewhere
    other than the client thread. these work items are enqueued onto
    the cachetable kibbutz and are done in a first in first out order.

cleaner threads:

    the cleaner thread wakes up every so often (say, 1 second) and chooses
    a small number (say, 5) of nodes as candidates for a flush. the one
    with the largest cache pressure is chosen to be flushed. cache pressure
    is a function of the size of the node in the cachetable plus the work done.
    the cleaner thread need not actually do a flush when awoken, so only
    nodes that have sufficient cache pressure are flushed.

135
checkpointing:
136 137 138 139 140 141 142 143 144

    the checkpoint thread wakes up every minute to checkpoint dirty nodes
    to disk. at the time of this writing, nodes during checkpoint are
    locked and cannot be queried or flushed to. a design in which nodes
    are copied before checkpoint is being considered as a way to reduce
    the performance variability caused by a checkpoint locking too
    many nodes and preventing other threads from traversing down the tree,
    for a query or otherwise.

145
To shrink a file: Let X be the size of the reachable data.
146 147 148
    We define an acceptable bloat constant of C.  For example we set C=2 if we are willing to allow the file to be as much as 2X in size.
    The goal is to find the smallest amount of stuff we can move to get the file down to size CX.
    That seems like a difficult problem, so we use the following heuristics:
149 150 151 152 153 154 155 156
       If we can relocate the last block to an lower location, then do so immediately.        (The file gets smaller right away, so even though the new location
         may even not be in the first CX bytes, we are making the file smaller.)
       Otherwise all of the earlier blocks are smaller than the last block (of size L).         So find the smallest region that has L free bytes in it.
         (This can be computed in one pass)
         Move the first allocated block in that region to some location not in the interior of the region.
               (Outside of the region is OK, and reallocating the block at the edge of the region is OK).
            This has the effect of creating a smaller region with at least L free bytes in it.
         Go back to the top (because by now some other block may have been allocated or freed).
157 158 159 160 161 162 163 164 165
    Claim: if there are no other allocations going on concurrently, then this algorithm will shrink the file reasonably efficiently.  By this I mean that
       each block of shrinkage does the smallest amount of work possible.  That doesn't mean that the work overall is minimized.
    Note: If there are other allocations and deallocations going on concurrently, we might never get enough space to move the last block.  But it takes a lot
      of allocations and deallocations to make that happen, and it's probably reasonable for the file not to shrink in this case.

To split or merge a child of a node:
Split_or_merge (node, childnum) {
  If the child needs to be split (it's a leaf with too much stuff or a nonleaf with too much fanout)
    fetch the node and the child into main memory.
166
    split the child, producing two nodes A and B, and also a pivot.   Don't worry if the resulting child is still too big or too small.         Fix it on the next pass.
167
    fixup node to point at the two new children.  Don't worry about the node getting too much fanout.
168
    return;
169 170 171 172
  If the child needs to be merged (it's a leaf with too little stuff (less than 1/4 full) or a nonleaf with too little fanout (less than 1/4)
    fetch node, the child  and a sibling of the child into main memory.
    move all messages from the node to the two children (so that the FIFOs are empty)
    If the two siblings together fit into one node then
173
      merge the two siblings.
174 175 176
      fixup the node to point at one child
    Otherwise
      load balance the content of the two nodes
177
    Don't worry about the resulting children having too many messages or otherwise being too big or too small.        Fix it on the next pass.
178 179
  }
}
180

181 182
Here's how querying works:

183 184
lookups:
    - As of Dr. No, we don't do any tree shaping on lookup.
185
    - We don't promote eagerly or use aggressive promotion or passive-aggressive
186
    promotion.        We just push messages down according to the traditional FT_HANDLE
187 188
    algorithm on insertions.
    - when a node is brought into memory, we apply ancestor messages above it.
189 190 191 192

basement nodes, bulk fetch,  and partial fetch:
    - leaf nodes are comprised of N basement nodes, each of nominal size. when
    a query hits a leaf node. it may require one or more basement nodes to be in memory.
193
    - for point queries, we do not read the entire node into memory. instead,
194 195
      we only read in the required basement node
    - for range queries, cursors may return cursor continue in their callback
196 197 198 199
      to take a the shortcut path until the end of the basement node.
    - for range queries, cursors may prelock a range of keys (with or without a txn).
      the fractal tree will prefetch nodes aggressively until the end of the range.
    - without a prelocked range, range queries behave like successive point queries.
200 201

*/
202

203
#include "checkpoint.h"
204 205 206 207 208 209 210 211 212
#include "ft.h"
#include "ft-cachetable-wrappers.h"
#include "ft-flusher.h"
#include "ft-internal.h"
#include "ft_layout_version.h"
#include "key.h"
#include "log-internal.h"
#include "sub_block.h"
#include "txn_manager.h"
John Esmet's avatar
John Esmet committed
213
#include "leafentry.h"
214
#include "xids.h"
215
#include "ft_msg.h"
216

217
#include <toku_race_tools.h>
John Esmet's avatar
John Esmet committed
218

219
#include <portability/toku_atomic.h>
John Esmet's avatar
John Esmet committed
220

221
#include <util/context.h>
222
#include <util/mempool.h>
223
#include <util/status.h>
224 225
#include <util/rwlock.h>
#include <util/sort.h>
226
#include <util/scoped_malloc.h>
227 228

#include <stdint.h>
229

230
static const uint32_t this_version = FT_LAYOUT_VERSION;
231

232 233 234
/* Status is intended for display to humans to help understand system behavior.
 * It does not need to be perfectly thread-safe.
 */
235
static FT_STATUS_S ft_status;
236

237
#define STATUS_INIT(k,c,t,l,inc) TOKUDB_STATUS_INIT(ft_status, k, c, t, "brt: " l, inc)
238

239 240
static toku_mutex_t ft_open_close_lock;

241 242 243 244 245
static void
status_init(void)
{
    // Note, this function initializes the keyname, type, and legend fields.
    // Value fields are initialized to zero by compiler.
246 247 248 249
    STATUS_INIT(FT_UPDATES,                                DICTIONARY_UPDATES, PARCOUNT, "dictionary updates", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_UPDATES_BROADCAST,                      DICTIONARY_BROADCAST_UPDATES, PARCOUNT, "dictionary broadcast updates", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DESCRIPTOR_SET,                         DESCRIPTOR_SET, PARCOUNT, "descriptor set", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSN_DISCARDS,                           MESSAGES_IGNORED_BY_LEAF_DUE_TO_MSN, PARCOUNT, "messages ignored by leaf due to msn", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
250 251 252
    STATUS_INIT(FT_TOTAL_RETRIES,                          nullptr, PARCOUNT, "total search retries due to TRY_AGAIN", TOKU_ENGINE_STATUS);
    STATUS_INIT(FT_SEARCH_TRIES_GT_HEIGHT,                 nullptr, PARCOUNT, "searches requiring more tries than the height of the tree", TOKU_ENGINE_STATUS);
    STATUS_INIT(FT_SEARCH_TRIES_GT_HEIGHTPLUS3,            nullptr, PARCOUNT, "searches requiring more tries than the height of the tree plus three", TOKU_ENGINE_STATUS);
253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
    STATUS_INIT(FT_CREATE_LEAF,                            LEAF_NODES_CREATED, PARCOUNT, "leaf nodes created", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_CREATE_NONLEAF,                         NONLEAF_NODES_CREATED, PARCOUNT, "nonleaf nodes created", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DESTROY_LEAF,                           LEAF_NODES_DESTROYED, PARCOUNT, "leaf nodes destroyed", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DESTROY_NONLEAF,                        NONLEAF_NODES_DESTROYED, PARCOUNT, "nonleaf nodes destroyed", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSG_BYTES_IN,                           MESSAGES_INJECTED_AT_ROOT_BYTES, PARCOUNT, "bytes of messages injected at root (all trees)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSG_BYTES_OUT,                          MESSAGES_FLUSHED_FROM_H1_TO_LEAVES_BYTES, PARCOUNT, "bytes of messages flushed from h1 nodes to leaves", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSG_BYTES_CURR,                         MESSAGES_IN_TREES_ESTIMATE_BYTES, PARCOUNT, "bytes of messages currently in trees (estimate)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSG_NUM,                                MESSAGES_INJECTED_AT_ROOT, PARCOUNT, "messages injected at root", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_MSG_NUM_BROADCAST,                      BROADCASE_MESSAGES_INJECTED_AT_ROOT, PARCOUNT, "broadcast messages injected at root", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);

    STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_NORMAL,      BASEMENTS_DECOMPRESSED_TARGET_QUERY, PARCOUNT, "basements decompressed as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_AGGRESSIVE,  BASEMENTS_DECOMPRESSED_PRELOCKED_RANGE, PARCOUNT, "basements decompressed for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_PREFETCH,    BASEMENTS_DECOMPRESSED_PREFETCH, PARCOUNT, "basements decompressed for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_DECOMPRESSED_WRITE,       BASEMENTS_DECOMPRESSED_FOR_WRITE, PARCOUNT, "basements decompressed for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_NORMAL,     BUFFERS_DECOMPRESSED_TARGET_QUERY, PARCOUNT, "buffers decompressed as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_AGGRESSIVE, BUFFERS_DECOMPRESSED_PRELOCKED_RANGE, PARCOUNT, "buffers decompressed for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_PREFETCH,   BUFFERS_DECOMPRESSED_PREFETCH, PARCOUNT, "buffers decompressed for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_DECOMPRESSED_WRITE,      BUFFERS_DECOMPRESSED_FOR_WRITE, PARCOUNT, "buffers decompressed for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
271

272
    // Eviction statistics:
273 274 275 276 277 278 279 280
    STATUS_INIT(FT_FULL_EVICTIONS_LEAF,                    LEAF_NODE_FULL_EVICTIONS, PARCOUNT, "leaf node full evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_FULL_EVICTIONS_LEAF_BYTES,              LEAF_NODE_FULL_EVICTIONS_BYTES, PARCOUNT, "leaf node full evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF,                 NONLEAF_NODE_FULL_EVICTIONS, PARCOUNT, "nonleaf node full evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_FULL_EVICTIONS_NONLEAF_BYTES,           NONLEAF_NODE_FULL_EVICTIONS_BYTES, PARCOUNT, "nonleaf node full evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF,                 LEAF_NODE_PARTIAL_EVICTIONS, PARCOUNT, "leaf node partial evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PARTIAL_EVICTIONS_LEAF_BYTES,           LEAF_NODE_PARTIAL_EVICTIONS_BYTES, PARCOUNT, "leaf node partial evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF,              NONLEAF_NODE_PARTIAL_EVICTIONS, PARCOUNT, "nonleaf node partial evictions", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PARTIAL_EVICTIONS_NONLEAF_BYTES,        NONLEAF_NODE_PARTIAL_EVICTIONS_BYTES, PARCOUNT, "nonleaf node partial evictions (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
281

282 283 284
    // Disk read statistics: 
    //
    // Pivots: For queries, prefetching, or writing.
285 286 287 288 289 290 291 292 293
    STATUS_INIT(FT_NUM_PIVOTS_FETCHED_QUERY,               PIVOTS_FETCHED_FOR_QUERY, PARCOUNT, "pivots fetched for query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_QUERY,             PIVOTS_FETCHED_FOR_QUERY_BYTES, PARCOUNT, "pivots fetched for query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_QUERY,          PIVOTS_FETCHED_FOR_QUERY_SECONDS, TOKUTIME, "pivots fetched for query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_PIVOTS_FETCHED_PREFETCH,            PIVOTS_FETCHED_FOR_PREFETCH, PARCOUNT, "pivots fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_PREFETCH,          PIVOTS_FETCHED_FOR_PREFETCH_BYTES, PARCOUNT, "pivots fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_PREFETCH,       PIVOTS_FETCHED_FOR_PREFETCH_SECONDS, TOKUTIME, "pivots fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_PIVOTS_FETCHED_WRITE,               PIVOTS_FETCHED_FOR_WRITE, PARCOUNT, "pivots fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_PIVOTS_FETCHED_WRITE,             PIVOTS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "pivots fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_PIVOTS_FETCHED_WRITE,          PIVOTS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "pivots fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
294
    // Basements: For queries, aggressive fetching in prelocked range, prefetching, or writing.
295 296 297 298 299 300 301 302 303 304 305 306
    STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_NORMAL,           BASEMENTS_FETCHED_TARGET_QUERY, PARCOUNT, "basements fetched as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_NORMAL,         BASEMENTS_FETCHED_TARGET_QUERY_BYTES, PARCOUNT, "basements fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_NORMAL,      BASEMENTS_FETCHED_TARGET_QUERY_SECONDS, TOKUTIME, "basements fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_AGGRESSIVE,       BASEMENTS_FETCHED_PRELOCKED_RANGE, PARCOUNT, "basements fetched for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_AGGRESSIVE,     BASEMENTS_FETCHED_PRELOCKED_RANGE_BYTES, PARCOUNT, "basements fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_AGGRESSIVE,  BASEMENTS_FETCHED_PRELOCKED_RANGE_SECONDS, TOKUTIME, "basements fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_PREFETCH,         BASEMENTS_FETCHED_PREFETCH, PARCOUNT, "basements fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_PREFETCH,       BASEMENTS_FETCHED_PREFETCH_BYTES, PARCOUNT, "basements fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_PREFETCH,    BASEMENTS_FETCHED_PREFETCH_SECONDS, TOKUTIME, "basements fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_BASEMENTS_FETCHED_WRITE,            BASEMENTS_FETCHED_FOR_WRITE, PARCOUNT, "basements fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_BASEMENTS_FETCHED_WRITE,          BASEMENTS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "basements fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_BASEMENTS_FETCHED_WRITE,       BASEMENTS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "basements fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
307
    // Buffers: For queries, aggressive fetching in prelocked range, prefetching, or writing.
308 309 310 311 312 313 314 315 316 317 318 319
    STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_NORMAL,          BUFFERS_FETCHED_TARGET_QUERY, PARCOUNT, "buffers fetched as a target of a query", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_NORMAL,        BUFFERS_FETCHED_TARGET_QUERY_BYTES, PARCOUNT, "buffers fetched as a target of a query (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_NORMAL,     BUFFERS_FETCHED_TARGET_QUERY_SECONDS, TOKUTIME, "buffers fetched as a target of a query (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_AGGRESSIVE,      BUFFERS_FETCHED_PRELOCKED_RANGE, PARCOUNT, "buffers fetched for prelocked range", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_AGGRESSIVE,    BUFFERS_FETCHED_PRELOCKED_RANGE_BYTES, PARCOUNT, "buffers fetched for prelocked range (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_AGGRESSIVE, BUFFERS_FETCHED_PRELOCKED_RANGE_SECONDS, TOKUTIME, "buffers fetched for prelocked range (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_PREFETCH,        BUFFERS_FETCHED_PREFETCH, PARCOUNT, "buffers fetched for prefetch", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_PREFETCH,      BUFFERS_FETCHED_PREFETCH_BYTES, PARCOUNT, "buffers fetched for prefetch (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_PREFETCH,   BUFFERS_FETCHED_PREFETCH_SECONDS, TOKUTIME, "buffers fetched for prefetch (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NUM_MSG_BUFFER_FETCHED_WRITE,           BUFFERS_FETCHED_FOR_WRITE, PARCOUNT, "buffers fetched for write", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BYTES_MSG_BUFFER_FETCHED_WRITE,         BUFFERS_FETCHED_FOR_WRITE_BYTES, PARCOUNT, "buffers fetched for write (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_TOKUTIME_MSG_BUFFER_FETCHED_WRITE,      BUFFERS_FETCHED_FOR_WRITE_SECONDS, TOKUTIME, "buffers fetched for write (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
320

321
    // Disk write statistics.
322 323
    //
    // Leaf/Nonleaf: Not for checkpoint
324 325 326 327 328 329 330 331
    STATUS_INIT(FT_DISK_FLUSH_LEAF,                                         LEAF_NODES_FLUSHED_NOT_CHECKPOINT, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES,                                   LEAF_NODES_FLUSHED_NOT_CHECKPOINT_BYTES, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES,                      LEAF_NODES_FLUSHED_NOT_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "leaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME,                                LEAF_NODES_FLUSHED_NOT_CHECKPOINT_SECONDS, TOKUTIME, "leaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF,                                      NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES,                                NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES,                   NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (not for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME,                             NONLEAF_NODES_FLUSHED_TO_DISK_NOT_CHECKPOINT_SECONDS, TOKUTIME, "nonleaf nodes flushed to disk (not for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
332
    // Leaf/Nonleaf: For checkpoint
333 334 335 336 337 338 339 340
    STATUS_INIT(FT_DISK_FLUSH_LEAF_FOR_CHECKPOINT,                          LEAF_NODES_FLUSHED_CHECKPOINT, PARCOUNT, "leaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_BYTES_FOR_CHECKPOINT,                    LEAF_NODES_FLUSHED_CHECKPOINT_BYTES, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT,       LEAF_NODES_FLUSHED_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "leaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_LEAF_TOKUTIME_FOR_CHECKPOINT,                 LEAF_NODES_FLUSHED_CHECKPOINT_SECONDS, TOKUTIME, "leaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_FOR_CHECKPOINT,                       NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_BYTES_FOR_CHECKPOINT,                 NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT,    NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_UNCOMPRESSED_BYTES, PARCOUNT, "nonleaf nodes flushed to disk (for checkpoint) (uncompressed bytes)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_DISK_FLUSH_NONLEAF_TOKUTIME_FOR_CHECKPOINT,              NONLEAF_NODES_FLUSHED_TO_DISK_CHECKPOINT_SECONDS, TOKUTIME, "nonleaf nodes flushed to disk (for checkpoint) (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
341

342
    // CPU time statistics for [de]serialization and [de]compression.
343 344 345 346 347 348 349 350
    STATUS_INIT(FT_LEAF_COMPRESS_TOKUTIME,                                  LEAF_COMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "leaf compression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_LEAF_SERIALIZE_TOKUTIME,                                 LEAF_SERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "leaf serialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_LEAF_DECOMPRESS_TOKUTIME,                                LEAF_DECOMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "leaf decompression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_LEAF_DESERIALIZE_TOKUTIME,                               LEAF_DESERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "leaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NONLEAF_COMPRESS_TOKUTIME,                               NONLEAF_COMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf compression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NONLEAF_SERIALIZE_TOKUTIME,                              NONLEAF_SERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf serialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NONLEAF_DECOMPRESS_TOKUTIME,                             NONLEAF_DECOMPRESSION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf decompression to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_NONLEAF_DESERIALIZE_TOKUTIME,                            NONLEAF_DESERIALIZATION_TO_MEMORY_SECONDS, TOKUTIME, "nonleaf deserialization to memory (seconds)", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
351

352
    // Promotion statistics.
353 354 355 356 357 358 359 360 361 362 363 364 365
    STATUS_INIT(FT_PRO_NUM_ROOT_SPLIT,                     PROMOTION_ROOTS_SPLIT, PARCOUNT, "promotion: roots split", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_ROOT_H0_INJECT,                 PROMOTION_LEAF_ROOTS_INJECTED_INTO, PARCOUNT, "promotion: leaf roots injected into", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_ROOT_H1_INJECT,                 PROMOTION_H1_ROOTS_INJECTED_INTO, PARCOUNT, "promotion: h1 roots injected into", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_0,                 PROMOTION_INJECTIONS_AT_DEPTH_0, PARCOUNT, "promotion: injections at depth 0", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_1,                 PROMOTION_INJECTIONS_AT_DEPTH_1, PARCOUNT, "promotion: injections at depth 1", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_2,                 PROMOTION_INJECTIONS_AT_DEPTH_2, PARCOUNT, "promotion: injections at depth 2", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_3,                 PROMOTION_INJECTIONS_AT_DEPTH_3, PARCOUNT, "promotion: injections at depth 3", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_INJECT_DEPTH_GT3,               PROMOTION_INJECTIONS_LOWER_THAN_DEPTH_3, PARCOUNT, "promotion: injections lower than depth 3", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_STOP_NONEMPTY_BUF,              PROMOTION_STOPPED_NONEMPTY_BUFFER, PARCOUNT, "promotion: stopped because of a nonempty buffer", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_STOP_H1,                        PROMOTION_STOPPED_AT_HEIGHT_1, PARCOUNT, "promotion: stopped at height 1", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_STOP_LOCK_CHILD,                PROMOTION_STOPPED_CHILD_LOCKED_OR_NOT_IN_MEMORY, PARCOUNT, "promotion: stopped because the child was locked or not at all in memory", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_STOP_CHILD_INMEM,               PROMOTION_STOPPED_CHILD_NOT_FULLY_IN_MEMORY, PARCOUNT, "promotion: stopped because the child was not fully in memory", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_PRO_NUM_DIDNT_WANT_PROMOTE,             PROMOTION_STOPPED_AFTER_LOCKING_CHILD, PARCOUNT, "promotion: stopped anyway, after locking the child", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
366 367
    STATUS_INIT(FT_BASEMENT_DESERIALIZE_FIXED_KEYSIZE,     BASEMENT_DESERIALIZATION_FIXED_KEY, PARCOUNT, "basement nodes deserialized with fixed-keysize", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
    STATUS_INIT(FT_BASEMENT_DESERIALIZE_VARIABLE_KEYSIZE,  BASEMENT_DESERIALIZATION_VARIABLE_KEY, PARCOUNT, "basement nodes deserialized with variable-keysize", TOKU_ENGINE_STATUS|TOKU_GLOBAL_STATUS);
368

369
    ft_status.initialized = true;
370
}
371 372 373 374 375 376 377
static void status_destroy(void) {
    for (int i = 0; i < FT_STATUS_NUM_ROWS; ++i) {
        if (ft_status.status[i].type == PARCOUNT) {
            destroy_partitioned_counter(ft_status.status[i].value.parcount);
        }
    }
}
378 379 380
#undef STATUS_INIT

void
381 382
toku_ft_get_status(FT_STATUS s) {
    *s = ft_status;
383 384
}

385 386 387 388 389 390 391
#define STATUS_INC(x, d)                                                            \
    do {                                                                            \
        if (ft_status.status[x].type == PARCOUNT) {                                 \
            increment_partitioned_counter(ft_status.status[x].value.parcount, d);   \
        } else {                                                                    \
            toku_sync_fetch_and_add(&ft_status.status[x].value.num, d);             \
        }                                                                           \
392
    } while (0)
393

394 395 396 397 398 399 400 401
void toku_note_deserialized_basement_node(bool fixed_key_size) {
    if (fixed_key_size) {
        STATUS_INC(FT_BASEMENT_DESERIALIZE_FIXED_KEYSIZE, 1);
    } else {
        STATUS_INC(FT_BASEMENT_DESERIALIZE_VARIABLE_KEYSIZE, 1);
    }
}

402
bool is_entire_node_in_memory(FTNODE node) {
403 404 405 406 407 408 409
    for (int i = 0; i < node->n_children; i++) {
        if(BP_STATE(node,i) != PT_AVAIL) {
            return false;
        }
    }
    return true;
}
410

411
void
412 413
toku_assert_entire_node_in_memory(FTNODE UU() node) {
    paranoid_invariant(is_entire_node_in_memory(node));
414 415
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
416
uint32_t
417
get_leaf_num_entries(FTNODE node) {
Yoni Fogel's avatar
Yoni Fogel committed
418
    uint32_t result = 0;
419
    int i;
420
    toku_assert_entire_node_in_memory(node);
421
    for ( i = 0; i < node->n_children; i++) {
422
        result += BLB_DATA(node, i)->num_klpairs();
423 424 425 426
    }
    return result;
}

427
static enum reactivity
Zardosht Kasheff's avatar
Zardosht Kasheff committed
428
get_leaf_reactivity (FTNODE node, uint32_t nodesize) {
429
    enum reactivity re = RE_STABLE;
Leif Walsh's avatar
Leif Walsh committed
430
    toku_assert_entire_node_in_memory(node);
431
    paranoid_invariant(node->height==0);
432
    unsigned int size = toku_serialize_ftnode_size(node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
433
    if (size > nodesize && get_leaf_num_entries(node) > 1) {
Leif Walsh's avatar
Leif Walsh committed
434 435
        re = RE_FISSIBLE;
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
436
    else if ((size*4) < nodesize && !BLB_SEQINSERT(node, node->n_children-1)) {
Leif Walsh's avatar
Leif Walsh committed
437
        re = RE_FUSIBLE;
438 439
    }
    return re;
440 441
}

442
enum reactivity
443
get_nonleaf_reactivity(FTNODE node, unsigned int fanout) {
444
    paranoid_invariant(node->height>0);
445
    int n_children = node->n_children;
446 447
    if (n_children > (int) fanout) return RE_FISSIBLE;
    if (n_children*4 < (int) fanout) return RE_FUSIBLE;
448 449 450
    return RE_STABLE;
}

451
enum reactivity
452
get_node_reactivity(FT ft, FTNODE node) {
453
    toku_assert_entire_node_in_memory(node);
454
    if (node->height==0)
455
        return get_leaf_reactivity(node, ft->h->nodesize);
456
    else
457
        return get_nonleaf_reactivity(node, ft->h->fanout);
458 459
}

460 461 462
unsigned int
toku_bnc_nbytesinbuf(NONLEAF_CHILDINFO bnc)
{
463
    return toku_fifo_buffer_size_in_use(bnc->buffer);
464 465
}

Yoni Fogel's avatar
Yoni Fogel committed
466
// return true if the size of the buffers plus the amount of work done is large enough.   (But return false if there is nothing to be flushed (the buffers empty)).
467
bool
Zardosht Kasheff's avatar
Zardosht Kasheff committed
468
toku_ft_nonleaf_is_gorged (FTNODE node, uint32_t nodesize) {
Yoni Fogel's avatar
Yoni Fogel committed
469
    uint64_t size = toku_serialize_ftnode_size(node);
470

Yoni Fogel's avatar
Yoni Fogel committed
471
    bool buffers_are_empty = true;
472
    toku_assert_entire_node_in_memory(node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
473 474 475 476
    //
    // the nonleaf node is gorged if the following holds true:
    //  - the buffers are non-empty
    //  - the total workdone by the buffers PLUS the size of the buffers
Zardosht Kasheff's avatar
Zardosht Kasheff committed
477
    //     is greater than nodesize (which as of Maxwell should be
Zardosht Kasheff's avatar
Zardosht Kasheff committed
478 479
    //     4MB)
    //
480
    paranoid_invariant(node->height > 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
481 482 483
    for (int child = 0; child < node->n_children; ++child) {
        size += BP_WORKDONE(node, child);
    }
484
    for (int child = 0; child < node->n_children; ++child) {
485
        if (toku_bnc_nbytesinbuf(BNC(node, child)) > 0) {
Yoni Fogel's avatar
Yoni Fogel committed
486
            buffers_are_empty = false;
487 488 489
            break;
        }
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
490
    return ((size > nodesize)
491 492
            &&
            (!buffers_are_empty));
493 494
}

495 496
static void ft_verify_flags(FT UU(ft), FTNODE UU(node)) {
    paranoid_invariant(ft->h->flags == node->flags);
497
}
498

499
int toku_ft_debug_mode = 0;
500

Yoni Fogel's avatar
Yoni Fogel committed
501
uint32_t compute_child_fullhash (CACHEFILE cf, FTNODE node, int childnum) {
502 503
    paranoid_invariant(node->height>0);
    paranoid_invariant(childnum<node->n_children);
504
    return toku_cachetable_hash(cf, BP_BLOCKNUM(node, childnum));
505 506
}

507 508 509 510 511 512
int
toku_bnc_n_entries(NONLEAF_CHILDINFO bnc)
{
    return toku_fifo_n_entries(bnc->buffer);
}

513
static const DBT *prepivotkey (FTNODE node, int childnum, const DBT * const lower_bound_exclusive) {
514
    if (childnum==0)
515
        return lower_bound_exclusive;
516
    else {
517
        return &node->childkeys[childnum-1];
518 519 520
    }
}

521
static const DBT *postpivotkey (FTNODE node, int childnum, const DBT * const upper_bound_inclusive) {
522
    if (childnum+1 == node->n_children)
523
        return upper_bound_inclusive;
524
    else {
525
        return &node->childkeys[childnum];
526 527
    }
}
528
static struct pivot_bounds next_pivot_keys (FTNODE node, int childnum, struct pivot_bounds const * const old_pb) {
529
    struct pivot_bounds pb = {.lower_bound_exclusive = prepivotkey(node, childnum, old_pb->lower_bound_exclusive),
530
                              .upper_bound_inclusive = postpivotkey(node, childnum, old_pb->upper_bound_inclusive)};
531 532
    return pb;
}
533

534
// how much memory does this child buffer consume?
535
long
536
toku_bnc_memory_size(NONLEAF_CHILDINFO bnc)
537 538 539
{
    return (sizeof(*bnc) +
            toku_fifo_memory_footprint(bnc->buffer) +
540 541 542
            bnc->fresh_message_tree.memory_size() +
            bnc->stale_message_tree.memory_size() +
            bnc->broadcast_list.memory_size());
543 544 545 546 547 548
}

// how much memory in this child buffer holds useful data?
// originally created solely for use by test program(s).
long
toku_bnc_memory_used(NONLEAF_CHILDINFO bnc)
549 550
{
    return (sizeof(*bnc) +
551
            toku_fifo_memory_size_in_use(bnc->buffer) +
552 553 554
            bnc->fresh_message_tree.memory_size() +
            bnc->stale_message_tree.memory_size() +
            bnc->broadcast_list.memory_size());
555 556
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
557
static long
558
get_avail_internal_node_partition_size(FTNODE node, int i)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
559
{
560
    paranoid_invariant(node->height > 0);
561
    return toku_bnc_memory_size(BNC(node, i));
Zardosht Kasheff's avatar
Zardosht Kasheff committed
562 563
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
564

565
static long
566
ftnode_cachepressure_size(FTNODE node)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
{
    long retval = 0;
    bool totally_empty = true;
    if (node->height == 0) {
        goto exit;
    }
    else {
        for (int i = 0; i < node->n_children; i++) {
            if (BP_STATE(node,i) == PT_INVALID || BP_STATE(node,i) == PT_ON_DISK) {
                continue;
            }
            else if (BP_STATE(node,i) == PT_COMPRESSED) {
                SUB_BLOCK sb = BSB(node, i);
                totally_empty = false;
                retval += sb->compressed_size;
            }
            else if (BP_STATE(node,i) == PT_AVAIL) {
                totally_empty = totally_empty && (toku_bnc_n_entries(BNC(node, i)) == 0);
                retval += get_avail_internal_node_partition_size(node, i);
586
                retval += BP_WORKDONE(node, i);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
587 588
            }
            else {
589
                abort();
Zardosht Kasheff's avatar
Zardosht Kasheff committed
590 591 592 593 594 595 596 597 598 599
            }
        }
    }
exit:
    if (totally_empty) {
        return 0;
    }
    return retval;
}

600
static long
601
ftnode_memory_size (FTNODE node)
602
// Effect: Estimate how much main memory a node requires.
603
{
604 605 606
    long retval = 0;
    int n_children = node->n_children;
    retval += sizeof(*node);
607
    retval += (n_children)*(sizeof(node->bp[0]));
608
    retval += (n_children > 0 ? n_children-1 : 0)*(sizeof(node->childkeys[0]));
609
    retval += node->totalchildkeylens;
610 611 612 613 614 615 616

    // now calculate the sizes of the partitions
    for (int i = 0; i < n_children; i++) {
        if (BP_STATE(node,i) == PT_INVALID || BP_STATE(node,i) == PT_ON_DISK) {
            continue;
        }
        else if (BP_STATE(node,i) == PT_COMPRESSED) {
617
            SUB_BLOCK sb = BSB(node, i);
618 619 620 621 622
            retval += sizeof(*sb);
            retval += sb->compressed_size;
        }
        else if (BP_STATE(node,i) == PT_AVAIL) {
            if (node->height > 0) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
623
                retval += get_avail_internal_node_partition_size(node, i);
624 625
            }
            else {
626
                BASEMENTNODE bn = BLB(node, i);
627
                retval += sizeof(*bn);
628
                retval += BLB_DATA(node, i)->get_memory_size();
629 630 631
            }
        }
        else {
632
            abort();
633
        }
634
    }
635
    return retval;
636
}
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
637

638 639 640
PAIR_ATTR make_ftnode_pair_attr(FTNODE node) {
    long size = ftnode_memory_size(node);
    long cachepressure_size = ftnode_cachepressure_size(node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
641
    PAIR_ATTR result={
642 643 644 645 646
        .size = size,
        .nonleaf_size = (node->height > 0) ? size : 0,
        .leaf_size = (node->height > 0) ? 0 : size,
        .rollback_size = 0,
        .cache_pressure_size = cachepressure_size,
Yoni Fogel's avatar
Yoni Fogel committed
647
        .is_valid = true
648 649
    };
    return result;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
650 651
}

652 653
PAIR_ATTR make_invalid_pair_attr(void) {
    PAIR_ATTR result={
654 655 656 657 658
        .size = 0,
        .nonleaf_size = 0,
        .leaf_size = 0,
        .rollback_size = 0,
        .cache_pressure_size = 0,
Yoni Fogel's avatar
Yoni Fogel committed
659
        .is_valid = false
660 661
    };
    return result;
662
}
Zardosht Kasheff's avatar
Zardosht Kasheff committed
663 664


665
// assign unique dictionary id
666
static uint64_t dict_id_serial = 1;
667 668
static DICTIONARY_ID
next_dict_id(void) {
669
    uint64_t i = toku_sync_fetch_and_add(&dict_id_serial, 1);
670
    assert(i);        // guarantee unique dictionary id by asserting 64-bit counter never wraps
671 672 673 674
    DICTIONARY_ID d = {.dictid = i};
    return d;
}

675
//
676
// Given a bfe and a childnum, returns whether the query that constructed the bfe
677 678 679
// wants the child available.
// Requires: bfe->child_to_read to have been set
//
680
bool
681
toku_bfe_wants_child_available (struct ftnode_fetch_extra* bfe, int childnum)
682
{
683 684 685
    return bfe->type == ftnode_fetch_all ||
        (bfe->child_to_read == childnum &&
         (bfe->type == ftnode_fetch_subset || bfe->type == ftnode_fetch_keymatch));
686 687
}

688
int
689
toku_bfe_leftmost_child_wanted(struct ftnode_fetch_extra *bfe, FTNODE node)
690
{
691
    paranoid_invariant(bfe->type == ftnode_fetch_subset || bfe->type == ftnode_fetch_prefetch || bfe->type == ftnode_fetch_keymatch);
692 693
    if (bfe->left_is_neg_infty) {
        return 0;
694
    } else if (bfe->range_lock_left_key.data == nullptr) {
695 696
        return -1;
    } else {
697
        return toku_ftnode_which_child(node, &bfe->range_lock_left_key, &bfe->h->cmp_descriptor, bfe->h->compare_fun);
698 699 700 701
    }
}

int
702
toku_bfe_rightmost_child_wanted(struct ftnode_fetch_extra *bfe, FTNODE node)
703
{
704
    paranoid_invariant(bfe->type == ftnode_fetch_subset || bfe->type == ftnode_fetch_prefetch || bfe->type == ftnode_fetch_keymatch);
705 706
    if (bfe->right_is_pos_infty) {
        return node->n_children - 1;
707
    } else if (bfe->range_lock_right_key.data == nullptr) {
708 709
        return -1;
    } else {
710
        return toku_ftnode_which_child(node, &bfe->range_lock_right_key, &bfe->h->cmp_descriptor, bfe->h->compare_fun);
711 712
    }
}
713

714
static int
715
ft_cursor_rightmost_child_wanted(FT_CURSOR cursor, FT_HANDLE brt, FTNODE node)
716 717 718
{
    if (cursor->right_is_pos_infty) {
        return node->n_children - 1;
719
    } else if (cursor->range_lock_right_key.data == nullptr) {
720 721
        return -1;
    } else {
722
        return toku_ftnode_which_child(node, &cursor->range_lock_right_key, &brt->ft->cmp_descriptor, brt->ft->compare_fun);
723 724
    }
}
725

726
STAT64INFO_S
727
toku_get_and_clear_basement_stats(FTNODE leafnode) {
728 729 730
    invariant(leafnode->height == 0);
    STAT64INFO_S deltas = ZEROSTATS;
    for (int i = 0; i < leafnode->n_children; i++) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
731 732 733 734 735
        BASEMENTNODE bn = BLB(leafnode, i);
        invariant(BP_STATE(leafnode,i) == PT_AVAIL);
        deltas.numrows  += bn->stat64_delta.numrows;
        deltas.numbytes += bn->stat64_delta.numbytes;
        bn->stat64_delta = ZEROSTATS;
736 737 738 739
    }
    return deltas;
}

740 741 742
void toku_ft_status_update_flush_reason(FTNODE node, 
        uint64_t uncompressed_bytes_flushed, uint64_t bytes_written,
        tokutime_t write_time, bool for_checkpoint) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
743 744
    if (node->height == 0) {
        if (for_checkpoint) {
745
            STATUS_INC(FT_DISK_FLUSH_LEAF_FOR_CHECKPOINT, 1);
746 747 748
            STATUS_INC(FT_DISK_FLUSH_LEAF_BYTES_FOR_CHECKPOINT, bytes_written);
            STATUS_INC(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, uncompressed_bytes_flushed);
            STATUS_INC(FT_DISK_FLUSH_LEAF_TOKUTIME_FOR_CHECKPOINT, write_time);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
749 750
        }
        else {
751
            STATUS_INC(FT_DISK_FLUSH_LEAF, 1);
752 753 754
            STATUS_INC(FT_DISK_FLUSH_LEAF_BYTES, bytes_written);
            STATUS_INC(FT_DISK_FLUSH_LEAF_UNCOMPRESSED_BYTES, uncompressed_bytes_flushed);
            STATUS_INC(FT_DISK_FLUSH_LEAF_TOKUTIME, write_time);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
755 756 757 758
        }
    }
    else {
        if (for_checkpoint) {
759
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_FOR_CHECKPOINT, 1);
760 761 762
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_BYTES_FOR_CHECKPOINT, bytes_written);
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES_FOR_CHECKPOINT, uncompressed_bytes_flushed);
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_TOKUTIME_FOR_CHECKPOINT, write_time);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
763 764
        }
        else {
765
            STATUS_INC(FT_DISK_FLUSH_NONLEAF, 1);
766 767 768
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_BYTES, bytes_written);
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_UNCOMPRESSED_BYTES, uncompressed_bytes_flushed);
            STATUS_INC(FT_DISK_FLUSH_NONLEAF_TOKUTIME, write_time);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
769 770 771 772
        }
    }
}

773 774
static void ftnode_update_disk_stats(
    FTNODE ftnode,
775
    FT ft,
Yoni Fogel's avatar
Yoni Fogel committed
776
    bool for_checkpoint
777
    )
Zardosht Kasheff's avatar
Zardosht Kasheff committed
778 779 780
{
    STAT64INFO_S deltas = ZEROSTATS;
    // capture deltas before rebalancing basements for serialization
781
    deltas = toku_get_and_clear_basement_stats(ftnode);
782 783 784 785 786 787 788 789 790 791
    // locking not necessary here with respect to checkpointing
    // in Clayface (because of the pending lock and cachetable lock
    // in toku_cachetable_begin_checkpoint)
    // essentially, if we are dealing with a for_checkpoint 
    // parameter in a function that is called by the flush_callback,
    // then the cachetable needs to ensure that this is called in a safe
    // manner that does not interfere with the beginning
    // of a checkpoint, which it does with the cachetable lock
    // and pending lock
    toku_ft_update_stats(&ft->h->on_disk_stats, deltas);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
792
    if (for_checkpoint) {
793
        toku_ft_update_stats(&ft->checkpoint_header->on_disk_stats, deltas);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
794 795 796
    }
}

797
static void ftnode_clone_partitions(FTNODE node, FTNODE cloned_node) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
798 799
    for (int i = 0; i < node->n_children; i++) {
        BP_BLOCKNUM(cloned_node,i) = BP_BLOCKNUM(node,i);
800
        paranoid_invariant(BP_STATE(node,i) == PT_AVAIL);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
801 802 803
        BP_STATE(cloned_node,i) = PT_AVAIL;
        BP_WORKDONE(cloned_node, i) = BP_WORKDONE(node, i);
        if (node->height == 0) {
804
            set_BLB(cloned_node, i, toku_clone_bn(BLB(node,i)));
Zardosht Kasheff's avatar
Zardosht Kasheff committed
805 806 807 808 809 810 811
        }
        else {
            set_BNC(cloned_node, i, toku_clone_nl(BNC(node,i)));
        }
    }
}

812 813 814 815 816 817 818 819 820 821 822 823 824
void toku_ftnode_checkpoint_complete_callback(void *value_data) {
    FTNODE node = static_cast<FTNODE>(value_data);
    if (node->height > 0) {
        for (int i = 0; i < node->n_children; ++i) {
            if (BP_STATE(node, i) == PT_AVAIL) {
                NONLEAF_CHILDINFO bnc = BNC(node, i);
                bnc->flow[1] = bnc->flow[0];
                bnc->flow[0] = 0;
            }
        }
    }
}

825
void toku_ftnode_clone_callback(
826 827
    void* value_data,
    void** cloned_value_data,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
828
    long* clone_size,
829
    PAIR_ATTR* new_attr,
Yoni Fogel's avatar
Yoni Fogel committed
830
    bool for_checkpoint,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
831 832 833
    void* write_extraargs
    )
{
834
    FTNODE node = static_cast<FTNODE>(value_data);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
835
    toku_assert_entire_node_in_memory(node);
836 837
    FT ft = static_cast<FT>(write_extraargs);
    FTNODE XCALLOC(cloned_node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
838
    if (node->height == 0) {
839
        // set header stats, must be done before rebalancing
840
        ftnode_update_disk_stats(node, ft, for_checkpoint);
841
        // rebalance the leaf node
842
        rebalance_ftnode_leaf(node, ft->h->basementnodesize);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
843 844
    }

John Esmet's avatar
John Esmet committed
845
    cloned_node->oldest_referenced_xid_known = node->oldest_referenced_xid_known;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
    cloned_node->max_msn_applied_to_node_on_disk = node->max_msn_applied_to_node_on_disk;
    cloned_node->flags = node->flags;
    cloned_node->thisnodename = node->thisnodename;
    cloned_node->layout_version = node->layout_version;
    cloned_node->layout_version_original = node->layout_version_original;
    cloned_node->layout_version_read_from_disk = node->layout_version_read_from_disk;
    cloned_node->build_id = node->build_id;
    cloned_node->height = node->height;
    cloned_node->dirty = node->dirty;
    cloned_node->fullhash = node->fullhash;
    cloned_node->n_children = node->n_children;
    cloned_node->totalchildkeylens = node->totalchildkeylens;

    XMALLOC_N(node->n_children-1, cloned_node->childkeys);
    XMALLOC_N(node->n_children, cloned_node->bp);
    // clone pivots
    for (int i = 0; i < node->n_children-1; i++) {
863
        toku_clone_dbt(&cloned_node->childkeys[i], node->childkeys[i]);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
864 865
    }
    // clone partition
866
    ftnode_clone_partitions(node, cloned_node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
867 868 869 870

    // clear dirty bit
    node->dirty = 0;
    cloned_node->dirty = 0;
871
    node->layout_version_read_from_disk = FT_LAYOUT_VERSION;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
872 873
    // set new pair attr if necessary
    if (node->height == 0) {
874
        *new_attr = make_ftnode_pair_attr(node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
875 876
    }
    else {
Yoni Fogel's avatar
Yoni Fogel committed
877
        new_attr->is_valid = false;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
878
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
879
    *clone_size = ftnode_memory_size(cloned_node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
880 881 882
    *cloned_value_data = cloned_node;
}

883
static void ft_leaf_run_gc(FTNODE node, FT ft);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
884

885
void toku_ftnode_flush_callback(
886
    CACHEFILE UU(cachefile),
887 888
    int fd,
    BLOCKNUM nodename,
889
    void *ftnode_v,
890 891 892 893
    void** disk_data,
    void *extraargs,
    PAIR_ATTR size __attribute__((unused)),
    PAIR_ATTR* new_size,
Yoni Fogel's avatar
Yoni Fogel committed
894 895 896
    bool write_me,
    bool keep_me,
    bool for_checkpoint,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
897
    bool is_clone
898
    )
Zardosht Kasheff's avatar
Zardosht Kasheff committed
899
{
900 901
    FT h = (FT) extraargs;
    FTNODE ftnode = (FTNODE) ftnode_v;
902 903 904
    FTNODE_DISK_DATA* ndd = (FTNODE_DISK_DATA*)disk_data;
    assert(ftnode->thisnodename.b==nodename.b);
    int height = ftnode->height;
905
    if (write_me) {
906
        toku_assert_entire_node_in_memory(ftnode);
907 908 909
        if (height == 0) {
            ft_leaf_run_gc(ftnode, h);
        }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
910 911 912
        if (height == 0 && !is_clone) {
            ftnode_update_disk_stats(ftnode, h, for_checkpoint);
        }
913 914 915
        int r = toku_serialize_ftnode_to(fd, ftnode->thisnodename, ftnode, ndd, !is_clone, h, for_checkpoint);
        assert_zero(r);
        ftnode->layout_version_read_from_disk = FT_LAYOUT_VERSION;
916 917
    }
    if (!keep_me) {
918
        if (!is_clone) {
919 920 921 922 923 924 925 926
            long node_size = ftnode_memory_size(ftnode);
            if (ftnode->height == 0) {
                STATUS_INC(FT_FULL_EVICTIONS_LEAF, 1);
                STATUS_INC(FT_FULL_EVICTIONS_LEAF_BYTES, node_size);
            } else {
                STATUS_INC(FT_FULL_EVICTIONS_NONLEAF, 1);
                STATUS_INC(FT_FULL_EVICTIONS_NONLEAF_BYTES, node_size);
            }
927 928 929
            toku_free(*disk_data);
        }
        else {
930 931 932 933 934
            if (ftnode->height == 0) {
                for (int i = 0; i < ftnode->n_children; i++) {
                    if (BP_STATE(ftnode,i) == PT_AVAIL) {
                        BASEMENTNODE bn = BLB(ftnode, i);
                        toku_ft_decrease_stats(&h->in_memory_stats, bn->stat64_delta);
935 936 937 938
                    }
                }
            }
        }
939
        toku_ftnode_free(&ftnode);
940
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
941
    else {
942
        *new_size = make_ftnode_pair_attr(ftnode);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
943
    }
944 945
}

946
void
947
toku_ft_status_update_pivot_fetch_reason(struct ftnode_fetch_extra *bfe)
948
{
949
    if (bfe->type == ftnode_fetch_prefetch) {
950
        STATUS_INC(FT_NUM_PIVOTS_FETCHED_PREFETCH, 1);
951
        STATUS_INC(FT_BYTES_PIVOTS_FETCHED_PREFETCH, bfe->bytes_read);
952
        STATUS_INC(FT_TOKUTIME_PIVOTS_FETCHED_PREFETCH, bfe->io_time);
953
    } else if (bfe->type == ftnode_fetch_all) {
954
        STATUS_INC(FT_NUM_PIVOTS_FETCHED_WRITE, 1);
955
        STATUS_INC(FT_BYTES_PIVOTS_FETCHED_WRITE, bfe->bytes_read);
956
        STATUS_INC(FT_TOKUTIME_PIVOTS_FETCHED_WRITE, bfe->io_time);
957
    } else if (bfe->type == ftnode_fetch_subset || bfe->type == ftnode_fetch_keymatch) {
958
        STATUS_INC(FT_NUM_PIVOTS_FETCHED_QUERY, 1);
959
        STATUS_INC(FT_BYTES_PIVOTS_FETCHED_QUERY, bfe->bytes_read);
960
        STATUS_INC(FT_TOKUTIME_PIVOTS_FETCHED_QUERY, bfe->io_time);
961 962
    }
}
963

Zardosht Kasheff's avatar
Zardosht Kasheff committed
964
int toku_ftnode_fetch_callback (CACHEFILE UU(cachefile), PAIR p, int fd, BLOCKNUM nodename, uint32_t fullhash,
965
                                 void **ftnode_pv,  void** disk_data, PAIR_ATTR *sizep, int *dirtyp, void *extraargs) {
966
    assert(extraargs);
967 968 969 970
    assert(*ftnode_pv == NULL);
    FTNODE_DISK_DATA* ndd = (FTNODE_DISK_DATA*)disk_data;
    struct ftnode_fetch_extra *bfe = (struct ftnode_fetch_extra *)extraargs;
    FTNODE *node=(FTNODE*)ftnode_pv;
971 972 973
    // deserialize the node, must pass the bfe in because we cannot
    // evaluate what piece of the the node is necessary until we get it at
    // least partially into memory
974 975 976
    int r = toku_deserialize_ftnode_from(fd, nodename, fullhash, node, ndd, bfe);
    if (r != 0) {
        if (r == TOKUDB_BAD_CHECKSUM) {
977
            fprintf(stderr,
978 979
                    "Checksum failure while reading node in file %s.\n",
                    toku_cachefile_fname_in_env(cachefile));
980
        } else {
981
            fprintf(stderr, "Error deserializing node, errno = %d", r);
982 983
        }
        // make absolutely sure we crash before doing anything else.
984
        abort();
985
    }
986

987
    if (r == 0) {
988
        *sizep = make_ftnode_pair_attr(*node);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
989
        (*node)->ct_pair = p;
990
        *dirtyp = (*node)->dirty;  // deserialize could mark the node as dirty (presumably for upgrade)
991
    }
992 993 994
    return r;
}

995 996 997 998 999 1000
static bool ft_compress_buffers_before_eviction = true;

void toku_ft_set_compress_buffers_before_eviction(bool compress_buffers) {
    ft_compress_buffers_before_eviction = compress_buffers;
}

1001 1002
void toku_ftnode_pe_est_callback(
    void* ftnode_pv,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1003
    void* disk_data,
1004 1005
    long* bytes_freed_estimate,
    enum partial_eviction_cost *cost,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1006 1007 1008
    void* UU(write_extraargs)
    )
{
1009
    paranoid_invariant(ftnode_pv != NULL);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1010
    long bytes_to_free = 0;
1011
    FTNODE node = static_cast<FTNODE>(ftnode_pv);
1012
    if (node->dirty || node->height == 0 ||
1013
        node->layout_version_read_from_disk < FT_FIRST_LAYOUT_VERSION_WITH_BASEMENT_NODES) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
        *bytes_freed_estimate = 0;
        *cost = PE_CHEAP;
        goto exit;
    }

    //
    // we are dealing with a clean internal node
    //
    *cost = PE_EXPENSIVE;
    // now lets get an estimate for how much data we can free up
    // we estimate the compressed size of data to be how large
    // the compressed data is on disk
    for (int i = 0; i < node->n_children; i++) {
John Esmet's avatar
John Esmet committed
1027
        if (BP_STATE(node,i) == PT_AVAIL && BP_SHOULD_EVICT(node,i)) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1028 1029 1030 1031
            // calculate how much data would be freed if
            // we compress this node and add it to
            // bytes_to_free

1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
            if (ft_compress_buffers_before_eviction) {
                // first get an estimate for how much space will be taken
                // after compression, it is simply the size of compressed
                // data on disk plus the size of the struct that holds it
                FTNODE_DISK_DATA ndd = (FTNODE_DISK_DATA) disk_data;
                uint32_t compressed_data_size = BP_SIZE(ndd, i);
                compressed_data_size += sizeof(struct sub_block);

                // now get the space taken now
                uint32_t decompressed_data_size = get_avail_internal_node_partition_size(node,i);
                bytes_to_free += (decompressed_data_size - compressed_data_size);
            } else {
                bytes_to_free += get_avail_internal_node_partition_size(node, i);
            }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1046 1047 1048 1049 1050 1051 1052 1053
        }
    }

    *bytes_freed_estimate = bytes_to_free;
exit:
    return;
}

1054 1055 1056
// replace the child buffer with a compressed version of itself.
// @return the old child buffer
static NONLEAF_CHILDINFO
1057
compress_internal_node_partition(FTNODE node, int i, enum toku_compression_method compression_method)
1058 1059 1060 1061 1062
{
    // if we should evict, compress the
    // message buffer into a sub_block
    assert(BP_STATE(node, i) == PT_AVAIL);
    assert(node->height > 0);
1063
    SUB_BLOCK XMALLOC(sb);
1064
    sub_block_init(sb);
1065
    toku_create_compressed_partition_from_available(node, i, compression_method, sb);
1066

1067 1068
    // now set the state to compressed and return the old, available partition
    NONLEAF_CHILDINFO bnc = BNC(node, i);
1069 1070
    set_BSB(node, i, sb);
    BP_STATE(node,i) = PT_COMPRESSED;
1071
    return bnc;
1072 1073
}

1074
void toku_evict_bn_from_memory(FTNODE node, int childnum, FT h) {
1075 1076 1077
    // free the basement node
    assert(!node->dirty);
    BASEMENTNODE bn = BLB(node, childnum);
1078
    toku_ft_decrease_stats(&h->in_memory_stats, bn->stat64_delta);
1079 1080 1081 1082 1083
    destroy_basement_node(bn);
    set_BNULL(node, childnum);
    BP_STATE(node, childnum) = PT_ON_DISK;
}

1084 1085 1086 1087 1088 1089 1090 1091
BASEMENTNODE toku_detach_bn(FTNODE node, int childnum) {
    assert(BP_STATE(node, childnum) == PT_AVAIL);
    BASEMENTNODE bn = BLB(node, childnum);
    set_BNULL(node, childnum);
    BP_STATE(node, childnum) = PT_ON_DISK;
    return bn;
}

1092
// callback for partially evicting a node
1093 1094 1095 1096
int toku_ftnode_pe_callback(void *ftnode_pv, PAIR_ATTR old_attr, void *write_extraargs,
                            void (*finalize)(PAIR_ATTR new_attr, void *extra), void *finalize_extra) {
    FTNODE node = (FTNODE) ftnode_pv;
    FT ft = (FT) write_extraargs;
1097
    int num_partial_evictions = 0;
1098 1099 1100 1101 1102 1103 1104 1105 1106 1107

    // Hold things we intend to destroy here.
    // They will be taken care of after finalize().
    int num_basements_to_destroy = 0;
    int num_buffers_to_destroy = 0;
    int num_pointers_to_free = 0;
    BASEMENTNODE basements_to_destroy[node->n_children];
    NONLEAF_CHILDINFO buffers_to_destroy[node->n_children];
    void *pointers_to_free[node->n_children * 2];

1108
    // Don't partially evict dirty nodes
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1109 1110 1111
    if (node->dirty) {
        goto exit;
    }
1112 1113
    // Don't partially evict nodes whose partitions can't be read back
    // from disk individually
1114
    if (node->layout_version_read_from_disk < FT_FIRST_LAYOUT_VERSION_WITH_BASEMENT_NODES) {
1115 1116
        goto exit;
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1117
    //
1118
    // partial eviction for nonleaf nodes
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1119 1120 1121 1122 1123
    //
    if (node->height > 0) {
        for (int i = 0; i < node->n_children; i++) {
            if (BP_STATE(node,i) == PT_AVAIL) {
                if (BP_SHOULD_EVICT(node,i)) {
1124
                    NONLEAF_CHILDINFO bnc;
1125 1126
                    if (ft_compress_buffers_before_eviction) {
                        // When partially evicting, always compress with quicklz
1127
                        bnc = compress_internal_node_partition(
1128 1129 1130 1131 1132 1133 1134
                            node,
                            i,
                            TOKU_QUICKLZ_METHOD
                            );
                    } else {
                        // We're not compressing buffers before eviction. Simply
                        // detach the buffer and set the child's state to on-disk.
1135
                        bnc = BNC(node, i);
1136 1137 1138
                        set_BNULL(node, i);
                        BP_STATE(node, i) = PT_ON_DISK;
                    }
1139 1140
                    buffers_to_destroy[num_buffers_to_destroy++] = bnc;
                    num_partial_evictions++;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1141 1142 1143 1144 1145 1146 1147 1148 1149
                }
                else {
                    BP_SWEEP_CLOCK(node,i);
                }
            }
            else {
                continue;
            }
        }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
    }
    //
    // partial eviction strategy for basement nodes:
    //  if the bn is compressed, evict it
    //  else: check if it requires eviction, if it does, evict it, if not, sweep the clock count
    //
    else {
        for (int i = 0; i < node->n_children; i++) {
            // Get rid of compressed stuff no matter what.
            if (BP_STATE(node,i) == PT_COMPRESSED) {
1160
                SUB_BLOCK sb = BSB(node, i);
1161 1162
                pointers_to_free[num_pointers_to_free++] = sb->compressed_ptr;
                pointers_to_free[num_pointers_to_free++] = sb;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1163
                set_BNULL(node, i);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1164
                BP_STATE(node,i) = PT_ON_DISK;
1165
                num_partial_evictions++;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1166 1167 1168
            }
            else if (BP_STATE(node,i) == PT_AVAIL) {
                if (BP_SHOULD_EVICT(node,i)) {
1169 1170 1171 1172 1173 1174
                    BASEMENTNODE bn = BLB(node, i);
                    basements_to_destroy[num_basements_to_destroy++] = bn;
                    toku_ft_decrease_stats(&ft->in_memory_stats, bn->stat64_delta);
                    set_BNULL(node, i);
                    BP_STATE(node, i) = PT_ON_DISK;
                    num_partial_evictions++;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1175 1176 1177 1178 1179 1180 1181 1182 1183
                }
                else {
                    BP_SWEEP_CLOCK(node,i);
                }
            }
            else if (BP_STATE(node,i) == PT_ON_DISK) {
                continue;
            }
            else {
1184
                abort();
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1185 1186 1187
            }
        }
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1188

1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
exit:
    // call the finalize callback with a new pair attr
    PAIR_ATTR new_attr = make_ftnode_pair_attr(node);
    finalize(new_attr, finalize_extra);

    // destroy everything now that we've called finalize(),
    // and, by contract, and it's safe to do expensive work.
    for (int i = 0; i < num_basements_to_destroy; i++) {
        destroy_basement_node(basements_to_destroy[i]);
    }
    for (int i = 0; i < num_buffers_to_destroy; i++) {
        destroy_nonleaf_childinfo(buffers_to_destroy[i]);
    }
    for (int i = 0; i < num_pointers_to_free; i++) {
        toku_free(pointers_to_free[i]);
    }
    // stats
1206 1207
    if (num_partial_evictions > 0) {
        if (node->height == 0) {
1208
            long delta = old_attr.leaf_size - new_attr.leaf_size;
1209 1210 1211
            STATUS_INC(FT_PARTIAL_EVICTIONS_LEAF, num_partial_evictions);
            STATUS_INC(FT_PARTIAL_EVICTIONS_LEAF_BYTES, delta);
        } else {
1212
            long delta = old_attr.nonleaf_size - new_attr.nonleaf_size;
1213 1214 1215 1216
            STATUS_INC(FT_PARTIAL_EVICTIONS_NONLEAF, num_partial_evictions);
            STATUS_INC(FT_PARTIAL_EVICTIONS_NONLEAF_BYTES, delta);
        }
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1217 1218 1219
    return 0;
}

1220 1221 1222 1223 1224
// We touch the clock while holding a read lock.
// DRD reports a race but we want to ignore it.
// Using a valgrind suppressions file is better than the DRD_IGNORE_VAR macro because it's more targeted.
// We need a function to have something a drd suppression can reference
// see src/tests/drd.suppressions (unsafe_touch_clock)
1225
static void unsafe_touch_clock(FTNODE node, int i) {
1226 1227
    BP_TOUCH_CLOCK(node, i);
}
1228

Zardosht Kasheff's avatar
Zardosht Kasheff committed
1229
// Callback that states if a partial fetch of the node is necessary
1230 1231 1232 1233
// Currently, this function is responsible for the following things:
//  - reporting to the cachetable whether a partial fetch is required (as required by the contract of the callback)
//  - A couple of things that are NOT required by the callback, but we do for efficiency and simplicity reasons:
//   - for queries, set the value of bfe->child_to_read so that the query that called this can proceed with the query
1234
//      as opposed to having to evaluate toku_ft_search_which_child again. This is done to make the in-memory query faster
1235 1236 1237
//   - touch the necessary partition's clock. The reason we do it here is so that there is one central place it is done, and not done
//      by all the various callers
//
Yoni Fogel's avatar
Yoni Fogel committed
1238
bool toku_ftnode_pf_req_callback(void* ftnode_pv, void* read_extraargs) {
1239
    // placeholder for now
Yoni Fogel's avatar
Yoni Fogel committed
1240
    bool retval = false;
1241 1242
    FTNODE node = (FTNODE) ftnode_pv;
    struct ftnode_fetch_extra *bfe = (struct ftnode_fetch_extra *) read_extraargs;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1243 1244
    //
    // The three types of fetches that the brt layer may request are:
1245 1246 1247
    //  - ftnode_fetch_none: no partitions are necessary (example use: stat64)
    //  - ftnode_fetch_subset: some subset is necessary (example use: toku_ft_search)
    //  - ftnode_fetch_all: entire node is necessary (example use: flush, split, merge)
1248
    // The code below checks if the necessary partitions are already in memory,
Yoni Fogel's avatar
Yoni Fogel committed
1249
    // and if they are, return false, and if not, return true
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1250
    //
1251
    if (bfe->type == ftnode_fetch_none) {
Yoni Fogel's avatar
Yoni Fogel committed
1252
        retval = false;
1253
    }
1254
    else if (bfe->type == ftnode_fetch_all) {
Yoni Fogel's avatar
Yoni Fogel committed
1255
        retval = false;
1256
        for (int i = 0; i < node->n_children; i++) {
1257
            unsafe_touch_clock(node,i);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1258 1259 1260
            // if we find a partition that is not available,
            // then a partial fetch is required because
            // the entire node must be made available
1261
            if (BP_STATE(node,i) != PT_AVAIL) {
Yoni Fogel's avatar
Yoni Fogel committed
1262
                retval = true;
1263 1264 1265
            }
        }
    }
1266
    else if (bfe->type == ftnode_fetch_subset) {
1267 1268 1269 1270 1271
        // we do not take into account prefetching yet
        // as of now, if we need a subset, the only thing
        // we can possibly require is a single basement node
        // we find out what basement node the query cares about
        // and check if it is available
1272 1273
        paranoid_invariant(bfe->h->compare_fun);
        paranoid_invariant(bfe->search);
1274
        bfe->child_to_read = toku_ft_search_which_child(
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1275
            &bfe->h->cmp_descriptor,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1276
            bfe->h->compare_fun,
1277 1278 1279
            node,
            bfe->search
            );
1280
        unsafe_touch_clock(node,bfe->child_to_read);
Yoni Fogel's avatar
Yoni Fogel committed
1281
        // child we want to read is not available, must set retval to true
1282 1283
        retval = (BP_STATE(node, bfe->child_to_read) != PT_AVAIL);
    }
1284
    else if (bfe->type == ftnode_fetch_prefetch) {
1285 1286
        // makes no sense to have prefetching disabled
        // and still call this function
1287
        paranoid_invariant(!bfe->disable_prefetching);
1288 1289 1290 1291
        int lc = toku_bfe_leftmost_child_wanted(bfe, node);
        int rc = toku_bfe_rightmost_child_wanted(bfe, node);
        for (int i = lc; i <= rc; ++i) {
            if (BP_STATE(node, i) != PT_AVAIL) {
Yoni Fogel's avatar
Yoni Fogel committed
1292
                retval = true;
1293 1294
            }
        }
1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
    } else if (bfe->type == ftnode_fetch_keymatch) {
        // we do not take into account prefetching yet
        // as of now, if we need a subset, the only thing
        // we can possibly require is a single basement node
        // we find out what basement node the query cares about
        // and check if it is available
        paranoid_invariant(bfe->h->compare_fun);
        if (node->height == 0) {
            int left_child = toku_bfe_leftmost_child_wanted(bfe, node);
            int right_child = toku_bfe_rightmost_child_wanted(bfe, node);
            if (left_child == right_child) {
                bfe->child_to_read = left_child;
                unsafe_touch_clock(node,bfe->child_to_read);
                // child we want to read is not available, must set retval to true
                retval = (BP_STATE(node, bfe->child_to_read) != PT_AVAIL);
            }
        }
    } else {
1313
        // we have a bug. The type should be known
1314
        abort();
1315 1316
    }
    return retval;
1317 1318
}

1319
static void
1320
ft_status_update_partial_fetch_reason(
1321 1322 1323 1324
    struct ftnode_fetch_extra* bfe,
    int childnum,
    enum pt_state state,
    bool is_leaf
1325 1326 1327 1328
    )
{
    invariant(state == PT_COMPRESSED || state == PT_ON_DISK);
    if (is_leaf) {
1329
        if (bfe->type == ftnode_fetch_prefetch) {
1330
            if (state == PT_COMPRESSED) {
1331
                STATUS_INC(FT_NUM_BASEMENTS_DECOMPRESSED_PREFETCH, 1);
1332
            } else {
1333
                STATUS_INC(FT_NUM_BASEMENTS_FETCHED_PREFETCH, 1);
1334
                STATUS_INC(FT_BYTES_BASEMENTS_FETCHED_PREFETCH, bfe->bytes_read);
1335
                STATUS_INC(FT_TOKUTIME_BASEMENTS_FETCHED_PREFETCH, bfe->io_time);
1336
            }
1337
        } else if (bfe->type == ftnode_fetch_all) {
1338
            if (state == PT_COMPRESSED) {
1339
                STATUS_INC(FT_NUM_BASEMENTS_DECOMPRESSED_WRITE, 1);
1340
            } else {
1341
                STATUS_INC(FT_NUM_BASEMENTS_FETCHED_WRITE, 1);
1342
                STATUS_INC(FT_BYTES_BASEMENTS_FETCHED_WRITE, bfe->bytes_read);
1343
                STATUS_INC(FT_TOKUTIME_BASEMENTS_FETCHED_WRITE, bfe->io_time);
1344
            }
1345
        } else if (childnum == bfe->child_to_read) {
1346
            if (state == PT_COMPRESSED) {
1347
                STATUS_INC(FT_NUM_BASEMENTS_DECOMPRESSED_NORMAL, 1);
1348
            } else {
1349
                STATUS_INC(FT_NUM_BASEMENTS_FETCHED_NORMAL, 1);
1350
                STATUS_INC(FT_BYTES_BASEMENTS_FETCHED_NORMAL, bfe->bytes_read);
1351
                STATUS_INC(FT_TOKUTIME_BASEMENTS_FETCHED_NORMAL, bfe->io_time);
1352 1353 1354
            }
        } else {
            if (state == PT_COMPRESSED) {
1355
                STATUS_INC(FT_NUM_BASEMENTS_DECOMPRESSED_AGGRESSIVE, 1);
1356
            } else {
1357
                STATUS_INC(FT_NUM_BASEMENTS_FETCHED_AGGRESSIVE, 1);
1358
                STATUS_INC(FT_BYTES_BASEMENTS_FETCHED_AGGRESSIVE, bfe->bytes_read);
1359
                STATUS_INC(FT_TOKUTIME_BASEMENTS_FETCHED_AGGRESSIVE, bfe->io_time);
1360 1361 1362 1363
            }
        }
    }
    else {
1364
        if (bfe->type == ftnode_fetch_prefetch) {
1365
            if (state == PT_COMPRESSED) {
1366
                STATUS_INC(FT_NUM_MSG_BUFFER_DECOMPRESSED_PREFETCH, 1);
1367
            } else {
1368
                STATUS_INC(FT_NUM_MSG_BUFFER_FETCHED_PREFETCH, 1);
1369
                STATUS_INC(FT_BYTES_MSG_BUFFER_FETCHED_PREFETCH, bfe->bytes_read);
1370
                STATUS_INC(FT_TOKUTIME_MSG_BUFFER_FETCHED_PREFETCH, bfe->io_time);
1371
            }
1372
        } else if (bfe->type == ftnode_fetch_all) {
1373
            if (state == PT_COMPRESSED) {
1374
                STATUS_INC(FT_NUM_MSG_BUFFER_DECOMPRESSED_WRITE, 1);
1375
            } else {
1376
                STATUS_INC(FT_NUM_MSG_BUFFER_FETCHED_WRITE, 1);
1377
                STATUS_INC(FT_BYTES_MSG_BUFFER_FETCHED_WRITE, bfe->bytes_read);
1378
                STATUS_INC(FT_TOKUTIME_MSG_BUFFER_FETCHED_WRITE, bfe->io_time);
1379
            }
1380
        } else if (childnum == bfe->child_to_read) {
1381
            if (state == PT_COMPRESSED) {
1382
                STATUS_INC(FT_NUM_MSG_BUFFER_DECOMPRESSED_NORMAL, 1);
1383
            } else {
1384
                STATUS_INC(FT_NUM_MSG_BUFFER_FETCHED_NORMAL, 1);
1385
                STATUS_INC(FT_BYTES_MSG_BUFFER_FETCHED_NORMAL, bfe->bytes_read);
1386
                STATUS_INC(FT_TOKUTIME_MSG_BUFFER_FETCHED_NORMAL, bfe->io_time);
1387 1388 1389
            }
        } else {
            if (state == PT_COMPRESSED) {
1390
                STATUS_INC(FT_NUM_MSG_BUFFER_DECOMPRESSED_AGGRESSIVE, 1);
1391
            } else {
1392
                STATUS_INC(FT_NUM_MSG_BUFFER_FETCHED_AGGRESSIVE, 1);
1393
                STATUS_INC(FT_BYTES_MSG_BUFFER_FETCHED_AGGRESSIVE, bfe->bytes_read);
1394
                STATUS_INC(FT_TOKUTIME_MSG_BUFFER_FETCHED_AGGRESSIVE, bfe->io_time);
1395 1396 1397 1398 1399
            }
        }
    }
}

1400 1401 1402 1403 1404 1405 1406 1407
void toku_ft_status_update_serialize_times(FTNODE node, tokutime_t serialize_time, tokutime_t compress_time) {
    if (node->height == 0) {
        STATUS_INC(FT_LEAF_SERIALIZE_TOKUTIME, serialize_time);
        STATUS_INC(FT_LEAF_COMPRESS_TOKUTIME, compress_time);
    } else {
        STATUS_INC(FT_NONLEAF_SERIALIZE_TOKUTIME, serialize_time);
        STATUS_INC(FT_NONLEAF_COMPRESS_TOKUTIME, compress_time);
    }
1408 1409
}

1410 1411 1412 1413 1414 1415 1416 1417
void toku_ft_status_update_deserialize_times(FTNODE node, tokutime_t deserialize_time, tokutime_t decompress_time) {
    if (node->height == 0) {
        STATUS_INC(FT_LEAF_DESERIALIZE_TOKUTIME, deserialize_time);
        STATUS_INC(FT_LEAF_DECOMPRESS_TOKUTIME, decompress_time);
    } else {
        STATUS_INC(FT_NONLEAF_DESERIALIZE_TOKUTIME, deserialize_time);
        STATUS_INC(FT_NONLEAF_DECOMPRESS_TOKUTIME, decompress_time);
    }
1418 1419
}

1420
// callback for partially reading a node
1421 1422
// could have just used toku_ftnode_fetch_callback, but wanted to separate the two cases to separate functions
int toku_ftnode_pf_callback(void* ftnode_pv, void* disk_data, void* read_extraargs, int fd, PAIR_ATTR* sizep) {
1423
    int r = 0;
1424 1425 1426
    FTNODE node = (FTNODE) ftnode_pv;
    FTNODE_DISK_DATA ndd = (FTNODE_DISK_DATA) disk_data;
    struct ftnode_fetch_extra *bfe = (struct ftnode_fetch_extra *) read_extraargs;
1427
    // there must be a reason this is being called. If we get a garbage type or the type is ftnode_fetch_none,
1428
    // then something went wrong
1429
    assert((bfe->type == ftnode_fetch_subset) || (bfe->type == ftnode_fetch_all) || (bfe->type == ftnode_fetch_prefetch) || (bfe->type == ftnode_fetch_keymatch));
1430 1431
    // determine the range to prefetch
    int lc, rc;
1432
    if (!bfe->disable_prefetching &&
1433
        (bfe->type == ftnode_fetch_subset || bfe->type == ftnode_fetch_prefetch)
1434
        )
1435
    {
1436 1437 1438 1439 1440 1441
        lc = toku_bfe_leftmost_child_wanted(bfe, node);
        rc = toku_bfe_rightmost_child_wanted(bfe, node);
    } else {
        lc = -1;
        rc = -1;
    }
1442 1443 1444 1445
    for (int i = 0; i < node->n_children; i++) {
        if (BP_STATE(node,i) == PT_AVAIL) {
            continue;
        }
1446
        if ((lc <= i && i <= rc) || toku_bfe_wants_child_available(bfe, i)) {
1447 1448
            enum pt_state state = BP_STATE(node, i);
            if (state == PT_COMPRESSED) {
1449
                r = toku_deserialize_bp_from_compressed(node, i, bfe);
1450 1451
            } else {
                invariant(state == PT_ON_DISK);
1452
                r = toku_deserialize_bp_from_disk(node, ndd, i, fd, bfe);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1453
            }
1454
            ft_status_update_partial_fetch_reason(bfe, i, state, (node->height == 0));
1455
        }
1456

1457 1458
        if (r != 0) {
            if (r == TOKUDB_BAD_CHECKSUM) {
1459 1460 1461
                fprintf(stderr,
                        "Checksum failure while reading node partition in file %s.\n",
                        toku_cachefile_fname_in_env(bfe->h->cf));
1462
            } else {
1463 1464
                fprintf(stderr,
                        "Error while reading node partition %d\n",
1465
                        get_maybe_error_errno());
1466
            }
1467
            abort();
1468
        }
1469
    }
1470

1471
    *sizep = make_ftnode_pair_attr(node);
1472

1473
    return 0;
1474 1475
}

1476 1477 1478 1479 1480
struct cmd_leafval_heaviside_extra {
    ft_compare_func compare_fun;
    DESCRIPTOR desc;
    DBT const * const key;
};
1481

1482
//TODO: #1125 optimize
1483 1484 1485 1486 1487
static int
toku_cmd_leafval_heaviside(DBT const &kdbt, const struct cmd_leafval_heaviside_extra &be) {
    FAKE_DB(db, be.desc);
    DBT const * const key = be.key;
    return be.compare_fun(&db, &kdbt, key);
1488 1489
}

1490
static int
1491
ft_compare_pivot(DESCRIPTOR desc, ft_compare_func cmp, const DBT *key, const DBT *pivot)
1492
{
1493
    int r;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1494
    FAKE_DB(db, desc);
1495
    r = cmp(&db, key, pivot);
1496
    return r;
1497 1498
}

1499

1500
// destroys the internals of the ftnode, but it does not free the values
1501
// that are stored
1502
// this is common functionality for toku_ftnode_free and rebalance_ftnode_leaf
1503
// MUST NOT do anything besides free the structures that have been allocated
1504
void toku_destroy_ftnode_internals(FTNODE node)
1505
{
1506
    for (int i=0; i<node->n_children-1; i++) {
1507
        toku_destroy_dbt(&node->childkeys[i]);
1508 1509 1510
    }
    toku_free(node->childkeys);
    node->childkeys = NULL;
1511 1512 1513 1514

    for (int i=0; i < node->n_children; i++) {
        if (BP_STATE(node,i) == PT_AVAIL) {
            if (node->height > 0) {
1515
                destroy_nonleaf_childinfo(BNC(node,i));
1516
            } else {
1517
                destroy_basement_node(BLB(node, i));
1518
            }
1519
        } else if (BP_STATE(node,i) == PT_COMPRESSED) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1520 1521
            SUB_BLOCK sb = BSB(node,i);
            toku_free(sb->compressed_ptr);
1522
            toku_free(sb);
1523
        } else {
1524
            paranoid_invariant(is_BNULL(node, i));
1525
        }
1526
        set_BNULL(node, i);
1527 1528 1529
    }
    toku_free(node->bp);
    node->bp = NULL;
1530 1531 1532
}

/* Frees a node, including all the stuff in the hash table. */
1533 1534
void toku_ftnode_free(FTNODE *nodep) {
    FTNODE node = *nodep;
1535
    if (node->height == 0) {
1536
        STATUS_INC(FT_DESTROY_LEAF, 1);
1537
    } else {
1538
        STATUS_INC(FT_DESTROY_NONLEAF, 1);
1539
    }
1540
    toku_destroy_ftnode_internals(node);
1541
    toku_free(node);
1542
    *nodep = nullptr;
1543 1544
}

1545
void
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1546
toku_initialize_empty_ftnode (FTNODE n, BLOCKNUM nodename, int height, int num_children, int layout_version, unsigned int flags)
1547
// Effect: Fill in N as an empty ftnode.
1548
{
1549 1550
    paranoid_invariant(layout_version != 0);
    paranoid_invariant(height >= 0);
1551

1552
    if (height == 0) {
1553
        STATUS_INC(FT_CREATE_LEAF, 1);
1554
    } else {
1555
        STATUS_INC(FT_CREATE_NONLEAF, 1);
1556
    }
1557

1558
    n->max_msn_applied_to_node_on_disk = ZERO_MSN;    // correct value for root node, harmless for others
1559
    n->flags = flags;
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
1560
    n->thisnodename = nodename;
1561
    n->layout_version               = layout_version;
1562 1563 1564
    n->layout_version_original = layout_version;
    n->layout_version_read_from_disk = layout_version;
    n->height = height;
1565
    n->totalchildkeylens = 0;
1566
    n->childkeys = 0;
1567
    n->bp = 0;
1568
    n->n_children = num_children;
1569
    n->oldest_referenced_xid_known = TXNID_NONE;
1570

1571
    if (num_children > 0) {
1572 1573
        XMALLOC_N(num_children-1, n->childkeys);
        XMALLOC_N(num_children, n->bp);
1574
        for (int i = 0; i < num_children; i++) {
1575 1576
            BP_BLOCKNUM(n,i).b=0;
            BP_STATE(n,i) = PT_INVALID;
1577
            BP_WORKDONE(n,i) = 0;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1578
            BP_INIT_TOUCHED_CLOCK(n, i);
1579
            set_BNULL(n,i);
1580
            if (height > 0) {
1581 1582 1583
                set_BNC(n, i, toku_create_empty_nl());
            } else {
                set_BLB(n, i, toku_create_empty_bn());
1584
            }
1585
        }
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
1586
    }
1587
    n->dirty = 1;  // special case exception, it's okay to mark as dirty because the basements are empty
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
1588 1589
}

1590
static void
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1591 1592 1593
ft_init_new_root(FT ft, FTNODE oldroot, FTNODE *newrootp)
// Effect:  Create a new root node whose two children are the split of oldroot.
//  oldroot is unpinned in the process.
1594 1595
//  Leave the new root pinned.
{
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
    FTNODE newroot;

    BLOCKNUM old_blocknum = oldroot->thisnodename;
    uint32_t old_fullhash = oldroot->fullhash;
    PAIR old_pair = oldroot->ct_pair;
    
    int new_height = oldroot->height+1;
    uint32_t new_fullhash;
    BLOCKNUM new_blocknum;
    PAIR new_pair = NULL;

    cachetable_put_empty_node_with_dep_nodes(
        ft,
        1,
        &oldroot,
        &new_blocknum,
        &new_fullhash,
        &newroot
        );
    new_pair = newroot->ct_pair;
    
1617 1618
    assert(newroot);
    assert(new_height > 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
    toku_initialize_empty_ftnode (
        newroot, 
        new_blocknum, 
        new_height, 
        1, 
        ft->h->layout_version, 
        ft->h->flags
        );
    MSN msna = oldroot->max_msn_applied_to_node_on_disk;
    newroot->max_msn_applied_to_node_on_disk = msna;
1629
    BP_STATE(newroot,0) = PT_AVAIL;
1630
    newroot->dirty = 1;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

    // now do the "switcheroo"
    BP_BLOCKNUM(newroot,0) = new_blocknum;
    newroot->thisnodename = old_blocknum;
    newroot->fullhash = old_fullhash;
    newroot->ct_pair = old_pair;

    oldroot->thisnodename = new_blocknum;
    oldroot->fullhash = new_fullhash;
    oldroot->ct_pair = new_pair;

    toku_cachetable_swap_pair_values(old_pair, new_pair);

    toku_ft_split_child(
        ft,
        newroot,
        0, // childnum to split
1648 1649
        oldroot,
        SPLIT_EVENLY
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
        );

    // ft_split_child released locks on newroot
    // and oldroot, so now we repin and
    // return to caller
    struct ftnode_fetch_extra bfe;
    fill_bfe_for_full_read(&bfe, ft);
    toku_pin_ftnode_off_client_thread(
        ft,
        old_blocknum,
        old_fullhash,
        &bfe,
        PL_WRITE_EXPENSIVE, // may_modify_node
        0,
        NULL,
        newrootp
        );
1667
}
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
1668

1669
static void
1670
init_childinfo(FTNODE node, int childnum, FTNODE child) {
1671 1672
    BP_BLOCKNUM(node,childnum) = child->thisnodename;
    BP_STATE(node,childnum) = PT_AVAIL;
1673 1674
    BP_WORKDONE(node, childnum)   = 0;
    set_BNC(node, childnum, toku_create_empty_nl());
1675 1676 1677
}

static void
1678
init_childkey(FTNODE node, int childnum, const DBT *pivotkey) {
1679
    toku_clone_dbt(&node->childkeys[childnum], *pivotkey);
1680
    node->totalchildkeylens += pivotkey->size;
1681 1682
}

1683
// Used only by test programs: append a child node to a parent node
1684
void
1685
toku_ft_nonleaf_append_child(FTNODE node, FTNODE child, const DBT *pivotkey) {
1686 1687
    int childnum = node->n_children;
    node->n_children++;
1688
    XREALLOC_N(node->n_children, node->bp);
1689
    init_childinfo(node, childnum, child);
1690
    XREALLOC_N(node->n_children-1, node->childkeys);
1691
    if (pivotkey) {
1692 1693
        invariant(childnum > 0);
        init_childkey(node, childnum-1, pivotkey);
1694
    }
1695
    node->dirty = 1;
1696 1697
}

1698
void
1699
toku_ft_bn_apply_cmd_once (
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1700
    BASEMENTNODE bn,
1701
    const FT_MSG cmd,
Yoni Fogel's avatar
Yoni Fogel committed
1702
    uint32_t idx,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1703
    LEAFENTRY le,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1704
    TXNID oldest_referenced_xid,
1705
    GC_INFO gc_info,
1706 1707
    uint64_t *workdone,
    STAT64INFO stats_to_update
1708 1709
    )
// Effect: Apply cmd to leafentry (msn is ignored)
1710
//         Calculate work done by message on leafentry and add it to caller's workdone counter.
1711 1712 1713
//   idx is the location where it goes
//   le is old leafentry
{
1714
    size_t newsize=0, oldsize=0, workdone_this_le=0;
1715
    LEAFENTRY new_le=0;
1716 1717
    int64_t numbytes_delta = 0;  // how many bytes of user data (not including overhead) were added or deleted from this row
    int64_t numrows_delta = 0;   // will be +1 or -1 or 0 (if row was added or deleted or not)
1718 1719 1720 1721
    uint32_t key_storage_size = ft_msg_get_keylen(cmd) + sizeof(uint32_t);
    if (le) {
        oldsize = leafentry_memsize(le) + key_storage_size;
    }
1722

1723
    // toku_le_apply_msg() may call bn_data::mempool_malloc_and_update_dmt() to allocate more space.
1724
    // That means le is guaranteed to not cause a sigsegv but it may point to a mempool that is
1725
    // no longer in use.  We'll have to release the old mempool later.
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
    toku_le_apply_msg(
        cmd, 
        le,
        &bn->data_buffer,
        idx,
        oldest_referenced_xid, 
        gc_info, 
        &new_le, 
        &numbytes_delta
        );
1736 1737
    // at this point, we cannot trust cmd->u.id.key to be valid.
    // The dmt may have realloced its mempool and freed the one containing key.
1738

1739
    newsize = new_le ? (leafentry_memsize(new_le) +  + key_storage_size) : 0;
1740
    if (le && new_le) {
1741
        workdone_this_le = (oldsize > newsize ? oldsize : newsize);  // work done is max of le size before and after message application
1742

1743
    } else {           // we did not just replace a row, so ...
1744 1745 1746 1747 1748 1749 1750 1751 1752
        if (le) {
            //            ... we just deleted a row ...
            workdone_this_le = oldsize;
            numrows_delta = -1;
        }
        if (new_le) {
            //            ... or we just added a row
            workdone_this_le = newsize;
            numrows_delta = 1;
1753
        }
1754
    }
1755
    if (workdone) {  // test programs may call with NULL
1756
        *workdone += workdone_this_le;
1757
    }
1758

1759 1760 1761
    // now update stat64 statistics
    bn->stat64_delta.numrows  += numrows_delta;
    bn->stat64_delta.numbytes += numbytes_delta;
1762 1763 1764 1765 1766
    // the only reason stats_to_update may be null is for tests
    if (stats_to_update) {
        stats_to_update->numrows += numrows_delta;
        stats_to_update->numbytes += numbytes_delta;
    }
1767

1768 1769
}

1770 1771
static const uint32_t setval_tag = 0xee0ccb99; // this was gotten by doing "cat /dev/random|head -c4|od -x" to get a random number.  We want to make sure that the user actually passes us the setval_extra_s that we passed in.
struct setval_extra_s {
Yoni Fogel's avatar
Yoni Fogel committed
1772 1773
    uint32_t  tag;
    bool did_set_val;
1774
    int         setval_r;    // any error code that setval_fun wants to return goes here.
1775
    // need arguments for toku_ft_bn_apply_cmd_once
1776
    BASEMENTNODE bn;
1777
    MSN msn;              // captured from original message, not currently used
1778 1779
    XIDS xids;
    const DBT *key;
Yoni Fogel's avatar
Yoni Fogel committed
1780
    uint32_t idx;
1781
    LEAFENTRY le;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1782
    TXNID oldest_referenced_xid;
1783
    GC_INFO gc_info;
1784
    uint64_t * workdone;  // set by toku_ft_bn_apply_cmd_once()
1785
    STAT64INFO stats_to_update;
1786 1787 1788 1789 1790
};

/*
 * If new_val == NULL, we send a delete message instead of an insert.
 * This happens here instead of in do_delete() for consistency.
1791 1792
 * setval_fun() is called from handlerton, passing in svextra_v
 * from setval_extra_s input arg to brt->update_fun().
1793 1794
 */
static void setval_fun (const DBT *new_val, void *svextra_v) {
1795
    struct setval_extra_s *CAST_FROM_VOIDP(svextra, svextra_v);
1796 1797
    paranoid_invariant(svextra->tag==setval_tag);
    paranoid_invariant(!svextra->did_set_val);
Yoni Fogel's avatar
Yoni Fogel committed
1798
    svextra->did_set_val = true;
1799 1800

    {
1801
        // can't leave scope until toku_ft_bn_apply_cmd_once if
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1802 1803
        // this is a delete
        DBT val;
1804
        FT_MSG_S msg = { FT_NONE, svextra->msn, svextra->xids,
1805
                         .u = { .id = {svextra->key, NULL} } };
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1806
        if (new_val) {
1807
            msg.type = FT_INSERT;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1808 1809
            msg.u.id.val = new_val;
        } else {
1810
            msg.type = FT_DELETE_ANY;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1811 1812 1813
            toku_init_dbt(&val);
            msg.u.id.val = &val;
        }
1814
        toku_ft_bn_apply_cmd_once(svextra->bn, &msg,
1815
                                  svextra->idx, svextra->le,
1816
                                  svextra->oldest_referenced_xid, svextra->gc_info,
1817
                                  svextra->workdone, svextra->stats_to_update);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1818
        svextra->setval_r = 0;
1819
    }
1820 1821
}

1822
// We are already past the msn filter (in toku_ft_bn_apply_cmd(), which calls do_update()),
1823
// so capturing the msn in the setval_extra_s is not strictly required.         The alternative
1824 1825
// would be to put a dummy msn in the messages created by setval_fun(), but preserving
// the original msn seems cleaner and it preserves accountability at a lower layer.
1826
static int do_update(ft_update_func update_fun, DESCRIPTOR desc, BASEMENTNODE bn, FT_MSG cmd, uint32_t idx,
1827
                     LEAFENTRY le,
1828 1829
                     void* keydata,
                     uint32_t keylen,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1830
                     TXNID oldest_referenced_xid,
1831
                     GC_INFO gc_info,
1832 1833
                     uint64_t * workdone,
                     STAT64INFO stats_to_update) {
1834 1835 1836 1837 1838 1839 1840 1841 1842
    LEAFENTRY le_for_update;
    DBT key;
    const DBT *keyp;
    const DBT *update_function_extra;
    DBT vdbt;
    const DBT *vdbtp;

    // the location of data depends whether this is a regular or
    // broadcast update
1843
    if (cmd->type == FT_UPDATE) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1844 1845
        // key is passed in with command (should be same as from le)
        // update function extra is passed in with command
1846
        STATUS_INC(FT_UPDATES, 1);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1847 1848
        keyp = cmd->u.id.key;
        update_function_extra = cmd->u.id.val;
1849
    } else if (cmd->type == FT_UPDATE_BROADCAST_ALL) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1850 1851
        // key is not passed in with broadcast, it comes from le
        // update function extra is passed in with command
1852
        paranoid_invariant(le);  // for broadcast updates, we just hit all leafentries
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1853
                     // so this cannot be null
1854 1855
        paranoid_invariant(keydata);
        paranoid_invariant(keylen);
1856
        paranoid_invariant(cmd->u.id.key->size == 0);
1857
        STATUS_INC(FT_UPDATES_BROADCAST, 1);
1858
        keyp = toku_fill_dbt(&key, keydata, keylen);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1859
        update_function_extra = cmd->u.id.val;
1860
    } else {
1861
        abort();
1862 1863 1864
    }

    if (le && !le_latest_is_del(le)) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1865
        // if the latest val exists, use it, and we'll use the leafentry later
Yoni Fogel's avatar
Yoni Fogel committed
1866
        uint32_t vallen;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1867 1868
        void *valp = le_latest_val_and_len(le, &vallen);
        vdbtp = toku_fill_dbt(&vdbt, valp, vallen);
1869
    } else {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1870 1871
        // otherwise, the val and leafentry are both going to be null
        vdbtp = NULL;
1872
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1873
    le_for_update = le;
1874

Yoni Fogel's avatar
Yoni Fogel committed
1875
    struct setval_extra_s setval_extra = {setval_tag, false, 0, bn, cmd->msn, cmd->xids,
1876
                                          keyp, idx, le_for_update, oldest_referenced_xid, gc_info, workdone, stats_to_update};
1877
    // call handlerton's brt->update_fun(), which passes setval_extra to setval_fun()
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1878
    FAKE_DB(db, desc);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1879 1880 1881 1882 1883 1884 1885
    int r = update_fun(
        &db,
        keyp,
        vdbtp,
        update_function_extra,
        setval_fun, &setval_extra
        );
1886 1887 1888 1889 1890

    if (r == 0) { r = setval_extra.setval_r; }
    return r;
}

1891
// Should be renamed as something like "apply_cmd_to_basement()."
1892
void
1893 1894 1895
toku_ft_bn_apply_cmd (
    ft_compare_func compare_fun,
    ft_update_func update_fun,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1896
    DESCRIPTOR desc,
1897
    BASEMENTNODE bn,
1898
    FT_MSG cmd,
1899
    TXNID oldest_referenced_xid_known,
1900
    GC_INFO gc_info, 
1901 1902
    uint64_t *workdone,
    STAT64INFO stats_to_update
1903
    )
1904
// Effect:
1905 1906
//   Put a cmd into a leaf.
//   Calculate work done by message on leafnode and add it to caller's workdone counter.
1907
// The leaf could end up "too big" or "too small".  The caller must fix that up.
1908 1909
{
    LEAFENTRY storeddata;
1910 1911
    void* key = NULL;
    uint32_t keylen = 0;
1912

1913
    uint32_t num_klpairs;
1914
    int r;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1915
    struct cmd_leafval_heaviside_extra be = {compare_fun, desc, cmd->u.id.key};
1916

1917 1918
    unsigned int doing_seqinsert = bn->seqinsert;
    bn->seqinsert = 0;
1919

1920
    switch (cmd->type) {
1921 1922
    case FT_INSERT_NO_OVERWRITE:
    case FT_INSERT: {
Yoni Fogel's avatar
Yoni Fogel committed
1923
        uint32_t idx;
1924
        if (doing_seqinsert) {
1925
            idx = bn->data_buffer.num_klpairs();
1926
            DBT kdbt;
1927
            r = bn->data_buffer.fetch_key_and_len(idx-1, &kdbt.size, &kdbt.data);
1928
            if (r != 0) goto fz;
1929
            int cmp = toku_cmd_leafval_heaviside(kdbt, be);
1930 1931 1932 1933
            if (cmp >= 0) goto fz;
            r = DB_NOTFOUND;
        } else {
        fz:
1934 1935 1936 1937 1938 1939 1940
            r = bn->data_buffer.find_zero<decltype(be), toku_cmd_leafval_heaviside>(
                be,
                &storeddata,
                &key,
                &keylen,
                &idx
                );
1941 1942 1943 1944
        }
        if (r==DB_NOTFOUND) {
            storeddata = 0;
        } else {
1945
            assert_zero(r);
1946
        }
1947
        toku_ft_bn_apply_cmd_once(bn, cmd, idx, storeddata, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
1948 1949 1950 1951 1952

        // if the insertion point is within a window of the right edge of
        // the leaf then it is sequential
        // window = min(32, number of leaf entries/16)
        {
1953
            uint32_t s = bn->data_buffer.num_klpairs();
Yoni Fogel's avatar
Yoni Fogel committed
1954
            uint32_t w = s / 16;
1955 1956 1957 1958 1959 1960 1961 1962
            if (w == 0) w = 1;
            if (w > 32) w = 32;

            // within the window?
            if (s - idx <= w)
                bn->seqinsert = doing_seqinsert + 1;
        }
        break;
1963
    }
1964 1965 1966
    case FT_DELETE_ANY:
    case FT_ABORT_ANY:
    case FT_COMMIT_ANY: {
Yoni Fogel's avatar
Yoni Fogel committed
1967
        uint32_t idx;
1968 1969
        // Apply to all the matches

1970 1971 1972 1973 1974 1975 1976
        r = bn->data_buffer.find_zero<decltype(be), toku_cmd_leafval_heaviside>(
            be,
            &storeddata,
            &key,
            &keylen,
            &idx
            );
1977
        if (r == DB_NOTFOUND) break;
1978
        assert_zero(r);
1979
        toku_ft_bn_apply_cmd_once(bn, cmd, idx, storeddata, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
1980 1981

        break;
1982
    }
1983
    case FT_OPTIMIZE_FOR_UPGRADE:
1984
        // fall through so that optimize_for_upgrade performs rest of the optimize logic
1985 1986
    case FT_COMMIT_BROADCAST_ALL:
    case FT_OPTIMIZE:
1987
        // Apply to all leafentries
1988 1989
        num_klpairs = bn->data_buffer.num_klpairs();
        for (uint32_t idx = 0; idx < num_klpairs; ) {
1990 1991 1992 1993
            DBT curr_keydbt;
            void* curr_keyp = NULL;
            uint32_t curr_keylen = 0;
            r = bn->data_buffer.fetch_klpair(idx, &storeddata, &curr_keylen, &curr_keyp);
1994
            assert_zero(r);
1995 1996 1997 1998
            toku_fill_dbt(&curr_keydbt, curr_keyp, curr_keylen);
            // because this is a broadcast message, we need
            // to fill the key in the msg that we pass into toku_ft_bn_apply_cmd_once
            cmd->u.id.key = &curr_keydbt;
1999 2000
            int deleted = 0;
            if (!le_is_clean(storeddata)) { //If already clean, nothing to do.
2001
                toku_ft_bn_apply_cmd_once(bn, cmd, idx, storeddata, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
2002
                // at this point, we cannot trust cmd->u.id.key to be valid.
2003 2004 2005
                uint32_t new_dmt_size = bn->data_buffer.num_klpairs();
                if (new_dmt_size != num_klpairs) {
                    paranoid_invariant(new_dmt_size+1 == num_klpairs);
2006 2007 2008 2009 2010
                    //Item was deleted.
                    deleted = 1;
                }
            }
            if (deleted)
2011
                num_klpairs--;
2012 2013 2014
            else
                idx++;
        }
2015
        paranoid_invariant(bn->data_buffer.num_klpairs() == num_klpairs);
2016 2017

        break;
2018 2019
    case FT_COMMIT_BROADCAST_TXN:
    case FT_ABORT_BROADCAST_TXN:
2020
        // Apply to all leafentries if txn is represented
2021 2022
        num_klpairs = bn->data_buffer.num_klpairs();
        for (uint32_t idx = 0; idx < num_klpairs; ) {
2023 2024 2025 2026
            DBT curr_keydbt;
            void* curr_keyp = NULL;
            uint32_t curr_keylen = 0;
            r = bn->data_buffer.fetch_klpair(idx, &storeddata, &curr_keylen, &curr_keyp);
2027
            assert_zero(r);
2028 2029 2030 2031
            toku_fill_dbt(&curr_keydbt, curr_keyp, curr_keylen);
            // because this is a broadcast message, we need
            // to fill the key in the msg that we pass into toku_ft_bn_apply_cmd_once
            cmd->u.id.key = &curr_keydbt;
2032 2033
            int deleted = 0;
            if (le_has_xids(storeddata, cmd->xids)) {
2034
                toku_ft_bn_apply_cmd_once(bn, cmd, idx, storeddata, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
2035 2036 2037
                uint32_t new_dmt_size = bn->data_buffer.num_klpairs();
                if (new_dmt_size != num_klpairs) {
                    paranoid_invariant(new_dmt_size+1 == num_klpairs);
2038 2039 2040 2041 2042
                    //Item was deleted.
                    deleted = 1;
                }
            }
            if (deleted)
2043
                num_klpairs--;
2044 2045 2046
            else
                idx++;
        }
2047
        paranoid_invariant(bn->data_buffer.num_klpairs() == num_klpairs);
2048 2049

        break;
2050
    case FT_UPDATE: {
Yoni Fogel's avatar
Yoni Fogel committed
2051
        uint32_t idx;
2052 2053 2054 2055 2056 2057 2058
        r = bn->data_buffer.find_zero<decltype(be), toku_cmd_leafval_heaviside>(
            be,
            &storeddata,
            &key,
            &keylen,
            &idx
            );
2059
        if (r==DB_NOTFOUND) {
2060 2061 2062 2063 2064 2065 2066
            {
                //Point to msg's copy of the key so we don't worry about le being freed
                //TODO: 46 MAYBE Get rid of this when le_apply message memory is better handled
                key = cmd->u.id.key->data;
                keylen = cmd->u.id.key->size;
            }
            r = do_update(update_fun, desc, bn, cmd, idx, NULL, NULL, 0, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
2067
        } else if (r==0) {
2068
            r = do_update(update_fun, desc, bn, cmd, idx, storeddata, key, keylen, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
2069 2070
        } // otherwise, a worse error, just return it
        break;
2071
    }
2072
    case FT_UPDATE_BROADCAST_ALL: {
2073
        // apply to all leafentries.
Yoni Fogel's avatar
Yoni Fogel committed
2074 2075
        uint32_t idx = 0;
        uint32_t num_leafentries_before;
2076
        while (idx < (num_leafentries_before = bn->data_buffer.num_klpairs())) {
2077 2078 2079
            void* curr_key = nullptr;
            uint32_t curr_keylen = 0;
            r = bn->data_buffer.fetch_klpair(idx, &storeddata, &curr_keylen, &curr_key);
2080
            assert_zero(r);
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091

            //TODO: 46 replace this with something better than cloning key
            // TODO: (Zardosht) This may be unnecessary now, due to how the key
            // is handled in the bndata. Investigate and determine
            char clone_mem[curr_keylen];  // only lasts one loop, alloca would overflow (end of function)
            memcpy((void*)clone_mem, curr_key, curr_keylen);
            curr_key = (void*)clone_mem;

            // This is broken below. Have a compilation error checked
            // in as a reminder
            r = do_update(update_fun, desc, bn, cmd, idx, storeddata, curr_key, curr_keylen, oldest_referenced_xid_known, gc_info, workdone, stats_to_update);
2092
            assert_zero(r);
2093

2094
            if (num_leafentries_before == bn->data_buffer.num_klpairs()) {
2095 2096 2097 2098 2099
                // we didn't delete something, so increment the index.
                idx++;
            }
        }
        break;
2100
    }
2101
    case FT_NONE: break; // don't do anything
2102 2103
    }

2104
    return;
2105 2106
}

2107 2108
static inline int
key_msn_cmp(const DBT *a, const DBT *b, const MSN amsn, const MSN bmsn,
2109
            DESCRIPTOR descriptor, ft_compare_func key_cmp)
2110
{
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2111
    FAKE_DB(db, descriptor);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2112
    int r = key_cmp(&db, a, b);
2113
    if (r == 0) {
2114 2115 2116 2117 2118 2119 2120
        if (amsn.msn > bmsn.msn) {
            r = +1;
        } else if (amsn.msn < bmsn.msn) {
            r = -1;
        } else {
            r = 0;
        }
2121 2122 2123 2124 2125
    }
    return r;
}

int
2126
toku_fifo_entry_key_msn_heaviside(const int32_t &offset, const struct toku_fifo_entry_key_msn_heaviside_extra &extra)
2127
{
2128
    const struct fifo_entry *query = toku_fifo_get_entry(extra.fifo, offset);
2129
    DBT qdbt;
2130
    const DBT *query_key = fill_dbt_for_fifo_entry(&qdbt, query);
2131 2132 2133
    const DBT *target_key = extra.key;
    return key_msn_cmp(query_key, target_key, query->msn, extra.msn,
                       extra.desc, extra.cmp);
2134 2135 2136
}

int
2137
toku_fifo_entry_key_msn_cmp(const struct toku_fifo_entry_key_msn_cmp_extra &extra, const int32_t &ao, const int32_t &bo)
2138
{
2139 2140
    const struct fifo_entry *a = toku_fifo_get_entry(extra.fifo, ao);
    const struct fifo_entry *b = toku_fifo_get_entry(extra.fifo, bo);
2141 2142 2143 2144
    DBT adbt, bdbt;
    const DBT *akey = fill_dbt_for_fifo_entry(&adbt, a);
    const DBT *bkey = fill_dbt_for_fifo_entry(&bdbt, b);
    return key_msn_cmp(akey, bkey, a->msn, b->msn,
2145
                       extra.desc, extra.cmp);
2146 2147
}

2148
void toku_bnc_insert_msg(NONLEAF_CHILDINFO bnc, const void *key, ITEMLEN keylen, const void *data, ITEMLEN datalen, enum ft_msg_type type, MSN msn, XIDS xids, bool is_fresh, DESCRIPTOR desc, ft_compare_func cmp)
2149 2150 2151
// Effect: Enqueue the message represented by the parameters into the
//   bnc's buffer, and put it in either the fresh or stale message tree,
//   or the broadcast list.
2152 2153
//
// This is only exported for tests.
2154
{
2155
    int32_t offset;
2156 2157
    int r = toku_fifo_enq(bnc->buffer, key, keylen, data, datalen, type, msn, xids, is_fresh, &offset);
    assert_zero(r);
2158
    if (ft_msg_type_applies_once(type)) {
2159 2160
        DBT keydbt;
        struct toku_fifo_entry_key_msn_heaviside_extra extra = { .desc = desc, .cmp = cmp, .fifo = bnc->buffer, .key = toku_fill_dbt(&keydbt, key, keylen), .msn = msn };
2161
        if (is_fresh) {
2162
            r = bnc->fresh_message_tree.insert<struct toku_fifo_entry_key_msn_heaviside_extra, toku_fifo_entry_key_msn_heaviside>(offset, extra, nullptr);
2163
            assert_zero(r);
2164
        } else {
2165
            r = bnc->stale_message_tree.insert<struct toku_fifo_entry_key_msn_heaviside_extra, toku_fifo_entry_key_msn_heaviside>(offset, extra, nullptr);
2166
            assert_zero(r);
2167
        }
2168 2169
    } else {
        invariant(ft_msg_type_applies_all(type) || ft_msg_type_does_nothing(type));
2170 2171
        const uint32_t idx = bnc->broadcast_list.size();
        r = bnc->broadcast_list.insert_at(offset, idx);
2172
        assert_zero(r);
2173
    }
2174 2175 2176 2177
}

// append a cmd to a nonleaf node's child buffer
// should be static, but used by test programs
2178
void toku_ft_append_to_child_buffer(ft_compare_func compare_fun, DESCRIPTOR desc, FTNODE node, int childnum, enum ft_msg_type type, MSN msn, XIDS xids, bool is_fresh, const DBT *key, const DBT *val) {
2179
    paranoid_invariant(BP_STATE(node,childnum) == PT_AVAIL);
2180
    toku_bnc_insert_msg(BNC(node, childnum), key->data, key->size, val->data, val->size, type, msn, xids, is_fresh, desc, compare_fun);
2181
    node->dirty = 1;
2182 2183
}

2184
static void ft_nonleaf_cmd_once_to_child(ft_compare_func compare_fun, DESCRIPTOR desc, FTNODE node, int target_childnum, FT_MSG cmd, bool is_fresh, size_t flow_deltas[])
2185 2186 2187
// Previously we had passive aggressive promotion, but that causes a lot of I/O a the checkpoint.  So now we are just putting it in the buffer here.
// Also we don't worry about the node getting overfull here.  It's the caller's problem.
{
2188 2189 2190
    unsigned int childnum = (target_childnum >= 0
                             ? target_childnum
                             : toku_ftnode_which_child(node, cmd->u.id.key, desc, compare_fun));
2191
    toku_ft_append_to_child_buffer(compare_fun, desc, node, childnum, cmd->type, cmd->msn, cmd->xids, is_fresh, cmd->u.id.key, cmd->u.id.val);
2192 2193 2194
    NONLEAF_CHILDINFO bnc = BNC(node, childnum);
    bnc->flow[0] += flow_deltas[0];
    bnc->flow[1] += flow_deltas[1];
2195
}
2196

2197 2198 2199 2200
/* Find the leftmost child that may contain the key.
 * If the key exists it will be in the child whose number
 * is the return value of this function.
 */
2201 2202
int toku_ftnode_which_child(FTNODE node, const DBT *k,
                            DESCRIPTOR desc, ft_compare_func cmp) {
2203
    // a funny case of no pivots
2204
    if (node->n_children <= 1) return 0;
2205 2206

    // check the last key to optimize seq insertions
2207
    int n = node->n_children-1;
2208
    int c = ft_compare_pivot(desc, cmp, k, &node->childkeys[n-1]);
2209
    if (c > 0) return n;
2210 2211 2212 2213 2214 2215

    // binary search the pivots
    int lo = 0;
    int hi = n-1; // skip the last one, we checked it above
    int mi;
    while (lo < hi) {
2216
        mi = (lo + hi) / 2;
2217
        c = ft_compare_pivot(desc, cmp, k, &node->childkeys[mi]);
2218 2219 2220 2221 2222 2223 2224 2225 2226
        if (c > 0) {
            lo = mi+1;
            continue;
        }
        if (c < 0) {
            hi = mi;
            continue;
        }
        return mi;
2227 2228
    }
    return lo;
2229 2230
}

Leif Walsh's avatar
Leif Walsh committed
2231
// Used for HOT.
2232
int
2233
toku_ftnode_hot_next_child(FTNODE node,
2234 2235 2236
                           const DBT *k,
                           DESCRIPTOR desc,
                           ft_compare_func cmp) {
Leif Walsh's avatar
Leif Walsh committed
2237 2238 2239 2240 2241
    int low = 0;
    int hi = node->n_children - 1;
    int mi;
    while (low < hi) {
        mi = (low + hi) / 2;
2242
        int r = ft_compare_pivot(desc, cmp, k, &node->childkeys[mi]);
Leif Walsh's avatar
Leif Walsh committed
2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256
        if (r > 0) {
            low = mi + 1;
        } else if (r < 0) {
            hi = mi;
        } else {
            // if they were exactly equal, then we want the sub-tree under
            // the next pivot.
            return mi + 1;
        }
    }
    invariant(low == hi);
    return low;
}

2257 2258
// TODO Use this function to clean up other places where bits of messages are passed around
//      such as toku_bnc_insert_msg() and the call stack above it.
2259
static uint64_t
2260
ft_msg_size(FT_MSG msg) {
2261
    size_t keyval_size = msg->u.id.key->size + msg->u.id.val->size;
2262
    size_t xids_size = xids_get_serialize_size(msg->xids);
2263
    return keyval_size + KEY_VALUE_OVERHEAD + FT_CMD_OVERHEAD + xids_size;
2264 2265
}

2266
static void
2267
ft_nonleaf_cmd_all (ft_compare_func compare_fun, DESCRIPTOR desc, FTNODE node, FT_MSG cmd, bool is_fresh, size_t flow_deltas[])
2268 2269
// Effect: Put the cmd into a nonleaf node.  We put it into all children, possibly causing the children to become reactive.
//  We don't do the splitting and merging.  That's up to the caller after doing all the puts it wants to do.
2270
//  The re_array[i] gets set to the reactivity of any modified child i.         (And there may be several such children.)
2271
{
2272 2273
    for (int i = 0; i < node->n_children; i++) {
        ft_nonleaf_cmd_once_to_child(compare_fun, desc, node, i, cmd, is_fresh, flow_deltas);
2274 2275 2276
    }
}

Yoni Fogel's avatar
Yoni Fogel committed
2277
static bool
2278
ft_msg_applies_once(FT_MSG cmd)
2279
{
2280
    return ft_msg_type_applies_once(cmd->type);
2281 2282
}

Yoni Fogel's avatar
Yoni Fogel committed
2283
static bool
2284
ft_msg_applies_all(FT_MSG cmd)
2285
{
2286
    return ft_msg_type_applies_all(cmd->type);
2287 2288
}

Yoni Fogel's avatar
Yoni Fogel committed
2289
static bool
2290
ft_msg_does_nothing(FT_MSG cmd)
2291
{
2292
    return ft_msg_type_does_nothing(cmd->type);
2293 2294 2295
}

static void
2296
ft_nonleaf_put_cmd (ft_compare_func compare_fun, DESCRIPTOR desc, FTNODE node, int target_childnum, FT_MSG cmd, bool is_fresh, size_t flow_deltas[])
2297 2298
// Effect: Put the cmd into a nonleaf node.  We may put it into a child, possibly causing the child to become reactive.
//  We don't do the splitting and merging.  That's up to the caller after doing all the puts it wants to do.
2299
//  The re_array[i] gets set to the reactivity of any modified child i.         (And there may be several such children.)
2300 2301
//
{
2302 2303

    //
2304
    // see comments in toku_ft_leaf_apply_cmd
2305 2306
    // to understand why we handle setting
    // node->max_msn_applied_to_node_on_disk here,
2307
    // and don't do it in toku_ft_node_put_cmd
2308
    //
2309
    MSN cmd_msn = cmd->msn;
2310 2311
    invariant(cmd_msn.msn > node->max_msn_applied_to_node_on_disk.msn);
    node->max_msn_applied_to_node_on_disk = cmd_msn;
2312

2313 2314 2315 2316 2317
    if (ft_msg_applies_once(cmd)) {
        ft_nonleaf_cmd_once_to_child(compare_fun, desc, node, target_childnum, cmd, is_fresh, flow_deltas);
    } else if (ft_msg_applies_all(cmd)) {
        ft_nonleaf_cmd_all(compare_fun, desc, node, cmd, is_fresh, flow_deltas);
    } else {
2318
        paranoid_invariant(ft_msg_does_nothing(cmd));
2319 2320 2321
    }
}

2322 2323
// Garbage collect one leaf entry.
static void
2324
ft_basement_node_gc_once(BASEMENTNODE bn,
Yoni Fogel's avatar
Yoni Fogel committed
2325
                          uint32_t index,
2326 2327
                          void* keyp,
                          uint32_t keylen,
2328
                          LEAFENTRY leaf_entry,
2329 2330 2331
                          const xid_omt_t &snapshot_xids,
                          const rx_omt_t &referenced_xids,
                          const xid_omt_t &live_root_txns,
2332
                          TXNID oldest_referenced_xid_known,
2333 2334
                          STAT64INFO_S * delta)
{
2335
    paranoid_invariant(leaf_entry);
2336

John Esmet's avatar
John Esmet committed
2337 2338 2339 2340 2341 2342
    // Don't run garbage collection on non-mvcc leaf entries.
    if (leaf_entry->type != LE_MVCC) {
        goto exit;
    }

    // Don't run garbage collection if this leafentry decides it's not worth it.
2343
    if (!toku_le_worth_running_garbage_collection(leaf_entry, oldest_referenced_xid_known)) {
2344 2345 2346
        goto exit;
    }

2347 2348
    LEAFENTRY new_leaf_entry;
    new_leaf_entry = NULL;
2349 2350 2351 2352

    // The mempool doesn't free itself.  When it allocates new memory,
    // this pointer will be set to the older memory that must now be
    // freed.
2353 2354
    void * maybe_free;
    maybe_free = NULL;
2355

2356 2357 2358 2359
    // These will represent the number of bytes and rows changed as
    // part of the garbage collection.
    int64_t numbytes_delta;
    int64_t numrows_delta;
John Esmet's avatar
John Esmet committed
2360
    toku_le_garbage_collect(leaf_entry,
2361 2362 2363 2364
                            &bn->data_buffer,
                            index,
                            keyp,
                            keylen,
John Esmet's avatar
John Esmet committed
2365 2366 2367 2368
                            &new_leaf_entry,
                            snapshot_xids,
                            referenced_xids,
                            live_root_txns,
2369
                            oldest_referenced_xid_known,
2370
                            &numbytes_delta);
2371

2372
    numrows_delta = 0;
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
    if (new_leaf_entry) {
        numrows_delta = 0;
    } else {
        numrows_delta = -1;
    }

    // If we created a new mempool buffer we must free the
    // old/original buffer.
    if (maybe_free) {
        toku_free(maybe_free);
    }

    // Update stats.
    bn->stat64_delta.numrows += numrows_delta;
    bn->stat64_delta.numbytes += numbytes_delta;
    delta->numrows += numrows_delta;
    delta->numbytes += numbytes_delta;

2391
exit:
2392 2393 2394 2395 2396 2397
    return;
}

// Garbage collect all leaf entries for a given basement node.
static void
basement_node_gc_all_les(BASEMENTNODE bn,
2398 2399 2400
                         const xid_omt_t &snapshot_xids,
                         const rx_omt_t &referenced_xids,
                         const xid_omt_t &live_root_txns,
2401
                         TXNID oldest_referenced_xid_known,
2402 2403 2404
                         STAT64INFO_S * delta)
{
    int r = 0;
Yoni Fogel's avatar
Yoni Fogel committed
2405 2406
    uint32_t index = 0;
    uint32_t num_leafentries_before;
2407
    while (index < (num_leafentries_before = bn->data_buffer.num_klpairs())) {
2408 2409
        void* keyp = NULL;
        uint32_t keylen = 0;
2410
        LEAFENTRY leaf_entry;
John Esmet's avatar
John Esmet committed
2411
        r = bn->data_buffer.fetch_klpair(index, &leaf_entry, &keylen, &keyp);
2412
        assert_zero(r);
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
        ft_basement_node_gc_once(
            bn,
            index,
            keyp,
            keylen,
            leaf_entry,
            snapshot_xids,
            referenced_xids,
            live_root_txns,
            oldest_referenced_xid_known,
            delta
            );
2425
        // Check if the leaf entry was deleted or not.
2426
        if (num_leafentries_before == bn->data_buffer.num_klpairs()) {
2427 2428 2429 2430 2431
            ++index;
        }
    }
}

John Esmet's avatar
John Esmet committed
2432
// Garbage collect all leaf entires in all basement nodes.
2433
static void
2434
ft_leaf_gc_all_les(FTNODE node,
John Esmet's avatar
John Esmet committed
2435 2436 2437 2438
                   FT ft,
                   const xid_omt_t &snapshot_xids,
                   const rx_omt_t &referenced_xids,
                   const xid_omt_t &live_root_txns,
2439
                   TXNID oldest_referenced_xid_known)
2440 2441
{
    toku_assert_entire_node_in_memory(node);
2442
    paranoid_invariant_zero(node->height);
2443 2444 2445 2446 2447 2448 2449
    // Loop through each leaf entry, garbage collecting as we go.
    for (int i = 0; i < node->n_children; ++i) {
        // Perform the garbage collection.
        BASEMENTNODE bn = BLB(node, i);
        STAT64INFO_S delta;
        delta.numrows = 0;
        delta.numbytes = 0;
2450
        basement_node_gc_all_les(bn, snapshot_xids, referenced_xids, live_root_txns, oldest_referenced_xid_known, &delta);
John Esmet's avatar
John Esmet committed
2451
        toku_ft_update_stats(&ft->in_memory_stats, delta);
2452 2453 2454
    }
}

2455 2456 2457 2458 2459 2460 2461 2462 2463
static void
ft_leaf_run_gc(FTNODE node, FT ft) {
    TOKULOGGER logger = toku_cachefile_logger(ft->cf);
    if (logger) {
        xid_omt_t snapshot_txnids;
        rx_omt_t referenced_xids;
        xid_omt_t live_root_txns;
        toku_txn_manager_clone_state_for_gc(
            logger->txn_manager,
2464 2465 2466
            &snapshot_txnids,
            &referenced_xids,
            &live_root_txns
2467 2468 2469 2470 2471 2472 2473 2474 2475
            );
        
        // Perform garbage collection. Provide a full snapshot of the transaction
        // system plus the oldest known referenced xid that could have had messages
        // applied to this leaf.
        //
        // Using the oldest xid in either the referenced_xids or live_root_txns
        // snapshots is not sufficient, because there could be something older that is neither
        // live nor referenced, but instead aborted somewhere above us as a message in the tree.
2476
        ft_leaf_gc_all_les(node, ft, snapshot_txnids, referenced_xids, live_root_txns, node->oldest_referenced_xid_known);
2477 2478 2479 2480
        
        // Free the OMT's we used for garbage collecting.
        snapshot_txnids.destroy();
        referenced_xids.destroy();
2481
        live_root_txns.destroy();
2482 2483 2484
    }
}

2485
void toku_bnc_flush_to_child(
John Esmet's avatar
John Esmet committed
2486
    FT ft,
2487
    NONLEAF_CHILDINFO bnc,
John Esmet's avatar
John Esmet committed
2488
    FTNODE child,
2489
    TXNID oldest_referenced_xid_known
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2490
    )
2491
{
2492
    paranoid_invariant(bnc);
2493
    STAT64INFO_S stats_delta = {0,0};
2494
    size_t remaining_memsize = toku_fifo_buffer_size_in_use(bnc->buffer);
2495 2496 2497 2498
    FIFO_ITERATE(
        bnc->buffer, key, keylen, val, vallen, type, msn, xids, is_fresh,
        ({
            DBT hk,hv;
2499 2500
            FT_MSG_S ftcmd = { type, msn, xids, .u = { .id = { toku_fill_dbt(&hk, key, keylen),
                                                               toku_fill_dbt(&hv, val, vallen) } } };
2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
            size_t flow_deltas[] = { 0, 0 };
            if (remaining_memsize <= bnc->flow[0]) {
                // this message is in the current checkpoint's worth of
                // the end of the fifo
                flow_deltas[0] = FIFO_CURRENT_ENTRY_MEMSIZE;
            } else if (remaining_memsize <= bnc->flow[0] + bnc->flow[1]) {
                // this message is in the last checkpoint's worth of the
                // end of the fifo
                flow_deltas[1] = FIFO_CURRENT_ENTRY_MEMSIZE;
            }
2511
            toku_ft_node_put_cmd(
John Esmet's avatar
John Esmet committed
2512 2513 2514
                ft->compare_fun,
                ft->update_fun,
                &ft->cmp_descriptor,
2515
                child,
2516
                -1,
2517
                &ftcmd,
2518
                is_fresh,
2519
                make_gc_info(true), // mvcc_needed
2520
                flow_deltas,
2521
                &stats_delta
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2522
                );
2523
            remaining_memsize -= FIFO_CURRENT_ENTRY_MEMSIZE;
2524
        }));
John Esmet's avatar
John Esmet committed
2525
    child->oldest_referenced_xid_known = oldest_referenced_xid_known;
John Esmet's avatar
John Esmet committed
2526

2527
    invariant(remaining_memsize == 0);
2528
    if (stats_delta.numbytes || stats_delta.numrows) {
John Esmet's avatar
John Esmet committed
2529
        toku_ft_update_stats(&ft->in_memory_stats, stats_delta);
2530
    }
2531 2532
    if (child->height == 0) {
        ft_leaf_run_gc(child, ft);
2533 2534 2535 2536
        size_t buffsize = toku_fifo_buffer_size_in_use(bnc->buffer);
        STATUS_INC(FT_MSG_BYTES_OUT, buffsize);
        // may be misleading if there's a broadcast message in there
        STATUS_INC(FT_MSG_BYTES_CURR, -buffsize);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2537
    }
2538 2539
}

2540 2541 2542 2543 2544 2545
bool toku_bnc_should_promote(FT ft, NONLEAF_CHILDINFO bnc) {
    static const double factor = 0.125;
    const uint64_t flow_threshold = ft->h->nodesize * factor;
    return bnc->flow[0] >= flow_threshold || bnc->flow[1] >= flow_threshold;
}

Leif Walsh's avatar
Leif Walsh committed
2546
void
2547 2548 2549
toku_ft_node_put_cmd (
    ft_compare_func compare_fun,
    ft_update_func update_fun,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2550
    DESCRIPTOR desc,
2551
    FTNODE node,
2552
    int target_childnum,
2553
    FT_MSG cmd,
2554
    bool is_fresh,
2555
    GC_INFO gc_info,
2556
    size_t flow_deltas[],
2557
    STAT64INFO stats_to_update
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2558
    )
2559 2560
// Effect: Push CMD into the subtree rooted at NODE.
//   If NODE is a leaf, then
2561
//   put CMD into leaf, applying it to the leafentries
2562 2563
//   If NODE is a nonleaf, then push the cmd into the FIFO(s) of the relevent child(ren).
//   The node may become overfull.  That's not our problem.
2564
{
2565
    toku_assert_entire_node_in_memory(node);
2566
    //
2567
    // see comments in toku_ft_leaf_apply_cmd
2568 2569 2570 2571
    // to understand why we don't handle setting
    // node->max_msn_applied_to_node_on_disk here,
    // and instead defer to these functions
    //
2572
    if (node->height==0) {
2573
        toku_ft_leaf_apply_cmd(compare_fun, update_fun, desc, node, target_childnum, cmd, gc_info, nullptr, stats_to_update);
2574
    } else {
2575
        ft_nonleaf_put_cmd(compare_fun, desc, node, target_childnum, cmd, is_fresh, flow_deltas);
2576
    }
2577 2578
}

2579
static const struct pivot_bounds infinite_bounds = {.lower_bound_exclusive=NULL,
2580
                                                    .upper_bound_inclusive=NULL};
2581

Zardosht Kasheff's avatar
Zardosht Kasheff committed
2582

2583
// Effect: applies the cmd to the leaf if the appropriate basement node is in memory.
2584 2585
//           This function is called during message injection and/or flushing, so the entire
//           node MUST be in memory.
2586 2587 2588
void toku_ft_leaf_apply_cmd(
    ft_compare_func compare_fun,
    ft_update_func update_fun,
2589
    DESCRIPTOR desc,
2590
    FTNODE node,
2591
    int target_childnum,  // which child to inject to, or -1 if unknown
2592
    FT_MSG cmd,
2593
    GC_INFO gc_info,
2594 2595
    uint64_t *workdone,
    STAT64INFO stats_to_update
2596
    )
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2597
{
2598
    VERIFY_NODE(t, node);
2599
    toku_assert_entire_node_in_memory(node);
2600

2601
    //
2602
    // Because toku_ft_leaf_apply_cmd is called with the intent of permanently
2603 2604
    // applying a message to a leaf node (meaning the message is permanently applied
    // and will be purged from the system after this call, as opposed to
2605
    // toku_apply_ancestors_messages_to_node, which applies a message
2606 2607
    // for a query, but the message may still reside in the system and
    // be reapplied later), we mark the node as dirty and
2608 2609
    // take the opportunity to update node->max_msn_applied_to_node_on_disk.
    //
2610
    node->dirty = 1;
2611

2612 2613 2614
    //
    // we cannot blindly update node->max_msn_applied_to_node_on_disk,
    // we must check to see if the msn is greater that the one already stored,
2615
    // because the cmd may have already been applied earlier (via
2616
    // toku_apply_ancestors_messages_to_node) to answer a query
2617
    //
2618
    // This is why we handle node->max_msn_applied_to_node_on_disk both here
2619
    // and in ft_nonleaf_put_cmd, as opposed to in one location, toku_ft_node_put_cmd.
2620
    //
2621
    MSN cmd_msn = cmd->msn;
2622 2623 2624
    if (cmd_msn.msn > node->max_msn_applied_to_node_on_disk.msn) {
        node->max_msn_applied_to_node_on_disk = cmd_msn;
    }
2625

John Esmet's avatar
John Esmet committed
2626 2627
    // Pass the oldest possible live xid value to each basementnode
    // when we apply messages to them.
John Esmet's avatar
John Esmet committed
2628
    TXNID oldest_referenced_xid_known = node->oldest_referenced_xid_known;
John Esmet's avatar
John Esmet committed
2629

2630
    if (ft_msg_applies_once(cmd)) {
2631 2632 2633 2634 2635 2636
        unsigned int childnum = (target_childnum >= 0
                                 ? target_childnum
                                 : toku_ftnode_which_child(node, cmd->u.id.key, desc, compare_fun));
        BASEMENTNODE bn = BLB(node, childnum);
        if (cmd->msn.msn > bn->max_msn_applied.msn) {
            bn->max_msn_applied = cmd->msn;
2637
            toku_ft_bn_apply_cmd(compare_fun,
2638 2639 2640 2641
                                 update_fun,
                                 desc,
                                 bn,
                                 cmd,
2642
                                 oldest_referenced_xid_known,
2643
                                 gc_info,
2644 2645
                                 workdone,
                                 stats_to_update);
2646
        } else {
2647
            STATUS_INC(FT_MSN_DISCARDS, 1);
2648 2649
        }
    }
2650
    else if (ft_msg_applies_all(cmd)) {
2651
        for (int childnum=0; childnum<node->n_children; childnum++) {
2652 2653
            if (cmd->msn.msn > BLB(node, childnum)->max_msn_applied.msn) {
                BLB(node, childnum)->max_msn_applied = cmd->msn;
2654
                toku_ft_bn_apply_cmd(compare_fun,
2655 2656 2657 2658
                                      update_fun,
                                      desc,
                                      BLB(node, childnum),
                                      cmd,
2659
                                      oldest_referenced_xid_known,
2660
                                      gc_info,
2661 2662
                                      workdone,
                                      stats_to_update);
2663
            } else {
2664
                STATUS_INC(FT_MSN_DISCARDS, 1);
2665
            }
2666
        }
2667
    }
2668
    else if (!ft_msg_does_nothing(cmd)) {
2669
        abort();
2670 2671 2672 2673
    }
    VERIFY_NODE(t, node);
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
2674 2675 2676 2677 2678 2679
static void inject_message_in_locked_node(
    FT ft, 
    FTNODE node, 
    int childnum, 
    FT_MSG_S *cmd, 
    size_t flow_deltas[],
2680 2681
    TXNID oldest_referenced_xid,
    GC_INFO gc_info
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2682 2683
    ) 
{
2684 2685 2686 2687 2688
    // No guarantee that we're the writer, but oh well.
    // TODO(leif): Implement "do I have the lock or is it someone else?"
    // check in frwlock.  Should be possible with TOKU_PTHREAD_DEBUG, nop
    // otherwise.
    invariant(toku_ctpair_is_write_locked(node->ct_pair));
2689
    toku_assert_entire_node_in_memory(node);
John Esmet's avatar
John Esmet committed
2690 2691 2692 2693

    // Update the oldest known referenced xid for this node if it is younger
    // than the one currently known. Otherwise, it's better to keep the heurstic
    // we have and ignore this one.
2694 2695
    if (oldest_referenced_xid >= node->oldest_referenced_xid_known) {
        node->oldest_referenced_xid_known = oldest_referenced_xid;
John Esmet's avatar
John Esmet committed
2696 2697
    }

2698 2699 2700 2701 2702
    // Get the MSN from the header.  Now that we have a write lock on the
    // node we're injecting into, we know no other thread will get an MSN
    // after us and get that message into our subtree before us.
    cmd->msn.msn = toku_sync_add_and_fetch(&ft->h->max_msn_in_ft.msn, 1);
    paranoid_invariant(cmd->msn.msn > node->max_msn_applied_to_node_on_disk.msn);
2703
    STAT64INFO_S stats_delta = {0,0};
2704
    toku_ft_node_put_cmd(
2705 2706 2707
        ft->compare_fun,
        ft->update_fun,
        &ft->cmp_descriptor,
2708
        node,
2709
        childnum,
2710
        cmd,
2711
        true,
2712
        gc_info,
2713
        flow_deltas,
2714
        &stats_delta
2715
        );
2716
    if (stats_delta.numbytes || stats_delta.numrows) {
2717
        toku_ft_update_stats(&ft->in_memory_stats, stats_delta);
2718
    }
2719
    //
2720
    // assumption is that toku_ft_node_put_cmd will
2721 2722 2723
    // mark the node as dirty.
    // enforcing invariant here.
    //
2724
    paranoid_invariant(node->dirty != 0);
2725

2726
    // TODO: Why not at height 0?
2727 2728
    // update some status variables
    if (node->height != 0) {
2729
        uint64_t msgsize = ft_msg_size(cmd);
2730 2731 2732
        STATUS_INC(FT_MSG_BYTES_IN, msgsize);
        STATUS_INC(FT_MSG_BYTES_CURR, msgsize);
        STATUS_INC(FT_MSG_NUM, 1);
2733
        if (ft_msg_applies_all(cmd)) {
2734
            STATUS_INC(FT_MSG_NUM_BROADCAST, 1);
2735
        }
2736
    }
2737 2738 2739 2740

    // verify that msn of latest message was captured in root node
    paranoid_invariant(cmd->msn.msn == node->max_msn_applied_to_node_on_disk.msn);

John Esmet's avatar
John Esmet committed
2741
    // if we call toku_ft_flush_some_child, then that function unpins the root
2742 2743
    // otherwise, we unpin ourselves
    if (node->height > 0 && toku_ft_nonleaf_is_gorged(node, ft->h->nodesize)) {
John Esmet's avatar
John Esmet committed
2744
        toku_ft_flush_node_on_background_thread(ft, node);
2745 2746 2747 2748
    }
    else {
        toku_unpin_ftnode(ft, node);
    }
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
2749 2750
}

2751 2752 2753 2754 2755 2756 2757 2758 2759
// seqinsert_loc is a bitmask.
// The root counts as being both on the "left extreme" and on the "right extreme".
// Therefore, at the root, you're at LEFT_EXTREME | RIGHT_EXTREME.
typedef char seqinsert_loc;
static const seqinsert_loc NEITHER_EXTREME = 0;
static const seqinsert_loc LEFT_EXTREME = 1;
static const seqinsert_loc RIGHT_EXTREME = 2;

static bool process_maybe_reactive_child(FT ft, FTNODE parent, FTNODE child, int childnum, seqinsert_loc loc)
2760
// Effect:
2761 2762 2763 2764 2765 2766 2767
//  If child needs to be split or merged, do that.
//  parent and child will be unlocked if this happens
//  also, the batched pin will have ended if this happens
// Requires: parent and child are read locked
// Returns:
//  true if relocking is needed
//  false otherwise
2768
{
2769
    enum reactivity re = get_node_reactivity(ft, child);
2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802
    enum reactivity newre;
    BLOCKNUM child_blocknum;
    uint32_t child_fullhash;
    switch (re) {
    case RE_STABLE:
        return false;
    case RE_FISSIBLE:
        {
            // We only have a read lock on the parent.  We need to drop both locks, and get write locks.
            BLOCKNUM parent_blocknum = parent->thisnodename;
            uint32_t parent_fullhash = toku_cachetable_hash(ft->cf, parent_blocknum);
            int parent_height = parent->height;
            int parent_n_children = parent->n_children;
            toku_unpin_ftnode_read_only(ft, child);
            toku_unpin_ftnode_read_only(ft, parent);
            struct ftnode_fetch_extra bfe;
            fill_bfe_for_full_read(&bfe, ft);
            FTNODE newparent, newchild;
            toku_pin_ftnode_off_client_thread_batched(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent);
            if (newparent->height != parent_height || newparent->n_children != parent_n_children ||
                childnum >= newparent->n_children || toku_bnc_n_entries(BNC(newparent, childnum))) {
                // If the height changed or childnum is now off the end, something clearly got split or merged out from under us.
                // If something got injected in this node, then it got split or merged and we shouldn't be splitting it.
                // But we already unpinned the child so we need to have the caller re-try the pins.
                toku_unpin_ftnode_read_only(ft, newparent);
                return true;
            }
            // It's ok to reuse the same childnum because if we get something
            // else we need to split, well, that's crazy, but let's go ahead
            // and split it.
            child_blocknum = BP_BLOCKNUM(newparent, childnum);
            child_fullhash = compute_child_fullhash(ft->cf, newparent, childnum);
            toku_pin_ftnode_off_client_thread_batched(ft, child_blocknum, child_fullhash, &bfe, PL_WRITE_CHEAP, 1, &newparent, &newchild);
2803
            newre = get_node_reactivity(ft, newchild);
2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848
            if (newre == RE_FISSIBLE) {
                enum split_mode split_mode;
                if (newparent->height == 1 && (loc & LEFT_EXTREME) && childnum == 0) {
                    split_mode = SPLIT_RIGHT_HEAVY;
                } else if (newparent->height == 1 && (loc & RIGHT_EXTREME) && childnum == newparent->n_children - 1) {
                    split_mode = SPLIT_LEFT_HEAVY;
                } else {
                    split_mode = SPLIT_EVENLY;
                }
                toku_ft_split_child(ft, newparent, childnum, newchild, split_mode);
            } else {
                // some other thread already got it, just unpin and tell the
                // caller to retry
                toku_unpin_ftnode_read_only(ft, newchild);
                toku_unpin_ftnode_read_only(ft, newparent);
            }
            return true;
        }
    case RE_FUSIBLE:
        {
            if (parent->height == 1) {
                // prevent re-merging of recently unevenly-split nodes
                if (((loc & LEFT_EXTREME) && childnum <= 1) ||
                    ((loc & RIGHT_EXTREME) && childnum >= parent->n_children - 2)) {
                    return false;
                }
            }

            int parent_height = parent->height;
            BLOCKNUM parent_blocknum = parent->thisnodename;
            uint32_t parent_fullhash = toku_cachetable_hash(ft->cf, parent_blocknum);
            toku_unpin_ftnode_read_only(ft, child);
            toku_unpin_ftnode_read_only(ft, parent);
            struct ftnode_fetch_extra bfe;
            fill_bfe_for_full_read(&bfe, ft);
            FTNODE newparent, newchild;
            toku_pin_ftnode_off_client_thread_batched(ft, parent_blocknum, parent_fullhash, &bfe, PL_WRITE_CHEAP, 0, nullptr, &newparent);
            if (newparent->height != parent_height || childnum >= newparent->n_children) {
                // looks like this is the root and it got merged, let's just start over (like in the split case above)
                toku_unpin_ftnode_read_only(ft, newparent);
                return true;
            }
            child_blocknum = BP_BLOCKNUM(newparent, childnum);
            child_fullhash = compute_child_fullhash(ft->cf, newparent, childnum);
            toku_pin_ftnode_off_client_thread_batched(ft, child_blocknum, child_fullhash, &bfe, PL_READ, 1, &newparent, &newchild);
2849
            newre = get_node_reactivity(ft, newchild);
2850
            if (newre == RE_FUSIBLE && newparent->n_children >= 2) {
2851 2852 2853
                toku_unpin_ftnode_read_only(ft, newchild);
                toku_ft_merge_child(ft, newparent, childnum);
            } else {
2854 2855 2856 2857 2858 2859 2860 2861 2862
                // Could be a weird case where newparent has only one
                // child.  In this case, we want to inject here but we've
                // already unpinned the caller's copy of parent so we have
                // to ask them to re-pin, or they could (very rarely)
                // dereferenced memory in a freed node.  TODO: we could
                // give them back the copy of the parent we pinned.
                //
                // Otherwise, some other thread already got it, just unpin
                // and tell the caller to retry
2863 2864 2865 2866 2867
                toku_unpin_ftnode_read_only(ft, newchild);
                toku_unpin_ftnode_read_only(ft, newparent);
            }
            return true;
        }
2868
    }
2869 2870
    abort();
}
2871

2872
static void inject_message_at_this_blocknum(FT ft, CACHEKEY cachekey, uint32_t fullhash, FT_MSG_S *cmd, size_t flow_deltas[], TXNID oldest_referenced_xid, GC_INFO gc_info)
2873 2874 2875 2876
// Effect:
//  Inject cmd into the node at this blocknum (cachekey).
//  Gets a write lock on the node for you.
{
2877
    toku::context inject_ctx(CTX_MESSAGE_INJECTION);
2878
    FTNODE node;
2879 2880 2881 2882 2883 2884
    struct ftnode_fetch_extra bfe;
    fill_bfe_for_full_read(&bfe, ft);
    toku_pin_ftnode_off_client_thread_batched(ft, cachekey, fullhash, &bfe, PL_WRITE_CHEAP, 0, NULL, &node);
    toku_assert_entire_node_in_memory(node);
    paranoid_invariant(node->fullhash==fullhash);
    ft_verify_flags(ft, node);
2885
    inject_message_in_locked_node(ft, node, -1, cmd, flow_deltas, oldest_referenced_xid, gc_info);
2886
}
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2887

2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
__attribute__((const))
static inline bool should_inject_in_node(seqinsert_loc loc, int height, int depth)
// We should inject directly in a node if:
//  - it's a leaf, or
//  - it's a height 1 node not at either extreme, or
//  - it's a depth 2 node not at either extreme
{
    return (height == 0 || (loc == NEITHER_EXTREME && (height <= 1 || depth >= 2)));
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
2898 2899 2900 2901 2902 2903 2904
static void push_something_in_subtree(
    FT ft, 
    FTNODE subtree_root, 
    int target_childnum, 
    FT_MSG_S *cmd, 
    size_t flow_deltas[], 
    TXNID oldest_referenced_xid, 
2905
    GC_INFO gc_info,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2906 2907 2908 2909
    int depth, 
    seqinsert_loc loc, 
    bool just_did_split_or_merge
    )
2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
// Effects:
//  Assign cmd an MSN from ft->h.
//  Put cmd in the subtree rooted at node.  Due to promotion the message may not be injected directly in this node.
//  Unlock node or schedule it to be unlocked (after a background flush).
//   Either way, the caller is not responsible for unlocking node.
// Requires:
//  subtree_root is read locked and fully in memory.
// Notes:
//  In Ming, the basic rules of promotion are as follows:
//   Don't promote broadcast messages.
//   Don't promote past non-empty buffers.
//   Otherwise, promote at most to height 1 or depth 2 (whichever is highest), as far as the birdie asks you to promote.
//    We don't promote to leaves because injecting into leaves is expensive, mostly because of #5605 and some of #5552.
//    We don't promote past depth 2 because we found that gives us enough parallelism without costing us too much pinning work.
//
//    This is true with the following caveats:
//     We always promote all the way to the leaves on the rightmost and leftmost edges of the tree, for sequential insertions.
//      (That means we can promote past depth 2 near the edges of the tree.)
//
//   When the birdie is still saying we should promote, we use get_and_pin so that we wait to get the node.
//   If the birdie doesn't say to promote, we try maybe_get_and_pin.  If we get the node cheaply, and it's dirty, we promote anyway.
{
    toku_assert_entire_node_in_memory(subtree_root);
    if (should_inject_in_node(loc, subtree_root->height, depth)) {
        switch (depth) {
        case 0:
            STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_0, 1); break;
        case 1:
            STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_1, 1); break;
        case 2:
            STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_2, 1); break;
        case 3:
            STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_3, 1); break;
        default:
            STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_GT3, 1); break;
        }
2946
        inject_message_in_locked_node(ft, subtree_root, target_childnum, cmd, flow_deltas, oldest_referenced_xid, gc_info);
2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001
    } else {
        int r;
        int childnum;
        NONLEAF_CHILDINFO bnc;

        // toku_ft_root_put_cmd should not have called us otherwise.
        paranoid_invariant(ft_msg_applies_once(cmd));

        childnum = (target_childnum >= 0 ? target_childnum
                    : toku_ftnode_which_child(subtree_root, cmd->u.id.key, &ft->cmp_descriptor, ft->compare_fun));
        bnc = BNC(subtree_root, childnum);

        if (toku_bnc_n_entries(bnc) > 0) {
            // The buffer is non-empty, give up on promoting.
            STATUS_INC(FT_PRO_NUM_STOP_NONEMPTY_BUF, 1);
            goto relock_and_push_here;
        }

        seqinsert_loc next_loc;
        if ((loc & LEFT_EXTREME) && childnum == 0) {
            next_loc = LEFT_EXTREME;
        } else if ((loc & RIGHT_EXTREME) && childnum == subtree_root->n_children - 1) {
            next_loc = RIGHT_EXTREME;
        } else {
            next_loc = NEITHER_EXTREME;
        }

        if (next_loc == NEITHER_EXTREME && subtree_root->height <= 1) {
            // Never promote to leaf nodes except on the edges
            STATUS_INC(FT_PRO_NUM_STOP_H1, 1);
            goto relock_and_push_here;
        }

        {
            const BLOCKNUM child_blocknum = BP_BLOCKNUM(subtree_root, childnum);
            toku_verify_blocknum_allocated(ft->blocktable, child_blocknum);
            const uint32_t child_fullhash = toku_cachetable_hash(ft->cf, child_blocknum);

            FTNODE child;
            {
                const int child_height = subtree_root->height - 1;
                const int child_depth = depth + 1;
                // If we're locking a leaf, or a height 1 node or depth 2
                // node in the middle, we know we won't promote further
                // than that, so just get a write lock now.
                const pair_lock_type lock_type = (should_inject_in_node(next_loc, child_height, child_depth)
                                                  ? PL_WRITE_CHEAP
                                                  : PL_READ);
                if (next_loc != NEITHER_EXTREME || (toku_bnc_should_promote(ft, bnc) && depth <= 1)) {
                    // If we're on either extreme, or the birdie wants to
                    // promote and we're in the top two levels of the
                    // tree, don't stop just because someone else has the
                    // node locked.
                    struct ftnode_fetch_extra bfe;
                    fill_bfe_for_full_read(&bfe, ft);
3002 3003 3004 3005 3006 3007 3008 3009 3010
                    if (lock_type == PL_WRITE_CHEAP) {
                        // We intend to take the write lock for message injection
                        toku::context inject_ctx(CTX_MESSAGE_INJECTION);
                        toku_pin_ftnode_off_client_thread_batched(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child);
                    } else {
                        // We're going to keep promoting
                        toku::context promo_ctx(CTX_PROMO);
                        toku_pin_ftnode_off_client_thread_batched(ft, child_blocknum, child_fullhash, &bfe, lock_type, 0, nullptr, &child);
                    }
3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042
                } else {
                    r = toku_maybe_pin_ftnode_clean(ft, child_blocknum, child_fullhash, lock_type, &child);
                    if (r != 0) {
                        // We couldn't get the child cheaply, so give up on promoting.
                        STATUS_INC(FT_PRO_NUM_STOP_LOCK_CHILD, 1);
                        goto relock_and_push_here;
                    }
                    if (is_entire_node_in_memory(child)) {
                        // toku_pin_ftnode... touches the clock but toku_maybe_pin_ftnode... doesn't.
                        // This prevents partial eviction.
                        for (int i = 0; i < child->n_children; ++i) {
                            BP_TOUCH_CLOCK(child, i);
                        }
                    } else {
                        // We got the child, but it's not fully in memory.  Give up on promoting.
                        STATUS_INC(FT_PRO_NUM_STOP_CHILD_INMEM, 1);
                        goto unlock_child_and_push_here;
                    }
                }
            }
            paranoid_invariant_notnull(child);

            if (!just_did_split_or_merge) {
                BLOCKNUM subtree_root_blocknum = subtree_root->thisnodename;
                uint32_t subtree_root_fullhash = toku_cachetable_hash(ft->cf, subtree_root_blocknum);
                const bool did_split_or_merge = process_maybe_reactive_child(ft, subtree_root, child, childnum, loc);
                if (did_split_or_merge) {
                    // Need to re-pin this node and try at this level again.
                    FTNODE newparent;
                    struct ftnode_fetch_extra bfe;
                    fill_bfe_for_full_read(&bfe, ft); // should be fully in memory, we just split it
                    toku_pin_ftnode_off_client_thread_batched(ft, subtree_root_blocknum, subtree_root_fullhash, &bfe, PL_READ, 0, nullptr, &newparent);
3043
                    push_something_in_subtree(ft, newparent, -1, cmd, flow_deltas, oldest_referenced_xid, gc_info, depth, loc, true);
3044 3045 3046
                    return;
                }
            }
3047

3048
            if (next_loc != NEITHER_EXTREME || child->dirty || toku_bnc_should_promote(ft, bnc)) {
3049
                push_something_in_subtree(ft, child, -1, cmd, flow_deltas, oldest_referenced_xid, gc_info, depth + 1, next_loc, false);
3050 3051 3052 3053 3054 3055
                toku_sync_fetch_and_add(&bnc->flow[0], flow_deltas[0]);
                // The recursive call unpinned the child, but
                // we're responsible for unpinning subtree_root.
                toku_unpin_ftnode_read_only(ft, subtree_root);
                return;
            }
3056

3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
            STATUS_INC(FT_PRO_NUM_DIDNT_WANT_PROMOTE, 1);
        unlock_child_and_push_here:
            // We locked the child, but we decided not to promote.
            // Unlock the child, and fall through to the next case.
            toku_unpin_ftnode_read_only(ft, child);
        }
    relock_and_push_here:
        // Give up on promoting.
        // We have subtree_root read-locked and we don't have a child locked.
        // Drop the read lock, grab a write lock, and inject here.
        {
            // Right now we have a read lock on subtree_root, but we want
            // to inject into it so we get a write lock instead.
            BLOCKNUM subtree_root_blocknum = subtree_root->thisnodename;
            uint32_t subtree_root_fullhash = toku_cachetable_hash(ft->cf, subtree_root_blocknum);
            toku_unpin_ftnode_read_only(ft, subtree_root);
            switch (depth) {
            case 0:
                STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_0, 1); break;
            case 1:
                STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_1, 1); break;
            case 2:
                STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_2, 1); break;
            case 3:
                STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_3, 1); break;
            default:
                STATUS_INC(FT_PRO_NUM_INJECT_DEPTH_GT3, 1); break;
            }
3085
            inject_message_at_this_blocknum(ft, subtree_root_blocknum, subtree_root_fullhash, cmd, flow_deltas, oldest_referenced_xid, gc_info);
3086 3087 3088 3089
        }
    }
}

3090 3091 3092 3093 3094 3095
void toku_ft_root_put_cmd(
    FT ft, 
    FT_MSG_S *cmd, 
    TXNID oldest_referenced_xid,
    GC_INFO gc_info
    )
3096 3097 3098
// Effect:
//  - assign msn to cmd and update msn in the header
//  - push the cmd into the ft
3099

3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
// As of Clayface, the root blocknum is a constant, so preventing a
// race between message injection and the split of a root is the job
// of the cachetable's locking rules.
//
// We also hold the MO lock for a number of reasons, but an important
// one is to make sure that a begin_checkpoint may not start while
// this code is executing. A begin_checkpoint does (at least) two things
// that can interfere with the operations here:
//  - Copies the header to a checkpoint header. Because we may change
//    the max_msn_in_ft below, we don't want the header to be copied in
//    the middle of these operations.
//  - Takes note of the log's LSN. Because this put operation has
//    already been logged, this message injection must be included
//    in any checkpoint that contains this put's logentry.
//    Holding the mo lock throughout this function ensures that fact.
{
3116 3117
    toku::context promo_ctx(CTX_PROMO);

3118 3119 3120
    // blackhole fractal trees drop all messages, so do nothing.
    if (ft->blackhole) {
        return;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3121
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3122

3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
    FTNODE node;

    uint32_t fullhash;
    CACHEKEY root_key;
    toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
    struct ftnode_fetch_extra bfe;
    fill_bfe_for_full_read(&bfe, ft);

    size_t flow_deltas[] = { toku_ft_msg_memsize_in_fifo(cmd), 0 };

    pair_lock_type lock_type;
    lock_type = PL_READ; // try first for a read lock
    // If we need to split the root, we'll have to change from a read lock
    // to a write lock and check again.  We change the variable lock_type
    // and jump back to here.
 change_lock_type:
    // get the root node
    toku_pin_ftnode_off_client_thread_batched(ft, root_key, fullhash, &bfe, lock_type, 0, NULL, &node);
    toku_assert_entire_node_in_memory(node);
    paranoid_invariant(node->fullhash==fullhash);
    ft_verify_flags(ft, node);

    // First handle a reactive root.
    // This relocking for split algorithm will cause every message
    // injection thread to change lock type back and forth, when only one
    // of them needs to in order to handle the split.  That's not great,
    // but root splits are incredibly rare.
3150
    enum reactivity re = get_node_reactivity(ft, node);
3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
    switch (re) {
    case RE_STABLE:
    case RE_FUSIBLE: // cannot merge anything at the root
        if (lock_type != PL_READ) {
            // We thought we needed to split, but someone else got to
            // it before us.  Downgrade to a read lock.
            toku_unpin_ftnode_read_only(ft, node);
            lock_type = PL_READ;
            goto change_lock_type;
        }
        break;
    case RE_FISSIBLE:
        if (lock_type == PL_READ) {
            // Here, we only have a read lock on the root.  In order
            // to split it, we need a write lock, but in the course of
            // gaining the write lock, someone else may have gotten in
            // before us and split it.  So we upgrade to a write lock
            // and check again.
            toku_unpin_ftnode_read_only(ft, node);
            lock_type = PL_WRITE_CHEAP;
            goto change_lock_type;
        } else {
            // We have a write lock, now we can split.
            ft_init_new_root(ft, node, &node);
            // Then downgrade back to a read lock, and we can finally
            // do the injection.
            toku_unpin_ftnode_off_client_thread(ft, node);
            lock_type = PL_READ;
            STATUS_INC(FT_PRO_NUM_ROOT_SPLIT, 1);
            goto change_lock_type;
        }
        break;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3183
    }
3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
    // If we get to here, we have a read lock and the root doesn't
    // need to be split.  It's safe to inject the message.
    paranoid_invariant(lock_type == PL_READ);
    // We cannot assert that we have the read lock because frwlock asserts
    // that its mutex is locked when we check if there are any readers.
    // That wouldn't give us a strong guarantee that we have the read lock
    // anyway.

    // Now, either inject here or promote.  We decide based on a heuristic:
    if (node->height == 0 || !ft_msg_applies_once(cmd)) {
        // If the root's a leaf or we're injecting a broadcast, drop the read lock and inject here.
        toku_unpin_ftnode_read_only(ft, node);
        STATUS_INC(FT_PRO_NUM_ROOT_H0_INJECT, 1);
3197
        inject_message_at_this_blocknum(ft, root_key, fullhash, cmd, flow_deltas, oldest_referenced_xid, gc_info);
3198 3199
    } else if (node->height > 1) {
        // If the root's above height 1, we are definitely eligible for promotion.
3200
        push_something_in_subtree(ft, node, -1, cmd, flow_deltas, oldest_referenced_xid, gc_info, 0, LEFT_EXTREME | RIGHT_EXTREME, false);
3201 3202 3203 3204 3205 3206
    } else {
        // The root's height 1.  We may be eligible for promotion here.
        // On the extremes, we want to promote, in the middle, we don't.
        int childnum = toku_ftnode_which_child(node, cmd->u.id.key, &ft->cmp_descriptor, ft->compare_fun);
        if (childnum == 0 || childnum == node->n_children - 1) {
            // On the extremes, promote.  We know which childnum we're going to, so pass that down too.
3207
            push_something_in_subtree(ft, node, childnum, cmd, flow_deltas, oldest_referenced_xid, gc_info, 0, LEFT_EXTREME | RIGHT_EXTREME, false);
3208 3209 3210 3211
        } else {
            // At height 1 in the middle, don't promote, drop the read lock and inject here.
            toku_unpin_ftnode_read_only(ft, node);
            STATUS_INC(FT_PRO_NUM_ROOT_H1_INJECT, 1);
3212
            inject_message_at_this_blocknum(ft, root_key, fullhash, cmd, flow_deltas, oldest_referenced_xid, gc_info);
3213
        }
3214
    }
3215 3216
}

3217
// Effect: Insert the key-val pair into brt.
3218 3219
void toku_ft_insert (FT_HANDLE brt, DBT *key, DBT *val, TOKUTXN txn) {
    toku_ft_maybe_insert(brt, key, val, txn, false, ZERO_LSN, true, FT_INSERT);
3220 3221
}

3222
void toku_ft_load_recovery(TOKUTXN txn, FILENUM old_filenum, char const * new_iname, int do_fsync, int do_log, LSN *load_lsn) {
3223
    paranoid_invariant(txn);
Yoni Fogel's avatar
Yoni Fogel committed
3224
    toku_txn_force_fsync_on_commit(txn);  //If the txn commits, the commit MUST be in the log
3225
                                          //before the (old) file is actually unlinked
Yoni Fogel's avatar
Yoni Fogel committed
3226 3227
    TOKULOGGER logger = toku_txn_logger(txn);

3228
    BYTESTRING new_iname_bs = {.len=(uint32_t) strlen(new_iname), .data=(char*)new_iname};
3229 3230
    toku_logger_save_rollback_load(txn, old_filenum, &new_iname_bs);
    if (do_log && logger) {
3231
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3232
        toku_log_load(logger, load_lsn, do_fsync, txn, xid, old_filenum, new_iname_bs);
Yoni Fogel's avatar
Yoni Fogel committed
3233 3234 3235
    }
}

3236 3237 3238 3239
// 2954
// this function handles the tasks needed to be recoverable
//  - write to rollback log
//  - write to recovery log
3240
void toku_ft_hot_index_recovery(TOKUTXN txn, FILENUMS filenums, int do_fsync, int do_log, LSN *hot_index_lsn)
3241
{
3242
    paranoid_invariant(txn);
3243 3244 3245
    TOKULOGGER logger = toku_txn_logger(txn);

    // write to the rollback log
3246 3247
    toku_logger_save_rollback_hot_index(txn, &filenums);
    if (do_log && logger) {
3248
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3249
        // write to the recovery log
3250
        toku_log_hot_index(logger, hot_index_lsn, do_fsync, txn, xid, filenums);
3251 3252
    }
}
3253

3254 3255
// Effect: Optimize the ft.
void toku_ft_optimize (FT_HANDLE brt) {
3256
    TOKULOGGER logger = toku_cachefile_logger(brt->ft->cf);
3257
    if (logger) {
3258
        TXNID oldest = toku_txn_manager_get_oldest_living_xid(logger->txn_manager);
3259

3260 3261 3262 3263 3264 3265
        XIDS root_xids = xids_get_root_xids();
        XIDS message_xids;
        if (oldest == TXNID_NONE_LIVING) {
            message_xids = root_xids;
        }
        else {
3266 3267
            int r = xids_create_child(root_xids, &message_xids, oldest);
            invariant(r == 0);
3268
        }
3269

3270 3271 3272 3273
        DBT key;
        DBT val;
        toku_init_dbt(&key);
        toku_init_dbt(&val);
3274
        FT_MSG_S ftcmd = { FT_OPTIMIZE, ZERO_MSN, message_xids, .u = { .id = {&key,&val} } };
3275
        toku_ft_root_put_cmd(brt->ft, &ftcmd, TXNID_NONE, make_gc_info(true));
3276 3277
        xids_destroy(&message_xids);
    }
3278 3279
}

3280
void toku_ft_load(FT_HANDLE brt, TOKUTXN txn, char const * new_iname, int do_fsync, LSN *load_lsn) {
3281
    FILENUM old_filenum = toku_cachefile_filenum(brt->ft->cf);
Yoni Fogel's avatar
Yoni Fogel committed
3282
    int do_log = 1;
3283
    toku_ft_load_recovery(txn, old_filenum, new_iname, do_fsync, do_log, load_lsn);
Yoni Fogel's avatar
Yoni Fogel committed
3284 3285
}

3286 3287
// ft actions for logging hot index filenums
void toku_ft_hot_index(FT_HANDLE brt __attribute__ ((unused)), TOKUTXN txn, FILENUMS filenums, int do_fsync, LSN *lsn) {
3288
    int do_log = 1;
3289
    toku_ft_hot_index_recovery(txn, filenums, do_fsync, do_log, lsn);
3290 3291
}

3292
void
3293
toku_ft_log_put (TOKUTXN txn, FT_HANDLE brt, const DBT *key, const DBT *val) {
3294
    TOKULOGGER logger = toku_txn_logger(txn);
3295
    if (logger) {
3296 3297
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
        BYTESTRING valbs = {.len=val->size, .data=(char *) val->data};
3298
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3299
        toku_log_enq_insert(logger, (LSN*)0, 0, txn, toku_cachefile_filenum(brt->ft->cf), xid, keybs, valbs);
3300 3301 3302
    }
}

3303
void
3304
toku_ft_log_put_multiple (TOKUTXN txn, FT_HANDLE src_ft, FT_HANDLE *brts, uint32_t num_fts, const DBT *key, const DBT *val) {
3305
    assert(txn);
3306
    assert(num_fts > 0);
3307 3308
    TOKULOGGER logger = toku_txn_logger(txn);
    if (logger) {
3309
        FILENUM         fnums[num_fts];
3310
        uint32_t i;
3311
        for (i = 0; i < num_fts; i++) {
3312
            fnums[i] = toku_cachefile_filenum(brts[i]->ft->cf);
3313
        }
3314 3315 3316
        FILENUMS filenums = {.num = num_fts, .filenums = fnums};
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
        BYTESTRING valbs = {.len=val->size, .data=(char *) val->data};
3317
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3318 3319
        FILENUM src_filenum = src_ft ? toku_cachefile_filenum(src_ft->ft->cf) : FILENUM_NONE;
        toku_log_enq_insert_multiple(logger, (LSN*)0, 0, txn, src_filenum, filenums, xid, keybs, valbs);
3320 3321 3322
    }
}

3323
void toku_ft_maybe_insert (FT_HANDLE ft_h, DBT *key, DBT *val, TOKUTXN txn, bool oplsn_valid, LSN oplsn, bool do_logging, enum ft_msg_type type) {
3324
    paranoid_invariant(type==FT_INSERT || type==FT_INSERT_NO_OVERWRITE);
3325
    XIDS message_xids = xids_get_root_xids(); //By default use committed messages
3326
    TXNID_PAIR xid = toku_txn_get_txnid(txn);
3327
    if (txn) {
3328 3329 3330 3331
        BYTESTRING keybs = {key->size, (char *) key->data};
        toku_logger_save_rollback_cmdinsert(txn, toku_cachefile_filenum(ft_h->ft->cf), &keybs);
        toku_txn_maybe_note_ft(txn, ft_h->ft);
        message_xids = toku_txn_get_xids(txn);
Bradley C. Kuszmaul's avatar
Rename  
Bradley C. Kuszmaul committed
3332
    }
3333
    TOKULOGGER logger = toku_txn_logger(txn);
3334
    if (do_logging && logger) {
3335 3336
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
        BYTESTRING valbs = {.len=val->size, .data=(char *) val->data};
3337
        if (type == FT_INSERT) {
3338
            toku_log_enq_insert(logger, (LSN*)0, 0, txn, toku_cachefile_filenum(ft_h->ft->cf), xid, keybs, valbs);
3339 3340
        }
        else {
3341
            toku_log_enq_insert_no_overwrite(logger, (LSN*)0, 0, txn, toku_cachefile_filenum(ft_h->ft->cf), xid, keybs, valbs);
3342
        }
3343 3344
    }

3345
    LSN treelsn;
3346
    if (oplsn_valid && oplsn.lsn <= (treelsn = toku_ft_checkpoint_lsn(ft_h->ft)).lsn) {
3347
        // do nothing
3348
    } else {
3349
        TXNID oldest_referenced_xid = (txn) ? txn->oldest_referenced_xid : TXNID_NONE;
3350
        toku_ft_send_insert(ft_h, key, val, message_xids, type, oldest_referenced_xid, make_gc_info(txn ? !txn->for_recovery : false));
3351
    }
3352
}
3353

3354
static void
3355
ft_send_update_msg(FT_HANDLE brt, FT_MSG_S *msg, TOKUTXN txn) {
3356
    msg->xids = (txn
3357 3358
                 ? toku_txn_get_xids(txn)
                 : xids_get_root_xids());
3359 3360
    
    TXNID oldest_referenced_xid = (txn) ? txn->oldest_referenced_xid : TXNID_NONE;
3361
    toku_ft_root_put_cmd(brt->ft, msg, oldest_referenced_xid, make_gc_info(txn ? !txn->for_recovery : false));
3362 3363
}

3364
void toku_ft_maybe_update(FT_HANDLE ft_h, const DBT *key, const DBT *update_function_extra,
Yoni Fogel's avatar
Yoni Fogel committed
3365 3366
                      TOKUTXN txn, bool oplsn_valid, LSN oplsn,
                      bool do_logging) {
3367
    TXNID_PAIR xid = toku_txn_get_txnid(txn);
3368
    if (txn) {
3369
        BYTESTRING keybs = { key->size, (char *) key->data };
3370
        toku_logger_save_rollback_cmdupdate(
3371 3372
            txn, toku_cachefile_filenum(ft_h->ft->cf), &keybs);
        toku_txn_maybe_note_ft(txn, ft_h->ft);
3373 3374
    }

3375 3376
    TOKULOGGER logger;
    logger = toku_txn_logger(txn);
3377
    if (do_logging && logger) {
3378
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
3379
        BYTESTRING extrabs = {.len=update_function_extra->size,
3380
                              .data = (char *) update_function_extra->data};
3381
        toku_log_enq_update(logger, NULL, 0, txn,
3382
                                toku_cachefile_filenum(ft_h->ft->cf),
3383
                                xid, keybs, extrabs);
3384 3385 3386
    }

    LSN treelsn;
3387 3388
    if (oplsn_valid && oplsn.lsn <= (treelsn = toku_ft_checkpoint_lsn(ft_h->ft)).lsn) {
        // do nothing
3389
    } else {
3390
        FT_MSG_S msg = { FT_UPDATE, ZERO_MSN, NULL,
3391
                         .u = { .id = { key, update_function_extra } } };
3392
        ft_send_update_msg(ft_h, &msg, txn);
3393 3394 3395
    }
}

3396
void toku_ft_maybe_update_broadcast(FT_HANDLE ft_h, const DBT *update_function_extra,
Yoni Fogel's avatar
Yoni Fogel committed
3397 3398
                                TOKUTXN txn, bool oplsn_valid, LSN oplsn,
                                bool do_logging, bool is_resetting_op) {
3399
    TXNID_PAIR xid = toku_txn_get_txnid(txn);
Yoni Fogel's avatar
Yoni Fogel committed
3400
    uint8_t  resetting = is_resetting_op ? 1 : 0;
3401
    if (txn) {
3402
        toku_logger_save_rollback_cmdupdatebroadcast(txn, toku_cachefile_filenum(ft_h->ft->cf), resetting);
3403
        toku_txn_maybe_note_ft(txn, ft_h->ft);
3404 3405
    }

3406 3407
    TOKULOGGER logger;
    logger = toku_txn_logger(txn);
3408
    if (do_logging && logger) {
3409
        BYTESTRING extrabs = {.len=update_function_extra->size,
3410
                              .data = (char *) update_function_extra->data};
3411
        toku_log_enq_updatebroadcast(logger, NULL, 0, txn,
3412
                                         toku_cachefile_filenum(ft_h->ft->cf),
3413
                                         xid, extrabs, resetting);
3414 3415
    }

3416
    //TODO(yoni): remove treelsn here and similar calls (no longer being used)
3417 3418
    LSN treelsn;
    if (oplsn_valid &&
3419
        oplsn.lsn <= (treelsn = toku_ft_checkpoint_lsn(ft_h->ft)).lsn) {
3420

3421
    } else {
3422 3423
        DBT nullkey;
        const DBT *nullkeyp = toku_init_dbt(&nullkey);
3424
        FT_MSG_S msg = { FT_UPDATE_BROADCAST_ALL, ZERO_MSN, NULL,
3425
                         .u = { .id = { nullkeyp, update_function_extra } } };
3426
        ft_send_update_msg(ft_h, &msg, txn);
3427 3428 3429
    }
}

3430
void toku_ft_send_insert(FT_HANDLE brt, DBT *key, DBT *val, XIDS xids, enum ft_msg_type type, TXNID oldest_referenced_xid, GC_INFO gc_info) {
3431
    FT_MSG_S ftcmd = { type, ZERO_MSN, xids, .u = { .id = { key, val } } };
3432
    toku_ft_root_put_cmd(brt->ft, &ftcmd, oldest_referenced_xid, gc_info);
3433 3434
}

3435
void toku_ft_send_commit_any(FT_HANDLE brt, DBT *key, XIDS xids, TXNID oldest_referenced_xid, GC_INFO gc_info) {
3436
    DBT val;
3437
    FT_MSG_S ftcmd = { FT_COMMIT_ANY, ZERO_MSN, xids, .u = { .id = { key, toku_init_dbt(&val) } } };
3438
    toku_ft_root_put_cmd(brt->ft, &ftcmd, oldest_referenced_xid, gc_info);
3439 3440
}

3441 3442
void toku_ft_delete(FT_HANDLE brt, DBT *key, TOKUTXN txn) {
    toku_ft_maybe_delete(brt, key, txn, false, ZERO_LSN, true);
3443 3444
}

3445
void
3446
toku_ft_log_del(TOKUTXN txn, FT_HANDLE brt, const DBT *key) {
3447
    TOKULOGGER logger = toku_txn_logger(txn);
3448
    if (logger) {
3449
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
3450
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3451
        toku_log_enq_delete_any(logger, (LSN*)0, 0, txn, toku_cachefile_filenum(brt->ft->cf), xid, keybs);
3452 3453 3454
    }
}

3455
void
3456
toku_ft_log_del_multiple (TOKUTXN txn, FT_HANDLE src_ft, FT_HANDLE *brts, uint32_t num_fts, const DBT *key, const DBT *val) {
3457
    assert(txn);
3458
    assert(num_fts > 0);
3459 3460
    TOKULOGGER logger = toku_txn_logger(txn);
    if (logger) {
3461
        FILENUM         fnums[num_fts];
3462
        uint32_t i;
3463
        for (i = 0; i < num_fts; i++) {
3464
            fnums[i] = toku_cachefile_filenum(brts[i]->ft->cf);
3465
        }
3466 3467 3468
        FILENUMS filenums = {.num = num_fts, .filenums = fnums};
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
        BYTESTRING valbs = {.len=val->size, .data=(char *) val->data};
3469
        TXNID_PAIR xid = toku_txn_get_txnid(txn);
3470 3471
        FILENUM src_filenum = src_ft ? toku_cachefile_filenum(src_ft->ft->cf) : FILENUM_NONE;
        toku_log_enq_delete_multiple(logger, (LSN*)0, 0, txn, src_filenum, filenums, xid, keybs, valbs);
3472 3473 3474
    }
}

3475
void toku_ft_maybe_delete(FT_HANDLE ft_h, DBT *key, TOKUTXN txn, bool oplsn_valid, LSN oplsn, bool do_logging) {
3476
    XIDS message_xids = xids_get_root_xids(); //By default use committed messages
3477
    TXNID_PAIR xid = toku_txn_get_txnid(txn);
3478
    if (txn) {
3479 3480 3481 3482
        BYTESTRING keybs = {key->size, (char *) key->data};
        toku_logger_save_rollback_cmddelete(txn, toku_cachefile_filenum(ft_h->ft->cf), &keybs);
        toku_txn_maybe_note_ft(txn, ft_h->ft);
        message_xids = toku_txn_get_xids(txn);
3483
    }
3484
    TOKULOGGER logger = toku_txn_logger(txn);
3485
    if (do_logging && logger) {
3486
        BYTESTRING keybs = {.len=key->size, .data=(char *) key->data};
3487
        toku_log_enq_delete_any(logger, (LSN*)0, 0, txn, toku_cachefile_filenum(ft_h->ft->cf), xid, keybs);
3488
    }
3489

3490
    LSN treelsn;
3491
    if (oplsn_valid && oplsn.lsn <= (treelsn = toku_ft_checkpoint_lsn(ft_h->ft)).lsn) {
3492
        // do nothing
3493
    } else {
3494
        TXNID oldest_referenced_xid = (txn) ? txn->oldest_referenced_xid : TXNID_NONE;
3495
        toku_ft_send_delete(ft_h, key, message_xids, oldest_referenced_xid, make_gc_info(txn ? !txn->for_recovery : false));
3496
    }
3497 3498
}

3499
void toku_ft_send_delete(FT_HANDLE brt, DBT *key, XIDS xids, TXNID oldest_referenced_xid, GC_INFO gc_info) {
3500
    DBT val; toku_init_dbt(&val);
3501
    FT_MSG_S ftcmd = { FT_DELETE_ANY, ZERO_MSN, xids, .u = { .id = { key, &val } } };
3502
    toku_ft_root_put_cmd(brt->ft, &ftcmd, oldest_referenced_xid, gc_info);
3503 3504
}

3505 3506
/* ******************** open,close and create  ********************** */

3507
// Test only function (not used in running system). This one has no env
3508
int toku_open_ft_handle (const char *fname, int is_create, FT_HANDLE *ft_handle_p, int nodesize,
3509 3510 3511 3512
                   int basementnodesize,
                   enum toku_compression_method compression_method,
                   CACHETABLE cachetable, TOKUTXN txn,
                   int (*compare_fun)(DB *, const DBT*,const DBT*)) {
3513
    FT_HANDLE brt;
3514 3515
    const int only_create = 0;

3516
    toku_ft_handle_create(&brt);
3517 3518 3519
    toku_ft_handle_set_nodesize(brt, nodesize);
    toku_ft_handle_set_basementnodesize(brt, basementnodesize);
    toku_ft_handle_set_compression_method(brt, compression_method);
3520
    toku_ft_handle_set_fanout(brt, 16);
3521
    toku_ft_set_bt_compare(brt, compare_fun);
3522

3523
    int r = toku_ft_handle_open(brt, fname, is_create, only_create, cachetable, txn);
3524
    if (r != 0) {
3525
        return r;
3526 3527
    }

3528
    *ft_handle_p = brt;
3529 3530 3531
    return r;
}

3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
static bool use_direct_io = true;

void toku_ft_set_direct_io (bool direct_io_on) {
    use_direct_io = direct_io_on;
}

static inline int ft_open_maybe_direct(const char *filename, int oflag, int mode) {
    if (use_direct_io) {
        return toku_os_open_direct(filename, oflag, mode);
    } else {
        return toku_os_open(filename, oflag, mode);
    }
}

3546 3547
// open a file for use by the brt
// Requires:  File does not exist.
3548
static int ft_create_file(FT_HANDLE UU(brt), const char *fname, int *fdp) {
3549
    mode_t mode = S_IRWXU|S_IRWXG|S_IRWXO;
3550
    int r;
3551
    int fd;
3552
    int er;
3553
    fd = ft_open_maybe_direct(fname, O_RDWR | O_BINARY, mode);
3554
    assert(fd==-1);
3555 3556
    if ((er = get_maybe_error_errno()) != ENOENT) {
        return er;
3557
    }
3558
    fd = ft_open_maybe_direct(fname, O_RDWR | O_CREAT | O_BINARY, mode);
3559
    if (fd==-1) {
3560
        r = get_error_errno();
3561
        return r;
3562
    }
3563 3564

    r = toku_fsync_directory(fname);
Rich Prohaska's avatar
Rich Prohaska committed
3565 3566 3567 3568 3569 3570 3571
    if (r == 0) {
        *fdp = fd;
    } else {
        int rr = close(fd);
        assert_zero(rr);
    }
    return r;
3572 3573 3574
}

// open a file for use by the brt.  if the file does not exist, error
3575
static int ft_open_file(const char *fname, int *fdp) {
3576 3577
    mode_t mode = S_IRWXU|S_IRWXG|S_IRWXO;
    int fd;
3578
    fd = ft_open_maybe_direct(fname, O_RDWR | O_BINARY, mode);
3579
    if (fd==-1) {
3580
        return get_error_errno();
3581 3582 3583 3584 3585
    }
    *fdp = fd;
    return 0;
}

3586 3587
void
toku_ft_handle_set_compression_method(FT_HANDLE t, enum toku_compression_method method)
3588
{
3589 3590 3591 3592 3593 3594
    if (t->ft) {
        toku_ft_set_compression_method(t->ft, method);
    }
    else {
        t->options.compression_method = method;
    }
3595 3596
}

3597 3598
void
toku_ft_handle_get_compression_method(FT_HANDLE t, enum toku_compression_method *methodp)
3599
{
3600 3601 3602 3603 3604 3605
    if (t->ft) {
        toku_ft_get_compression_method(t->ft, methodp);
    }
    else {
        *methodp = t->options.compression_method;
    }
3606 3607
}

3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628
void
toku_ft_handle_set_fanout(FT_HANDLE ft_handle, unsigned int fanout)
{
    if (ft_handle->ft) {
        toku_ft_set_fanout(ft_handle->ft, fanout);
    }
    else {
        ft_handle->options.fanout = fanout;
    }
}

void
toku_ft_handle_get_fanout(FT_HANDLE ft_handle, unsigned int *fanout)
{
    if (ft_handle->ft) {
        toku_ft_get_fanout(ft_handle->ft, fanout);
    }
    else {
        *fanout = ft_handle->options.fanout;
    }
}
3629
static int
Yoni Fogel's avatar
Yoni Fogel committed
3630
verify_builtin_comparisons_consistent(FT_HANDLE t, uint32_t flags) {
3631
    if ((flags & TOKU_DB_KEYCMP_BUILTIN) && (t->options.compare_fun != toku_builtin_compare_fun))
3632
        return EINVAL;
3633 3634 3635
    return 0;
}

3636 3637 3638 3639
//
// See comments in toku_db_change_descriptor to understand invariants 
// in the system when this function is called
//
3640
void toku_ft_change_descriptor(
3641
    FT_HANDLE ft_h,
3642 3643
    const DBT* old_descriptor,
    const DBT* new_descriptor,
Yoni Fogel's avatar
Yoni Fogel committed
3644
    bool do_log,
3645
    TOKUTXN txn,
Yoni Fogel's avatar
Yoni Fogel committed
3646
    bool update_cmp_descriptor
3647
    )
3648 3649 3650
{
    DESCRIPTOR_S new_d;

3651 3652 3653 3654 3655
    // if running with txns, save to rollback + write to recovery log
    if (txn) {
        // put information into rollback file
        BYTESTRING old_desc_bs = { old_descriptor->size, (char *) old_descriptor->data };
        BYTESTRING new_desc_bs = { new_descriptor->size, (char *) new_descriptor->data };
3656
        toku_logger_save_rollback_change_fdescriptor(
3657
            txn,
3658
            toku_cachefile_filenum(ft_h->ft->cf),
3659
            &old_desc_bs
3660
            );
3661 3662 3663 3664
        toku_txn_maybe_note_ft(txn, ft_h->ft);

        if (do_log) {
            TOKULOGGER logger = toku_txn_logger(txn);
3665
            TXNID_PAIR xid = toku_txn_get_txnid(txn);
3666
            toku_log_change_fdescriptor(
3667 3668 3669 3670 3671 3672 3673 3674 3675
                logger, NULL, 0,
                txn,
                toku_cachefile_filenum(ft_h->ft->cf),
                xid,
                old_desc_bs,
                new_desc_bs,
                update_cmp_descriptor
                );
        }
3676
    }
3677 3678 3679

    // write new_descriptor to header
    new_d.dbt = *new_descriptor;
3680
    toku_ft_update_descriptor(ft_h->ft, &new_d);
3681
    // very infrequent operation, worth precise threadsafe count
3682
    STATUS_INC(FT_DESCRIPTOR_SET, 1);
3683

3684
    if (update_cmp_descriptor) {
3685
        toku_ft_update_cmp_descriptor(ft_h->ft);
3686
    }
3687 3688
}

3689 3690 3691
static void
toku_ft_handle_inherit_options(FT_HANDLE t, FT ft) {
    struct ft_options options = {
3692 3693 3694
        .nodesize = ft->h->nodesize,
        .basementnodesize = ft->h->basementnodesize,
        .compression_method = ft->h->compression_method,
3695
        .fanout = ft->h->fanout,
3696
        .flags = ft->h->flags,
3697 3698 3699 3700
        .compare_fun = ft->compare_fun,
        .update_fun = ft->update_fun
    };
    t->options = options;
Yoni Fogel's avatar
Yoni Fogel committed
3701
    t->did_set_flags = true;
3702 3703
}

3704
// This is the actual open, used for various purposes, such as normal use, recovery, and redirect.
3705 3706
// fname_in_env is the iname, relative to the env_dir  (data_dir is already in iname as prefix).
// The checkpointed version (checkpoint_lsn) of the dictionary must be no later than max_acceptable_lsn .
3707
// Requires: The multi-operation client lock must be held to prevent a checkpoint from occuring.
3708
static int
3709
ft_handle_open(FT_HANDLE ft_h, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn, FILENUM use_filenum, DICTIONARY_ID use_dictionary_id, LSN max_acceptable_lsn) {
3710
    int r;
Yoni Fogel's avatar
Yoni Fogel committed
3711
    bool txn_created = false;
3712 3713
    char *fname_in_cwd = NULL;
    CACHEFILE cf = NULL;
3714
    FT ft = NULL;
Yoni Fogel's avatar
Yoni Fogel committed
3715
    bool did_create = false;
3716
    toku_ft_open_close_lock();
3717

3718 3719
    if (ft_h->did_set_flags) {
        r = verify_builtin_comparisons_consistent(ft_h, ft_h->options.flags);
3720 3721
        if (r!=0) { goto exit; }
    }
3722

3723
    assert(is_create || !only_create);
3724 3725
    FILENUM reserved_filenum;
    reserved_filenum = use_filenum;
3726
    fname_in_cwd = toku_cachetable_get_fname_in_cwd(cachetable, fname_in_env);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3727
    bool was_already_open;
3728
    {
3729
        int fd = -1;
3730
        r = ft_open_file(fname_in_cwd, &fd);
John Esmet's avatar
John Esmet committed
3731 3732 3733
        if (reserved_filenum.fileid == FILENUM_NONE.fileid) {
            reserved_filenum = toku_cachetable_reserve_filenum(cachetable);
        }
3734
        if (r==ENOENT && is_create) {
Yoni Fogel's avatar
Yoni Fogel committed
3735
            did_create = true;
3736 3737
            mode_t mode = S_IRWXU|S_IRWXG|S_IRWXO;
            if (txn) {
3738
                BYTESTRING bs = { .len=(uint32_t) strlen(fname_in_env), .data = (char*)fname_in_env };
3739
                toku_logger_save_rollback_fcreate(txn, reserved_filenum, &bs); // bs is a copy of the fname relative to the environment
3740
            }
Yoni Fogel's avatar
Yoni Fogel committed
3741
            txn_created = (bool)(txn!=NULL);
3742
            toku_logger_log_fcreate(txn, fname_in_env, reserved_filenum, mode, ft_h->options.flags, ft_h->options.nodesize, ft_h->options.basementnodesize, ft_h->options.compression_method);
3743
            r = ft_create_file(ft_h, fname_in_cwd, &fd);
Rich Prohaska's avatar
Rich Prohaska committed
3744
            if (r) { goto exit; }
3745 3746
        }
        if (r) { goto exit; }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3747
        r=toku_cachetable_openfd_with_filenum(&cf, cachetable, fd, fname_in_env, reserved_filenum, &was_already_open);
3748
        if (r) { goto exit; }
3749
    }
3750
    assert(ft_h->options.nodesize>0);
3751
    if (is_create) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3752
        r = toku_read_ft_and_store_in_cachefile(ft_h, cf, max_acceptable_lsn, &ft);
3753
        if (r==TOKUDB_DICTIONARY_NO_HEADER) {
3754
            toku_ft_create(&ft, &ft_h->options, cf, txn);
3755 3756 3757 3758 3759 3760 3761 3762 3763 3764
        }
        else if (r!=0) {
            goto exit;
        }
        else if (only_create) {
            assert_zero(r);
            r = EEXIST;
            goto exit;
        }
        // if we get here, then is_create was true but only_create was false,
3765 3766
        // so it is ok for toku_read_ft_and_store_in_cachefile to have read
        // the header via toku_read_ft_and_store_in_cachefile
3767
    } else {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
3768
        r = toku_read_ft_and_store_in_cachefile(ft_h, cf, max_acceptable_lsn, &ft);
3769 3770
        if (r) { goto exit; }
    }
3771 3772
    if (!ft_h->did_set_flags) {
        r = verify_builtin_comparisons_consistent(ft_h, ft_h->options.flags);
3773
        if (r) { goto exit; }
3774
    } else if (ft_h->options.flags != ft->h->flags) {                  /* if flags have been set then flags must match */
3775 3776
        r = EINVAL;
        goto exit;
3777
    }
3778
    toku_ft_handle_inherit_options(ft_h, ft);
3779 3780

    if (!was_already_open) {
3781
        if (!did_create) { //Only log the fopen that OPENs the file.  If it was already open, don't log.
3782
            toku_logger_log_fopen(txn, fname_in_env, toku_cachefile_filenum(cf), ft_h->options.flags);
3783
        }
3784
    }
3785 3786
    int use_reserved_dict_id;
    use_reserved_dict_id = use_dictionary_id.dictid != DICTIONARY_ID_NONE.dictid;
3787
    if (!was_already_open) {
3788 3789 3790 3791 3792 3793 3794
        DICTIONARY_ID dict_id;
        if (use_reserved_dict_id) {
            dict_id = use_dictionary_id;
        }
        else {
            dict_id = next_dict_id();
        }
3795
        ft->dict_id = dict_id;
3796 3797
    }
    else {
3798 3799
        // dict_id is already in header
        if (use_reserved_dict_id) {
3800
            assert(ft->dict_id.dictid == use_dictionary_id.dictid);
3801
        }
3802
    }
3803 3804 3805
    assert(ft);
    assert(ft->dict_id.dictid != DICTIONARY_ID_NONE.dictid);
    assert(ft->dict_id.dictid < dict_id_serial);
3806

3807 3808 3809
    // important note here,
    // after this point, where we associate the header
    // with the brt, the function is not allowed to fail
3810 3811
    // Code that handles failure (located below "exit"),
    // depends on this
3812
    toku_ft_note_ft_handle_open(ft, ft_h);
3813
    if (txn_created) {
3814
        assert(txn);
3815
        toku_txn_maybe_note_ft(txn, ft);
3816
    }
3817

3818
    //Opening a brt may restore to previous checkpoint.         Truncate if necessary.
3819
    {
3820
        int fd = toku_cachefile_get_fd (ft->cf);
3821
        toku_maybe_truncate_file_on_open(ft->blocktable, fd);
3822
    }
3823 3824 3825 3826 3827 3828

    r = 0;
exit:
    if (fname_in_cwd) {
        toku_free(fname_in_cwd);
    }
John Esmet's avatar
John Esmet committed
3829
    if (r != 0 && cf) {
3830
        if (ft) {
John Esmet's avatar
John Esmet committed
3831 3832 3833 3834 3835 3836
            // we only call toku_ft_note_ft_handle_open
            // when the function succeeds, so if we are here,
            // then that means we have a reference to the header
            // but we have not linked it to this brt. So,
            // we can simply try to remove the header.
            // We don't need to unlink this brt from the header
3837
            toku_ft_grab_reflock(ft);
Yoni Fogel's avatar
Yoni Fogel committed
3838
            bool needed = toku_ft_needed_unlocked(ft);
3839 3840
            toku_ft_release_reflock(ft);
            if (!needed) {
3841 3842
                // close immediately.
                toku_ft_evict_from_memory(ft, false, ZERO_LSN);
3843 3844
            }
        }
John Esmet's avatar
John Esmet committed
3845
        else {
3846
            toku_cachefile_close(&cf, false, ZERO_LSN);
John Esmet's avatar
John Esmet committed
3847
        }
3848
    }
3849
    toku_ft_open_close_unlock();
3850
    return r;
3851 3852
}

3853
// Open a brt for the purpose of recovery, which requires that the brt be open to a pre-determined FILENUM
3854
// and may require a specific checkpointed version of the file.
3855
// (dict_id is assigned by the ft_handle_open() function.)
3856
int
3857
toku_ft_handle_open_recovery(FT_HANDLE t, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn, FILENUM use_filenum, LSN max_acceptable_lsn) {
3858
    int r;
3859
    assert(use_filenum.fileid != FILENUM_NONE.fileid);
3860
    r = ft_handle_open(t, fname_in_env, is_create, only_create, cachetable,
3861
                 txn, use_filenum, DICTIONARY_ID_NONE, max_acceptable_lsn);
3862 3863 3864
    return r;
}

3865
// Open a brt in normal use.  The FILENUM and dict_id are assigned by the ft_handle_open() function.
3866
// Requires: The multi-operation client lock must be held to prevent a checkpoint from occuring.
3867
int
3868
toku_ft_handle_open(FT_HANDLE t, const char *fname_in_env, int is_create, int only_create, CACHETABLE cachetable, TOKUTXN txn) {
3869
    int r;
3870
    r = ft_handle_open(t, fname_in_env, is_create, only_create, cachetable, txn, FILENUM_NONE, DICTIONARY_ID_NONE, MAX_LSN);
3871 3872 3873
    return r;
}

3874 3875 3876 3877
// clone an ft handle. the cloned handle has a new dict_id but refers to the same fractal tree
int 
toku_ft_handle_clone(FT_HANDLE *cloned_ft_handle, FT_HANDLE ft_handle, TOKUTXN txn) {
    FT_HANDLE result_ft_handle; 
3878
    toku_ft_handle_create(&result_ft_handle);
3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890

    // we're cloning, so the handle better have an open ft and open cf
    invariant(ft_handle->ft);
    invariant(ft_handle->ft->cf);

    // inherit the options of the ft whose handle is being cloned.
    toku_ft_handle_inherit_options(result_ft_handle, ft_handle->ft);

    // we can clone the handle by creating a new handle with the same fname
    CACHEFILE cf = ft_handle->ft->cf;
    CACHETABLE ct = toku_cachefile_get_cachetable(cf);
    const char *fname_in_env = toku_cachefile_fname_in_env(cf);
3891
    int r = toku_ft_handle_open(result_ft_handle, fname_in_env, false, false, ct, txn); 
3892 3893 3894 3895 3896 3897 3898 3899
    if (r != 0) {
        toku_ft_handle_close(result_ft_handle);
        result_ft_handle = NULL;
    }
    *cloned_ft_handle = result_ft_handle;
    return r;
}

3900
// Open a brt in normal use.  The FILENUM and dict_id are assigned by the ft_handle_open() function.
3901
int
3902 3903
toku_ft_handle_open_with_dict_id(
    FT_HANDLE t,
3904 3905 3906 3907 3908
    const char *fname_in_env,
    int is_create,
    int only_create,
    CACHETABLE cachetable,
    TOKUTXN txn,
3909
    DICTIONARY_ID use_dictionary_id
3910
    )
3911
{
3912
    int r;
3913
    r = ft_handle_open(
3914 3915 3916 3917 3918 3919 3920 3921
        t,
        fname_in_env,
        is_create,
        only_create,
        cachetable,
        txn,
        FILENUM_NONE,
        use_dictionary_id,
3922 3923
        MAX_LSN
        );
3924 3925 3926 3927
    return r;
}

DICTIONARY_ID
3928
toku_ft_get_dictionary_id(FT_HANDLE brt) {
3929
    FT h = brt->ft;
3930 3931 3932 3933
    DICTIONARY_ID dict_id = h->dict_id;
    return dict_id;
}

3934 3935 3936
void toku_ft_set_flags(FT_HANDLE ft_handle, unsigned int flags) {
    ft_handle->did_set_flags = true;
    ft_handle->options.flags = flags;
3937 3938
}

3939 3940
void toku_ft_get_flags(FT_HANDLE ft_handle, unsigned int *flags) {
    *flags = ft_handle->options.flags;
3941 3942
}

3943
void toku_ft_get_maximum_advised_key_value_lengths (unsigned int *max_key_len, unsigned int *max_val_len)
3944 3945 3946 3947 3948 3949
// return the maximum advisable key value lengths.  The brt doesn't enforce these.
{
    *max_key_len = 32*1024;
    *max_val_len = 32*1024*1024;
}

3950 3951 3952 3953 3954 3955 3956 3957

void toku_ft_handle_set_nodesize(FT_HANDLE ft_handle, unsigned int nodesize) {
    if (ft_handle->ft) {
        toku_ft_set_nodesize(ft_handle->ft, nodesize);
    }
    else {
        ft_handle->options.nodesize = nodesize;
    }
3958 3959
}

3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984
void toku_ft_handle_get_nodesize(FT_HANDLE ft_handle, unsigned int *nodesize) {
    if (ft_handle->ft) {
        toku_ft_get_nodesize(ft_handle->ft, nodesize);
    }
    else {
        *nodesize = ft_handle->options.nodesize;
    }
}

void toku_ft_handle_set_basementnodesize(FT_HANDLE ft_handle, unsigned int basementnodesize) {
    if (ft_handle->ft) {
        toku_ft_set_basementnodesize(ft_handle->ft, basementnodesize);
    }
    else {
        ft_handle->options.basementnodesize = basementnodesize;
    }
}

void toku_ft_handle_get_basementnodesize(FT_HANDLE ft_handle, unsigned int *basementnodesize) {
    if (ft_handle->ft) {
        toku_ft_get_basementnodesize(ft_handle->ft, basementnodesize);
    }
    else {
        *basementnodesize = ft_handle->options.basementnodesize;
    }
3985 3986
}

3987
void toku_ft_set_bt_compare(FT_HANDLE brt, int (*bt_compare)(DB*, const DBT*, const DBT*)) {
3988
    brt->options.compare_fun = bt_compare;
3989 3990
}

3991
void toku_ft_set_redirect_callback(FT_HANDLE brt, on_redirect_callback redir_cb, void* extra) {
3992 3993 3994 3995
    brt->redirect_callback = redir_cb;
    brt->redirect_callback_extra = extra;
}

3996
void toku_ft_set_update(FT_HANDLE brt, ft_update_func update_fun) {
3997
    brt->options.update_fun = update_fun;
3998 3999
}

4000
ft_compare_func toku_ft_get_bt_compare (FT_HANDLE brt) {
4001
    return brt->options.compare_fun;
4002 4003
}

4004 4005
static void
ft_remove_handle_ref_callback(FT UU(ft), void *extra) {
4006
    FT_HANDLE CAST_FROM_VOIDP(handle, extra);
4007 4008 4009
    toku_list_remove(&handle->live_ft_handle_link);
}

4010 4011 4012 4013 4014 4015
// close an ft handle during normal operation. the underlying ft may or may not close,
// depending if there are still references. an lsn for this close will come from the logger.
void
toku_ft_handle_close(FT_HANDLE ft_handle) {
    // There are error paths in the ft_handle_open that end with ft_handle->ft==NULL.
    FT ft = ft_handle->ft;
4016
    if (ft) {
4017 4018
        const bool oplsn_valid = false;
        toku_ft_remove_reference(ft, oplsn_valid, ZERO_LSN, ft_remove_handle_ref_callback, ft_handle);
4019
    }
4020
    toku_free(ft_handle);
4021 4022
}

4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039
// close an ft handle during recovery. the underlying ft must close, and will use the given lsn.
void 
toku_ft_handle_close_recovery(FT_HANDLE ft_handle, LSN oplsn) {
    FT ft = ft_handle->ft;
    // the ft must exist if closing during recovery. error paths during 
    // open for recovery should close handles using toku_ft_handle_close()
    assert(ft);
    const bool oplsn_valid = true;
    toku_ft_remove_reference(ft, oplsn_valid, oplsn, ft_remove_handle_ref_callback, ft_handle);
    toku_free(ft_handle);
}

// TODO: remove this, callers should instead just use toku_ft_handle_close()
int 
toku_close_ft_handle_nolsn (FT_HANDLE ft_handle, char** UU(error_string)) {
    toku_ft_handle_close(ft_handle);
    return 0;
4040 4041
}

4042 4043
void toku_ft_handle_create(FT_HANDLE *ft_handle_ptr) {
    FT_HANDLE XMALLOC(brt);
4044
    memset(brt, 0, sizeof *brt);
4045
    toku_list_init(&brt->live_ft_handle_link);
4046
    brt->options.flags = 0;
Yoni Fogel's avatar
Yoni Fogel committed
4047
    brt->did_set_flags = false;
4048 4049 4050
    brt->options.nodesize = FT_DEFAULT_NODE_SIZE;
    brt->options.basementnodesize = FT_DEFAULT_BASEMENT_NODE_SIZE;
    brt->options.compression_method = TOKU_DEFAULT_COMPRESSION_METHOD;
4051
    brt->options.fanout = FT_DEFAULT_FANOUT;
4052 4053
    brt->options.compare_fun = toku_builtin_compare_fun;
    brt->options.update_fun = NULL;
4054
    *ft_handle_ptr = brt;
4055
}
4056

4057 4058
/* ************* CURSORS ********************* */

4059
static inline void
4060
ft_cursor_cleanup_dbts(FT_CURSOR c) {
4061 4062
    toku_destroy_dbt(&c->key);
    toku_destroy_dbt(&c->val);
4063 4064
}

4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075
//
// This function is used by the leafentry iterators.
// returns TOKUDB_ACCEPT if live transaction context is allowed to read a value
// that is written by transaction with LSN of id
// live transaction context may read value if either id is the root ancestor of context, or if
// id was committed before context's snapshot was taken.
// For id to be committed before context's snapshot was taken, the following must be true:
//  - id < context->snapshot_txnid64 AND id is not in context's live root transaction list
// For the above to NOT be true:
//  - id > context->snapshot_txnid64 OR id is in context's live root transaction list
//
4076
static int
4077
does_txn_read_entry(TXNID id, TOKUTXN context) {
4078 4079
    int rval;
    TXNID oldest_live_in_snapshot = toku_get_oldest_in_live_root_txn_list(context);
4080 4081 4082 4083
    if (oldest_live_in_snapshot == TXNID_NONE && id < context->snapshot_txnid64) {
        rval = TOKUDB_ACCEPT;
    }
    else if (id < oldest_live_in_snapshot || id == context->txnid.parent_id64) {
4084
        rval = TOKUDB_ACCEPT;
4085
    }
4086
    else if (id > context->snapshot_txnid64 || toku_is_txn_in_live_root_txn_list(*context->live_root_txn_list, id)) {
4087
        rval = 0;
4088 4089
    }
    else {
4090
        rval = TOKUDB_ACCEPT;
4091 4092 4093 4094
    }
    return rval;
}

4095
static inline void
4096
ft_cursor_extract_val(LEAFENTRY le,
4097
                               FT_CURSOR cursor,
Yoni Fogel's avatar
Yoni Fogel committed
4098
                               uint32_t *vallen,
4099
                               void            **val) {
4100
    if (toku_ft_cursor_is_leaf_mode(cursor)) {
4101 4102
        *val = le;
        *vallen = leafentry_memsize(le);
4103
    } else if (cursor->is_snapshot_read) {
4104
        int r = le_iterate_val(
4105 4106 4107 4108 4109 4110
            le,
            does_txn_read_entry,
            val,
            vallen,
            cursor->ttxn
            );
4111
        lazy_assert_zero(r);
4112
    } else {
4113
        *val = le_latest_val_and_len(le, vallen);
4114
    }
4115 4116
}

4117 4118 4119
int toku_ft_cursor (
    FT_HANDLE brt,
    FT_CURSOR *cursorptr,
4120
    TOKUTXN ttxn,
Yoni Fogel's avatar
Yoni Fogel committed
4121 4122
    bool is_snapshot_read,
    bool disable_prefetching
4123
    )
4124 4125
{
    if (is_snapshot_read) {
4126
        invariant(ttxn != NULL);
4127
        int accepted = does_txn_read_entry(brt->ft->h->root_xid_that_created, ttxn);
4128 4129 4130 4131
        if (accepted!=TOKUDB_ACCEPT) {
            invariant(accepted==0);
            return TOKUDB_MVCC_DICTIONARY_TOO_NEW;
        }
4132
    }
4133
    FT_CURSOR XCALLOC(cursor);
4134
    cursor->ft_handle = brt;
Yoni Fogel's avatar
Yoni Fogel committed
4135
    cursor->prefetching = false;
4136 4137
    toku_init_dbt(&cursor->range_lock_left_key);
    toku_init_dbt(&cursor->range_lock_right_key);
Yoni Fogel's avatar
Yoni Fogel committed
4138 4139
    cursor->left_is_neg_infty = false;
    cursor->right_is_pos_infty = false;
4140
    cursor->is_snapshot_read = is_snapshot_read;
Yoni Fogel's avatar
Yoni Fogel committed
4141
    cursor->is_leaf_mode = false;
4142
    cursor->ttxn = ttxn;
4143
    cursor->disable_prefetching = disable_prefetching;
Yoni Fogel's avatar
Yoni Fogel committed
4144
    cursor->is_temporary = false;
4145 4146 4147 4148
    *cursorptr = cursor;
    return 0;
}

4149 4150
void toku_ft_cursor_remove_restriction(FT_CURSOR ftcursor) {
    ftcursor->out_of_range_error = 0;
4151
    ftcursor->direction = 0;
4152 4153
}

4154 4155 4156 4157 4158 4159
void toku_ft_cursor_set_check_interrupt_cb(FT_CURSOR ftcursor, FT_CHECK_INTERRUPT_CALLBACK cb, void *extra) {
    ftcursor->interrupt_cb = cb;
    ftcursor->interrupt_cb_extra = extra;
}


4160
void
4161
toku_ft_cursor_set_temporary(FT_CURSOR ftcursor) {
Yoni Fogel's avatar
Yoni Fogel committed
4162
    ftcursor->is_temporary = true;
4163 4164
}

4165
void
4166
toku_ft_cursor_set_leaf_mode(FT_CURSOR ftcursor) {
Yoni Fogel's avatar
Yoni Fogel committed
4167
    ftcursor->is_leaf_mode = true;
4168 4169 4170
}

int
4171 4172
toku_ft_cursor_is_leaf_mode(FT_CURSOR ftcursor) {
    return ftcursor->is_leaf_mode;
4173 4174
}

4175
void
4176
toku_ft_cursor_set_range_lock(FT_CURSOR cursor, const DBT *left, const DBT *right,
4177 4178
                              bool left_is_neg_infty, bool right_is_pos_infty,
                              int out_of_range_error)
4179
{
4180 4181
    // Destroy any existing keys and then clone the given left, right keys
    toku_destroy_dbt(&cursor->range_lock_left_key);
4182
    if (left_is_neg_infty) {
Yoni Fogel's avatar
Yoni Fogel committed
4183
        cursor->left_is_neg_infty = true;
4184
    } else {
4185
        toku_clone_dbt(&cursor->range_lock_left_key, *left);
4186
    }
4187 4188

    toku_destroy_dbt(&cursor->range_lock_right_key);
4189
    if (right_is_pos_infty) {
Yoni Fogel's avatar
Yoni Fogel committed
4190
        cursor->right_is_pos_infty = true;
4191
    } else {
4192
        toku_clone_dbt(&cursor->range_lock_right_key, *right);
4193
    }
4194

4195 4196
    // TOKUDB_FOUND_BUT_REJECTED is a DB_NOTFOUND with instructions to stop looking. (Faster)
    cursor->out_of_range_error = out_of_range_error == DB_NOTFOUND ? TOKUDB_FOUND_BUT_REJECTED : out_of_range_error;
4197
    cursor->direction = 0;
4198 4199
}

4200
void toku_ft_cursor_close(FT_CURSOR cursor) {
4201
    ft_cursor_cleanup_dbts(cursor);
4202 4203
    toku_destroy_dbt(&cursor->range_lock_left_key);
    toku_destroy_dbt(&cursor->range_lock_right_key);
4204
    toku_free(cursor);
4205
}
4206

4207
static inline void ft_cursor_set_prefetching(FT_CURSOR cursor) {
Yoni Fogel's avatar
Yoni Fogel committed
4208
    cursor->prefetching = true;
4209 4210
}

Yoni Fogel's avatar
Yoni Fogel committed
4211
static inline bool ft_cursor_prefetching(FT_CURSOR cursor) {
4212 4213 4214
    return cursor->prefetching;
}

Yoni Fogel's avatar
Yoni Fogel committed
4215 4216
//Return true if cursor is uninitialized.  false otherwise.
static bool
4217
ft_cursor_not_set(FT_CURSOR cursor) {
4218
    assert((cursor->key.data==NULL) == (cursor->val.data==NULL));
Yoni Fogel's avatar
Yoni Fogel committed
4219
    return (bool)(cursor->key.data == NULL);
4220 4221
}

4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240
//
//
//
//
//
//
//
//
//
// TODO: ask Yoni why second parameter here is not const 
//
//
//
//
//
//
//
//
//
4241
static int
4242 4243 4244
heaviside_from_search_t(const DBT &kdbt, ft_search_t &search) {
    int cmp = search.compare(search,
                              search.k ? &kdbt : 0);
4245
    // The search->compare function returns only 0 or 1
4246
    switch (search.direction) {
4247 4248
    case FT_SEARCH_LEFT:   return cmp==0 ? -1 : +1;
    case FT_SEARCH_RIGHT:  return cmp==0 ? +1 : -1; // Because the comparison runs backwards for right searches.
4249
    }
4250
    abort(); return 0;
4251 4252 4253
}


4254 4255 4256
//
// Returns true if the value that is to be read is empty.
//
4257
static inline int
4258
is_le_val_del(LEAFENTRY le, FT_CURSOR ftcursor) {
4259
    int rval;
4260
    if (ftcursor->is_snapshot_read) {
Yoni Fogel's avatar
Yoni Fogel committed
4261
        bool is_del;
4262 4263 4264 4265
        le_iterate_is_del(
            le,
            does_txn_read_entry,
            &is_del,
4266
            ftcursor->ttxn
4267 4268
            );
        rval = is_del;
4269 4270
    }
    else {
4271
        rval = le_latest_is_del(le);
4272
    }
4273
    return rval;
4274 4275
}

4276
struct store_fifo_offset_extra {
4277
    int32_t *offsets;
4278 4279 4280
    int i;
};

4281 4282
int store_fifo_offset(const int32_t &offset, const uint32_t UU(idx), struct store_fifo_offset_extra *const extra) __attribute__((nonnull(3)));
int store_fifo_offset(const int32_t &offset, const uint32_t UU(idx), struct store_fifo_offset_extra *const extra)
4283
{
4284 4285
    extra->offsets[extra->i] = offset;
    extra->i++;
4286 4287 4288
    return 0;
}

4289 4290 4291 4292 4293
/**
 * Given pointers to offsets within a FIFO where we can find messages,
 * figure out the MSN of each message, and compare those MSNs.  Returns 1,
 * 0, or -1 if a is larger than, equal to, or smaller than b.
 */
4294 4295
int fifo_offset_msn_cmp(FIFO &fifo, const int32_t &ao, const int32_t &bo);
int fifo_offset_msn_cmp(FIFO &fifo, const int32_t &ao, const int32_t &bo)
4296
{
4297 4298
    const struct fifo_entry *a = toku_fifo_get_entry(fifo, ao);
    const struct fifo_entry *b = toku_fifo_get_entry(fifo, bo);
4299 4300 4301 4302 4303 4304 4305
    if (a->msn.msn > b->msn.msn) {
        return +1;
    }
    if (a->msn.msn < b->msn.msn) {
        return -1;
    }
    return 0;
4306 4307
}

4308 4309
/**
 * Given a fifo_entry, either decompose it into its parameters and call
4310
 * toku_ft_bn_apply_cmd, or discard it, based on its MSN and the MSN of the
4311 4312
 * basement node.
 */
4313
static void
4314
do_bn_apply_cmd(FT_HANDLE t, BASEMENTNODE bn, struct fifo_entry *entry, TXNID oldest_referenced_xid, uint64_t *workdone, STAT64INFO stats_to_update)
4315
{
4316 4317 4318 4319
    // The messages are being iterated over in (key,msn) order or just in
    // msn order, so all the messages for one key, from one buffer, are in
    // ascending msn order.  So it's ok that we don't update the basement
    // node's msn until the end.
4320 4321 4322
    if (entry->msn.msn > bn->max_msn_applied.msn) {
        ITEMLEN keylen = entry->keylen;
        ITEMLEN vallen = entry->vallen;
4323
        enum ft_msg_type type = fifo_entry_get_msg_type(entry);
4324 4325 4326
        MSN msn = entry->msn;
        const XIDS xids = (XIDS) &entry->xids_s;
        bytevec key = xids_get_end_of_array(xids);
Yoni Fogel's avatar
Yoni Fogel committed
4327
        bytevec val = (uint8_t*)key + entry->keylen;
4328 4329 4330 4331

        DBT hk;
        toku_fill_dbt(&hk, key, keylen);
        DBT hv;
4332
        FT_MSG_S ftcmd = { type, msn, xids, .u = { .id = { &hk, toku_fill_dbt(&hv, val, vallen) } } };
4333
        toku_ft_bn_apply_cmd(
4334 4335 4336
            t->ft->compare_fun,
            t->ft->update_fun,
            &t->ft->cmp_descriptor,
4337
            bn,
4338
            &ftcmd,
4339 4340
            oldest_referenced_xid,
            make_gc_info(true), //mvcc is needed
4341
            workdone,
4342 4343
            stats_to_update
            );
4344
    } else {
4345
        STATUS_INC(FT_MSN_DISCARDS, 1);
4346
    }
4347 4348 4349 4350 4351
    // We must always mark entry as stale since it has been marked
    // (using omt::iterate_and_mark_range)
    // It is possible to call do_bn_apply_cmd even when it won't apply the message because
    // the node containing it could have been evicted and brought back in.
    entry->is_fresh = false;
4352 4353
}

4354
struct iterate_do_bn_apply_cmd_extra {
4355
    FT_HANDLE t;
4356
    BASEMENTNODE bn;
4357
    NONLEAF_CHILDINFO bnc;
4358
    TXNID oldest_referenced_xid;
4359
    uint64_t *workdone;
4360
    STAT64INFO stats_to_update;
4361 4362
};

4363 4364
int iterate_do_bn_apply_cmd(const int32_t &offset, const uint32_t UU(idx), struct iterate_do_bn_apply_cmd_extra *const e) __attribute__((nonnull(3)));
int iterate_do_bn_apply_cmd(const int32_t &offset, const uint32_t UU(idx), struct iterate_do_bn_apply_cmd_extra *const e)
4365
{
4366
    struct fifo_entry *entry = toku_fifo_get_entry(e->bnc->buffer, offset);
4367
    do_bn_apply_cmd(e->t, e->bn, entry, e->oldest_referenced_xid, e->workdone, e->stats_to_update);
4368 4369 4370
    return 0;
}

4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385
/**
 * Given the bounds of the basement node to which we will apply messages,
 * find the indexes within message_tree which contain the range of
 * relevant messages.
 *
 * The message tree contains offsets into the buffer, where messages are
 * found.  The pivot_bounds are the lower bound exclusive and upper bound
 * inclusive, because they come from pivot keys in the tree.  We want OMT
 * indices, which must have the lower bound be inclusive and the upper
 * bound exclusive.  We will get these by telling toku_omt_find to look
 * for something strictly bigger than each of our pivot bounds.
 *
 * Outputs the OMT indices in lbi (lower bound inclusive) and ube (upper
 * bound exclusive).
 */
4386
template<typename find_bounds_omt_t>
4387
static void
4388 4389
find_bounds_within_message_tree(
    DESCRIPTOR desc,       /// used for cmp
4390
    ft_compare_func cmp,  /// used to compare keys
4391
    const find_bounds_omt_t &message_tree,      /// tree holding FIFO offsets, in which we want to look for indices
4392 4393
    FIFO buffer,           /// buffer in which messages are found
    struct pivot_bounds const * const bounds,  /// key bounds within the basement node we're applying messages to
4394 4395
    uint32_t *lbi,        /// (output) "lower bound inclusive" (index into message_tree)
    uint32_t *ube         /// (output) "upper bound exclusive" (index into message_tree)
4396 4397 4398
    )
{
    int r = 0;
4399 4400

    if (bounds->lower_bound_exclusive) {
4401 4402 4403 4404 4405
        // By setting msn to MAX_MSN and by using direction of +1, we will
        // get the first message greater than (in (key, msn) order) any
        // message (with any msn) with the key lower_bound_exclusive.
        // This will be a message we want to try applying, so it is the
        // "lower bound inclusive" within the message_tree.
4406 4407 4408 4409 4410 4411 4412 4413 4414
        struct toku_fifo_entry_key_msn_heaviside_extra lbi_extra;
        ZERO_STRUCT(lbi_extra);
        lbi_extra.desc = desc;
        lbi_extra.cmp = cmp;
        lbi_extra.fifo = buffer;
        lbi_extra.key = bounds->lower_bound_exclusive;
        lbi_extra.msn = MAX_MSN;
        int32_t found_lb;
        r = message_tree.template find<struct toku_fifo_entry_key_msn_heaviside_extra, toku_fifo_entry_key_msn_heaviside>(lbi_extra, +1, &found_lb, lbi);
4415
        if (r == DB_NOTFOUND) {
4416 4417 4418
            // There is no relevant data (the lower bound is bigger than
            // any message in this tree), so we have no range and we're
            // done.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4419 4420
            *lbi = 0;
            *ube = 0;
4421
            return;
4422 4423
        }
        if (bounds->upper_bound_inclusive) {
4424
            // Check if what we found for lbi is greater than the upper
4425 4426
            // bound inclusive that we have.  If so, there are no relevant
            // messages between these bounds.
4427
            const DBT *ubi = bounds->upper_bound_inclusive;
4428
            const int32_t offset = found_lb;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4429 4430
            DBT found_lbidbt;
            fill_dbt_for_fifo_entry(&found_lbidbt, toku_fifo_get_entry(buffer, offset));
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4431
            FAKE_DB(db, desc);
4432
            int c = cmp(&db, &found_lbidbt, ubi);
4433 4434 4435 4436 4437
            // These DBTs really are both inclusive bounds, so we need
            // strict inequality in order to determine that there's
            // nothing between them.  If they're equal, then we actually
            // need to apply the message pointed to by lbi, and also
            // anything with the same key but a bigger msn.
4438
            if (c > 0) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4439 4440
                *lbi = 0;
                *ube = 0;
4441
                return;
4442 4443
            }
        }
4444
    } else {
4445 4446
        // No lower bound given, it's negative infinity, so we start at
        // the first message in the OMT.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4447
        *lbi = 0;
4448 4449
    }
    if (bounds->upper_bound_inclusive) {
4450 4451 4452 4453
        // Again, we use an msn of MAX_MSN and a direction of +1 to get
        // the first thing bigger than the upper_bound_inclusive key.
        // This is therefore the smallest thing we don't want to apply,
        // and toku_omt_iterate_on_range will not examine it.
4454 4455 4456 4457 4458 4459 4460 4461
        struct toku_fifo_entry_key_msn_heaviside_extra ube_extra;
        ZERO_STRUCT(ube_extra);
        ube_extra.desc = desc;
        ube_extra.cmp = cmp;
        ube_extra.fifo = buffer;
        ube_extra.key = bounds->upper_bound_inclusive;
        ube_extra.msn = MAX_MSN;
        r = message_tree.template find<struct toku_fifo_entry_key_msn_heaviside_extra, toku_fifo_entry_key_msn_heaviside>(ube_extra, +1, nullptr, ube);
4462
        if (r == DB_NOTFOUND) {
4463 4464 4465
            // Couldn't find anything in the buffer bigger than our key,
            // so we need to look at everything up to the end of
            // message_tree.
4466
            *ube = message_tree.size();
4467
        }
4468
    } else {
4469 4470
        // No upper bound given, it's positive infinity, so we need to go
        // through the end of the OMT.
4471
        *ube = message_tree.size();
4472 4473 4474
    }
}

4475 4476 4477 4478 4479 4480 4481
/**
 * For each message in the ancestor's buffer (determined by childnum) that
 * is key-wise between lower_bound_exclusive and upper_bound_inclusive,
 * apply the message to the basement node.  We treat the bounds as minus
 * or plus infinity respectively if they are NULL.  Do not mark the node
 * as dirty (preserve previous state of 'dirty' bit).
 */
4482
static void
4483
bnc_apply_messages_to_basement_node(
4484
    FT_HANDLE t,             // used for comparison function
4485
    BASEMENTNODE bn,   // where to apply messages
4486
    FTNODE ancestor,  // the ancestor node where we can find messages to apply
4487
    int childnum,      // which child buffer of ancestor contains messages we want
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4488
    struct pivot_bounds const * const bounds,  // contains pivot key bounds of this basement node
4489
    TXNID oldest_referenced_xid, // may be younger than what's in ancestor, we should grab the value from the highest node we have
Yoni Fogel's avatar
Yoni Fogel committed
4490
    bool* msgs_applied
4491 4492 4493 4494
    )
{
    int r;
    NONLEAF_CHILDINFO bnc = BNC(ancestor, childnum);
4495

4496 4497
    // Determine the offsets in the message trees between which we need to
    // apply messages from this buffer
4498
    STAT64INFO_S stats_delta = {0,0};
4499 4500
    uint64_t workdone_this_ancestor = 0;

4501
    uint32_t stale_lbi, stale_ube;
4502
    if (!bn->stale_ancestor_messages_applied) {
4503
        find_bounds_within_message_tree(&t->ft->cmp_descriptor, t->ft->compare_fun, bnc->stale_message_tree, bnc->buffer, bounds, &stale_lbi, &stale_ube);
4504
    } else {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4505 4506
        stale_lbi = 0;
        stale_ube = 0;
4507
    }
Yoni Fogel's avatar
Yoni Fogel committed
4508
    uint32_t fresh_lbi, fresh_ube;
4509
    find_bounds_within_message_tree(&t->ft->cmp_descriptor, t->ft->compare_fun, bnc->fresh_message_tree, bnc->buffer, bounds, &fresh_lbi, &fresh_ube);
4510

4511 4512
    // We now know where all the messages we must apply are, so one of the
    // following 4 cases will do the application, depending on which of
4513 4514
    // the lists contains relevant messages:
    //
4515
    // 1. broadcast messages and anything else, or a mix of fresh and stale
4516 4517
    // 2. only fresh messages
    // 3. only stale messages
4518 4519 4520
    if (bnc->broadcast_list.size() > 0 ||
        (stale_lbi != stale_ube && fresh_lbi != fresh_ube)) {
        // We have messages in multiple trees, so we grab all
4521 4522
        // the relevant messages' offsets and sort them by MSN, then apply
        // them in MSN order.
4523
        const int buffer_size = ((stale_ube - stale_lbi) + (fresh_ube - fresh_lbi) + bnc->broadcast_list.size());
4524 4525
        toku::scoped_malloc offsets_buf(buffer_size * sizeof(int32_t));
        int32_t *offsets = reinterpret_cast<int32_t *>(offsets_buf.get());
4526
        struct store_fifo_offset_extra sfo_extra = { .offsets = offsets, .i = 0 };
4527

4528
        // Populate offsets array with offsets to stale messages
4529
        r = bnc->stale_message_tree.iterate_on_range<struct store_fifo_offset_extra, store_fifo_offset>(stale_lbi, stale_ube, &sfo_extra);
4530
        assert_zero(r);
4531

4532 4533
        // Then store fresh offsets, and mark them to be moved to stale later.
        r = bnc->fresh_message_tree.iterate_and_mark_range<struct store_fifo_offset_extra, store_fifo_offset>(fresh_lbi, fresh_ube, &sfo_extra);
4534 4535
        assert_zero(r);

4536
        // Store offsets of all broadcast messages.
4537
        r = bnc->broadcast_list.iterate<struct store_fifo_offset_extra, store_fifo_offset>(&sfo_extra);
4538
        assert_zero(r);
4539
        invariant(sfo_extra.i == buffer_size);
4540 4541

        // Sort by MSN.
4542
        r = toku::sort<int32_t, FIFO, fifo_offset_msn_cmp>::mergesort_r(offsets, buffer_size, bnc->buffer);
4543 4544
        assert_zero(r);

4545
        // Apply the messages in MSN order.
4546
        for (int i = 0; i < buffer_size; ++i) {
Yoni Fogel's avatar
Yoni Fogel committed
4547
            *msgs_applied = true;
4548
            struct fifo_entry *entry = toku_fifo_get_entry(bnc->buffer, offsets[i]);
4549
            do_bn_apply_cmd(t, bn, entry, oldest_referenced_xid, &workdone_this_ancestor, &stats_delta);
4550
        }
4551
    } else if (stale_lbi == stale_ube) {
4552
        // No stale messages to apply, we just apply fresh messages, and mark them to be moved to stale later.
4553
        struct iterate_do_bn_apply_cmd_extra iter_extra = { .t = t, .bn = bn, .bnc = bnc, .oldest_referenced_xid = oldest_referenced_xid, .workdone = &workdone_this_ancestor, .stats_to_update = &stats_delta };
Yoni Fogel's avatar
Yoni Fogel committed
4554
        if (fresh_ube - fresh_lbi > 0) *msgs_applied = true;
4555
        r = bnc->fresh_message_tree.iterate_and_mark_range<struct iterate_do_bn_apply_cmd_extra, iterate_do_bn_apply_cmd>(fresh_lbi, fresh_ube, &iter_extra);
4556
        assert_zero(r);
4557 4558
    } else {
        invariant(fresh_lbi == fresh_ube);
4559 4560
        // No fresh messages to apply, we just apply stale messages.

Yoni Fogel's avatar
Yoni Fogel committed
4561
        if (stale_ube - stale_lbi > 0) *msgs_applied = true;
4562
        struct iterate_do_bn_apply_cmd_extra iter_extra = { .t = t, .bn = bn, .bnc = bnc, .oldest_referenced_xid = oldest_referenced_xid, .workdone = &workdone_this_ancestor, .stats_to_update = &stats_delta };
4563

4564
        r = bnc->stale_message_tree.iterate_on_range<struct iterate_do_bn_apply_cmd_extra, iterate_do_bn_apply_cmd>(stale_lbi, stale_ube, &iter_extra);
4565
        assert_zero(r);
4566
    }
4567 4568 4569
    //
    // update stats
    //
4570 4571 4572
    if (workdone_this_ancestor > 0) {
        (void) toku_sync_fetch_and_add(&BP_WORKDONE(ancestor, childnum), workdone_this_ancestor);
    }
4573
    if (stats_delta.numbytes || stats_delta.numrows) {
4574
        toku_ft_update_stats(&t->ft->in_memory_stats, stats_delta);
4575
    }
4576 4577
}

4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615
static void
apply_ancestors_messages_to_bn(
    FT_HANDLE t,
    FTNODE node,
    int childnum,
    ANCESTORS ancestors,
    struct pivot_bounds const * const bounds, 
    TXNID oldest_referenced_xid,
    bool* msgs_applied
    )
{
    BASEMENTNODE curr_bn = BLB(node, childnum);
    struct pivot_bounds curr_bounds = next_pivot_keys(node, childnum, bounds);
    for (ANCESTORS curr_ancestors = ancestors; curr_ancestors; curr_ancestors = curr_ancestors->next) {
        if (curr_ancestors->node->max_msn_applied_to_node_on_disk.msn > curr_bn->max_msn_applied.msn) {
            paranoid_invariant(BP_STATE(curr_ancestors->node, curr_ancestors->childnum) == PT_AVAIL);
            bnc_apply_messages_to_basement_node(
                t,
                curr_bn,
                curr_ancestors->node,
                curr_ancestors->childnum,
                &curr_bounds,
                oldest_referenced_xid,
                msgs_applied
                );
            // We don't want to check this ancestor node again if the
            // next time we query it, the msn hasn't changed.
            curr_bn->max_msn_applied = curr_ancestors->node->max_msn_applied_to_node_on_disk;
        }
    }
    // At this point, we know all the stale messages above this
    // basement node have been applied, and any new messages will be
    // fresh, so we don't need to look at stale messages for this
    // basement node, unless it gets evicted (and this field becomes
    // false when it's read in again).
    curr_bn->stale_ancestor_messages_applied = true;
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
4616
void
4617 4618 4619 4620 4621 4622 4623 4624
toku_apply_ancestors_messages_to_node (
    FT_HANDLE t, 
    FTNODE node, 
    ANCESTORS ancestors, 
    struct pivot_bounds const * const bounds, 
    bool* msgs_applied, 
    int child_to_read
    )
4625
// Effect:
4626
//   Bring a leaf node up-to-date according to all the messages in the ancestors.
4627
//   If the leaf node is already up-to-date then do nothing.
4628 4629 4630 4631 4632
//   If the leaf node is not already up-to-date, then record the work done
//   for that leaf in each ancestor.
// Requires:
//   This is being called when pinning a leaf node for the query path.
//   The entire root-to-leaf path is pinned and appears in the ancestors list.
4633 4634
{
    VERIFY_NODE(t, node);
4635
    paranoid_invariant(node->height == 0);
4636

4637
    TXNID oldest_referenced_xid = ancestors->node->oldest_referenced_xid_known;
4638
    for (ANCESTORS curr_ancestors = ancestors; curr_ancestors; curr_ancestors = curr_ancestors->next) {
4639 4640
        if (curr_ancestors->node->oldest_referenced_xid_known > oldest_referenced_xid) {
            oldest_referenced_xid = curr_ancestors->node->oldest_referenced_xid_known;
4641 4642 4643
        }
    }

4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
    if (!node->dirty && child_to_read >= 0) {
        paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
        apply_ancestors_messages_to_bn(
            t,
            node,
            child_to_read,
            ancestors,
            bounds,
            oldest_referenced_xid,
            msgs_applied
            );
    }
    else {
        // know we are a leaf node
        // An important invariant:
        // We MUST bring every available basement node for a dirty node up to date.
        // flushing on the cleaner thread depends on this. This invariant
        // allows the cleaner thread to just pick an internal node and flush it
        // as opposed to being forced to start from the root.
        for (int i = 0; i < node->n_children; i++) {
            if (BP_STATE(node, i) != PT_AVAIL) { continue; }
            apply_ancestors_messages_to_bn(
                t,
                node,
                i,
                ancestors,
                bounds,
                oldest_referenced_xid,
                msgs_applied
                );
4674
        }
4675 4676
    }
    VERIFY_NODE(t, node);
4677 4678
}

4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741
static bool bn_needs_ancestors_messages(
    FT ft,
    FTNODE node,
    int childnum,
    struct pivot_bounds const * const bounds,
    ANCESTORS ancestors, 
    MSN* max_msn_applied
    ) 
{
    BASEMENTNODE bn = BLB(node, childnum);
    struct pivot_bounds curr_bounds = next_pivot_keys(node, childnum, bounds);
    bool needs_ancestors_messages = false;
    for (ANCESTORS curr_ancestors = ancestors; curr_ancestors; curr_ancestors = curr_ancestors->next) {
        if (curr_ancestors->node->max_msn_applied_to_node_on_disk.msn > bn->max_msn_applied.msn) {
            paranoid_invariant(BP_STATE(curr_ancestors->node, curr_ancestors->childnum) == PT_AVAIL);
            NONLEAF_CHILDINFO bnc = BNC(curr_ancestors->node, curr_ancestors->childnum);
            if (bnc->broadcast_list.size() > 0) {
                needs_ancestors_messages = true;
                goto cleanup;
            }
            if (!bn->stale_ancestor_messages_applied) {
                uint32_t stale_lbi, stale_ube;
                find_bounds_within_message_tree(&ft->cmp_descriptor,
                                                ft->compare_fun,
                                                bnc->stale_message_tree,
                                                bnc->buffer,
                                                &curr_bounds,
                                                &stale_lbi,
                                                &stale_ube);
                if (stale_lbi < stale_ube) {
                    needs_ancestors_messages = true;
                    goto cleanup;
                }
            }
            uint32_t fresh_lbi, fresh_ube;
            find_bounds_within_message_tree(&ft->cmp_descriptor,
                                            ft->compare_fun,
                                            bnc->fresh_message_tree,
                                            bnc->buffer,
                                            &curr_bounds,
                                            &fresh_lbi,
                                            &fresh_ube);
            if (fresh_lbi < fresh_ube) {
                needs_ancestors_messages = true;
                goto cleanup;
            }
            if (curr_ancestors->node->max_msn_applied_to_node_on_disk.msn > max_msn_applied->msn) {
                max_msn_applied->msn = curr_ancestors->node->max_msn_applied_to_node_on_disk.msn;
            }
        }
    }
cleanup:
    return needs_ancestors_messages;
}

bool toku_ft_leaf_needs_ancestors_messages(
    FT ft, 
    FTNODE node, 
    ANCESTORS ancestors, 
    struct pivot_bounds const * const bounds, 
    MSN *const max_msn_in_path, 
    int child_to_read
    )
Leif Walsh's avatar
Leif Walsh committed
4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759
// Effect: Determine whether there are messages in a node's ancestors
//  which must be applied to it.  These messages are in the correct
//  keyrange for any available basement nodes, and are in nodes with the
//  correct max_msn_applied_to_node_on_disk.
// Notes:
//  This is an approximate query.
// Output:
//  max_msn_in_path: max of "max_msn_applied_to_node_on_disk" over
//    ancestors.  This is used later to update basement nodes'
//    max_msn_applied values in case we don't do the full algorithm.
// Returns:
//  true if there may be some such messages
//  false only if there are definitely no such messages
// Rationale:
//  When we pin a node with a read lock, we want to quickly determine if
//  we should exchange it for a write lock in preparation for applying
//  messages.  If there are no messages, we don't need the write lock.
{
4760
    paranoid_invariant(node->height == 0);
Leif Walsh's avatar
Leif Walsh committed
4761
    bool needs_ancestors_messages = false;
4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786
    // child_to_read may be -1 in test cases
    if (!node->dirty && child_to_read >= 0) {
        paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
        needs_ancestors_messages = bn_needs_ancestors_messages(
            ft,
            node,
            child_to_read,
            bounds,
            ancestors,
            max_msn_in_path
            );
    }
    else {
        for (int i = 0; i < node->n_children; ++i) {
            if (BP_STATE(node, i) != PT_AVAIL) { continue; }
            needs_ancestors_messages = bn_needs_ancestors_messages(
                ft,
                node,
                i,
                bounds,
                ancestors,
                max_msn_in_path
                );
            if (needs_ancestors_messages) {
                goto cleanup;
Leif Walsh's avatar
Leif Walsh committed
4787 4788 4789 4790 4791 4792 4793
            }
        }
    }
cleanup:
    return needs_ancestors_messages;
}

4794
void toku_ft_bn_update_max_msn(FTNODE node, MSN max_msn_applied, int child_to_read) {
Leif Walsh's avatar
Leif Walsh committed
4795
    invariant(node->height == 0);
4796 4797 4798
    if (!node->dirty && child_to_read >= 0) {
        paranoid_invariant(BP_STATE(node, child_to_read) == PT_AVAIL);
        BASEMENTNODE bn = BLB(node, child_to_read);
Leif Walsh's avatar
Leif Walsh committed
4799
        if (max_msn_applied.msn > bn->max_msn_applied.msn) {
4800
            // see comment below
4801
            (void) toku_sync_val_compare_and_swap(&bn->max_msn_applied.msn, bn->max_msn_applied.msn, max_msn_applied.msn);
Leif Walsh's avatar
Leif Walsh committed
4802 4803
        }
    }
4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817
    else {
        for (int i = 0; i < node->n_children; ++i) {
            if (BP_STATE(node, i) != PT_AVAIL) { continue; }
            BASEMENTNODE bn = BLB(node, i);
            if (max_msn_applied.msn > bn->max_msn_applied.msn) {
                // This function runs in a shared access context, so to silence tools
                // like DRD, we use a CAS and ignore the result.
                // Any threads trying to update these basement nodes should be
                // updating them to the same thing (since they all have a read lock on
                // the same root-to-leaf path) so this is safe.
                (void) toku_sync_val_compare_and_swap(&bn->max_msn_applied.msn, bn->max_msn_applied.msn, max_msn_applied.msn);
            }
        }
    }
Leif Walsh's avatar
Leif Walsh committed
4818 4819
}

4820 4821 4822 4823 4824
struct copy_to_stale_extra {
    FT ft;
    NONLEAF_CHILDINFO bnc;
};

4825 4826
int copy_to_stale(const int32_t &offset, const uint32_t UU(idx), struct copy_to_stale_extra *const extra) __attribute__((nonnull(3)));
int copy_to_stale(const int32_t &offset, const uint32_t UU(idx), struct copy_to_stale_extra *const extra)
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855
{
    struct fifo_entry *entry = toku_fifo_get_entry(extra->bnc->buffer, offset);
    DBT keydbt;
    DBT *key = fill_dbt_for_fifo_entry(&keydbt, entry);
    struct toku_fifo_entry_key_msn_heaviside_extra heaviside_extra = { .desc = &extra->ft->cmp_descriptor, .cmp = extra->ft->compare_fun, .fifo = extra->bnc->buffer, .key = key, .msn = entry->msn };
    int r = extra->bnc->stale_message_tree.insert<struct toku_fifo_entry_key_msn_heaviside_extra, toku_fifo_entry_key_msn_heaviside>(offset, heaviside_extra, nullptr);
    invariant_zero(r);
    return 0;
}

__attribute__((nonnull))
void
toku_move_ftnode_messages_to_stale(FT ft, FTNODE node) {
    invariant(node->height > 0);
    for (int i = 0; i < node->n_children; ++i) {
        if (BP_STATE(node, i) != PT_AVAIL) {
            continue;
        }
        NONLEAF_CHILDINFO bnc = BNC(node, i);
        // We can't delete things out of the fresh tree inside the above
        // procedures because we're still looking at the fresh tree.  Instead
        // we have to move messages after we're done looking at it.
        struct copy_to_stale_extra cts_extra = { .ft = ft, .bnc = bnc };
        int r = bnc->fresh_message_tree.iterate_over_marked<struct copy_to_stale_extra, copy_to_stale>(&cts_extra);
        invariant_zero(r);
        bnc->fresh_message_tree.delete_all_marked();
    }
}

4856 4857 4858 4859 4860 4861
static int cursor_check_restricted_range(FT_CURSOR c, bytevec key, ITEMLEN keylen) {
    if (c->out_of_range_error) {
        FT ft = c->ft_handle->ft;
        FAKE_DB(db, &ft->cmp_descriptor);
        DBT found_key;
        toku_fill_dbt(&found_key, key, keylen);
4862 4863
        if ((!c->left_is_neg_infty && c->direction <= 0 && ft->compare_fun(&db, &found_key, &c->range_lock_left_key) < 0) ||
            (!c->right_is_pos_infty && c->direction >= 0 && ft->compare_fun(&db, &found_key, &c->range_lock_right_key) > 0)) {
4864 4865 4866 4867
            invariant(c->out_of_range_error);
            return c->out_of_range_error;
        }
    }
4868 4869 4870
    // Reset cursor direction to mitigate risk if some query type doesn't set the direction.
    // It is always correct to check both bounds (which happens when direction==0) but it can be slower.
    c->direction = 0;
4871 4872 4873
    return 0;
}

4874
static int
4875 4876
ft_cursor_shortcut (
    FT_CURSOR cursor,
4877
    int direction,
4878 4879
    uint32_t index,
    bn_data* bd,
4880
    FT_GET_CALLBACK_FUNCTION getf,
4881
    void *getf_v,
Yoni Fogel's avatar
Yoni Fogel committed
4882
    uint32_t *keylen,
4883
    void **key,
Yoni Fogel's avatar
Yoni Fogel committed
4884
    uint32_t *vallen,
4885 4886 4887
    void **val
    );

4888 4889
// This is a bottom layer of the search functions.
static int
4890
ft_search_basement_node(
4891
    BASEMENTNODE bn,
4892 4893
    ft_search_t *search,
    FT_GET_CALLBACK_FUNCTION getf,
4894
    void *getf_v,
Yoni Fogel's avatar
Yoni Fogel committed
4895
    bool *doprefetch,
4896
    FT_CURSOR ftcursor,
Yoni Fogel's avatar
Yoni Fogel committed
4897
    bool can_bulk_fetch
4898
    )
4899
{
4900
    // Now we have to convert from ft_search_t to the heaviside function with a direction.  What a pain...
4901

4902 4903
    int direction;
    switch (search->direction) {
4904 4905
    case FT_SEARCH_LEFT:   direction = +1; goto ok;
    case FT_SEARCH_RIGHT:  direction = -1; goto ok;
4906 4907
    }
    return EINVAL;  // This return and the goto are a hack to get both compile-time and run-time checking on enum
4908
ok: ;
Yoni Fogel's avatar
Yoni Fogel committed
4909
    uint32_t idx = 0;
4910 4911 4912 4913 4914 4915 4916 4917 4918 4919 4920
    LEAFENTRY le;
    uint32_t keylen;
    void *key;
    int r = bn->data_buffer.find<decltype(*search), heaviside_from_search_t>(
        *search, 
        direction, 
        &le, 
        &key, 
        &keylen, 
        &idx
        );
4921 4922
    if (r!=0) return r;

4923
    if (toku_ft_cursor_is_leaf_mode(ftcursor))
4924
        goto got_a_good_value;        // leaf mode cursors see all leaf entries
4925
    if (is_le_val_del(le,ftcursor)) {
4926 4927 4928 4929
        // Provisionally deleted stuff is gone.
        // So we need to scan in the direction to see if we can find something
        while (1) {
            switch (search->direction) {
4930
            case FT_SEARCH_LEFT:
4931
                idx++;
4932
                if (idx >= bn->data_buffer.num_klpairs()) {
4933 4934 4935
                    if (ftcursor->interrupt_cb && ftcursor->interrupt_cb(ftcursor->interrupt_cb_extra)) {
                        return TOKUDB_INTERRUPTED;
                    }
4936
                    return DB_NOTFOUND;
4937
                }
4938
                break;
4939
            case FT_SEARCH_RIGHT:
4940 4941 4942 4943
                if (idx == 0) {
                    if (ftcursor->interrupt_cb && ftcursor->interrupt_cb(ftcursor->interrupt_cb_extra)) {
                        return TOKUDB_INTERRUPTED;
                    }
4944
                    return DB_NOTFOUND;
4945
                }
4946 4947 4948
                idx--;
                break;
            default:
4949
                abort();
4950
            }
4951
            r = bn->data_buffer.fetch_klpair(idx, &le, &keylen, &key);
4952
            assert_zero(r); // we just validated the index
4953
            if (!is_le_val_del(le,ftcursor)) goto got_a_good_value;
4954
        }
4955 4956
    }
got_a_good_value:
4957
    {
Yoni Fogel's avatar
Yoni Fogel committed
4958
        uint32_t vallen;
4959 4960
        void *val;

4961 4962 4963 4964 4965
        ft_cursor_extract_val(le,
                              ftcursor,
                              &vallen,
                              &val
                              );
4966 4967 4968 4969
        r = cursor_check_restricted_range(ftcursor, key, keylen);
        if (r==0) {
            r = getf(keylen, key, vallen, val, getf_v, false);
        }
4970
        if (r==0 || r == TOKUDB_CURSOR_CONTINUE) {
4971 4972 4973 4974 4975
            // 
            // IMPORTANT: bulk fetch CANNOT go past the current basement node,
            // because there is no guarantee that messages have been applied
            // to other basement nodes, as part of #5770
            //
4976
            if (r == TOKUDB_CURSOR_CONTINUE && can_bulk_fetch) {
4977 4978
                r = ft_cursor_shortcut(
                    ftcursor,
4979
                    direction,
4980 4981
                    idx,
                    &bn->data_buffer,
4982 4983 4984 4985 4986 4987 4988 4989 4990
                    getf,
                    getf_v,
                    &keylen,
                    &key,
                    &vallen,
                    &val
                    );
            }

4991 4992
            ft_cursor_cleanup_dbts(ftcursor);
            if (!ftcursor->is_temporary) {
4993 4994
                toku_memdup_dbt(&ftcursor->key, key, keylen);
                toku_memdup_dbt(&ftcursor->val, val, vallen);
4995
            }
4996
            //The search was successful.  Prefetching can continue.
Yoni Fogel's avatar
Yoni Fogel committed
4997
            *doprefetch = true;
4998
        }
4999
    }
5000
    if (r == TOKUDB_CURSOR_CONTINUE) r = 0;
5001
    return r;
5002 5003 5004
}

static int
5005 5006 5007 5008
ft_search_node (
    FT_HANDLE brt,
    FTNODE node,
    ft_search_t *search,
5009
    int child_to_search,
5010
    FT_GET_CALLBACK_FUNCTION getf,
5011
    void *getf_v,
Yoni Fogel's avatar
Yoni Fogel committed
5012
    bool *doprefetch,
5013
    FT_CURSOR ftcursor,
5014 5015
    UNLOCKERS unlockers,
    ANCESTORS,
5016
    struct pivot_bounds const * const bounds,
Yoni Fogel's avatar
Yoni Fogel committed
5017
    bool can_bulk_fetch
5018
    );
5019

5020
static int
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5021
ftnode_fetch_callback_and_free_bfe(CACHEFILE cf, PAIR p, int fd, BLOCKNUM nodename, uint32_t fullhash, void **ftnode_pv, void** UU(disk_data), PAIR_ATTR *sizep, int *dirtyp, void *extraargs)
5022
{
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5023
    int r = toku_ftnode_fetch_callback(cf, p, fd, nodename, fullhash, ftnode_pv, disk_data, sizep, dirtyp, extraargs);
5024
    struct ftnode_fetch_extra *CAST_FROM_VOIDP(ffe, extraargs);
5025 5026
    destroy_bfe_for_prefetch(ffe);
    toku_free(ffe);
5027 5028 5029 5030
    return r;
}

static int
5031
ftnode_pf_callback_and_free_bfe(void *ftnode_pv, void* disk_data, void *read_extraargs, int fd, PAIR_ATTR *sizep)
5032
{
5033
    int r = toku_ftnode_pf_callback(ftnode_pv, disk_data, read_extraargs, fd, sizep);
5034
    struct ftnode_fetch_extra *CAST_FROM_VOIDP(ffe, read_extraargs);
5035 5036
    destroy_bfe_for_prefetch(ffe);
    toku_free(ffe);
5037 5038 5039
    return r;
}

5040
static void
Yoni Fogel's avatar
Yoni Fogel committed
5041
ft_node_maybe_prefetch(FT_HANDLE brt, FTNODE node, int childnum, FT_CURSOR ftcursor, bool *doprefetch) {
5042 5043
    // the number of nodes to prefetch
    const int num_nodes_to_prefetch = 1;
Rich Prohaska's avatar
Rich Prohaska committed
5044

5045
    // if we want to prefetch in the tree
5046
    // then prefetch the next children if there are any
5047 5048
    if (*doprefetch && ft_cursor_prefetching(ftcursor) && !ftcursor->disable_prefetching) {
        int rc = ft_cursor_rightmost_child_wanted(ftcursor, brt, node);
5049
        for (int i = childnum + 1; (i <= childnum + num_nodes_to_prefetch) && (i <= rc); i++) {
5050
            BLOCKNUM nextchildblocknum = BP_BLOCKNUM(node, i);
Yoni Fogel's avatar
Yoni Fogel committed
5051
            uint32_t nextfullhash = compute_child_fullhash(brt->ft->cf, node, i);
5052
            struct ftnode_fetch_extra *MALLOC(bfe);
5053
            fill_bfe_for_prefetch(bfe, brt->ft, ftcursor);
Yoni Fogel's avatar
Yoni Fogel committed
5054
            bool doing_prefetch = false;
5055
            toku_cachefile_prefetch(
5056
                brt->ft->cf,
5057 5058
                nextchildblocknum,
                nextfullhash,
5059
                get_write_callbacks_for_node(brt->ft),
5060 5061 5062
                ftnode_fetch_callback_and_free_bfe,
                toku_ftnode_pf_req_callback,
                ftnode_pf_callback_and_free_bfe,
5063 5064 5065 5066 5067 5068 5069
                bfe,
                &doing_prefetch
                );
            if (!doing_prefetch) {
                destroy_bfe_for_prefetch(bfe);
                toku_free(bfe);
            }
Yoni Fogel's avatar
Yoni Fogel committed
5070
            *doprefetch = false;
5071
        }
5072 5073 5074
    }
}

5075 5076 5077
struct unlock_ftnode_extra {
    FT_HANDLE ft_handle;
    FTNODE node;
Yoni Fogel's avatar
Yoni Fogel committed
5078
    bool msgs_applied;
5079 5080 5081
};
// When this is called, the cachetable lock is held
static void
5082
unlock_ftnode_fun (void *v) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5083 5084
    struct unlock_ftnode_extra *x = NULL;
    CAST_FROM_VOIDP(x, v);
5085 5086
    FT_HANDLE brt = x->ft_handle;
    FTNODE node = x->node;
5087
    // CT lock is held
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5088
    int r = toku_cachetable_unpin_ct_prelocked_no_flush(
5089
        brt->ft->cf,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5090
        node->ct_pair,
5091
        (enum cachetable_dirty) node->dirty,
5092
        x->msgs_applied ? make_ftnode_pair_attr(node) : make_invalid_pair_attr()
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5093
        );
5094
    assert_zero(r);
5095 5096
}

5097
/* search in a node's child */
5098
static int
Yoni Fogel's avatar
Yoni Fogel committed
5099 5100
ft_search_child(FT_HANDLE brt, FTNODE node, int childnum, ft_search_t *search, FT_GET_CALLBACK_FUNCTION getf, void *getf_v, bool *doprefetch, FT_CURSOR ftcursor, UNLOCKERS unlockers,
                 ANCESTORS ancestors, struct pivot_bounds const * const bounds, bool can_bulk_fetch)
5101
// Effect: Search in a node's child.  Searches are read-only now (at least as far as the hardcopy is concerned).
5102
{
5103
    struct ancestors next_ancestors = {node, childnum, ancestors};
5104

5105
    BLOCKNUM childblocknum = BP_BLOCKNUM(node,childnum);
Yoni Fogel's avatar
Yoni Fogel committed
5106
    uint32_t fullhash = compute_child_fullhash(brt->ft->cf, node, childnum);
5107
    FTNODE childnode = nullptr;
5108

5109 5110 5111
    // If the current node's height is greater than 1, then its child is an internal node.
    // Therefore, to warm the cache better (#5798), we want to read all the partitions off disk in one shot.
    bool read_all_partitions = node->height > 1;
5112
    struct ftnode_fetch_extra bfe;
5113
    fill_bfe_for_subset_read(
5114
        &bfe,
5115
        brt->ft,
5116
        search,
5117 5118 5119 5120
        &ftcursor->range_lock_left_key,
        &ftcursor->range_lock_right_key,
        ftcursor->left_is_neg_infty,
        ftcursor->right_is_pos_infty,
5121 5122
        ftcursor->disable_prefetching,
        read_all_partitions
5123
        );
Yoni Fogel's avatar
Yoni Fogel committed
5124
    bool msgs_applied = false;
5125
    {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5126 5127 5128 5129 5130 5131 5132 5133 5134 5135 5136 5137 5138
        int rr = toku_pin_ftnode_batched(brt, childblocknum, fullhash,
                                         unlockers,
                                         &next_ancestors, bounds,
                                         &bfe,
                                         true,
                                         &childnode,
                                         &msgs_applied);
        if (rr==TOKUDB_TRY_AGAIN) {
            return rr;
        }
        // We end the batch before applying ancestor messages if we get
        // all the way to a leaf.
        invariant_zero(rr);
5139 5140
    }

5141
    struct unlock_ftnode_extra unlock_extra   = {brt,childnode,msgs_applied};
Yoni Fogel's avatar
Yoni Fogel committed
5142
    struct unlockers next_unlockers = {true, unlock_ftnode_fun, (void*)&unlock_extra, unlockers};
5143

5144
    int r = ft_search_node(brt, childnode, search, bfe.child_to_read, getf, getf_v, doprefetch, ftcursor, &next_unlockers, &next_ancestors, bounds, can_bulk_fetch);
5145
    if (r!=TOKUDB_TRY_AGAIN) {
5146 5147
        // maybe prefetch the next child
        if (r == 0 && node->height == 1) {
5148
            ft_node_maybe_prefetch(brt, node, childnum, ftcursor, doprefetch);
5149
        }
5150

5151
        assert(next_unlockers.locked);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5152
        if (msgs_applied) {
5153
            toku_unpin_ftnode(brt->ft, childnode);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5154 5155
        }
        else {
5156
            toku_unpin_ftnode_read_only(brt->ft, childnode);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5157
        }
5158
    } else {
5159
        // try again.
5160 5161

        // there are two cases where we get TOKUDB_TRY_AGAIN
5162
        //  case 1 is when some later call to toku_pin_ftnode returned
5163
        //  that value and unpinned all the nodes anyway. case 2
5164
        //  is when ft_search_node had to stop its search because
5165 5166
        //  some piece of a node that it needed was not in memory. In this case,
        //  the node was not unpinned, so we unpin it here
5167
        if (next_unlockers.locked) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5168
            if (msgs_applied) {
5169
                toku_unpin_ftnode(brt->ft, childnode);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5170 5171
            }
            else {
5172
                toku_unpin_ftnode_read_only(brt->ft, childnode);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5173
            }
5174
        }
5175
    }
5176

5177 5178 5179
    return r;
}

5180
static inline int
5181
search_which_child_cmp_with_bound(DB *db, ft_compare_func cmp, FTNODE node, int childnum, ft_search_t *search, DBT *dbt)
5182
{
5183
    return cmp(db, toku_copy_dbt(dbt, node->childkeys[childnum]), &search->pivot_bound);
5184 5185
}

5186
int
5187
toku_ft_search_which_child(
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5188
    DESCRIPTOR desc,
5189 5190 5191
    ft_compare_func cmp,
    FTNODE node,
    ft_search_t *search
5192
    )
5193
{
5194 5195 5196 5197 5198 5199 5200 5201 5202
    if (node->n_children <= 1) return 0;

    DBT pivotkey;
    toku_init_dbt(&pivotkey);
    int lo = 0;
    int hi = node->n_children - 1;
    int mi;
    while (lo < hi) {
        mi = (lo + hi) / 2;
5203
        toku_copy_dbt(&pivotkey, node->childkeys[mi]);
5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214
        // search->compare is really strange, and only works well with a
        // linear search, it makes binary search a pita.
        //
        // if you are searching left to right, it returns
        //   "0" for pivots that are < the target, and
        //   "1" for pivots that are >= the target
        // if you are searching right to left, it's the opposite.
        //
        // so if we're searching from the left and search->compare says
        // "1", we want to go left from here, if it says "0" we want to go
        // right.  searching from the right does the opposite.
5215
        bool c = search->compare(*search, &pivotkey);
5216 5217
        if (((search->direction == FT_SEARCH_LEFT) && c) ||
            ((search->direction == FT_SEARCH_RIGHT) && !c)) {
5218 5219
            hi = mi;
        } else {
5220 5221
            assert(((search->direction == FT_SEARCH_LEFT) && !c) ||
                   ((search->direction == FT_SEARCH_RIGHT) && c));
5222 5223 5224 5225 5226
            lo = mi + 1;
        }
    }
    // ready to return something, if the pivot is bounded, we have to move
    // over a bit to get away from what we've already searched
5227
    if (search->pivot_bound.data != nullptr) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5228
        FAKE_DB(db, desc);
5229
        if (search->direction == FT_SEARCH_LEFT) {
5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248
            while (lo < node->n_children - 1 &&
                   search_which_child_cmp_with_bound(&db, cmp, node, lo, search, &pivotkey) <= 0) {
                // searching left to right, if the comparison says the
                // current pivot (lo) is left of or equal to our bound,
                // don't search that child again
                lo++;
            }
        } else {
            while (lo > 0 &&
                   search_which_child_cmp_with_bound(&db, cmp, node, lo - 1, search, &pivotkey) >= 0) {
                // searching right to left, same argument as just above
                // (but we had to pass lo - 1 because the pivot between lo
                // and the thing just less than it is at that position in
                // the childkeys array)
                lo--;
            }
        }
    }
    return lo;
5249
}
5250

5251 5252
static void
maybe_search_save_bound(
5253
    FTNODE node,
5254
    int child_searched,
5255
    ft_search_t *search)
5256
{
5257
    int p = (search->direction == FT_SEARCH_LEFT) ? child_searched : child_searched - 1;
5258
    if (p >= 0 && p < node->n_children-1) {
5259 5260
        toku_destroy_dbt(&search->pivot_bound);
        toku_clone_dbt(&search->pivot_bound, node->childkeys[p]);
5261 5262 5263 5264
    }
}

static int
5265 5266 5267 5268
ft_search_node(
    FT_HANDLE brt,
    FTNODE node,
    ft_search_t *search,
5269
    int child_to_search,
5270
    FT_GET_CALLBACK_FUNCTION getf,
5271
    void *getf_v,
Yoni Fogel's avatar
Yoni Fogel committed
5272
    bool *doprefetch,
5273
    FT_CURSOR ftcursor,
5274
    UNLOCKERS unlockers,
5275
    ANCESTORS ancestors,
5276
    struct pivot_bounds const * const bounds,
Yoni Fogel's avatar
Yoni Fogel committed
5277
    bool can_bulk_fetch
5278
    )
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5279 5280
{
    int r = 0;
5281
    // assert that we got a valid child_to_search
5282 5283
    invariant(child_to_search >= 0);
    invariant(child_to_search < node->n_children);
5284 5285 5286 5287
    //
    // At this point, we must have the necessary partition available to continue the search
    //
    assert(BP_STATE(node,child_to_search) == PT_AVAIL);
5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318
    const struct pivot_bounds next_bounds = next_pivot_keys(node, child_to_search, bounds);
    if (node->height > 0) {
        r = ft_search_child(
            brt,
            node,
            child_to_search,
            search,
            getf,
            getf_v,
            doprefetch,
            ftcursor,
            unlockers,
            ancestors,
            &next_bounds,
            can_bulk_fetch
            );
    }
    else {
        r = ft_search_basement_node(
            BLB(node, child_to_search),
            search,
            getf,
            getf_v,
            doprefetch,
            ftcursor,
            can_bulk_fetch
            );
    }
    if (r == 0) {
        return r; //Success
    }
5319

5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332 5333 5334
    if (r != DB_NOTFOUND) {
        return r; //Error (or message to quit early, such as TOKUDB_FOUND_BUT_REJECTED or TOKUDB_TRY_AGAIN)
    }
    // not really necessary, just put this here so that reading the
    // code becomes simpler. The point is at this point in the code,
    // we know that we got DB_NOTFOUND and we have to continue
    assert(r == DB_NOTFOUND);
    // we have a new pivotkey
    if (node->height == 0) {
        // when we run off the end of a basement, try to lock the range up to the pivot. solves #3529
        const DBT *pivot = nullptr;
        if (search->direction == FT_SEARCH_LEFT) {
            pivot = next_bounds.upper_bound_inclusive; // left -> right
        } else {
            pivot = next_bounds.lower_bound_exclusive; // right -> left
5335
        }
5336 5337 5338 5339
        if (pivot != nullptr) {
            int rr = getf(pivot->size, pivot->data, 0, nullptr, getf_v, true);
            if (rr != 0) {
                return rr; // lock was not granted
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5340 5341
            }
        }
5342
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5343

5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357
    // If we got a DB_NOTFOUND then we have to search the next record.        Possibly everything present is not visible.
    // This way of doing DB_NOTFOUND is a kludge, and ought to be simplified.  Something like this is needed for DB_NEXT, but
    //        for point queries, it's overkill.  If we got a DB_NOTFOUND on a point query then we should just stop looking.
    // When releasing locks on I/O we must not search the same subtree again, or we won't be guaranteed to make forward progress.
    // If we got a DB_NOTFOUND, then the pivot is too small if searching from left to right (too large if searching from right to left).
    // So save the pivot key in the search object.
    maybe_search_save_bound(node, child_to_search, search);
    // as part of #5770, if we can continue searching,
    // we MUST return TOKUDB_TRY_AGAIN,
    // because there is no guarantee that messages have been applied
    // on any other path.
    if ((search->direction == FT_SEARCH_LEFT && child_to_search < node->n_children-1) ||
        (search->direction == FT_SEARCH_RIGHT && child_to_search > 0)) {
        r = TOKUDB_TRY_AGAIN;
5358
    }
5359

5360
    return r;
5361 5362 5363
}

static int
Yoni Fogel's avatar
Yoni Fogel committed
5364
toku_ft_search (FT_HANDLE brt, ft_search_t *search, FT_GET_CALLBACK_FUNCTION getf, void *getf_v, FT_CURSOR ftcursor, bool can_bulk_fetch)
5365 5366 5367
// Effect: Perform a search.  Associate cursor with a leaf if possible.
// All searches are performed through this function.
{
5368
    int r;
5369
    uint trycount = 0;     // How many tries did it take to get the result?
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5370
    FT ft = brt->ft;
5371

5372 5373
    toku::context search_ctx(CTX_SEARCH);

Zardosht Kasheff's avatar
Zardosht Kasheff committed
5374
try_again:
5375

5376
    trycount++;
5377

Zardosht Kasheff's avatar
Zardosht Kasheff committed
5378 5379 5380 5381 5382 5383 5384 5385 5386 5387
    //
    // Here is how searches work
    // At a high level, we descend down the tree, using the search parameter
    // to guide us towards where to look. But the search parameter is not
    // used here to determine which child of a node to read (regardless
    // of whether that child is another node or a basement node)
    // The search parameter is used while we are pinning the node into
    // memory, because that is when the system needs to ensure that
    // the appropriate partition of the child we are using is in memory.
    // So, here are the steps for a search (and this applies to this function
5388 5389 5390
    // as well as ft_search_child:
    //  - Take the search parameter, and create a ftnode_fetch_extra, that will be used by toku_pin_ftnode(_holding_lock)
    //  - Call toku_pin_ftnode(_holding_lock) with the bfe as the extra for the fetch callback (in case the node is not at all in memory)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5391
    //       and the partial fetch callback (in case the node is perhaps partially in memory) to the fetch the node
5392
    //  - This eventually calls either toku_ftnode_fetch_callback or  toku_ftnode_pf_req_callback depending on whether the node is in
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5393
    //     memory at all or not.
5394 5395 5396
    //  - Within these functions, the "ft_search_t search" parameter is used to evaluate which child the search is interested in.
    //     If the node is not in memory at all, toku_ftnode_fetch_callback will read the node and decompress only the partition for the
    //     relevant child, be it a message buffer or basement node. If the node is in memory, then toku_ftnode_pf_req_callback
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5397
    //     will tell the cachetable that a partial fetch is required if and only if the relevant child is not in memory. If the relevant child
5398
    //     is not in memory, then toku_ftnode_pf_callback is called to fetch the partition.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5399
    //  - These functions set bfe->child_to_read so that the search code does not need to reevaluate it.
5400 5401 5402
    //  - Just to reiterate, all of the last item happens within toku_ftnode_pin(_holding_lock)
    //  - At this point, toku_ftnode_pin_holding_lock has returned, with bfe.child_to_read set,
    //  - ft_search_node is called, assuming that the node and its relevant partition are in memory.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5403
    //
5404
    struct ftnode_fetch_extra bfe;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5405 5406
    fill_bfe_for_subset_read(
        &bfe,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5407
        ft,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5408
        search,
5409 5410 5411 5412
        &ftcursor->range_lock_left_key,
        &ftcursor->range_lock_right_key,
        ftcursor->left_is_neg_infty,
        ftcursor->right_is_pos_infty,
5413 5414
        ftcursor->disable_prefetching,
        true // We may as well always read the whole root into memory, if it's a leaf node it's a tiny tree anyway.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5415
        );
5416
    FTNODE node = NULL;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5417
    {
Yoni Fogel's avatar
Yoni Fogel committed
5418
        uint32_t fullhash;
5419
        CACHEKEY root_key;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5420 5421 5422
        toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
        toku_pin_ftnode_off_client_thread_batched(
            ft,
5423
            root_key,
5424
            fullhash,
5425
            &bfe,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5426
            PL_READ, // may_modify_node set to false, because root cannot change during search
5427 5428 5429 5430
            0,
            NULL,
            &node
            );
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5431
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5432

5433
    uint tree_height = node->height + 1;  // How high is the tree?  This is the height of the root node plus one (leaf is at height 0).
5434

Zardosht Kasheff's avatar
Zardosht Kasheff committed
5435

Yoni Fogel's avatar
Yoni Fogel committed
5436 5437
    struct unlock_ftnode_extra unlock_extra   = {brt,node,false};
    struct unlockers                unlockers      = {true, unlock_ftnode_fun, (void*)&unlock_extra, (UNLOCKERS)NULL};
5438

5439
    {
Yoni Fogel's avatar
Yoni Fogel committed
5440
        bool doprefetch = false;
5441
        //static int counter = 0;         counter++;
5442
        r = ft_search_node(brt, node, search, bfe.child_to_read, getf, getf_v, &doprefetch, ftcursor, &unlockers, (ANCESTORS)NULL, &infinite_bounds, can_bulk_fetch);
5443
        if (r==TOKUDB_TRY_AGAIN) {
5444
            // there are two cases where we get TOKUDB_TRY_AGAIN
5445
            //  case 1 is when some later call to toku_pin_ftnode returned
5446
            //  that value and unpinned all the nodes anyway. case 2
5447
            //  is when ft_search_node had to stop its search because
5448
            //  some piece of a node that it needed was not in memory.
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5449
            //  In this case, the node was not unpinned, so we unpin it here
5450
            if (unlockers.locked) {
5451
                toku_unpin_ftnode_read_only(brt->ft, node);
5452
            }
5453 5454 5455 5456
            goto try_again;
        } else {
            assert(unlockers.locked);
        }
5457 5458
    }

5459
    assert(unlockers.locked);
5460
    toku_unpin_ftnode_read_only(brt->ft, node);
5461

5462

5463 5464
    //Heaviside function (+direction) queries define only a lower or upper
    //bound.  Some queries require both an upper and lower bound.
5465
    //They do this by wrapping the FT_GET_CALLBACK_FUNCTION with another
5466 5467 5468 5469 5470 5471
    //test that checks for the other bound.  If the other bound fails,
    //it returns TOKUDB_FOUND_BUT_REJECTED which means not found, but
    //stop searching immediately, as opposed to DB_NOTFOUND
    //which can mean not found, but keep looking in another leaf.
    if (r==TOKUDB_FOUND_BUT_REJECTED) r = DB_NOTFOUND;
    else if (r==DB_NOTFOUND) {
5472
        //We truly did not find an answer to the query.
5473
        //Therefore, the FT_GET_CALLBACK_FUNCTION has NOT been called.
5474 5475 5476 5477 5478 5479 5480
        //The contract specifies that the callback function must be called
        //for 'r= (0|DB_NOTFOUND|TOKUDB_FOUND_BUT_REJECTED)'
        //TODO: #1378 This is not the ultimate location of this call to the
        //callback.  It is surely wrong for node-level locking, and probably
        //wrong for the STRADDLE callback for heaviside function(two sets of key/vals)
        int r2 = getf(0,NULL, 0,NULL, getf_v, false);
        if (r2!=0) r = r2;
5481
    }
5482
    {   // accounting (to detect and measure thrashing)
5483
        uint retrycount = trycount - 1;         // how many retries were needed?
5484 5485 5486
        if (retrycount) {
            STATUS_INC(FT_TOTAL_RETRIES, retrycount);
        }
5487
        if (retrycount > tree_height) {         // if at least one node was read from disk more than once
5488
            STATUS_INC(FT_SEARCH_TRIES_GT_HEIGHT, 1);
5489
            if (retrycount > (tree_height+3))
5490
                STATUS_INC(FT_SEARCH_TRIES_GT_HEIGHTPLUS3, 1);
5491
        }
5492
    }
5493 5494 5495
    return r;
}

5496 5497
struct ft_cursor_search_struct {
    FT_GET_CALLBACK_FUNCTION getf;
5498
    void *getf_v;
5499 5500
    FT_CURSOR cursor;
    ft_search_t *search;
5501
};
5502

5503 5504
/* search for the first kv pair that matches the search object */
static int
Yoni Fogel's avatar
Yoni Fogel committed
5505
ft_cursor_search(FT_CURSOR cursor, ft_search_t *search, FT_GET_CALLBACK_FUNCTION getf, void *getf_v, bool can_bulk_fetch)
5506
{
5507
    int r = toku_ft_search(cursor->ft_handle, search, getf, getf_v, cursor, can_bulk_fetch);
5508 5509 5510
    return r;
}

5511
static inline int compare_k_x(FT_HANDLE brt, const DBT *k, const DBT *x) {
5512 5513
    FAKE_DB(db, &brt->ft->cmp_descriptor);
    return brt->ft->compare_fun(&db, k, x);
5514 5515
}

5516
static int
5517
ft_cursor_compare_one(const ft_search_t &search __attribute__((__unused__)), const DBT *x __attribute__((__unused__)))
5518
{
5519 5520 5521
    return 1;
}

5522 5523 5524
static int ft_cursor_compare_set(const ft_search_t &search, const DBT *x) {
    FT_HANDLE CAST_FROM_VOIDP(brt, search.context);
    return compare_k_x(brt, search.k, x) <= 0; /* return min xy: kv <= xy */
5525 5526
}

5527
static int
5528
ft_cursor_current_getf(ITEMLEN keylen,                 bytevec key,
5529 5530
                        ITEMLEN vallen,                 bytevec val,
                        void *v, bool lock_only) {
5531
    struct ft_cursor_search_struct *CAST_FROM_VOIDP(bcss, v);
5532 5533
    int r;
    if (key==NULL) {
5534
        r = bcss->getf(0, NULL, 0, NULL, bcss->getf_v, lock_only);
5535
    } else {
5536
        FT_CURSOR cursor = bcss->cursor;
5537 5538
        DBT newkey;
        toku_fill_dbt(&newkey, key, keylen);
5539
        if (compare_k_x(cursor->ft_handle, &cursor->key, &newkey) != 0) {
5540 5541 5542 5543 5544
            r = bcss->getf(0, NULL, 0, NULL, bcss->getf_v, lock_only); // This was once DB_KEYEMPTY
            if (r==0) r = TOKUDB_FOUND_BUT_REJECTED;
        }
        else
            r = bcss->getf(keylen, key, vallen, val, bcss->getf_v, lock_only);
5545 5546 5547 5548 5549
    }
    return r;
}

int
5550
toku_ft_cursor_current(FT_CURSOR cursor, int op, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5551
{
5552
    if (ft_cursor_not_set(cursor))
5553
        return EINVAL;
5554
    cursor->direction = 0;
5555
    if (op == DB_CURRENT) {
5556 5557
        struct ft_cursor_search_struct bcss = {getf, getf_v, cursor, 0};
        ft_search_t search; ft_search_init(&search, ft_cursor_compare_set, FT_SEARCH_LEFT, &cursor->key, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5558
        int r = toku_ft_search(cursor->ft_handle, &search, ft_cursor_current_getf, &bcss, cursor, false);
5559
        ft_search_finish(&search);
5560
        return r;
5561
    }
5562
    return getf(cursor->key.size, cursor->key.data, cursor->val.size, cursor->val.data, getf_v, false); // ft_cursor_copyout(cursor, outkey, outval);
5563 5564
}

5565
int
5566
toku_ft_cursor_first(FT_CURSOR cursor, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5567
{
5568
    cursor->direction = 0;
5569
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_one, FT_SEARCH_LEFT, 0, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5570
    int r = ft_cursor_search(cursor, &search, getf, getf_v, false);
5571
    ft_search_finish(&search);
5572
    return r;
5573 5574
}

5575
int
5576
toku_ft_cursor_last(FT_CURSOR cursor, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5577
{
5578
    cursor->direction = 0;
5579
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_one, FT_SEARCH_RIGHT, 0, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5580
    int r = ft_cursor_search(cursor, &search, getf, getf_v, false);
5581
    ft_search_finish(&search);
5582
    return r;
5583 5584
}

5585 5586 5587
static int ft_cursor_compare_next(const ft_search_t &search, const DBT *x) {
    FT_HANDLE CAST_FROM_VOIDP(brt, search.context);
    return compare_k_x(brt, search.k, x) < 0; /* return min xy: kv < xy */
5588 5589
}

5590
static int
5591 5592
ft_cursor_shortcut (
    FT_CURSOR cursor,
5593
    int direction,
5594 5595
    uint32_t index,
    bn_data* bd,
5596
    FT_GET_CALLBACK_FUNCTION getf,
5597
    void *getf_v,
Yoni Fogel's avatar
Yoni Fogel committed
5598
    uint32_t *keylen,
5599
    void **key,
Yoni Fogel's avatar
Yoni Fogel committed
5600
    uint32_t *vallen,
5601
    void **val
5602
    )
5603
{
5604 5605 5606
    int r = 0;
    // if we are searching towards the end, limit is last element
    // if we are searching towards the beginning, limit is the first element
5607
    uint32_t limit = (direction > 0) ? (bd->num_klpairs() - 1) : 0;
5608 5609 5610 5611

    //Starting with the prev, find the first real (non-provdel) leafentry.
    while (index != limit) {
        index += direction;
5612 5613 5614 5615 5616 5617
        LEAFENTRY le;
        void* foundkey = NULL;
        uint32_t foundkeylen = 0;
        
        r = bd->fetch_klpair(index, &le, &foundkeylen, &foundkey);
        invariant_zero(r);
5618

5619
        if (toku_ft_cursor_is_leaf_mode(cursor) || !is_le_val_del(le, cursor)) {
5620
            ft_cursor_extract_val(
5621 5622 5623 5624 5625
                le,
                cursor,
                vallen,
                val
                );
5626 5627
            *key = foundkey;
            *keylen = foundkeylen;
5628

5629
            cursor->direction = direction;
5630
            r = cursor_check_restricted_range(cursor, *key, *keylen);
5631 5632 5633 5634 5635 5636
            if (r!=0) {
                paranoid_invariant(r == cursor->out_of_range_error);
                // We already got at least one entry from the bulk fetch.
                // Return 0 (instead of out of range error).
                r = 0;
                break;
5637
            }
5638
            r = getf(*keylen, *key, *vallen, *val, getf_v, false);
5639
            if (r == TOKUDB_CURSOR_CONTINUE) {
5640 5641 5642 5643 5644
                continue;
            }
            else {
                break;
            }
5645
        }
5646
    }
5647

5648
    return r;
5649 5650 5651
}

int
5652
toku_ft_cursor_next(FT_CURSOR cursor, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5653
{
5654
    cursor->direction = +1;
5655
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_next, FT_SEARCH_LEFT, &cursor->key, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5656
    int r = ft_cursor_search(cursor, &search, getf, getf_v, true);
5657 5658
    ft_search_finish(&search);
    if (r == 0) ft_cursor_set_prefetching(cursor);
5659
    return r;
5660 5661
}

5662
static int
5663
ft_cursor_search_eq_k_x_getf(ITEMLEN keylen,               bytevec key,
5664 5665
                              ITEMLEN vallen,               bytevec val,
                              void *v, bool lock_only) {
5666
    struct ft_cursor_search_struct *CAST_FROM_VOIDP(bcss, v);
5667 5668
    int r;
    if (key==NULL) {
5669
        r = bcss->getf(0, NULL, 0, NULL, bcss->getf_v, false);
5670
    } else {
5671
        FT_CURSOR cursor = bcss->cursor;
5672 5673
        DBT newkey;
        toku_fill_dbt(&newkey, key, keylen);
5674
        if (compare_k_x(cursor->ft_handle, bcss->search->k, &newkey) == 0) {
5675 5676 5677 5678 5679
            r = bcss->getf(keylen, key, vallen, val, bcss->getf_v, lock_only);
        } else {
            r = bcss->getf(0, NULL, 0, NULL, bcss->getf_v, lock_only);
            if (r==0) r = TOKUDB_FOUND_BUT_REJECTED;
        }
5680 5681 5682
    }
    return r;
}
5683 5684 5685

/* search for the kv pair that matches the search object and is equal to k */
static int
5686
ft_cursor_search_eq_k_x(FT_CURSOR cursor, ft_search_t *search, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5687
{
5688
    struct ft_cursor_search_struct bcss = {getf, getf_v, cursor, search};
Yoni Fogel's avatar
Yoni Fogel committed
5689
    int r = toku_ft_search(cursor->ft_handle, search, ft_cursor_search_eq_k_x_getf, &bcss, cursor, false);
5690
    return r;
5691 5692
}

5693 5694 5695
static int ft_cursor_compare_prev(const ft_search_t &search, const DBT *x) {
    FT_HANDLE CAST_FROM_VOIDP(brt, search.context);
    return compare_k_x(brt, search.k, x) > 0; /* return max xy: kv > xy */
5696 5697
}

5698
int
5699
toku_ft_cursor_prev(FT_CURSOR cursor, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5700
{
5701
    cursor->direction = -1;
5702
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_prev, FT_SEARCH_RIGHT, &cursor->key, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5703
    int r = ft_cursor_search(cursor, &search, getf, getf_v, true);
5704
    ft_search_finish(&search);
5705
    return r;
5706 5707
}

5708 5709 5710
static int ft_cursor_compare_set_range(const ft_search_t &search, const DBT *x) {
    FT_HANDLE CAST_FROM_VOIDP(brt, search.context);
    return compare_k_x(brt, search.k, x) <= 0; /* return kv <= xy */
5711 5712 5713
}

int
5714
toku_ft_cursor_set(FT_CURSOR cursor, DBT *key, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5715
{
5716
    cursor->direction = 0;
5717 5718 5719
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_set_range, FT_SEARCH_LEFT, key, cursor->ft_handle);
    int r = ft_cursor_search_eq_k_x(cursor, &search, getf, getf_v);
    ft_search_finish(&search);
5720
    return r;
5721 5722 5723
}

int
5724
toku_ft_cursor_set_range(FT_CURSOR cursor, DBT *key, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5725
{
5726
    cursor->direction = 0;
5727
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_set_range, FT_SEARCH_LEFT, key, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5728
    int r = ft_cursor_search(cursor, &search, getf, getf_v, false);
5729
    ft_search_finish(&search);
5730
    return r;
5731 5732
}

5733 5734 5735
static int ft_cursor_compare_set_range_reverse(const ft_search_t &search, const DBT *x) {
    FT_HANDLE CAST_FROM_VOIDP(brt, search.context);
    return compare_k_x(brt, search.k, x) >= 0; /* return kv >= xy */
5736 5737 5738
}

int
5739
toku_ft_cursor_set_range_reverse(FT_CURSOR cursor, DBT *key, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5740
{
5741
    cursor->direction = 0;
5742
    ft_search_t search; ft_search_init(&search, ft_cursor_compare_set_range_reverse, FT_SEARCH_RIGHT, key, cursor->ft_handle);
Yoni Fogel's avatar
Yoni Fogel committed
5743
    int r = ft_cursor_search(cursor, &search, getf, getf_v, false);
5744
    ft_search_finish(&search);
5745
    return r;
5746 5747 5748
}


5749 5750 5751
//TODO: When tests have been rewritten, get rid of this function.
//Only used by tests.
int
5752
toku_ft_cursor_get (FT_CURSOR cursor, DBT *key, FT_GET_CALLBACK_FUNCTION getf, void *getf_v, int get_flags)
5753
{
5754
    int op = get_flags & DB_OPFLAGS_MASK;
5755
    if (get_flags & ~DB_OPFLAGS_MASK)
5756
        return EINVAL;
5757 5758 5759 5760

    switch (op) {
    case DB_CURRENT:
    case DB_CURRENT_BINDING:
5761
        return toku_ft_cursor_current(cursor, op, getf, getf_v);
5762
    case DB_FIRST:
5763
        return toku_ft_cursor_first(cursor, getf, getf_v);
5764
    case DB_LAST:
5765
        return toku_ft_cursor_last(cursor, getf, getf_v);
5766
    case DB_NEXT:
John Esmet's avatar
John Esmet committed
5767
        if (ft_cursor_not_set(cursor)) {
5768
            return toku_ft_cursor_first(cursor, getf, getf_v);
John Esmet's avatar
John Esmet committed
5769
        } else {
5770
            return toku_ft_cursor_next(cursor, getf, getf_v);
John Esmet's avatar
John Esmet committed
5771
        }
5772
    case DB_PREV:
John Esmet's avatar
John Esmet committed
5773
        if (ft_cursor_not_set(cursor)) {
5774
            return toku_ft_cursor_last(cursor, getf, getf_v);
John Esmet's avatar
John Esmet committed
5775
        } else {
5776
            return toku_ft_cursor_prev(cursor, getf, getf_v);
John Esmet's avatar
John Esmet committed
5777
        }
5778
    case DB_SET:
5779
        return toku_ft_cursor_set(cursor, key, getf, getf_v);
5780
    case DB_SET_RANGE:
5781
        return toku_ft_cursor_set_range(cursor, key, getf, getf_v);
5782
    default: ;// Fall through
5783
    }
5784
    return EINVAL;
5785 5786
}

5787
void
5788
toku_ft_cursor_peek(FT_CURSOR cursor, const DBT **pkey, const DBT **pval)
5789 5790
// Effect: Retrieves a pointer to the DBTs for the current key and value.
// Requires:  The caller may not modify the DBTs or the memory at which they points.
5791
// Requires:  The caller must be in the context of a
5792
// FT_GET_(STRADDLE_)CALLBACK_FUNCTION
5793 5794 5795 5796 5797 5798
{
    *pkey = &cursor->key;
    *pval = &cursor->val;
}

//We pass in toku_dbt_fake to the search functions, since it will not pass the
5799
//key(or val) to the heaviside function if key(or val) is NULL.
5800 5801 5802
//It is not used for anything else,
//the actual 'extra' information for the heaviside function is inside the
//wrapper.
5803
static const DBT __toku_dbt_fake = {};
5804 5805
static const DBT* const toku_dbt_fake = &__toku_dbt_fake;

Yoni Fogel's avatar
Yoni Fogel committed
5806
bool toku_ft_cursor_uninitialized(FT_CURSOR c) {
5807
    return ft_cursor_not_set(c);
5808 5809 5810
}


5811 5812
/* ********************************* lookup **************************************/

5813
int
5814
toku_ft_lookup (FT_HANDLE brt, DBT *k, FT_GET_CALLBACK_FUNCTION getf, void *getf_v)
5815
{
5816
    int r, rr;
5817
    FT_CURSOR cursor;
5818

Yoni Fogel's avatar
Yoni Fogel committed
5819
    rr = toku_ft_cursor(brt, &cursor, NULL, false, false);
5820 5821
    if (rr != 0) return rr;

5822
    int op = DB_SET;
5823
    r = toku_ft_cursor_get(cursor, k, getf, getf_v, op);
5824

5825
    toku_ft_cursor_close(cursor);
5826 5827 5828 5829

    return r;
}

5830
/* ********************************* delete **************************************/
5831
static int
5832
getf_nothing (ITEMLEN UU(keylen), bytevec UU(key), ITEMLEN UU(vallen), bytevec UU(val), void *UU(pair_v), bool UU(lock_only)) {
5833 5834 5835 5836
    return 0;
}

int
5837
toku_ft_cursor_delete(FT_CURSOR cursor, int flags, TOKUTXN txn) {
5838 5839 5840
    int r;

    int unchecked_flags = flags;
Yoni Fogel's avatar
Yoni Fogel committed
5841
    bool error_if_missing = (bool) !(flags&DB_DELETE_ANY);
5842 5843
    unchecked_flags &= ~DB_DELETE_ANY;
    if (unchecked_flags!=0) r = EINVAL;
5844
    else if (ft_cursor_not_set(cursor)) r = EINVAL;
5845
    else {
5846 5847
        r = 0;
        if (error_if_missing) {
5848
            r = toku_ft_cursor_current(cursor, DB_CURRENT, getf_nothing, NULL);
5849 5850
        }
        if (r == 0) {
5851
            toku_ft_delete(cursor->ft_handle, &cursor->key, txn);
5852
        }
5853 5854 5855 5856 5857 5858 5859
    }
    return r;
}

/* ********************* keyrange ************************ */


5860
struct keyrange_compare_s {
5861 5862
    FT ft;
    const DBT *key;
5863 5864
};

5865
static int
5866
keyrange_compare (DBT const &kdbt, const struct keyrange_compare_s &s) {
5867
    // TODO: maybe put a const fake_db in the header
5868 5869
    FAKE_DB(db, &s.ft->cmp_descriptor);
    return s.ft->compare_fun(&db, &kdbt, s.key);
5870 5871
}

5872
static void
5873 5874 5875 5876 5877
keysrange_in_leaf_partition (FT_HANDLE brt, FTNODE node,
                             DBT* key_left, DBT* key_right,
                             int left_child_number, int right_child_number, uint64_t estimated_num_rows,
                             uint64_t *less, uint64_t* equal_left, uint64_t* middle,
                             uint64_t* equal_right, uint64_t* greater, bool* single_basement_node)
5878
// If the partition is in main memory then estimate the number
5879 5880
// Treat key_left == NULL as negative infinity
// Treat key_right == NULL as positive infinity
5881
{
5882
    paranoid_invariant(node->height == 0); // we are in a leaf
5883 5884 5885 5886 5887 5888 5889
    paranoid_invariant(!(key_left == NULL && key_right != NULL));
    paranoid_invariant(left_child_number <= right_child_number);
    bool single_basement = left_child_number == right_child_number;
    paranoid_invariant(!single_basement || (BP_STATE(node, left_child_number) == PT_AVAIL));
    if (BP_STATE(node, left_child_number) == PT_AVAIL) {
        int r;
        // The partition is in main memory then get an exact count.
5890
        struct keyrange_compare_s s_left = {brt->ft, key_left};
5891 5892 5893
        BASEMENTNODE bn = BLB(node, left_child_number);
        uint32_t idx_left = 0;
        // if key_left is NULL then set r==-1 and idx==0.
5894
        r = key_left ? bn->data_buffer.find_zero<decltype(s_left), keyrange_compare>(s_left, nullptr, nullptr, nullptr, &idx_left) : -1;
5895 5896 5897
        *less = idx_left;
        *equal_left = (r==0) ? 1 : 0;

5898
        uint32_t size = bn->data_buffer.num_klpairs();
5899 5900 5901
        uint32_t idx_right = size;
        r = -1;
        if (single_basement && key_right) {
5902
            struct keyrange_compare_s s_right = {brt->ft, key_right};
5903
            r = bn->data_buffer.find_zero<decltype(s_right), keyrange_compare>(s_right, nullptr, nullptr, nullptr, &idx_right);
5904
        }
5905 5906 5907
        *middle = idx_right - idx_left - *equal_left;
        *equal_right = (r==0) ? 1 : 0;
        *greater = size - idx_right - *equal_right;
5908
    } else {
5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921
        paranoid_invariant(!single_basement);
        uint32_t idx_left = estimated_num_rows / 2;
        if (!key_left) {
            //Both nullptr, assume key_left belongs before leftmost entry, key_right belongs after rightmost entry
            idx_left = 0;
            paranoid_invariant(!key_right);
        }
        // Assume idx_left and idx_right point to where key_left and key_right belong, (but are not there).
        *less = idx_left;
        *equal_left = 0;
        *middle = estimated_num_rows - idx_left;
        *equal_right = 0;
        *greater = 0;
5922
    }
5923
    *single_basement_node = single_basement;
5924 5925
}

5926
static int
5927 5928 5929 5930
toku_ft_keysrange_internal (FT_HANDLE brt, FTNODE node,
                            DBT* key_left, DBT* key_right, bool may_find_right,
                            uint64_t* less, uint64_t* equal_left, uint64_t* middle,
                            uint64_t* equal_right, uint64_t* greater, bool* single_basement_node,
Yoni Fogel's avatar
Yoni Fogel committed
5931
                            uint64_t estimated_num_rows,
5932 5933
                            struct ftnode_fetch_extra *min_bfe, // set up to read a minimal read.
                            struct ftnode_fetch_extra *match_bfe, // set up to read a basement node iff both keys in it
5934
                            struct unlockers *unlockers, ANCESTORS ancestors, struct pivot_bounds const * const bounds)
5935 5936 5937
// Implementation note: Assign values to less, equal, and greater, and then on the way out (returning up the stack) we add more values in.
{
    int r = 0;
5938
    // if KEY is NULL then use the leftmost key.
5939 5940 5941 5942 5943 5944
    int left_child_number = key_left ? toku_ftnode_which_child (node, key_left, &brt->ft->cmp_descriptor, brt->ft->compare_fun) : 0;
    int right_child_number = node->n_children;  // Sentinel that does not equal left_child_number.
    if (may_find_right) {
        right_child_number = key_right ? toku_ftnode_which_child (node, key_right, &brt->ft->cmp_descriptor, brt->ft->compare_fun) : node->n_children - 1;
    }

5945 5946
    uint64_t rows_per_child = estimated_num_rows / node->n_children;
    if (node->height == 0) {
5947 5948
        keysrange_in_leaf_partition(brt, node, key_left, key_right, left_child_number, right_child_number,
                                    rows_per_child, less, equal_left, middle, equal_right, greater, single_basement_node);
5949

5950 5951 5952 5953 5954 5955
        *less    += rows_per_child * left_child_number;
        if (*single_basement_node) {
            *greater += rows_per_child * (node->n_children - left_child_number - 1);
        } else {
            *middle += rows_per_child * (node->n_children - left_child_number - 1);
        }
5956
    } else {
5957
        // do the child.
5958 5959 5960
        struct ancestors next_ancestors = {node, left_child_number, ancestors};
        BLOCKNUM childblocknum = BP_BLOCKNUM(node, left_child_number);
        uint32_t fullhash = compute_child_fullhash(brt->ft->cf, node, left_child_number);
5961
        FTNODE childnode;
Yoni Fogel's avatar
Yoni Fogel committed
5962
        bool msgs_applied = false;
5963
        bool child_may_find_right = may_find_right && left_child_number == right_child_number;
5964
        r = toku_pin_ftnode_batched(
5965 5966 5967 5968 5969 5970
            brt,
            childblocknum,
            fullhash,
            unlockers,
            &next_ancestors,
            bounds,
5971
            child_may_find_right ? match_bfe : min_bfe,
Yoni Fogel's avatar
Yoni Fogel committed
5972
            false,
5973
            &childnode,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5974 5975
            &msgs_applied
            );
5976
        paranoid_invariant(!msgs_applied);
5977
        if (r != TOKUDB_TRY_AGAIN) {
5978
            assert_zero(r);
5979

Yoni Fogel's avatar
Yoni Fogel committed
5980 5981
            struct unlock_ftnode_extra unlock_extra   = {brt,childnode,false};
            struct unlockers next_unlockers = {true, unlock_ftnode_fun, (void*)&unlock_extra, unlockers};
5982
            const struct pivot_bounds next_bounds = next_pivot_keys(node, left_child_number, bounds);
5983

5984 5985 5986
            r = toku_ft_keysrange_internal(brt, childnode, key_left, key_right, child_may_find_right,
                                           less, equal_left, middle, equal_right, greater, single_basement_node,
                                           rows_per_child, min_bfe, match_bfe, &next_unlockers, &next_ancestors, &next_bounds);
5987
            if (r != TOKUDB_TRY_AGAIN) {
5988
                assert_zero(r);
5989

5990 5991 5992 5993 5994 5995
                *less    += rows_per_child * left_child_number;
                if (*single_basement_node) {
                    *greater += rows_per_child * (node->n_children - left_child_number - 1);
                } else {
                    *middle += rows_per_child * (node->n_children - left_child_number - 1);
                }
5996

5997
                assert(unlockers->locked);
5998
                toku_unpin_ftnode_read_only(brt->ft, childnode);
5999 6000
            }
        }
6001
    }
6002
    return r;
6003 6004
}

6005 6006
void toku_ft_keysrange(FT_HANDLE brt, DBT* key_left, DBT* key_right, uint64_t *less_p, uint64_t* equal_left_p, uint64_t* middle_p, uint64_t* equal_right_p, uint64_t* greater_p, bool* middle_3_exact_p)
// Effect: Return an estimate  of the number of keys to the left, the number equal (to left key), number between keys, number equal to right key, and the number to the right of both keys.
6007
//   The values are an estimate.
6008 6009 6010 6011
//   If you perform a keyrange on two keys that are in the same basement, equal_less, middle, and equal_right will be exact.
//   4184: What to do with a NULL key?
//   key_left==NULL is treated as -infinity
//   key_right==NULL is treated as +infinity
6012
//   If KEY is NULL then the system picks an arbitrary key and returns it.
6013
//   key_right can be non-null only if key_left is non-null;
6014
{
6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033
    if (!key_left && key_right) {
        // Simplify internals by only supporting key_right != null when key_left != null
        // If key_right != null and key_left == null, then swap them and fix up numbers.
        uint64_t less = 0, equal_left = 0, middle = 0, equal_right = 0, greater = 0;
        toku_ft_keysrange(brt, key_right, nullptr, &less, &equal_left, &middle, &equal_right, &greater, middle_3_exact_p);
        *less_p = 0;
        *equal_left_p = 0;
        *middle_p = less;
        *equal_right_p = equal_left;
        *greater_p = middle;
        invariant_zero(equal_right);
        invariant_zero(greater);
        return;
    }
    paranoid_invariant(!(!key_left && key_right));
    struct ftnode_fetch_extra min_bfe;
    struct ftnode_fetch_extra match_bfe;
    fill_bfe_for_min_read(&min_bfe, brt->ft);  // read pivot keys but not message buffers
    fill_bfe_for_keymatch(&match_bfe, brt->ft, key_left, key_right, false, false);  // read basement node only if both keys in it.
6034
try_again:
6035
    {
6036 6037
        uint64_t less = 0, equal_left = 0, middle = 0, equal_right = 0, greater = 0;
        bool single_basement_node = false;
6038
        FTNODE node = NULL;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6039
        {
Yoni Fogel's avatar
Yoni Fogel committed
6040
            uint32_t fullhash;
6041
            CACHEKEY root_key;
6042
            toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
6043
            toku_pin_ftnode_off_client_thread_batched(
6044
                brt->ft,
6045
                root_key,
6046
                fullhash,
6047
                &match_bfe,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6048
                PL_READ, // may_modify_node, cannot change root during keyrange
6049 6050 6051 6052
                0,
                NULL,
                &node
                );
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6053
        }
6054

Yoni Fogel's avatar
Yoni Fogel committed
6055 6056
        struct unlock_ftnode_extra unlock_extra = {brt,node,false};
        struct unlockers unlockers = {true, unlock_ftnode_fun, (void*)&unlock_extra, (UNLOCKERS)NULL};
6057 6058

        {
6059
            int r;
6060
            int64_t numrows = brt->ft->in_memory_stats.numrows;
6061 6062
            if (numrows < 0)
                numrows = 0;  // prevent appearance of a negative number
6063 6064 6065 6066
            r = toku_ft_keysrange_internal (brt, node, key_left, key_right, true,
                                            &less, &equal_left, &middle, &equal_right, &greater,
                                            &single_basement_node, numrows,
                                            &min_bfe, &match_bfe, &unlockers, (ANCESTORS)NULL, &infinite_bounds);
6067 6068 6069 6070 6071
            assert(r == 0 || r == TOKUDB_TRY_AGAIN);
            if (r == TOKUDB_TRY_AGAIN) {
                assert(!unlockers.locked);
                goto try_again;
            }
6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101 6102 6103 6104 6105 6106
            // May need to do a second query.
            if (!single_basement_node && key_right != nullptr) {
                // "greater" is stored in "middle"
                invariant_zero(equal_right);
                invariant_zero(greater);
                uint64_t less2 = 0, equal_left2 = 0, middle2 = 0, equal_right2 = 0, greater2 = 0;
                bool ignore;
                r = toku_ft_keysrange_internal (brt, node, key_right, nullptr, false,
                                                &less2, &equal_left2, &middle2, &equal_right2, &greater2,
                                                &ignore, numrows,
                                                &min_bfe, &match_bfe, &unlockers, (ANCESTORS)nullptr, &infinite_bounds);
                assert(r == 0 || r == TOKUDB_TRY_AGAIN);
                if (r == TOKUDB_TRY_AGAIN) {
                    assert(!unlockers.locked);
                    goto try_again;
                }
                invariant_zero(equal_right2);
                invariant_zero(greater2);
                // Update numbers.
                // less is already correct.
                // equal_left is already correct.

                // "middle" currently holds everything greater than left_key in first query
                // 'middle2' currently holds everything greater than right_key in second query
                // 'equal_left2' is how many match right_key

                // Prevent underflow.
                if (middle >= equal_left2 + middle2) {
                    middle -= equal_left2 + middle2;
                } else {
                    middle = 0;
                }
                equal_right = equal_left2;
                greater = middle2;
            }
6107 6108
        }
        assert(unlockers.locked);
6109
        toku_unpin_ftnode_read_only(brt->ft, node);
6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126
        if (!key_right) {
            paranoid_invariant_zero(equal_right);
            paranoid_invariant_zero(greater);
        }
        if (!key_left) {
            paranoid_invariant_zero(less);
            paranoid_invariant_zero(equal_left);
        }
        *less_p        = less;
        *equal_left_p  = equal_left;
        *middle_p      = middle;
        *equal_right_p = equal_right;
        *greater_p     = greater;
        *middle_3_exact_p = single_basement_node;
    }
}

6127 6128 6129 6130 6131 6132 6133
struct get_key_after_bytes_iterate_extra {
    uint64_t skip_len;
    uint64_t *skipped;
    void (*callback)(const DBT *, uint64_t, void *);
    void *cb_extra;
};

6134
static int get_key_after_bytes_iterate(const void* key, const uint32_t keylen, const LEAFENTRY & le, const uint32_t UU(idx), struct get_key_after_bytes_iterate_extra * const e) {
6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153
    // only checking the latest val, mvcc will make this inaccurate
    uint64_t pairlen = keylen + le_latest_vallen(le);
    if (*e->skipped + pairlen > e->skip_len) {
        // found our key!
        DBT end_key;
        toku_fill_dbt(&end_key, key, keylen);
        e->callback(&end_key, *e->skipped, e->cb_extra);
        return 1;
    } else {
        *e->skipped += pairlen;
        return 0;
    }
}

static int get_key_after_bytes_in_basementnode(FT ft, BASEMENTNODE bn, const DBT *start_key, uint64_t skip_len, void (*callback)(const DBT *, uint64_t, void *), void *cb_extra, uint64_t *skipped) {
    int r;
    uint32_t idx_left = 0;
    if (start_key != nullptr) {
        struct keyrange_compare_s cmp = {ft, start_key};
6154
        r = bn->data_buffer.find_zero<decltype(cmp), keyrange_compare>(cmp, nullptr, nullptr, nullptr, &idx_left);
6155 6156 6157
        assert(r == 0 || r == DB_NOTFOUND);
    }
    struct get_key_after_bytes_iterate_extra iter_extra = {skip_len, skipped, callback, cb_extra};
6158
    r = bn->data_buffer.iterate_on_range<get_key_after_bytes_iterate_extra, get_key_after_bytes_iterate>(idx_left, bn->data_buffer.num_klpairs(), &iter_extra);
6159

6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175 6176 6177
    // Invert the sense of r == 0 (meaning the iterate finished, which means we didn't find what we wanted)
    if (r == 1) {
        r = 0;
    } else {
        r = DB_NOTFOUND;
    }
    return r;
}

static int get_key_after_bytes_in_subtree(FT_HANDLE ft_h, FT ft, FTNODE node, UNLOCKERS unlockers, ANCESTORS ancestors, PIVOT_BOUNDS bounds, FTNODE_FETCH_EXTRA bfe, ft_search_t *search, uint64_t subtree_bytes, const DBT *start_key, uint64_t skip_len, void (*callback)(const DBT *, uint64_t, void *), void *cb_extra, uint64_t *skipped);

static int get_key_after_bytes_in_child(FT_HANDLE ft_h, FT ft, FTNODE node, UNLOCKERS unlockers, ANCESTORS ancestors, PIVOT_BOUNDS bounds, FTNODE_FETCH_EXTRA bfe, ft_search_t *search, int childnum, uint64_t subtree_bytes, const DBT *start_key, uint64_t skip_len, void (*callback)(const DBT *, uint64_t, void *), void *cb_extra, uint64_t *skipped) {
    int r;
    struct ancestors next_ancestors = {node, childnum, ancestors};
    BLOCKNUM childblocknum = BP_BLOCKNUM(node, childnum);
    uint32_t fullhash = compute_child_fullhash(ft->cf, node, childnum);
    FTNODE child;
    bool msgs_applied = false;
6178
    r = toku_pin_ftnode_batched(ft_h, childblocknum, fullhash, unlockers, &next_ancestors, bounds, bfe, false, &child, &msgs_applied);
6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231 6232 6233 6234 6235 6236 6237 6238 6239 6240 6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257 6258 6259 6260 6261 6262 6263 6264 6265 6266 6267 6268
    paranoid_invariant(!msgs_applied);
    if (r == TOKUDB_TRY_AGAIN) {
        return r;
    }
    assert_zero(r);
    struct unlock_ftnode_extra unlock_extra = {ft_h, child, false};
    struct unlockers next_unlockers = {true, unlock_ftnode_fun, (void *) &unlock_extra, unlockers};
    const struct pivot_bounds next_bounds = next_pivot_keys(node, childnum, bounds);
    return get_key_after_bytes_in_subtree(ft_h, ft, child, &next_unlockers, &next_ancestors, &next_bounds, bfe, search, subtree_bytes, start_key, skip_len, callback, cb_extra, skipped);
}

static int get_key_after_bytes_in_subtree(FT_HANDLE ft_h, FT ft, FTNODE node, UNLOCKERS unlockers, ANCESTORS ancestors, PIVOT_BOUNDS bounds, FTNODE_FETCH_EXTRA bfe, ft_search_t *search, uint64_t subtree_bytes, const DBT *start_key, uint64_t skip_len, void (*callback)(const DBT *, uint64_t, void *), void *cb_extra, uint64_t *skipped) {
    int r;
    int childnum = toku_ft_search_which_child(&ft->cmp_descriptor, ft->compare_fun, node, search);
    const uint64_t child_subtree_bytes = subtree_bytes / node->n_children;
    if (node->height == 0) {
        r = DB_NOTFOUND;
        for (int i = childnum; r == DB_NOTFOUND && i < node->n_children; ++i) {
            // The theory here is that a leaf node could only be very
            // unbalanced if it's dirty, which means all its basements are
            // available.  So if a basement node is available, we should
            // check it as carefully as possible, but if it's compressed
            // or on disk, then it should be fairly well balanced so we
            // can trust the fanout calculation.
            if (BP_STATE(node, i) == PT_AVAIL) {
                r = get_key_after_bytes_in_basementnode(ft, BLB(node, i), (i == childnum) ? start_key : nullptr, skip_len, callback, cb_extra, skipped);
            } else {
                *skipped += child_subtree_bytes;
                if (*skipped >= skip_len && i < node->n_children - 1) {
                    callback(&node->childkeys[i], *skipped, cb_extra);
                    r = 0;
                }
                // Otherwise, r is still DB_NOTFOUND.  If this is the last
                // basement node, we'll return DB_NOTFOUND and that's ok.
                // Some ancestor in the call stack will check the next
                // node over and that will call the callback, or if no
                // such node exists, we're at the max key and we should
                // return DB_NOTFOUND up to the top.
            }
        }
    } else {
        r = get_key_after_bytes_in_child(ft_h, ft, node, unlockers, ancestors, bounds, bfe, search, childnum, child_subtree_bytes, start_key, skip_len, callback, cb_extra, skipped);
        for (int i = childnum + 1; r == DB_NOTFOUND && i < node->n_children; ++i) {
            if (*skipped + child_subtree_bytes < skip_len) {
                *skipped += child_subtree_bytes;
            } else {
                r = get_key_after_bytes_in_child(ft_h, ft, node, unlockers, ancestors, bounds, bfe, search, i, child_subtree_bytes, nullptr, skip_len, callback, cb_extra, skipped);    
            }
        }
    }

    if (r != TOKUDB_TRY_AGAIN) {
        assert(unlockers->locked);
        toku_unpin_ftnode_read_only(ft, node);
        unlockers->locked = false;
    }
    return r;
}

int toku_ft_get_key_after_bytes(FT_HANDLE ft_h, const DBT *start_key, uint64_t skip_len, void (*callback)(const DBT *end_key, uint64_t actually_skipped, void *extra), void *cb_extra)
// Effect:
//  Call callback with end_key set to the largest key such that the sum of the sizes of the key/val pairs in the range [start_key, end_key) is <= skip_len.
//  Call callback with actually_skipped set to the sum of the sizes of the key/val pairs in the range [start_key, end_key).
// Notes:
//  start_key == nullptr is interpreted as negative infinity.
//  end_key == nullptr is interpreted as positive infinity.
//  Only the latest val is counted toward the size, in the case of MVCC data.
// Implementation:
//  This is an estimated calculation.  We assume for a node that each of its subtrees have equal size.  If the tree is a single basement node, then we will be accurate, but otherwise we could be quite off.
// Returns:
//  0 on success
//  an error code otherwise
{
    FT ft = ft_h->ft;
    struct ftnode_fetch_extra bfe;
    fill_bfe_for_min_read(&bfe, ft);
    while (true) {
        FTNODE root;
        {
            uint32_t fullhash;
            CACHEKEY root_key;
            toku_calculate_root_offset_pointer(ft, &root_key, &fullhash);
            toku_pin_ftnode_off_client_thread_batched(ft, root_key, fullhash, &bfe, PL_READ, 0, nullptr, &root);
        }
        struct unlock_ftnode_extra unlock_extra = {ft_h, root, false};
        struct unlockers unlockers = {true, unlock_ftnode_fun, (void*)&unlock_extra, (UNLOCKERS) nullptr};
        ft_search_t search;
        ft_search_init(&search, (start_key == nullptr ? ft_cursor_compare_one : ft_cursor_compare_set_range), FT_SEARCH_LEFT, start_key, ft_h);
        
        int r;
6269 6270 6271 6272 6273 6274
        // We can't do this because of #5768, there may be dictionaries in the wild that have negative stats.  This won't affect mongo so it's ok:
        //paranoid_invariant(ft->in_memory_stats.numbytes >= 0);
        int64_t numbytes = ft->in_memory_stats.numbytes;
        if (numbytes < 0) {
            numbytes = 0;
        }
6275
        uint64_t skipped = 0;
6276
        r = get_key_after_bytes_in_subtree(ft_h, ft, root, &unlockers, nullptr, &infinite_bounds, &bfe, &search, (uint64_t) numbytes, start_key, skip_len, callback, cb_extra, &skipped);
6277 6278 6279 6280 6281 6282 6283 6284 6285 6286 6287
        assert(!unlockers.locked);
        if (r != TOKUDB_TRY_AGAIN) {
            if (r == DB_NOTFOUND) {
                callback(nullptr, skipped, cb_extra);
                r = 0;
            }
            return r;
        }
    }
}

6288 6289 6290 6291 6292 6293 6294
//Test-only wrapper for the old one-key range function
void toku_ft_keyrange(FT_HANDLE brt, DBT *key, uint64_t *less,  uint64_t *equal,  uint64_t *greater) {
    uint64_t zero_equal_right, zero_greater;
    bool ignore;
    toku_ft_keysrange(brt, key, nullptr, less, equal, greater, &zero_equal_right, &zero_greater, &ignore);
    invariant_zero(zero_equal_right);
    invariant_zero(zero_greater);
6295 6296
}

6297
void toku_ft_handle_stat64 (FT_HANDLE brt, TOKUTXN UU(txn), struct ftstat64_s *s) {
6298
    toku_ft_stat64(brt->ft, s);
6299 6300
}

6301 6302 6303 6304 6305 6306 6307 6308
void toku_ft_handle_get_fractal_tree_info64(FT_HANDLE ft_h, struct ftinfo64 *s) {
    toku_ft_get_fractal_tree_info64(ft_h->ft, s);
}

int toku_ft_handle_iterate_fractal_tree_block_map(FT_HANDLE ft_h, int (*iter)(uint64_t,int64_t,int64_t,int64_t,int64_t,void*), void *iter_extra) {
    return toku_ft_iterate_fractal_tree_block_map(ft_h->ft, iter, iter_extra);
}

6309 6310
/* ********************* debugging dump ************************ */
static int
6311
toku_dump_ftnode (FILE *file, FT_HANDLE brt, BLOCKNUM blocknum, int depth, const DBT *lorange, const DBT *hirange) {
6312
    int result=0;
6313
    FTNODE node;
6314
    toku_get_node_for_verify(blocknum, brt, &node);
6315
    result=toku_verify_ftnode(brt, brt->ft->h->max_msn_in_ft, brt->ft->h->max_msn_in_ft, false, node, -1, lorange, hirange, NULL, NULL, 0, 1, 0);
Yoni Fogel's avatar
Yoni Fogel committed
6316
    uint32_t fullhash = toku_cachetable_hash(brt->ft->cf, blocknum);
6317
    struct ftnode_fetch_extra bfe;
6318
    fill_bfe_for_full_read(&bfe, brt->ft);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6319 6320
    toku_pin_ftnode_off_client_thread(
        brt->ft,
6321
        blocknum,
6322
        fullhash,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6323 6324 6325
        &bfe,
        PL_WRITE_EXPENSIVE,
        0,
6326
        NULL,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6327
        &node
6328
        );
6329
    assert(node->fullhash==fullhash);
6330
    fprintf(file, "%*sNode=%p\n", depth, "", node);
6331

Zardosht Kasheff's avatar
Zardosht Kasheff committed
6332 6333
    fprintf(file, "%*sNode %" PRId64 " height=%d n_children=%d  keyrange=%s %s\n",
            depth, "", blocknum.b, node->height, node->n_children, (char*)(lorange ? lorange->data : 0), (char*)(hirange ? hirange->data : 0));
6334
    {
6335 6336 6337
        int i;
        for (i=0; i+1< node->n_children; i++) {
            fprintf(file, "%*spivotkey %d =", depth+1, "", i);
6338
            toku_print_BYTESTRING(file, node->childkeys[i].size, (char *) node->childkeys[i].data);
6339 6340 6341 6342
            fprintf(file, "\n");
        }
        for (i=0; i< node->n_children; i++) {
            if (node->height > 0) {
6343
                NONLEAF_CHILDINFO bnc = BNC(node, i);
6344 6345 6346 6347
                fprintf(file, "%*schild %d buffered (%d entries):", depth+1, "", i, toku_bnc_n_entries(bnc));
                FIFO_ITERATE(bnc->buffer, key, keylen, data, datalen, type, msn, xids, UU(is_fresh),
                             {
                                 data=data; datalen=datalen; keylen=keylen;
6348
                                 fprintf(file, "%*s xid=%" PRIu64 " %u (type=%d) msn=0x%" PRIu64 "\n", depth+2, "", xids_get_innermost_xid(xids), (unsigned)toku_dtoh32(*(int*)key), type, msn.msn);
6349 6350 6351 6352 6353
                                 //assert(strlen((char*)key)+1==keylen);
                                 //assert(strlen((char*)data)+1==datalen);
                             });
            }
            else {
6354
                int size = BLB_DATA(node, i)->num_klpairs();
6355 6356
                if (0)
                    for (int j=0; j<size; j++) {
6357 6358 6359 6360
                        LEAFENTRY le;
                        void* keyp = NULL;
                        uint32_t keylen = 0;
                        int r = BLB_DATA(node,i)->fetch_klpair(j, &le, &keylen, &keyp);
6361 6362
                        assert_zero(r);
                        fprintf(file, " [%d]=", j);
6363
                        print_klpair(file, keyp, keylen, le);
6364 6365 6366 6367 6368 6369 6370 6371 6372
                        fprintf(file, "\n");
                    }
                fprintf(file, "\n");
            }
        }
        if (node->height > 0) {
            for (i=0; i<node->n_children; i++) {
                fprintf(file, "%*schild %d\n", depth, "", i);
                if (i>0) {
6373
                    char *CAST_FROM_VOIDP(key, node->childkeys[i-1].data);
6374 6375
                    fprintf(file, "%*spivot %d len=%u %u\n", depth+1, "", i-1, node->childkeys[i-1].size, (unsigned)toku_dtoh32(*(int*)key));
                }
6376
                toku_dump_ftnode(file, brt, BP_BLOCKNUM(node, i), depth+4,
6377 6378 6379 6380
                                  (i==0) ? lorange : &node->childkeys[i-1],
                                  (i==node->n_children-1) ? hirange : &node->childkeys[i]);
            }
        }
6381
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6382
    toku_unpin_ftnode_off_client_thread(brt->ft, node);
6383 6384 6385
    return result;
}

6386
int toku_dump_ft (FILE *f, FT_HANDLE brt) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6387
    int r;
6388 6389
    assert(brt->ft);
    toku_dump_translation_table(f, brt->ft->blocktable);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6390
    {
Yoni Fogel's avatar
Yoni Fogel committed
6391
        uint32_t fullhash = 0;
6392
        CACHEKEY root_key;
6393
        toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
6394
        r = toku_dump_ftnode(f, brt, root_key, 0, 0, 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6395 6396
    }
    return r;
6397
}
6398

6399
int toku_ft_layer_init(void) {
Yoni Fogel's avatar
Yoni Fogel committed
6400 6401
    int r = 0;
    //Portability must be initialized first
6402 6403
    r = toku_portability_init();
    if (r) { goto exit; }
6404 6405
    r = db_env_set_toku_product_name("tokudb");
    if (r) { goto exit; }
6406

6407
    partitioned_counters_init();
6408
    status_init();
6409
    txn_status_init();
6410 6411
    toku_checkpoint_init();
    toku_ft_serialize_layer_init();
6412
    toku_mutex_init(&ft_open_close_lock, NULL);
6413
    toku_scoped_malloc_init();
6414
exit:
Yoni Fogel's avatar
Yoni Fogel committed
6415
    return r;
Yoni Fogel's avatar
Yoni Fogel committed
6416 6417
}

6418
void toku_ft_layer_destroy(void) {
6419
    toku_mutex_destroy(&ft_open_close_lock);
6420 6421
    toku_ft_serialize_layer_destroy();
    toku_checkpoint_destroy();
6422
    status_destroy();
6423
    txn_status_destroy();
6424
    toku_context_status_destroy();
6425
    partitioned_counters_destroy();
6426
    toku_scoped_malloc_destroy();
Yoni Fogel's avatar
Yoni Fogel committed
6427
    //Portability must be cleaned up last
6428
    toku_portability_destroy();
Yoni Fogel's avatar
Yoni Fogel committed
6429 6430
}

6431 6432
// This lock serializes all opens and closes because the cachetable requires that clients do not try to open or close a cachefile in parallel.  We made
// it coarser by not allowing any cachefiles to be open or closed in parallel.
6433 6434 6435 6436 6437 6438 6439 6440
void toku_ft_open_close_lock(void) {
    toku_mutex_lock(&ft_open_close_lock);
}

void toku_ft_open_close_unlock(void) {
    toku_mutex_unlock(&ft_open_close_lock);
}

6441 6442
// Prepare to remove a dictionary from the database when this transaction is committed:
//  - mark transaction as NEED fsync on commit
6443
//  - make entry in rollback log
6444
//  - make fdelete entry in recovery log
6445 6446 6447 6448 6449 6450 6451 6452 6453 6454 6455 6456
//
// Effect: when the txn commits, the ft's cachefile will be marked as unlink
//         on close. see toku_commit_fdelete and how unlink on close works
//         in toku_cachefile_close();
// Requires: serialized with begin checkpoint
//           this does not need to take the open close lock because
//           1.) the ft/cf cannot go away because we have a live handle.
//           2.) we're not setting the unlink on close bit _here_. that
//           happens on txn commit (as the name suggests).
//           3.) we're already holding the multi operation lock to 
//           synchronize with begin checkpoint.
// Contract: the iname of the ft should never be reused.
6457
void toku_ft_unlink_on_commit(FT_HANDLE handle, TOKUTXN txn) {
6458
    assert(txn);
6459 6460

    CACHEFILE cf = handle->ft->cf;
6461
    FT CAST_FROM_VOIDP(ft, toku_cachefile_get_userdata(cf));
6462

6463 6464
    toku_txn_maybe_note_ft(txn, ft);

6465 6466 6467 6468
    // If the txn commits, the commit MUST be in the log before the file is actually unlinked
    toku_txn_force_fsync_on_commit(txn); 
    // make entry in rollback log
    FILENUM filenum = toku_cachefile_filenum(cf);
6469
    toku_logger_save_rollback_fdelete(txn, filenum);
6470
    // make entry in recovery log
6471
    toku_logger_log_fdelete(txn, filenum);
6472 6473
}

6474 6475 6476 6477 6478 6479
// Non-transactional version of fdelete
//
// Effect: The ft file is unlinked when the handle closes and it's ft is not
//         pinned by checkpoint. see toku_remove_ft_ref() and how unlink on
//         close works in toku_cachefile_close();
// Requires: serialized with begin checkpoint
6480
void toku_ft_unlink(FT_HANDLE handle) {
6481
    CACHEFILE cf;
6482 6483
    cf = handle->ft->cf;
    toku_cachefile_unlink_on_close(cf);
6484 6485
}

6486
int
6487
toku_ft_get_fragmentation(FT_HANDLE brt, TOKU_DB_FRAGMENTATION report) {
6488 6489
    int r;

6490
    int fd = toku_cachefile_get_fd(brt->ft->cf);
6491
    toku_ft_lock(brt->ft);
6492 6493

    int64_t file_size;
6494
    r = toku_os_get_file_size(fd, &file_size);
6495
    if (r==0) {
6496
        report->file_size_bytes = file_size;
6497
        toku_block_table_get_fragmentation_unlocked(brt->ft->blocktable, report);
6498
    }
6499
    toku_ft_unlock(brt->ft);
6500 6501
    return r;
}
6502

Yoni Fogel's avatar
Yoni Fogel committed
6503
static bool is_empty_fast_iter (FT_HANDLE brt, FTNODE node) {
6504
    if (node->height > 0) {
6505
        for (int childnum=0; childnum<node->n_children; childnum++) {
6506
            if (toku_bnc_nbytesinbuf(BNC(node, childnum)) != 0) {
6507 6508
                return 0; // it's not empty if there are bytes in buffers
            }
6509
            FTNODE childnode;
6510 6511
            {
                BLOCKNUM childblocknum = BP_BLOCKNUM(node,childnum);
Yoni Fogel's avatar
Yoni Fogel committed
6512
                uint32_t fullhash =  compute_child_fullhash(brt->ft->cf, node, childnum);
6513
                struct ftnode_fetch_extra bfe;
6514
                fill_bfe_for_full_read(&bfe, brt->ft);
6515
                // don't need to pass in dependent nodes as we are not
6516
                // modifying nodes we are pinning
6517
                toku_pin_ftnode_off_client_thread(
6518
                    brt->ft,
6519 6520 6521
                    childblocknum,
                    fullhash,
                    &bfe,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6522
                    PL_READ, // may_modify_node set to false, as nodes not modified
6523 6524 6525
                    0,
                    NULL,
                    &childnode
6526
                    );
6527 6528
            }
            int child_is_empty = is_empty_fast_iter(brt, childnode);
6529
            toku_unpin_ftnode(brt->ft, childnode);
6530 6531 6532
            if (!child_is_empty) return 0;
        }
        return 1;
6533
    } else {
6534
        // leaf:  If the dmt is empty, we are happy.
6535
        for (int i = 0; i < node->n_children; i++) {
6536
            if (BLB_DATA(node, i)->num_klpairs()) {
Yoni Fogel's avatar
Yoni Fogel committed
6537
                return false;
6538 6539
            }
        }
Yoni Fogel's avatar
Yoni Fogel committed
6540
        return true;
6541 6542 6543
    }
}

Yoni Fogel's avatar
Yoni Fogel committed
6544
bool toku_ft_is_empty_fast (FT_HANDLE brt)
6545 6546 6547
// A fast check to see if the tree is empty.  If there are any messages or leafentries, we consider the tree to be nonempty.  It's possible that those
// messages and leafentries would all optimize away and that the tree is empty, but we'll say it is nonempty.
{
Yoni Fogel's avatar
Yoni Fogel committed
6548
    uint32_t fullhash;
6549
    FTNODE node;
6550
    {
6551
        CACHEKEY root_key;
6552
        toku_calculate_root_offset_pointer(brt->ft, &root_key, &fullhash);
6553
        struct ftnode_fetch_extra bfe;
6554
        fill_bfe_for_full_read(&bfe, brt->ft);
6555
        toku_pin_ftnode_off_client_thread(
6556
            brt->ft,
6557
            root_key,
6558
            fullhash,
6559
            &bfe,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
6560
            PL_READ, // may_modify_node set to false, node does not change
6561 6562 6563
            0,
            NULL,
            &node
6564
            );
6565
    }
Yoni Fogel's avatar
Yoni Fogel committed
6566
    bool r = is_empty_fast_iter(brt, node);
6567
    toku_unpin_ftnode(brt->ft, node);
6568 6569
    return r;
}
6570

6571
// test-only
6572
int toku_ft_strerror_r(int error, char *buf, size_t buflen)
6573 6574
{
    if (error>=0) {
6575
        return (long) strerror_r(error, buf, buflen);
6576
    } else {
6577 6578 6579 6580 6581 6582 6583 6584 6585
        switch (error) {
        case DB_KEYEXIST:
            snprintf(buf, buflen, "Key exists");
            return 0;
        case TOKUDB_CANCELED:
            snprintf(buf, buflen, "User canceled operation");
            return 0;
        default:
            snprintf(buf, buflen, "Unknown error %d", error);
6586
            return EINVAL;
6587
        }
6588 6589
    }
}
6590

6591
#include <toku_race_tools.h>
6592
void __attribute__((__constructor__)) toku_ft_helgrind_ignore(void);
6593
void
6594
toku_ft_helgrind_ignore(void) {
6595
    TOKU_VALGRIND_HG_DISABLE_CHECKING(&ft_status, sizeof ft_status);
6596
}
6597

6598
#undef STATUS_INC