electrobun 0.0.1 → 0.0.2

package/src/bsdiff/zstd/contrib/pzstd/utils/ResourcePool.h

@@ -1,96 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#pragma once
-
-#include <cassert>
-#include <functional>
-#include <memory>
-#include <mutex>
-#include <vector>
-
-namespace pzstd {
-
-/**
- * An unbounded pool of resources.
- * A `ResourcePool<T>` requires a factory function that takes allocates `T*` and
- * a free function that frees a `T*`.
- * Calling `ResourcePool::get()` will give you a new `ResourcePool::UniquePtr`
- * to a `T`, and when it goes out of scope the resource will be returned to the
- * pool.
- * The `ResourcePool<T>` *must* survive longer than any resources it hands out.
- * Remember that `ResourcePool<T>` hands out mutable `T`s, so make sure to clean
- * up the resource before or after every use.
- */
-template <typename T>
-class ResourcePool {
- public:
-  class Deleter;
-  using Factory = std::function<T*()>;
-  using Free = std::function<void(T*)>;
-  using UniquePtr = std::unique_ptr<T, Deleter>;
-
- private:
-  std::mutex mutex_;
-  Factory factory_;
-  Free free_;
-  std::vector<T*> resources_;
-  unsigned inUse_;
-
- public:
-  /**
-   * Creates a `ResourcePool`.
-   *
-   * @param factory  The function to use to create new resources.
-   * @param free     The function to use to free resources created by `factory`.
-   */
-  ResourcePool(Factory factory, Free free)
-      : factory_(std::move(factory)), free_(std::move(free)), inUse_(0) {}
-
-  /**
-   * @returns  A unique pointer to a resource.  The resource is null iff
-   *           there are no available resources and `factory()` returns null.
-   */
-  UniquePtr get() {
-    std::lock_guard<std::mutex> lock(mutex_);
-    if (!resources_.empty()) {
-      UniquePtr resource{resources_.back(), Deleter{*this}};
-      resources_.pop_back();
-      ++inUse_;
-      return resource;
-    }
-    UniquePtr resource{factory_(), Deleter{*this}};
-    ++inUse_;
-    return resource;
-  }
-
-  ~ResourcePool() noexcept {
-    assert(inUse_ == 0);
-    for (const auto resource : resources_) {
-      free_(resource);
-    }
-  }
-
-  class Deleter {
-    ResourcePool *pool_;
-  public:
-    explicit Deleter(ResourcePool &pool) : pool_(&pool) {}
-
-    void operator() (T *resource) {
-      std::lock_guard<std::mutex> lock(pool_->mutex_);
-      // Make sure we don't put null resources into the pool
-      if (resource) {
-        pool_->resources_.push_back(resource);
-      }
-      assert(pool_->inUse_ > 0);
-      --pool_->inUse_;
-    }
-  };
-};
-
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/ScopeGuard.h

@@ -1,50 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#pragma once
-
-#include <utility>
-
-namespace pzstd {
-
-/**
- * Dismissable scope guard.
- * `Function` must be callable and take no parameters.
- * Unless `dismiss()` is called, the callable is executed upon destruction of
- * `ScopeGuard`.
- *
- * Example:
- *
- *   auto guard = makeScopeGuard([&] { cleanup(); });
- */
-template <typename Function>
-class ScopeGuard {
-  Function function;
-  bool dismissed;
-
- public:
-  explicit ScopeGuard(Function&& function)
-      : function(std::move(function)), dismissed(false) {}
-
-  void dismiss() {
-    dismissed = true;
-  }
-
-  ~ScopeGuard() noexcept {
-    if (!dismissed) {
-      function();
-    }
-  }
-};
-
-/// Creates a scope guard from `function`.
-template <typename Function>
-ScopeGuard<Function> makeScopeGuard(Function&& function) {
-  return ScopeGuard<Function>(std::forward<Function>(function));
-}
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/ThreadPool.h

@@ -1,58 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#pragma once
-
-#include "utils/WorkQueue.h"
-
-#include <cstddef>
-#include <functional>
-#include <thread>
-#include <vector>
-
-namespace pzstd {
-/// A simple thread pool that pulls tasks off its queue in FIFO order.
-class ThreadPool {
-  std::vector<std::thread> threads_;
-
-  WorkQueue<std::function<void()>> tasks_;
-
- public:
-  /// Constructs a thread pool with `numThreads` threads.
-  explicit ThreadPool(std::size_t numThreads) {
-    threads_.reserve(numThreads);
-    for (std::size_t i = 0; i < numThreads; ++i) {
-      threads_.emplace_back([this] {
-        std::function<void()> task;
-        while (tasks_.pop(task)) {
-          task();
-        }
-      });
-    }
-  }
-
-  /// Finishes all tasks currently in the queue.
-  ~ThreadPool() {
-    tasks_.finish();
-    for (auto& thread : threads_) {
-      thread.join();
-    }
-  }
-
-  /**
-   * Adds `task` to the queue of tasks to execute. Since `task` is a
-   * `std::function<>`, it cannot be a move only type. So any lambda passed must
-   * not capture move only types (like `std::unique_ptr`).
-   *
-   * @param task  The task to execute.
-   */
-  void add(std::function<void()> task) {
-    tasks_.push(std::move(task));
-  }
-};
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/WorkQueue.h

@@ -1,181 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#pragma once
-
-#include "utils/Buffer.h"
-
-#include <atomic>
-#include <cassert>
-#include <cstddef>
-#include <condition_variable>
-#include <cstddef>
-#include <functional>
-#include <mutex>
-#include <queue>
-
-namespace pzstd {
-
-/// Unbounded thread-safe work queue.
-template <typename T>
-class WorkQueue {
-  // Protects all member variable access
-  std::mutex mutex_;
-  std::condition_variable readerCv_;
-  std::condition_variable writerCv_;
-  std::condition_variable finishCv_;
-
-  std::queue<T> queue_;
-  bool done_;
-  std::size_t maxSize_;
-
-  // Must have lock to call this function
-  bool full() const {
-    if (maxSize_ == 0) {
-      return false;
-    }
-    return queue_.size() >= maxSize_;
-  }
-
- public:
-  /**
-   * Constructs an empty work queue with an optional max size.
-   * If `maxSize == 0` the queue size is unbounded.
-   *
-   * @param maxSize The maximum allowed size of the work queue.
-   */
-  WorkQueue(std::size_t maxSize = 0) : done_(false), maxSize_(maxSize) {}
-
-  /**
-   * Push an item onto the work queue.  Notify a single thread that work is
-   * available.  If `finish()` has been called, do nothing and return false.
-   * If `push()` returns false, then `item` has not been moved from.
-   *
-   * @param item  Item to push onto the queue.
-   * @returns     True upon success, false if `finish()` has been called.  An
-   *               item was pushed iff `push()` returns true.
-   */
-  bool push(T&& item) {
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      while (full() && !done_) {
-        writerCv_.wait(lock);
-      }
-      if (done_) {
-        return false;
-      }
-      queue_.push(std::move(item));
-    }
-    readerCv_.notify_one();
-    return true;
-  }
-
-  /**
-   * Attempts to pop an item off the work queue.  It will block until data is
-   * available or `finish()` has been called.
-   *
-   * @param[out] item  If `pop` returns `true`, it contains the popped item.
-   *                    If `pop` returns `false`, it is unmodified.
-   * @returns          True upon success.  False if the queue is empty and
-   *                    `finish()` has been called.
-   */
-  bool pop(T& item) {
-    {
-      std::unique_lock<std::mutex> lock(mutex_);
-      while (queue_.empty() && !done_) {
-        readerCv_.wait(lock);
-      }
-      if (queue_.empty()) {
-        assert(done_);
-        return false;
-      }
-      item = std::move(queue_.front());
-      queue_.pop();
-    }
-    writerCv_.notify_one();
-    return true;
-  }
-
-  /**
-   * Sets the maximum queue size.  If `maxSize == 0` then it is unbounded.
-   *
-   * @param maxSize The new maximum queue size.
-   */
-  void setMaxSize(std::size_t maxSize) {
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      maxSize_ = maxSize;
-    }
-    writerCv_.notify_all();
-  }
-
-  /**
-   * Promise that `push()` won't be called again, so once the queue is empty
-   * there will never any more work.
-   */
-  void finish() {
-    {
-      std::lock_guard<std::mutex> lock(mutex_);
-      assert(!done_);
-      done_ = true;
-    }
-    readerCv_.notify_all();
-    writerCv_.notify_all();
-    finishCv_.notify_all();
-  }
-
-  /// Blocks until `finish()` has been called (but the queue may not be empty).
-  void waitUntilFinished() {
-    std::unique_lock<std::mutex> lock(mutex_);
-    while (!done_) {
-      finishCv_.wait(lock);
-    }
-  }
-};
-
-/// Work queue for `Buffer`s that knows the total number of bytes in the queue.
-class BufferWorkQueue {
-  WorkQueue<Buffer> queue_;
-  std::atomic<std::size_t> size_;
-
- public:
-  BufferWorkQueue(std::size_t maxSize = 0) : queue_(maxSize), size_(0) {}
-
-  void push(Buffer buffer) {
-    size_.fetch_add(buffer.size());
-    queue_.push(std::move(buffer));
-  }
-
-  bool pop(Buffer& buffer) {
-    bool result = queue_.pop(buffer);
-    if (result) {
-      size_.fetch_sub(buffer.size());
-    }
-    return result;
-  }
-
-  void setMaxSize(std::size_t maxSize) {
-    queue_.setMaxSize(maxSize);
-  }
-
-  void finish() {
-    queue_.finish();
-  }
-
-  /**
-   * Blocks until `finish()` has been called.
-   *
-   * @returns The total number of bytes of all the `Buffer`s currently in the
-   *           queue.
-   */
-  std::size_t size() {
-    queue_.waitUntilFinished();
-    return size_.load();
-  }
-};
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/test/BUCK

@@ -1,35 +0,0 @@
-cxx_test(
-    name='buffer_test',
-    srcs=['BufferTest.cpp'],
-    deps=['//contrib/pzstd/utils:buffer'],
-)
-
-cxx_test(
-    name='range_test',
-    srcs=['RangeTest.cpp'],
-    deps=['//contrib/pzstd/utils:range'],
-)
-
-cxx_test(
-    name='resource_pool_test',
-    srcs=['ResourcePoolTest.cpp'],
-    deps=['//contrib/pzstd/utils:resource_pool'],
-)
-
-cxx_test(
-    name='scope_guard_test',
-    srcs=['ScopeGuardTest.cpp'],
-    deps=['//contrib/pzstd/utils:scope_guard'],
-)
-
-cxx_test(
-    name='thread_pool_test',
-    srcs=['ThreadPoolTest.cpp'],
-    deps=['//contrib/pzstd/utils:thread_pool'],
-)
-
-cxx_test(
-    name='work_queue_test',
-    srcs=['RangeTest.cpp'],
-    deps=['//contrib/pzstd/utils:work_queue'],
-)

package/src/bsdiff/zstd/contrib/pzstd/utils/test/BufferTest.cpp

@@ -1,89 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#include "utils/Buffer.h"
-#include "utils/Range.h"
-
-#include <gtest/gtest.h>
-#include <memory>
-
-using namespace pzstd;
-
-namespace {
-void deleter(const unsigned char* buf) {
-  delete[] buf;
-}
-}
-
-TEST(Buffer, Constructors) {
-  Buffer empty;
-  EXPECT_TRUE(empty.empty());
-  EXPECT_EQ(0, empty.size());
-
-  Buffer sized(5);
-  EXPECT_FALSE(sized.empty());
-  EXPECT_EQ(5, sized.size());
-
-  Buffer moved(std::move(sized));
-  EXPECT_FALSE(sized.empty());
-  EXPECT_EQ(5, sized.size());
-
-  Buffer assigned;
-  assigned = std::move(moved);
-  EXPECT_FALSE(sized.empty());
-  EXPECT_EQ(5, sized.size());
-}
-
-TEST(Buffer, BufferManagement) {
-  std::shared_ptr<unsigned char> buf(new unsigned char[10], deleter);
-  {
-    Buffer acquired(buf, MutableByteRange(buf.get(), buf.get() + 10));
-    EXPECT_EQ(2, buf.use_count());
-    Buffer moved(std::move(acquired));
-    EXPECT_EQ(2, buf.use_count());
-    Buffer assigned;
-    assigned = std::move(moved);
-    EXPECT_EQ(2, buf.use_count());
-
-    Buffer split = assigned.splitAt(5);
-    EXPECT_EQ(3, buf.use_count());
-
-    split.advance(1);
-    assigned.subtract(1);
-    EXPECT_EQ(3, buf.use_count());
-  }
-  EXPECT_EQ(1, buf.use_count());
-}
-
-TEST(Buffer, Modifiers) {
-  Buffer buf(10);
-  {
-    unsigned char i = 0;
-    for (auto& byte : buf.range()) {
-      byte = i++;
-    }
-  }
-
-  auto prefix = buf.splitAt(2);
-
-  ASSERT_EQ(2, prefix.size());
-  EXPECT_EQ(0, *prefix.data());
-
-  ASSERT_EQ(8, buf.size());
-  EXPECT_EQ(2, *buf.data());
-
-  buf.advance(2);
-  EXPECT_EQ(4, *buf.data());
-
-  EXPECT_EQ(9, *(buf.range().end() - 1));
-
-  buf.subtract(2);
-  EXPECT_EQ(7, *(buf.range().end() - 1));
-
-  EXPECT_EQ(4, buf.size());
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/test/RangeTest.cpp

@@ -1,82 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#include "utils/Range.h"
-
-#include <gtest/gtest.h>
-#include <string>
-
-using namespace pzstd;
-
-// Range is directly copied from folly.
-// Just some sanity tests to make sure everything seems to work.
-
-TEST(Range, Constructors) {
-  StringPiece empty;
-  EXPECT_TRUE(empty.empty());
-  EXPECT_EQ(0, empty.size());
-
-  std::string str = "hello";
-  {
-    Range<std::string::const_iterator> piece(str.begin(), str.end());
-    EXPECT_EQ(5, piece.size());
-    EXPECT_EQ('h', *piece.data());
-    EXPECT_EQ('o', *(piece.end() - 1));
-  }
-
-  {
-    StringPiece piece(str.data(), str.size());
-    EXPECT_EQ(5, piece.size());
-    EXPECT_EQ('h', *piece.data());
-    EXPECT_EQ('o', *(piece.end() - 1));
-  }
-
-  {
-    StringPiece piece(str);
-    EXPECT_EQ(5, piece.size());
-    EXPECT_EQ('h', *piece.data());
-    EXPECT_EQ('o', *(piece.end() - 1));
-  }
-
-  {
-    StringPiece piece(str.c_str());
-    EXPECT_EQ(5, piece.size());
-    EXPECT_EQ('h', *piece.data());
-    EXPECT_EQ('o', *(piece.end() - 1));
-  }
-}
-
-TEST(Range, Modifiers) {
-  StringPiece range("hello world");
-  ASSERT_EQ(11, range.size());
-
-  {
-    auto hello = range.subpiece(0, 5);
-    EXPECT_EQ(5, hello.size());
-    EXPECT_EQ('h', *hello.data());
-    EXPECT_EQ('o', *(hello.end() - 1));
-  }
-  {
-    auto hello = range;
-    hello.subtract(6);
-    EXPECT_EQ(5, hello.size());
-    EXPECT_EQ('h', *hello.data());
-    EXPECT_EQ('o', *(hello.end() - 1));
-  }
-  {
-    auto world = range;
-    world.advance(6);
-    EXPECT_EQ(5, world.size());
-    EXPECT_EQ('w', *world.data());
-    EXPECT_EQ('d', *(world.end() - 1));
-  }
-
-  std::string expected = "hello world";
-  EXPECT_EQ(expected, std::string(range.begin(), range.end()));
-  EXPECT_EQ(expected, std::string(range.data(), range.size()));
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/test/ResourcePoolTest.cpp

@@ -1,72 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#include "utils/ResourcePool.h"
-
-#include <gtest/gtest.h>
-#include <atomic>
-#include <thread>
-
-using namespace pzstd;
-
-TEST(ResourcePool, FullTest) {
-  unsigned numCreated = 0;
-  unsigned numDeleted = 0;
-  {
-    ResourcePool<int> pool(
-      [&numCreated] { ++numCreated; return new int{5}; },
-      [&numDeleted](int *x) { ++numDeleted; delete x; });
-
-    {
-      auto i = pool.get();
-      EXPECT_EQ(5, *i);
-      *i = 6;
-    }
-    {
-      auto i = pool.get();
-      EXPECT_EQ(6, *i);
-      auto j = pool.get();
-      EXPECT_EQ(5, *j);
-      *j = 7;
-    }
-    {
-      auto i = pool.get();
-      EXPECT_EQ(6, *i);
-      auto j = pool.get();
-      EXPECT_EQ(7, *j);
-    }
-  }
-  EXPECT_EQ(2, numCreated);
-  EXPECT_EQ(numCreated, numDeleted);
-}
-
-TEST(ResourcePool, ThreadSafe) {
-  std::atomic<unsigned> numCreated{0};
-  std::atomic<unsigned> numDeleted{0};
-  {
-    ResourcePool<int> pool(
-      [&numCreated] { ++numCreated; return new int{0}; },
-      [&numDeleted](int *x) { ++numDeleted; delete x; });
-    auto push = [&pool] {
-      for (int i = 0; i < 100; ++i) {
-        auto x = pool.get();
-        ++*x;
-      }
-    };
-    std::thread t1{push};
-    std::thread t2{push};
-    t1.join();
-    t2.join();
-
-    auto x = pool.get();
-    auto y = pool.get();
-    EXPECT_EQ(200, *x + *y);
-  }
-  EXPECT_GE(2, numCreated);
-  EXPECT_EQ(numCreated, numDeleted);
-}

package/src/bsdiff/zstd/contrib/pzstd/utils/test/ScopeGuardTest.cpp

@@ -1,28 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * All rights reserved.
- *
- * This source code is licensed under both the BSD-style license (found in the
- * LICENSE file in the root directory of this source tree) and the GPLv2 (found
- * in the COPYING file in the root directory of this source tree).
- */
-#include "utils/ScopeGuard.h"
-
-#include <gtest/gtest.h>
-
-using namespace pzstd;
-
-TEST(ScopeGuard, Dismiss) {
-  {
-    auto guard = makeScopeGuard([&] { EXPECT_TRUE(false); });
-    guard.dismiss();
-  }
-}
-
-TEST(ScopeGuard, Executes) {
-  bool executed = false;
-  {
-    auto guard = makeScopeGuard([&] { executed = true; });
-  }
-  EXPECT_TRUE(executed);
-}