couchbase 3.0.0.alpha.2-universal-darwin-19 → 3.0.0-universal-darwin-19

data/ext/third_party/asio/asio/src/tests/latency/udp_server.cpp

@@ -1,125 +0,0 @@
-//
-// udp_server.cpp
-// ~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <asio/io_context.hpp>
-#include <asio/ip/udp.hpp>
-#include <boost/shared_ptr.hpp>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <vector>
-#include "allocator.hpp"
-
-using asio::ip::udp;
-
-#include <asio/yield.hpp>
-
-class udp_server : asio::coroutine
-{
-public:
-  udp_server(asio::io_context& io_context,
-      unsigned short port, std::size_t buf_size) :
-    socket_(io_context, udp::endpoint(udp::v4(), port)),
-    buffer_(buf_size)
-  {
-  }
-
-  void operator()(asio::error_code ec, std::size_t n = 0)
-  {
-    reenter (this) for (;;)
-    {
-      yield socket_.async_receive_from(
-          asio::buffer(buffer_),
-          sender_, ref(this));
-
-      if (!ec)
-      {
-        for (std::size_t i = 0; i < n; ++i) buffer_[i] = ~buffer_[i];
-        socket_.send_to(asio::buffer(buffer_, n), sender_, 0, ec);
-      }
-    }
-  }
-
-  friend void* asio_handler_allocate(std::size_t n, udp_server* s)
-  {
-    return s->allocator_.allocate(n);
-  }
-
-  friend void asio_handler_deallocate(void* p, std::size_t, udp_server* s)
-  {
-    s->allocator_.deallocate(p);
-  }
-
-  struct ref
-  {
-    explicit ref(udp_server* p)
-      : p_(p)
-    {
-    }
-
-    void operator()(asio::error_code ec, std::size_t n = 0)
-    {
-      (*p_)(ec, n);
-    }
-
-  private:
-    udp_server* p_;
-
-    friend void* asio_handler_allocate(std::size_t n, ref* r)
-    {
-      return asio_handler_allocate(n, r->p_);
-    }
-
-    friend void asio_handler_deallocate(void* p, std::size_t n, ref* r)
-    {
-      asio_handler_deallocate(p, n, r->p_);
-    }
-  };
-
-private:
-  udp::socket socket_;
-  std::vector<unsigned char> buffer_;
-  udp::endpoint sender_;
-  allocator allocator_;
-};
-
-#include <asio/unyield.hpp>
-
-int main(int argc, char* argv[])
-{
-  if (argc != 5)
-  {
-    std::fprintf(stderr,
-        "Usage: udp_server <port1> <nports> "
-        "<bufsize> {spin|block}\n");
-    return 1;
-  }
-
-  unsigned short first_port = static_cast<unsigned short>(std::atoi(argv[1]));
-  unsigned short num_ports = static_cast<unsigned short>(std::atoi(argv[2]));
-  std::size_t buf_size = std::atoi(argv[3]);
-  bool spin = (std::strcmp(argv[4], "spin") == 0);
-
-  asio::io_context io_context(1);
-  std::vector<boost::shared_ptr<udp_server> > servers;
-
-  for (unsigned short i = 0; i < num_ports; ++i)
-  {
-    unsigned short port = first_port + i;
-    boost::shared_ptr<udp_server> s(new udp_server(io_context, port, buf_size));
-    servers.push_back(s);
-    (*s)(asio::error_code());
-  }
-
-  if (spin)
-    for (;;) io_context.poll();
-  else
-    io_context.run();
-}

data/ext/third_party/asio/asio/src/tests/performance/.gitignore

@@ -1,11 +0,0 @@
-.deps
-.dirstamp
-*.o
-*.obj
-*.exe
-client
-server
-*.ilk
-*.manifest
-*.pdb
-*.tds

data/ext/third_party/asio/asio/src/tests/performance/client.cpp

@@ -1,286 +0,0 @@
-//
-// client.cpp
-// ~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include "asio.hpp"
-#include <algorithm>
-#include <boost/bind/bind.hpp>
-#include <boost/mem_fn.hpp>
-#include <iostream>
-#include <list>
-#include <string>
-#include "handler_allocator.hpp"
-
-class stats
-{
-public:
-  stats()
-    : mutex_(),
-      total_bytes_written_(0),
-      total_bytes_read_(0)
-  {
-  }
-
-  void add(size_t bytes_written, size_t bytes_read)
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    total_bytes_written_ += bytes_written;
-    total_bytes_read_ += bytes_read;
-  }
-
-  void print()
-  {
-    asio::detail::mutex::scoped_lock lock(mutex_);
-    std::cout << total_bytes_written_ << " total bytes written\n";
-    std::cout << total_bytes_read_ << " total bytes read\n";
-  }
-
-private:
-  asio::detail::mutex mutex_;
-  size_t total_bytes_written_;
-  size_t total_bytes_read_;
-};
-
-class session
-{
-public:
-  session(asio::io_context& ioc, size_t block_size, stats& s)
-    : strand_(ioc),
-      socket_(ioc),
-      block_size_(block_size),
-      read_data_(new char[block_size]),
-      read_data_length_(0),
-      write_data_(new char[block_size]),
-      unwritten_count_(0),
-      bytes_written_(0),
-      bytes_read_(0),
-      stats_(s)
-  {
-    for (size_t i = 0; i < block_size_; ++i)
-      write_data_[i] = static_cast<char>(i % 128);
-  }
-
-  ~session()
-  {
-    stats_.add(bytes_written_, bytes_read_);
-
-    delete[] read_data_;
-    delete[] write_data_;
-  }
-
-  void start(asio::ip::tcp::resolver::results_type endpoints)
-  {
-    asio::async_connect(socket_, endpoints,
-        asio::bind_executor(strand_,
-          boost::bind(&session::handle_connect, this,
-            asio::placeholders::error)));
-  }
-
-  void stop()
-  {
-    asio::post(strand_, boost::bind(&session::close_socket, this));
-  }
-
-private:
-  void handle_connect(const asio::error_code& err)
-  {
-    if (!err)
-    {
-      asio::error_code set_option_err;
-      asio::ip::tcp::no_delay no_delay(true);
-      socket_.set_option(no_delay, set_option_err);
-      if (!set_option_err)
-      {
-        ++unwritten_count_;
-        async_write(socket_, asio::buffer(write_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void handle_read(const asio::error_code& err, size_t length)
-  {
-    if (!err)
-    {
-      bytes_read_ += length;
-
-      read_data_length_ = length;
-      ++unwritten_count_;
-      if (unwritten_count_ == 1)
-      {
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void handle_write(const asio::error_code& err, size_t length)
-  {
-    if (!err && length > 0)
-    {
-      bytes_written_ += length;
-
-      --unwritten_count_;
-      if (unwritten_count_ == 1)
-      {
-        std::swap(read_data_, write_data_);
-        async_write(socket_, asio::buffer(write_data_, read_data_length_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(write_allocator_,
-                boost::bind(&session::handle_write, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-        socket_.async_read_some(asio::buffer(read_data_, block_size_),
-            asio::bind_executor(strand_,
-              make_custom_alloc_handler(read_allocator_,
-                boost::bind(&session::handle_read, this,
-                  asio::placeholders::error,
-                  asio::placeholders::bytes_transferred))));
-      }
-    }
-  }
-
-  void close_socket()
-  {
-    socket_.close();
-  }
-
-private:
-  asio::io_context::strand strand_;
-  asio::ip::tcp::socket socket_;
-  size_t block_size_;
-  char* read_data_;
-  size_t read_data_length_;
-  char* write_data_;
-  int unwritten_count_;
-  size_t bytes_written_;
-  size_t bytes_read_;
-  stats& stats_;
-  handler_allocator read_allocator_;
-  handler_allocator write_allocator_;
-};
-
-class client
-{
-public:
-  client(asio::io_context& ioc,
-      const asio::ip::tcp::resolver::results_type endpoints,
-      size_t block_size, size_t session_count, int timeout)
-    : io_context_(ioc),
-      stop_timer_(ioc),
-      sessions_(),
-      stats_()
-  {
-    stop_timer_.expires_after(asio::chrono::seconds(timeout));
-    stop_timer_.async_wait(boost::bind(&client::handle_timeout, this));
-
-    for (size_t i = 0; i < session_count; ++i)
-    {
-      session* new_session = new session(io_context_, block_size, stats_);
-      new_session->start(endpoints);
-      sessions_.push_back(new_session);
-    }
-  }
-
-  ~client()
-  {
-    while (!sessions_.empty())
-    {
-      delete sessions_.front();
-      sessions_.pop_front();
-    }
-
-    stats_.print();
-  }
-
-  void handle_timeout()
-  {
-    std::for_each(sessions_.begin(), sessions_.end(),
-        boost::mem_fn(&session::stop));
-  }
-
-private:
-  asio::io_context& io_context_;
-  asio::steady_timer stop_timer_;
-  std::list<session*> sessions_;
-  stats stats_;
-};
-
-int main(int argc, char* argv[])
-{
-  try
-  {
-    if (argc != 7)
-    {
-      std::cerr << "Usage: client <host> <port> <threads> <blocksize> ";
-      std::cerr << "<sessions> <time>\n";
-      return 1;
-    }
-
-    using namespace std; // For atoi.
-    const char* host = argv[1];
-    const char* port = argv[2];
-    int thread_count = atoi(argv[3]);
-    size_t block_size = atoi(argv[4]);
-    size_t session_count = atoi(argv[5]);
-    int timeout = atoi(argv[6]);
-
-    asio::io_context ioc;
-
-    asio::ip::tcp::resolver r(ioc);
-    asio::ip::tcp::resolver::results_type endpoints =
-      r.resolve(host, port);
-
-    client c(ioc, endpoints, block_size, session_count, timeout);
-
-    std::list<asio::thread*> threads;
-    while (--thread_count > 0)
-    {
-      asio::thread* new_thread = new asio::thread(
-          boost::bind(&asio::io_context::run, &ioc));
-      threads.push_back(new_thread);
-    }
-
-    ioc.run();
-
-    while (!threads.empty())
-    {
-      threads.front()->join();
-      delete threads.front();
-      threads.pop_front();
-    }
-  }
-  catch (std::exception& e)
-  {
-    std::cerr << "Exception: " << e.what() << "\n";
-  }
-
-  return 0;
-}

data/ext/third_party/asio/asio/src/tests/performance/handler_allocator.hpp

@@ -1,112 +0,0 @@
-//
-// handler_allocator.cpp
-// ~~~~~~~~~~~~~~~~~~~~~
-//
-// Copyright (c) 2003-2020 Christopher M. Kohlhoff (chris at kohlhoff dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef HANDLER_ALLOCATOR_HPP
-#define HANDLER_ALLOCATOR_HPP
-
-#include "asio.hpp"
-#include <boost/aligned_storage.hpp>
-#include <boost/noncopyable.hpp>
-
-// Class to manage the memory to be used for handler-based custom allocation.
-// It contains a single block of memory which may be returned for allocation
-// requests. If the memory is in use when an allocation request is made, the
-// allocator delegates allocation to the global heap.
-class handler_allocator
-  : private boost::noncopyable
-{
-public:
-  handler_allocator()
-    : in_use_(false)
-  {
-  }
-
-  void* allocate(std::size_t size)
-  {
-    if (!in_use_ && size < storage_.size)
-    {
-      in_use_ = true;
-      return storage_.address();
-    }
-
-    return ::operator new(size);
-  }
-
-  void deallocate(void* pointer)
-  {
-    if (pointer == storage_.address())
-    {
-      in_use_ = false;
-    }
-    else
-    {
-      ::operator delete(pointer);
-    }
-  }
-
-private:
-  // Storage space used for handler-based custom memory allocation.
-  boost::aligned_storage<1024> storage_;
-
-  // Whether the handler-based custom allocation storage has been used.
-  bool in_use_;
-};
-
-// Wrapper class template for handler objects to allow handler memory
-// allocation to be customised. Calls to operator() are forwarded to the
-// encapsulated handler.
-template <typename Handler>
-class custom_alloc_handler
-{
-public:
-  custom_alloc_handler(handler_allocator& a, Handler h)
-    : allocator_(a),
-      handler_(h)
-  {
-  }
-
-  template <typename Arg1>
-  void operator()(Arg1 arg1)
-  {
-    handler_(arg1);
-  }
-
-  template <typename Arg1, typename Arg2>
-  void operator()(Arg1 arg1, Arg2 arg2)
-  {
-    handler_(arg1, arg2);
-  }
-
-  friend void* asio_handler_allocate(std::size_t size,
-      custom_alloc_handler<Handler>* this_handler)
-  {
-    return this_handler->allocator_.allocate(size);
-  }
-
-  friend void asio_handler_deallocate(void* pointer, std::size_t /*size*/,
-      custom_alloc_handler<Handler>* this_handler)
-  {
-    this_handler->allocator_.deallocate(pointer);
-  }
-
-private:
-  handler_allocator& allocator_;
-  Handler handler_;
-};
-
-// Helper function to wrap a handler object to add custom allocation.
-template <typename Handler>
-inline custom_alloc_handler<Handler> make_custom_alloc_handler(
-    handler_allocator& a, Handler h)
-{
-  return custom_alloc_handler<Handler>(a, h);
-}
-
-#endif // HANDLER_ALLOCATOR_HPP