couchbase 3.0.0.alpha.4 → 3.0.0.alpha.5

data/ext/third_party/spdlog/bench/latency.cpp

@@ -1,166 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// latency.cpp : spdlog latency benchmarks
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/daily_file_sink.h"
-#include "spdlog/sinks/null_sink.h"
-#include "spdlog/sinks/rotating_file_sink.h"
-
-void bench_c_string(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    const char *msg = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum pharetra metus cursus "
-                      "lacus placerat congue. Nulla egestas, mauris a tincidunt tempus, enim lectus volutpat mi, eu consequat sem "
-                      "libero nec massa. In dapibus ipsum a diam rhoncus gravida. Etiam non dapibus eros. Donec fringilla dui sed "
-                      "augue pretium, nec scelerisque est maximus. Nullam convallis, sem nec blandit maximus, nisi turpis ornare "
-                      "nisl, sit amet volutpat neque massa eu odio. Maecenas malesuada quam ex, posuere congue nibh turpis duis.";
-
-    for (auto _ : state)
-    {
-        logger->info(msg);
-    }
-}
-
-void bench_logger(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    int i = 0;
-    for (auto _ : state)
-    {
-        logger->info("Hello logger: msg number {}...............", ++i);
-    }
-}
-
-void bench_disabled_macro(benchmark::State &state, std::shared_ptr<spdlog::logger> logger)
-{
-    int i = 0;
-    benchmark::DoNotOptimize(i);      // prevent unused warnings
-    benchmark::DoNotOptimize(logger); // prevent unused warnings
-    for (auto _ : state)
-    {
-        SPDLOG_LOGGER_DEBUG(logger, "Hello logger: msg number {}...............", i++);
-        SPDLOG_DEBUG("Hello logger: msg number {}...............", i++);
-    }
-}
-
-#ifdef __linux__
-void bench_dev_null()
-{
-    auto dev_null_st = spdlog::basic_logger_st("/dev/null_st", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_st", bench_logger, std::move(dev_null_st))->UseRealTime();
-    spdlog::drop("/dev/null_st");
-
-    auto dev_null_mt = spdlog::basic_logger_mt("/dev/null_mt", "/dev/null");
-    benchmark::RegisterBenchmark("/dev/null_mt", bench_logger, std::move(dev_null_mt))->UseRealTime();
-    spdlog::drop("/dev/null_mt");
-}
-#endif // __linux__
-
-int main(int argc, char *argv[])
-{
-    using spdlog::sinks::null_sink_mt;
-    using spdlog::sinks::null_sink_st;
-
-    size_t file_size = 30 * 1024 * 1024;
-    size_t rotating_files = 5;
-    int n_threads = benchmark::CPUInfo::Get().num_cpus;
-
-    auto full_bench = argc > 1 && std::string(argv[1]) == "full";
-
-    // disabled loggers
-    auto disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    disabled_logger->set_level(spdlog::level::off);
-    benchmark::RegisterBenchmark("disabled-at-compile-time", bench_disabled_macro, disabled_logger);
-    benchmark::RegisterBenchmark("disabled-at-runtime", bench_logger, disabled_logger);
-    // with backtrace of 64
-    auto tracing_disabled_logger = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-    tracing_disabled_logger->enable_backtrace(64);
-    benchmark::RegisterBenchmark("disabled-at-runtime/backtrace", bench_logger, tracing_disabled_logger);
-
-    auto null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    benchmark::RegisterBenchmark("null_sink_st (500_bytes c_str)", bench_c_string, std::move(null_logger_st));
-    benchmark::RegisterBenchmark("null_sink_st", bench_logger, null_logger_st);
-    // with backtrace of 64
-    auto tracing_null_logger_st = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_st>());
-    tracing_null_logger_st->enable_backtrace(64);
-    benchmark::RegisterBenchmark("null_sink_st/backtrace", bench_logger, tracing_null_logger_st);
-
-#ifdef __linux
-    bench_dev_null();
-#endif // __linux__
-
-    if (full_bench)
-    {
-        // basic_st
-        auto basic_st = spdlog::basic_logger_st("basic_st", "latency_logs/basic_st.log", true);
-        benchmark::RegisterBenchmark("basic_st", bench_logger, std::move(basic_st))->UseRealTime();
-        spdlog::drop("basic_st");
-        // with backtrace of 64
-        auto tracing_basic_st = spdlog::basic_logger_st("tracing_basic_st", "latency_logs/tracing_basic_st.log", true);
-        tracing_basic_st->enable_backtrace(64);
-        benchmark::RegisterBenchmark("basic_st/backtrace", bench_logger, std::move(tracing_basic_st))->UseRealTime();
-        spdlog::drop("tracing_basic_st");
-
-        // rotating st
-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "latency_logs/rotating_st.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st", bench_logger, std::move(rotating_st))->UseRealTime();
-        spdlog::drop("rotating_st");
-        // with backtrace of 64
-        auto tracing_rotating_st =
-            spdlog::rotating_logger_st("tracing_rotating_st", "latency_logs/tracing_rotating_st.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_st/backtrace", bench_logger, std::move(tracing_rotating_st))->UseRealTime();
-        spdlog::drop("tracing_rotating_st");
-
-        // daily st
-        auto daily_st = spdlog::daily_logger_mt("daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st", bench_logger, std::move(daily_st))->UseRealTime();
-        spdlog::drop("daily_st");
-        auto tracing_daily_st = spdlog::daily_logger_mt("tracing_daily_st", "latency_logs/daily_st.log");
-        benchmark::RegisterBenchmark("daily_st/backtrace", bench_logger, std::move(tracing_daily_st))->UseRealTime();
-        spdlog::drop("tracing_daily_st");
-
-        //
-        // Multi threaded bench, 10 loggers using same logger concurrently
-        //
-        auto null_logger_mt = std::make_shared<spdlog::logger>("bench", std::make_shared<null_sink_mt>());
-        benchmark::RegisterBenchmark("null_sink_mt", bench_logger, null_logger_mt)->Threads(n_threads)->UseRealTime();
-
-        // basic_mt
-        auto basic_mt = spdlog::basic_logger_mt("basic_mt", "latency_logs/basic_mt.log", true);
-        benchmark::RegisterBenchmark("basic_mt", bench_logger, std::move(basic_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("basic_mt");
-
-        // rotating mt
-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "latency_logs/rotating_mt.log", file_size, rotating_files);
-        benchmark::RegisterBenchmark("rotating_mt", bench_logger, std::move(rotating_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("rotating_mt");
-
-        // daily mt
-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "latency_logs/daily_mt.log");
-        benchmark::RegisterBenchmark("daily_mt", bench_logger, std::move(daily_mt))->Threads(n_threads)->UseRealTime();
-        spdlog::drop("daily_mt");
-    }
-
-    // async
-    auto queue_size = 1024 * 1024 * 3;
-    auto tp = std::make_shared<spdlog::details::thread_pool>(queue_size, 1);
-    auto async_logger = std::make_shared<spdlog::async_logger>(
-        "async_logger", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-    benchmark::RegisterBenchmark("async_logger", bench_logger, async_logger)->Threads(n_threads)->UseRealTime();
-
-    auto async_logger_tracing = std::make_shared<spdlog::async_logger>(
-        "async_logger_tracing", std::make_shared<null_sink_mt>(), std::move(tp), spdlog::async_overflow_policy::overrun_oldest);
-    async_logger_tracing->enable_backtrace(32);
-    benchmark::RegisterBenchmark("async_logger/tracing", bench_logger, async_logger_tracing)->Threads(n_threads)->UseRealTime();
-
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}

data/ext/third_party/spdlog/bench/utils.h

@@ -1,34 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#pragma once
-
-#include <iomanip>
-#include <locale>
-#include <sstream>
-
-namespace utils {
-
-template<typename T>
-inline std::string format(const T &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << value;
-    return ss.str();
-}
-
-template<>
-inline std::string format(const double &value)
-{
-    static std::locale loc("");
-    std::stringstream ss;
-    ss.imbue(loc);
-    ss << std::fixed << std::setprecision(1) << value;
-    return ss.str();
-}
-
-} // namespace utils

data/ext/third_party/spdlog/example/CMakeLists.txt

@@ -1,23 +0,0 @@
-# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.2)
-project(spdlog_examples CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog REQUIRED)
-endif()
-
-# ---------------------------------------------------------------------------------------
-# Example of using pre-compiled library
-# ---------------------------------------------------------------------------------------
-add_executable(example example.cpp)
-target_link_libraries(example PRIVATE spdlog::spdlog)
-
-# ---------------------------------------------------------------------------------------
-# Example of using header-only library
-# ---------------------------------------------------------------------------------------
-if(SPDLOG_BUILD_EXAMPLE_HO)
-    add_executable(example_header_only example.cpp)
-    target_link_libraries(example_header_only PRIVATE spdlog::spdlog_header_only)
-endif()

data/ext/third_party/spdlog/example/example.cpp

@@ -1,282 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-// spdlog usage example
-
-#include <cstdio>
-
-void load_levels_example();
-void stdout_logger_example();
-void basic_example();
-void rotating_example();
-void daily_example();
-void async_example();
-void binary_example();
-void trace_example();
-void multi_sink_example();
-void user_defined_example();
-void err_handler_example();
-void syslog_example();
-void custom_flags_example();
-
-#include "spdlog/spdlog.h"
-#include "spdlog/cfg/env.h" // for loading levels from the environment variable
-
-int main(int, char *[])
-{
-    // Log levels can be loaded from argv/env using "SPDLOG_LEVEL"
-    load_levels_example();
-
-    spdlog::info("Welcome to spdlog version {}.{}.{}  !", SPDLOG_VER_MAJOR, SPDLOG_VER_MINOR, SPDLOG_VER_PATCH);
-
-    spdlog::warn("Easy padding in numbers like {:08d}", 12);
-    spdlog::critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
-    spdlog::info("Support for floats {:03.2f}", 1.23456);
-    spdlog::info("Positional args are {1} {0}..", "too", "supported");
-    spdlog::info("{:>8} aligned, {:<8} aligned", "right", "left");
-
-    // Runtime log levels
-    spdlog::set_level(spdlog::level::info); // Set global log level to info
-    spdlog::debug("This message should not be displayed!");
-    spdlog::set_level(spdlog::level::trace); // Set specific logger's log level
-    spdlog::debug("This message should be displayed..");
-
-    // Customize msg format for all loggers
-    spdlog::set_pattern("[%H:%M:%S %z] [%^%L%$] [thread %t] %v");
-    spdlog::info("This an info message with custom format");
-    spdlog::set_pattern("%+"); // back to default format
-    spdlog::set_level(spdlog::level::info);
-
-    // Backtrace support
-    // Loggers can store in a ring buffer all messages (including debug/trace) for later inspection.
-    // When needed, call dump_backtrace() to see what happened:
-    spdlog::enable_backtrace(10); // create ring buffer with capacity of 10  messages
-    for (int i = 0; i < 100; i++)
-    {
-        spdlog::debug("Backtrace message {}", i); // not logged..
-    }
-    // e.g. if some error happened:
-    spdlog::dump_backtrace(); // log them now!
-
-    try
-    {
-        stdout_logger_example();
-        basic_example();
-        rotating_example();
-        daily_example();
-        async_example();
-        binary_example();
-        multi_sink_example();
-        user_defined_example();
-        err_handler_example();
-        trace_example();
-        custom_flags_example();
-
-        // Flush all *registered* loggers using a worker thread every 3 seconds.
-        // note: registered loggers *must* be thread safe for this to work correctly!
-        spdlog::flush_every(std::chrono::seconds(3));
-
-        // Apply some function on all registered loggers
-        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) { l->info("End of example."); });
-
-        // Release all spdlog resources, and drop all loggers in the registry.
-        // This is optional (only mandatory if using windows + async log).
-        spdlog::shutdown();
-    }
-
-    // Exceptions will only be thrown upon failed logger or sink construction (not during logging).
-    catch (const spdlog::spdlog_ex &ex)
-    {
-        std::printf("Log initialization failed: %s\n", ex.what());
-        return 1;
-    }
-}
-
-#include "spdlog/sinks/stdout_color_sinks.h"
-// or #include "spdlog/sinks/stdout_sinks.h" if no colors needed.
-void stdout_logger_example()
-{
-    // Create color multi threaded logger.
-    auto console = spdlog::stdout_color_mt("console");
-    // or for stderr:
-    // auto console = spdlog::stderr_color_mt("error-logger");
-}
-
-#include "spdlog/sinks/basic_file_sink.h"
-void basic_example()
-{
-    // Create basic file logger (not rotated).
-    auto my_logger = spdlog::basic_logger_mt("file_logger", "logs/basic-log.txt");
-}
-
-#include "spdlog/sinks/rotating_file_sink.h"
-void rotating_example()
-{
-    // Create a file rotating logger with 5mb size max and 3 rotated files.
-    auto rotating_logger = spdlog::rotating_logger_mt("some_logger_name", "logs/rotating.txt", 1048576 * 5, 3);
-}
-
-#include "spdlog/sinks/daily_file_sink.h"
-void daily_example()
-{
-    // Create a daily logger - a new file is created every day on 2:30am.
-    auto daily_logger = spdlog::daily_logger_mt("daily_logger", "logs/daily.txt", 2, 30);
-}
-
-#include "spdlog/cfg/env.h"
-void load_levels_example()
-{
-    // Set the log level to "info" and mylogger to to "trace":
-    // SPDLOG_LEVEL=info,mylogger=trace && ./example
-    spdlog::cfg::load_env_levels();
-    // or from command line:
-    // ./example SPDLOG_LEVEL=info,mylogger=trace
-    // #include "spdlog/cfg/argv.h" // for loading levels from argv
-    // spdlog::cfg::load_argv_levels(args, argv);
-}
-
-#include "spdlog/async.h"
-void async_example()
-{
-    // Default thread pool settings can be modified *before* creating the async logger:
-    // spdlog::init_thread_pool(32768, 1); // queue with max 32k items 1 backing thread.
-    auto async_file = spdlog::basic_logger_mt<spdlog::async_factory>("async_file_logger", "logs/async_log.txt");
-    // alternatively:
-    // auto async_file = spdlog::create_async<spdlog::sinks::basic_file_sink_mt>("async_file_logger", "logs/async_log.txt");
-
-    for (int i = 1; i < 101; ++i)
-    {
-        async_file->info("Async message #{}", i);
-    }
-}
-
-// Log binary data as hex.
-// Many types of std::container<char> types can be used.
-// Iterator ranges are supported too.
-// Format flags:
-// {:X} - print in uppercase.
-// {:s} - don't separate each byte with space.
-// {:p} - don't print the position on each line start.
-// {:n} - don't split the output to lines.
-
-#include "spdlog/fmt/bin_to_hex.h"
-void binary_example()
-{
-    std::vector<char> buf(80);
-    for (int i = 0; i < 80; i++)
-    {
-        buf.push_back(static_cast<char>(i & 0xff));
-    }
-    spdlog::info("Binary example: {}", spdlog::to_hex(buf));
-    spdlog::info("Another binary example:{:n}", spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
-    // more examples:
-    // logger->info("uppercase: {:X}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters: {:Xs}", spdlog::to_hex(buf));
-    // logger->info("uppercase, no delimiters, no position info: {:Xsp}", spdlog::to_hex(buf));
-    // logger->info("hexdump style: {:a}", spdlog::to_hex(buf));
-    // logger->info("hexdump style, 20 chars per line {:a}", spdlog::to_hex(buf, 20));
-}
-
-// Compile time log levels.
-// define SPDLOG_ACTIVE_LEVEL to required level (e.g. SPDLOG_LEVEL_TRACE)
-void trace_example()
-{
-    // trace from default logger
-    SPDLOG_TRACE("Some trace message.. {} ,{}", 1, 3.23);
-    // debug from default logger
-    SPDLOG_DEBUG("Some debug message.. {} ,{}", 1, 3.23);
-
-    // trace from logger object
-    auto logger = spdlog::get("file_logger");
-    SPDLOG_LOGGER_TRACE(logger, "another trace message");
-}
-
-// A logger with multiple sinks (stdout and file) - each with a different format and log level.
-void multi_sink_example()
-{
-    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
-    console_sink->set_level(spdlog::level::warn);
-    console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");
-
-    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
-    file_sink->set_level(spdlog::level::trace);
-
-    spdlog::logger logger("multi_sink", {console_sink, file_sink});
-    logger.set_level(spdlog::level::debug);
-    logger.warn("this should appear in both console and file");
-    logger.info("this message should not appear in the console, only in the file");
-}
-
-// User defined types logging by implementing operator<<
-#include "spdlog/fmt/ostr.h" // must be included
-struct my_type
-{
-    int i;
-    template<typename OStream>
-    friend OStream &operator<<(OStream &os, const my_type &c)
-    {
-        return os << "[my_type i=" << c.i << "]";
-    }
-};
-
-void user_defined_example()
-{
-    spdlog::info("user defined type: {}", my_type{14});
-}
-
-// Custom error handler. Will be triggered on log failure.
-void err_handler_example()
-{
-    // can be set globally or per logger(logger->set_error_handler(..))
-    spdlog::set_error_handler([](const std::string &msg) { printf("*** Custom log error handler: %s ***\n", msg.c_str()); });
-}
-
-// syslog example (linux/osx/freebsd)
-#ifndef _WIN32
-#include "spdlog/sinks/syslog_sink.h"
-void syslog_example()
-{
-    std::string ident = "spdlog-example";
-    auto syslog_logger = spdlog::syslog_logger_mt("syslog", ident, LOG_PID);
-    syslog_logger->warn("This is warning that will end up in syslog.");
-}
-#endif
-
-// Android example.
-#if defined(__ANDROID__)
-#include "spdlog/sinks/android_sink.h"
-void android_example()
-{
-    std::string tag = "spdlog-android";
-    auto android_logger = spdlog::android_logger_mt("android", tag);
-    android_logger->critical("Use \"adb shell logcat\" to view this message.");
-}
-#endif
-
-// Log patterns can contain custom flags.
-// this will add custom flag '%*' which will be bound to a <my_formatter_flag> instance
-#include "spdlog/pattern_formatter.h"
-class my_formatter_flag : public spdlog::custom_flag_formatter
-{
-public:
-    void format(const spdlog::details::log_msg &, const std::tm &, spdlog::memory_buf_t &dest) override
-    {
-        std::string some_txt = "custom-flag";
-        dest.append(some_txt.data(), some_txt.data() + some_txt.size());
-    }
-
-    std::unique_ptr<custom_flag_formatter> clone() const override
-    {
-        return spdlog::details::make_unique<my_formatter_flag>();
-    }
-};
-
-void custom_flags_example()
-{
-
-    using spdlog::details::make_unique; // for pre c++14
-    auto formatter = make_unique<spdlog::pattern_formatter>();
-    formatter->add_flag<my_formatter_flag>('*').set_pattern("[%n] [%*] [%^%l%$] %v");
-    spdlog::set_formatter(std::move(formatter));
-}