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

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

@@ -1,25 +0,0 @@
-# Copyright(c) 2019 spdlog authors Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-cmake_minimum_required(VERSION 3.1)
-project(spdlog_bench CXX)
-
-if(NOT TARGET spdlog)
-    # Stand-alone build
-    find_package(spdlog CONFIG REQUIRED)
-endif()
-
-find_package(Threads REQUIRED)
-find_package(benchmark CONFIG REQUIRED)
-
-add_executable(bench bench.cpp)
-spdlog_enable_warnings(bench)
-target_link_libraries(bench PRIVATE spdlog::spdlog)
-
-add_executable(async_bench async_bench.cpp)
-target_link_libraries(async_bench PRIVATE spdlog::spdlog)
-
-add_executable(latency latency.cpp)
-target_link_libraries(latency PRIVATE benchmark::benchmark spdlog::spdlog)
-
-add_executable(formatter-bench formatter-bench.cpp)
-target_link_libraries(formatter-bench PRIVATE benchmark::benchmark spdlog::spdlog)

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

@@ -1,179 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.h"
-#include "spdlog/async.h"
-#include "spdlog/sinks/basic_file_sink.h"
-#include "spdlog/sinks/stdout_color_sinks.h"
-
-#include "utils.h"
-#include <atomic>
-#include <iostream>
-#include <memory>
-#include <string>
-#include <thread>
-
-using namespace std;
-using namespace std::chrono;
-using namespace spdlog;
-using namespace spdlog::sinks;
-using namespace utils;
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4996) // disable fopen warning under msvc
-#endif                          // _MSC_VER
-
-int count_lines(const char *filename)
-{
-    int counter = 0;
-    auto *infile = fopen(filename, "r");
-    int ch;
-    while (EOF != (ch = getc(infile)))
-    {
-        if ('\n' == ch)
-            counter++;
-    }
-    fclose(infile);
-
-    return counter;
-}
-
-void verify_file(const char *filename, int expected_count)
-{
-    spdlog::info("Verifying {} to contain {:n} line..", filename, expected_count);
-    auto count = count_lines(filename);
-    if (count != expected_count)
-    {
-        spdlog::error("Test failed. {} has {:n} lines instead of {:n}", filename, count, expected_count);
-        exit(1);
-    }
-    spdlog::info("Line count OK ({:n})\n", count);
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    int howmany = 1000000;
-    int queue_size = std::min(howmany + 2, 8192);
-    int threads = 10;
-    int iters = 3;
-
-    try
-    {
-        spdlog::set_pattern("[%^%l%$] %v");
-        if (argc == 1)
-        {
-            spdlog::info("Usage: {} <message_count> <threads> <q_size> <iterations>", argv[0]);
-            return 0;
-        }
-
-        if (argc > 1)
-            howmany = atoi(argv[1]);
-        if (argc > 2)
-            threads = atoi(argv[2]);
-        if (argc > 3)
-        {
-            queue_size = atoi(argv[3]);
-            if (queue_size > 500000)
-            {
-                spdlog::error("Max queue size allowed: 500,000");
-                exit(1);
-            }
-        }
-
-        if (argc > 4)
-            iters = atoi(argv[4]);
-
-        auto slot_size = sizeof(spdlog::details::async_msg);
-        spdlog::info("-------------------------------------------------");
-        spdlog::info("Messages     : {:n}", howmany);
-        spdlog::info("Threads      : {:n}", threads);
-        spdlog::info("Queue        : {:n} slots", queue_size);
-        spdlog::info("Queue memory : {:n} x {} = {:n} KB ", queue_size, slot_size, (queue_size * slot_size) / 1024);
-        spdlog::info("Total iters  : {:n}", iters);
-        spdlog::info("-------------------------------------------------");
-
-        const char *filename = "logs/basic_async.log";
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: block");
-        spdlog::info("*********************************");
-        for (int i = 0; i < iters; i++)
-        {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger = std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::block);
-            bench_mt(howmany, std::move(logger), threads);
-            // verify_file(filename, howmany);
-        }
-
-        spdlog::info("");
-        spdlog::info("*********************************");
-        spdlog::info("Queue Overflow Policy: overrun");
-        spdlog::info("*********************************");
-        // do same test but discard oldest if queue is full instead of blocking
-        filename = "logs/basic_async-overrun.log";
-        for (int i = 0; i < iters; i++)
-        {
-            auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
-            auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(filename, true);
-            auto logger =
-                std::make_shared<async_logger>("async_logger", std::move(file_sink), std::move(tp), async_overflow_policy::overrun_oldest);
-            bench_mt(howmany, std::move(logger), threads);
-        }
-        spdlog::shutdown();
-    }
-    catch (std::exception &ex)
-    {
-        std::cerr << "Error: " << ex.what() << std::endl;
-        perror("Last error");
-        return 1;
-    }
-    return 0;
-}
-
-void thread_fun(std::shared_ptr<spdlog::logger> logger, int howmany)
-{
-    for (int i = 0; i < howmany; i++)
-    {
-        logger->info("Hello logger: msg number {}", i);
-    }
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> logger, int thread_count)
-{
-    using std::chrono::high_resolution_clock;
-    vector<thread> threads;
-    auto start = high_resolution_clock::now();
-
-    int msgs_per_thread = howmany / thread_count;
-    int msgs_per_thread_mod = howmany % thread_count;
-    for (int t = 0; t < thread_count; ++t)
-    {
-        if (t == 0 && msgs_per_thread_mod)
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread + msgs_per_thread_mod));
-        else
-            threads.push_back(std::thread(thread_fun, logger, msgs_per_thread));
-    }
-
-    for (auto &t : threads)
-    {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info("Elapsed: {} secs\t {:n}/sec", delta_d, int(howmany / delta_d));
-}

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

@@ -1,238 +0,0 @@
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-//
-// bench.cpp : spdlog benchmarks
-//
-#include "spdlog/spdlog.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"
-
-#include "utils.h"
-#include <atomic>
-#include <cstdlib> // EXIT_FAILURE
-#include <memory>
-#include <string>
-#include <thread>
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log);
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count);
-
-// void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log);
-// void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log);
-
-static const size_t file_size = 30 * 1024 * 1024;
-static const size_t rotating_files = 5;
-static const int max_threads = 1000;
-
-void bench_threaded_logging(size_t threads, int iters)
-{
-    spdlog::info("**************************************************************");
-    spdlog::info("Multi threaded: {:n} threads, {:n} messages", threads, iters);
-    spdlog::info("**************************************************************");
-
-    auto basic_mt = spdlog::basic_logger_mt("basic_mt", "logs/basic_mt.log", true);
-    bench_mt(iters, std::move(basic_mt), threads);
-    auto basic_mt_tracing = spdlog::basic_logger_mt("basic_mt/backtrace-on", "logs/basic_mt.log", true);
-    basic_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(basic_mt_tracing), threads);
-
-    spdlog::info("");
-    auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt.log", file_size, rotating_files);
-    bench_mt(iters, std::move(rotating_mt), threads);
-    auto rotating_mt_tracing = spdlog::rotating_logger_mt("rotating_mt/backtrace-on", "logs/rotating_mt.log", file_size, rotating_files);
-    rotating_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(rotating_mt_tracing), threads);
-
-    spdlog::info("");
-    auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt.log");
-    bench_mt(iters, std::move(daily_mt), threads);
-    auto daily_mt_tracing = spdlog::daily_logger_mt("daily_mt/backtrace-on", "logs/daily_mt.log");
-    daily_mt_tracing->enable_backtrace(32);
-    bench_mt(iters, std::move(daily_mt_tracing), threads);
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-void bench_single_threaded(int iters)
-{
-    spdlog::info("**************************************************************");
-    spdlog::info("Single threaded: {:n} messages", iters);
-    spdlog::info("**************************************************************");
-
-    auto basic_st = spdlog::basic_logger_st("basic_st", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st));
-
-    auto basic_st_tracing = spdlog::basic_logger_st("basic_st/backtrace-on", "logs/basic_st.log", true);
-    bench(iters, std::move(basic_st_tracing));
-
-    spdlog::info("");
-    auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st.log", file_size, rotating_files);
-    bench(iters, std::move(rotating_st));
-    auto rotating_st_tracing = spdlog::rotating_logger_st("rotating_st/backtrace-on", "logs/rotating_st.log", file_size, rotating_files);
-    rotating_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(rotating_st_tracing));
-
-    spdlog::info("");
-    auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st.log");
-    bench(iters, std::move(daily_st));
-    auto daily_st_tracing = spdlog::daily_logger_st("daily_st/backtrace-on", "logs/daily_st.log");
-    daily_st_tracing->enable_backtrace(32);
-    bench(iters, std::move(daily_st_tracing));
-
-    spdlog::info("");
-    auto empty_logger = std::make_shared<spdlog::logger>("level-off");
-    empty_logger->set_level(spdlog::level::off);
-    bench(iters, empty_logger);
-
-    auto empty_logger_tracing = std::make_shared<spdlog::logger>("level-off/backtrace-on");
-    empty_logger_tracing->set_level(spdlog::level::off);
-    empty_logger_tracing->enable_backtrace(32);
-    bench(iters, empty_logger_tracing);
-}
-
-int main(int argc, char *argv[])
-{
-    spdlog::set_automatic_registration(false);
-    spdlog::default_logger()->set_pattern("[%^%l%$] %v");
-    int iters = 250000;
-    size_t threads = 4;
-    try
-    {
-
-        if (argc > 1)
-        {
-            iters = std::stoi(argv[1]);
-        }
-        if (argc > 2)
-        {
-            threads = std::stoul(argv[2]);
-        }
-
-        if (threads > max_threads)
-        {
-            throw std::runtime_error(fmt::format("Number of threads exceeds maximum({}})", max_threads));
-        }
-
-        bench_single_threaded(iters);
-        bench_threaded_logging(1, iters);
-        bench_threaded_logging(threads, iters);
-    }
-    catch (std::exception &ex)
-    {
-        spdlog::error(ex.what());
-        return EXIT_FAILURE;
-    }
-    return EXIT_SUCCESS;
-}
-
-void bench(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        log->info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-    spdlog::drop(log->name());
-}
-
-void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, size_t thread_count)
-{
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-    using std::chrono::high_resolution_clock;
-
-    std::vector<std::thread> threads;
-    threads.reserve(thread_count);
-    auto start = high_resolution_clock::now();
-    for (size_t t = 0; t < thread_count; ++t)
-    {
-        threads.emplace_back([&]() {
-            for (int j = 0; j < howmany / static_cast<int>(thread_count); j++)
-            {
-                log->info("Hello logger: msg number {}", j);
-            }
-        });
-    }
-
-    for (auto &t : threads)
-    {
-        t.join();
-    };
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-    spdlog::drop(log->name());
-}
-
-/*
-void bench_default_api(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::info("Hello logger: msg number {}", i);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-}
-
-void bench_c_string(int howmany, std::shared_ptr<spdlog::logger> log)
-{
-    using std::chrono::high_resolution_clock;
-    using std::chrono::duration;
-    using std::chrono::duration_cast;
-
-    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.";
-
-    auto orig_default = spdlog::default_logger();
-    spdlog::set_default_logger(log);
-    auto start = high_resolution_clock::now();
-    for (auto i = 0; i < howmany; ++i)
-    {
-        spdlog::log(spdlog::level::info, msg);
-    }
-
-    auto delta = high_resolution_clock::now() - start;
-    auto delta_d = duration_cast<duration<double>>(delta).count();
-    spdlog::drop(log->name());
-    spdlog::set_default_logger(std::move(orig_default));
-    spdlog::info("{:<30} Elapsed: {:0.2f} secs {:>16n}/sec", log->name(), delta_d, int(howmany / delta_d));
-}
-
-*/

data/ext/third_party/spdlog/bench/formatter-bench.cpp

@@ -1,80 +0,0 @@
-//
-// Copyright(c) 2018 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-
-#include "benchmark/benchmark.h"
-
-#include "spdlog/spdlog.h"
-#include "spdlog/pattern_formatter.h"
-
-void bench_formatter(benchmark::State &state, std::string pattern)
-{
-    auto formatter = spdlog::details::make_unique<spdlog::pattern_formatter>(pattern);
-    spdlog::memory_buf_t dest;
-    std::string logger_name = "logger-name";
-    const char *text = "Hello. This is some message with length of 80                                   ";
-
-    spdlog::source_loc source_loc{"a/b/c/d/myfile.cpp", 123, "some_func()"};
-    spdlog::details::log_msg msg(source_loc, logger_name, spdlog::level::info, text);
-
-    for (auto _ : state)
-    {
-        dest.clear();
-        formatter->format(msg, dest);
-        benchmark::DoNotOptimize(dest);
-    }
-}
-
-void bench_formatters()
-{
-    // basic patterns(single flag)
-    std::string all_flags = "+vtPnlLaAbBcCYDmdHIMSefFprRTXzEisg@luioO%";
-    std::vector<std::string> basic_patterns;
-    for (auto &flag : all_flags)
-    {
-        auto pattern = std::string("%") + flag;
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-
-        //        pattern = std::string("%16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-        //
-        //        // bench center padding
-        //        pattern = std::string("%=16") + flag;
-        //        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-    }
-
-    // complex patterns
-    std::vector<std::string> patterns = {
-        "[%D %X] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] %v",
-        "[%Y-%m-%d %H:%M:%S.%e] [%l] [%n] [%t] %v",
-    };
-    for (auto &pattern : patterns)
-    {
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern)->Iterations(2500000);
-    }
-}
-
-int main(int argc, char *argv[])
-{
-
-    spdlog::set_pattern("[%^%l%$] %v");
-    if (argc != 2)
-    {
-        spdlog::error("Usage: {} <pattern> (or \"all\" to bench all)", argv[0]);
-        exit(1);
-    }
-
-    std::string pattern = argv[1];
-    if (pattern == "all")
-    {
-        bench_formatters();
-    }
-    else
-    {
-        benchmark::RegisterBenchmark(pattern.c_str(), bench_formatter, pattern);
-    }
-    benchmark::Initialize(&argc, argv);
-    benchmark::RunSpecifiedBenchmarks();
-}