�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2F'>rocksdb</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fdb_stress_tool%2F'>db_stress_tool</a>/</p><hr><h3>✏️ Editing: batched_ops_stress.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>//  Copyright (c) 2011-present, Facebook, Inc.  All rights reserved.
//  This source code is licensed under both the GPLv2 (found in the
//  COPYING file in the root directory) and Apache 2.0 License
//  (found in the LICENSE.Apache file in the root directory).
//
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#ifdef GFLAGS
#include &quot;db_stress_tool/db_stress_common.h&quot;

namespace ROCKSDB_NAMESPACE {
class BatchedOpsStressTest : public StressTest {
 public:
  BatchedOpsStressTest() {}
  virtual ~BatchedOpsStressTest() {}

  // Given a key K and value V, this puts (&quot;0&quot;+K, &quot;0&quot;+V), (&quot;1&quot;+K, &quot;1&quot;+V), ...
  // (&quot;9&quot;+K, &quot;9&quot;+V) in DB atomically i.e in a single batch.
  // Also refer BatchedOpsStressTest::TestGet
  Status TestPut(ThreadState* thread, WriteOptions&amp; write_opts,
                 const ReadOptions&amp; /* read_opts */,
                 const std::vector&lt;int&gt;&amp; rand_column_families,
                 const std::vector&lt;int64_t&gt;&amp; rand_keys, char (&amp;value)[100],
                 std::unique_ptr&lt;MutexLock&gt;&amp; /* lock */) override {
    uint32_t value_base =
        thread-&gt;rand.Next() % thread-&gt;shared-&gt;UNKNOWN_SENTINEL;
    size_t sz = GenerateValue(value_base, value, sizeof(value));
    Slice v(value, sz);
    std::string keys[10] = {&quot;9&quot;, &quot;8&quot;, &quot;7&quot;, &quot;6&quot;, &quot;5&quot;, &quot;4&quot;, &quot;3&quot;, &quot;2&quot;, &quot;1&quot;, &quot;0&quot;};
    std::string values[10] = {&quot;9&quot;, &quot;8&quot;, &quot;7&quot;, &quot;6&quot;, &quot;5&quot;, &quot;4&quot;, &quot;3&quot;, &quot;2&quot;, &quot;1&quot;, &quot;0&quot;};
    Slice value_slices[10];
    WriteBatch batch;
    Status s;
    auto cfh = column_families_[rand_column_families[0]];
    std::string key_str = Key(rand_keys[0]);
    for (int i = 0; i &lt; 10; i++) {
      keys[i] += key_str;
      values[i] += v.ToString();
      value_slices[i] = values[i];
      if (FLAGS_use_merge) {
        batch.Merge(cfh, keys[i], value_slices[i]);
      } else {
        batch.Put(cfh, keys[i], value_slices[i]);
      }
    }

    s = db_-&gt;Write(write_opts, &amp;batch);
    if (!s.ok()) {
      fprintf(stderr, &quot;multiput error: %s\n&quot;, s.ToString().c_str());
      thread-&gt;stats.AddErrors(1);
    } else {
      // we did 10 writes each of size sz + 1
      thread-&gt;stats.AddBytesForWrites(10, (sz + 1) * 10);
    }

    return s;
  }

  // Given a key K, this deletes (&quot;0&quot;+K), (&quot;1&quot;+K),... (&quot;9&quot;+K)
  // in DB atomically i.e in a single batch. Also refer MultiGet.
  Status TestDelete(ThreadState* thread, WriteOptions&amp; writeoptions,
                    const std::vector&lt;int&gt;&amp; rand_column_families,
                    const std::vector&lt;int64_t&gt;&amp; rand_keys,
                    std::unique_ptr&lt;MutexLock&gt;&amp; /* lock */) override {
    std::string keys[10] = {&quot;9&quot;, &quot;7&quot;, &quot;5&quot;, &quot;3&quot;, &quot;1&quot;, &quot;8&quot;, &quot;6&quot;, &quot;4&quot;, &quot;2&quot;, &quot;0&quot;};

    WriteBatch batch;
    Status s;
    auto cfh = column_families_[rand_column_families[0]];
    std::string key_str = Key(rand_keys[0]);
    for (int i = 0; i &lt; 10; i++) {
      keys[i] += key_str;
      batch.Delete(cfh, keys[i]);
    }

    s = db_-&gt;Write(writeoptions, &amp;batch);
    if (!s.ok()) {
      fprintf(stderr, &quot;multidelete error: %s\n&quot;, s.ToString().c_str());
      thread-&gt;stats.AddErrors(1);
    } else {
      thread-&gt;stats.AddDeletes(10);
    }

    return s;
  }

  Status TestDeleteRange(ThreadState* /* thread */,
                         WriteOptions&amp; /* write_opts */,
                         const std::vector&lt;int&gt;&amp; /* rand_column_families */,
                         const std::vector&lt;int64_t&gt;&amp; /* rand_keys */,
                         std::unique_ptr&lt;MutexLock&gt;&amp; /* lock */) override {
    assert(false);
    return Status::NotSupported(
        &quot;BatchedOpsStressTest does not support &quot;
        &quot;TestDeleteRange&quot;);
  }

  void TestIngestExternalFile(
      ThreadState* /* thread */,
      const std::vector&lt;int&gt;&amp; /* rand_column_families */,
      const std::vector&lt;int64_t&gt;&amp; /* rand_keys */,
      std::unique_ptr&lt;MutexLock&gt;&amp; /* lock */) override {
    assert(false);
    fprintf(stderr,
            &quot;BatchedOpsStressTest does not support &quot;
            &quot;TestIngestExternalFile\n&quot;);
    std::terminate();
  }

  // Given a key K, this gets values for &quot;0&quot;+K, &quot;1&quot;+K,...&quot;9&quot;+K
  // in the same snapshot, and verifies that all the values are of the form
  // &quot;0&quot;+V, &quot;1&quot;+V,...&quot;9&quot;+V.
  // ASSUMES that BatchedOpsStressTest::TestPut was used to put (K, V) into
  // the DB.
  Status TestGet(ThreadState* thread, const ReadOptions&amp; readoptions,
                 const std::vector&lt;int&gt;&amp; rand_column_families,
                 const std::vector&lt;int64_t&gt;&amp; rand_keys) override {
    std::string keys[10] = {&quot;0&quot;, &quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;, &quot;5&quot;, &quot;6&quot;, &quot;7&quot;, &quot;8&quot;, &quot;9&quot;};
    Slice key_slices[10];
    std::string values[10];
    ReadOptions readoptionscopy = readoptions;
    readoptionscopy.snapshot = db_-&gt;GetSnapshot();
    std::string key_str = Key(rand_keys[0]);
    Slice key = key_str;
    auto cfh = column_families_[rand_column_families[0]];
    std::string from_db;
    Status s;
    for (int i = 0; i &lt; 10; i++) {
      keys[i] += key.ToString();
      key_slices[i] = keys[i];
      s = db_-&gt;Get(readoptionscopy, cfh, key_slices[i], &amp;from_db);
      if (!s.ok() &amp;&amp; !s.IsNotFound()) {
        fprintf(stderr, &quot;get error: %s\n&quot;, s.ToString().c_str());
        values[i] = &quot;&quot;;
        thread-&gt;stats.AddErrors(1);
        // we continue after error rather than exiting so that we can
        // find more errors if any
      } else if (s.IsNotFound()) {
        values[i] = &quot;&quot;;
        thread-&gt;stats.AddGets(1, 0);
      } else {
        values[i] = from_db;

        char expected_prefix = (keys[i])[0];
        char actual_prefix = (values[i])[0];
        if (actual_prefix != expected_prefix) {
          fprintf(stderr, &quot;error expected prefix = %c actual = %c\n&quot;,
                  expected_prefix, actual_prefix);
        }
        (values[i])[0] = &#039; &#039;;  // blank out the differing character
        thread-&gt;stats.AddGets(1, 1);
      }
    }
    db_-&gt;ReleaseSnapshot(readoptionscopy.snapshot);

    // Now that we retrieved all values, check that they all match
    for (int i = 1; i &lt; 10; i++) {
      if (values[i] != values[0]) {
        fprintf(stderr, &quot;error : inconsistent values for key %s: %s, %s\n&quot;,
                key.ToString(true).c_str(), StringToHex(values[0]).c_str(),
                StringToHex(values[i]).c_str());
        // we continue after error rather than exiting so that we can
        // find more errors if any
      }
    }

    return s;
  }

  std::vector&lt;Status&gt; TestMultiGet(
      ThreadState* thread, const ReadOptions&amp; readoptions,
      const std::vector&lt;int&gt;&amp; rand_column_families,
      const std::vector&lt;int64_t&gt;&amp; rand_keys) override {
    size_t num_keys = rand_keys.size();
    std::vector&lt;Status&gt; ret_status(num_keys);
    std::array&lt;std::string, 10&gt; keys = {{&quot;0&quot;, &quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;,
                                         &quot;5&quot;, &quot;6&quot;, &quot;7&quot;, &quot;8&quot;, &quot;9&quot;}};
    size_t num_prefixes = keys.size();
    for (size_t rand_key = 0; rand_key &lt; num_keys; ++rand_key) {
      std::vector&lt;Slice&gt; key_slices;
      std::vector&lt;PinnableSlice&gt; values(num_prefixes);
      std::vector&lt;Status&gt; statuses(num_prefixes);
      ReadOptions readoptionscopy = readoptions;
      readoptionscopy.snapshot = db_-&gt;GetSnapshot();
      std::vector&lt;std::string&gt; key_str;
      key_str.reserve(num_prefixes);
      key_slices.reserve(num_prefixes);
      std::string from_db;
      ColumnFamilyHandle* cfh = column_families_[rand_column_families[0]];

      for (size_t key = 0; key &lt; num_prefixes; ++key) {
        key_str.emplace_back(keys[key] + Key(rand_keys[rand_key]));
        key_slices.emplace_back(key_str.back());
      }
      db_-&gt;MultiGet(readoptionscopy, cfh, num_prefixes, key_slices.data(),
                    values.data(), statuses.data());
      for (size_t i = 0; i &lt; num_prefixes; i++) {
        Status s = statuses[i];
        if (!s.ok() &amp;&amp; !s.IsNotFound()) {
          fprintf(stderr, &quot;get error: %s\n&quot;, s.ToString().c_str());
          thread-&gt;stats.AddErrors(1);
          ret_status[rand_key] = s;
          // we continue after error rather than exiting so that we can
          // find more errors if any
        } else if (s.IsNotFound()) {
          thread-&gt;stats.AddGets(1, 0);
          ret_status[rand_key] = s;
        } else {
          char expected_prefix = (keys[i])[0];
          char actual_prefix = (values[i])[0];
          if (actual_prefix != expected_prefix) {
            fprintf(stderr, &quot;error expected prefix = %c actual = %c\n&quot;,
                    expected_prefix, actual_prefix);
          }
          std::string str;
          str.assign(values[i].data(), values[i].size());
          values[i].Reset();
          str[0] = &#039; &#039;;  // blank out the differing character
          values[i].PinSelf(str);
          thread-&gt;stats.AddGets(1, 1);
        }
      }
      db_-&gt;ReleaseSnapshot(readoptionscopy.snapshot);

      // Now that we retrieved all values, check that they all match
      for (size_t i = 1; i &lt; num_prefixes; i++) {
        if (values[i] != values[0]) {
          fprintf(stderr, &quot;error : inconsistent values for key %s: %s, %s\n&quot;,
                  key_str[i].c_str(), StringToHex(values[0].ToString()).c_str(),
                  StringToHex(values[i].ToString()).c_str());
          // we continue after error rather than exiting so that we can
          // find more errors if any
        }
      }
    }

    return ret_status;
  }

  // Given a key, this does prefix scans for &quot;0&quot;+P, &quot;1&quot;+P,...&quot;9&quot;+P
  // in the same snapshot where P is the first FLAGS_prefix_size - 1 bytes
  // of the key. Each of these 10 scans returns a series of values;
  // each series should be the same length, and it is verified for each
  // index i that all the i&#039;th values are of the form &quot;0&quot;+V, &quot;1&quot;+V,...&quot;9&quot;+V.
  // ASSUMES that MultiPut was used to put (K, V)
  Status TestPrefixScan(ThreadState* thread, const ReadOptions&amp; readoptions,
                        const std::vector&lt;int&gt;&amp; rand_column_families,
                        const std::vector&lt;int64_t&gt;&amp; rand_keys) override {
    size_t prefix_to_use =
        (FLAGS_prefix_size &lt; 0) ? 7 : static_cast&lt;size_t&gt;(FLAGS_prefix_size);
    std::string key_str = Key(rand_keys[0]);
    Slice key = key_str;
    auto cfh = column_families_[rand_column_families[0]];
    std::string prefixes[10] = {&quot;0&quot;, &quot;1&quot;, &quot;2&quot;, &quot;3&quot;, &quot;4&quot;,
                                &quot;5&quot;, &quot;6&quot;, &quot;7&quot;, &quot;8&quot;, &quot;9&quot;};
    Slice prefix_slices[10];
    ReadOptions readoptionscopy[10];
    const Snapshot* snapshot = db_-&gt;GetSnapshot();
    Iterator* iters[10];
    std::string upper_bounds[10];
    Slice ub_slices[10];
    Status s = Status::OK();
    for (int i = 0; i &lt; 10; i++) {
      prefixes[i] += key.ToString();
      prefixes[i].resize(prefix_to_use);
      prefix_slices[i] = Slice(prefixes[i]);
      readoptionscopy[i] = readoptions;
      readoptionscopy[i].snapshot = snapshot;
      if (thread-&gt;rand.OneIn(2) &amp;&amp;
          GetNextPrefix(prefix_slices[i], &amp;(upper_bounds[i]))) {
        // For half of the time, set the upper bound to the next prefix
        ub_slices[i] = Slice(upper_bounds[i]);
        readoptionscopy[i].iterate_upper_bound = &amp;(ub_slices[i]);
      }
      iters[i] = db_-&gt;NewIterator(readoptionscopy[i], cfh);
      iters[i]-&gt;Seek(prefix_slices[i]);
    }

    long count = 0;
    while (iters[0]-&gt;Valid() &amp;&amp; iters[0]-&gt;key().starts_with(prefix_slices[0])) {
      count++;
      std::string values[10];
      // get list of all values for this iteration
      for (int i = 0; i &lt; 10; i++) {
        // no iterator should finish before the first one
        assert(iters[i]-&gt;Valid() &amp;&amp;
               iters[i]-&gt;key().starts_with(prefix_slices[i]));
        values[i] = iters[i]-&gt;value().ToString();

        char expected_first = (prefixes[i])[0];
        char actual_first = (values[i])[0];

        if (actual_first != expected_first) {
          fprintf(stderr, &quot;error expected first = %c actual = %c\n&quot;,
                  expected_first, actual_first);
        }
        (values[i])[0] = &#039; &#039;;  // blank out the differing character
      }
      // make sure all values are equivalent
      for (int i = 0; i &lt; 10; i++) {
        if (values[i] != values[0]) {
          fprintf(stderr,
                  &quot;error : %d, inconsistent values for prefix %s: %s, %s\n&quot;, i,
                  prefixes[i].c_str(), StringToHex(values[0]).c_str(),
                  StringToHex(values[i]).c_str());
          // we continue after error rather than exiting so that we can
          // find more errors if any
        }
        iters[i]-&gt;Next();
      }
    }

    // cleanup iterators and snapshot
    for (int i = 0; i &lt; 10; i++) {
      // if the first iterator finished, they should have all finished
      assert(!iters[i]-&gt;Valid() ||
             !iters[i]-&gt;key().starts_with(prefix_slices[i]));
      assert(iters[i]-&gt;status().ok());
      delete iters[i];
    }
    db_-&gt;ReleaseSnapshot(snapshot);

    if (s.ok()) {
      thread-&gt;stats.AddPrefixes(1, count);
    } else {
      fprintf(stderr, &quot;TestPrefixScan error: %s\n&quot;, s.ToString().c_str());
      thread-&gt;stats.AddErrors(1);
    }

    return s;
  }

  void VerifyDb(ThreadState* /* thread */) const override {}
};

StressTest* CreateBatchedOpsStressTest() { return new BatchedOpsStressTest(); }

}  // namespace ROCKSDB_NAMESPACE
#endif  // GFLAGS
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Frocksdb%2Frocksdb%2Fdb_stress_tool'>🔙 Back</a></p>