From c83dd5d60ef28fba30ca5abd9ae217a65b8d2300 Mon Sep 17 00:00:00 2001
From: Alexander Kiselev <kiselev.alexander@gmail.com>
Date: Mon, 19 Mar 2018 19:17:26 +0300
Subject: [PATCH 1/3] Added: g3log, log4cplus, log4cpp, p7. Changes: boost,
 easylogging, g2log, glog, spdlog.

---
 bench/easyl-mt.conf          | 10 ++++
 bench/g3log-async.cpp        | 62 +++++++++++++++++++++++
 bench/log4cplus-bench-mt.cpp | 80 +++++++++++++++++++++++++++++
 bench/log4cplus-bench.cpp    | 54 ++++++++++++++++++++
 bench/log4cpp-bench-mt.cpp   | 74 +++++++++++++++++++++++++++
 bench/log4cpp-bench.cpp      | 48 ++++++++++++++++++
 bench/p7-bench-mt.cpp        | 97 ++++++++++++++++++++++++++++++++++++
 bench/p7-bench.cpp           | 70 ++++++++++++++++++++++++++
 8 files changed, 495 insertions(+)
 create mode 100644 bench/easyl-mt.conf
 create mode 100644 bench/g3log-async.cpp
 create mode 100644 bench/log4cplus-bench-mt.cpp
 create mode 100644 bench/log4cplus-bench.cpp
 create mode 100644 bench/log4cpp-bench-mt.cpp
 create mode 100644 bench/log4cpp-bench.cpp
 create mode 100644 bench/p7-bench-mt.cpp
 create mode 100644 bench/p7-bench.cpp

diff --git a/bench/easyl-mt.conf b/bench/easyl-mt.conf
new file mode 100644
index 00000000..8895b281
--- /dev/null
+++ b/bench/easyl-mt.conf
@@ -0,0 +1,10 @@
+* GLOBAL:
+    FORMAT                  =   "[%datetime]: %msg"
+    FILENAME                =   ./logs/easylogging-mt.log
+    ENABLED                 =   true
+    TO_FILE                 =   true
+    TO_STANDARD_OUTPUT      =   false
+    MILLISECONDS_WIDTH      =   3
+    PERFORMANCE_TRACKING    =   false
+    MAX_LOG_FILE_SIZE       =   10485760
+    Log_Flush_Threshold		= 	10485760
diff --git a/bench/g3log-async.cpp b/bench/g3log-async.cpp
new file mode 100644
index 00000000..b5e15a2b
--- /dev/null
+++ b/bench/g3log-async.cpp
@@ -0,0 +1,62 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <atomic>
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+
+#include "g3log/g3log.hpp"
+#include "g3log/logworker.hpp"
+
+using namespace std;
+template <typename T> std::string format(const T &value);
+
+int main(int argc, char *argv[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+    int thread_count = 10;
+
+    if (argc > 1)
+        thread_count = atoi(argv[1]);
+
+    int howmany = 1000000;
+
+    auto worker = g3::LogWorker::createLogWorker();
+    auto handle= worker->addDefaultLogger(argv[0], "logs");
+    g3::initializeLogging(worker.get());
+
+    std::atomic<int> msg_counter{0};
+    vector<thread> threads;
+    auto start = clock::now();
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]() {
+            while (true)
+            {
+                int counter = ++msg_counter;
+                if (counter > howmany)
+                    break;
+                LOG(INFO) << "g3log message #" << counter << ": This is some text for your pleasure";
+            }
+        }));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    cout << "Total: " << howmany << std::endl;
+    cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+}
diff --git a/bench/log4cplus-bench-mt.cpp b/bench/log4cplus-bench-mt.cpp
new file mode 100644
index 00000000..6acbf3fa
--- /dev/null
+++ b/bench/log4cplus-bench-mt.cpp
@@ -0,0 +1,80 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <atomic>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "log4cplus/logger.h"
+#include "log4cplus/fileappender.h"
+#include "log4cplus/layout.h"
+#include "log4cplus/ndc.h"
+#include "log4cplus/helpers/loglog.h"
+#include "log4cplus/helpers/property.h"
+#include "log4cplus/loggingmacros.h"
+
+using namespace log4cplus;
+
+int main(int argc, char * argv[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int thread_count = 10;
+    if (argc > 1)
+        thread_count = std::atoi(argv[1]);
+
+    int howmany = 1000000;
+
+    log4cplus::initialize();
+    SharedFileAppenderPtr append(
+        new FileAppender(LOG4CPLUS_TEXT("logs/log4cplus-bench-mt.log"), std::ios_base::trunc,
+            true, true));
+    append->setName(LOG4CPLUS_TEXT("File"));
+
+    log4cplus::tstring pattern = LOG4CPLUS_TEXT("%d{%Y-%m-%d %H:%M:%S.%Q}: %p - %m %n");
+    append->setLayout( std::auto_ptr<Layout>(new PatternLayout(pattern)) );
+    append->getloc();
+    Logger::getRoot().addAppender(SharedAppenderPtr(append.get()));
+
+    Logger root = Logger::getRoot();
+
+    std::atomic<int> msg_counter{0};
+    std::vector<std::thread> threads;
+
+    auto start = clock::now();
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]() {
+            while (true)
+            {
+                int counter = ++msg_counter;
+                if (counter > howmany)
+                    break;
+                LOG4CPLUS_INFO(root, "log4cplus message #" << counter << ": This is some text for your pleasure");
+            }
+        }));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    log4cplus::Logger::shutdown();
+    return 0;
+}
diff --git a/bench/log4cplus-bench.cpp b/bench/log4cplus-bench.cpp
new file mode 100644
index 00000000..e522e85a
--- /dev/null
+++ b/bench/log4cplus-bench.cpp
@@ -0,0 +1,54 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+
+#include "log4cplus/logger.h"
+#include "log4cplus/fileappender.h"
+#include "log4cplus/layout.h"
+#include "log4cplus/ndc.h"
+#include "log4cplus/helpers/loglog.h"
+#include "log4cplus/helpers/property.h"
+#include "log4cplus/loggingmacros.h"
+
+using namespace log4cplus;
+
+int main(int, char *[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int howmany = 1000000;
+
+    log4cplus::initialize();
+    SharedFileAppenderPtr append(
+        new FileAppender(LOG4CPLUS_TEXT("logs/log4cplus-bench.log"), std::ios_base::trunc,
+            true, true));
+    append->setName(LOG4CPLUS_TEXT("File"));
+
+    log4cplus::tstring pattern = LOG4CPLUS_TEXT("%d{%Y-%m-%d %H:%M:%S.%Q}: %p - %m %n");
+    append->setLayout( std::auto_ptr<Layout>(new PatternLayout(pattern)) );
+    append->getloc();
+    Logger::getRoot().addAppender(SharedAppenderPtr(append.get()));
+
+    Logger root = Logger::getRoot();
+
+    auto start = clock::now();
+    for (int i = 0; i < howmany; ++i)
+        LOG4CPLUS_INFO(root, "log4cplus message #" << i << ": This is some text for your pleasure");
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    log4cplus::Logger::shutdown();
+    return 0;
+}
diff --git a/bench/log4cpp-bench-mt.cpp b/bench/log4cpp-bench-mt.cpp
new file mode 100644
index 00000000..82f3a40f
--- /dev/null
+++ b/bench/log4cpp-bench-mt.cpp
@@ -0,0 +1,74 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <atomic>
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include "log4cpp/Category.hh"
+#include "log4cpp/Appender.hh"
+#include "log4cpp/FileAppender.hh"
+#include "log4cpp/Layout.hh"
+#include "log4cpp/BasicLayout.hh"
+#include "log4cpp/Priority.hh"
+#include "log4cpp/PatternLayout.hh"
+
+int main(int argc, char * argv[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int thread_count = 10;
+    if (argc > 1)
+        thread_count = std::atoi(argv[1]);
+
+    int howmany = 1000000;
+
+    log4cpp::Appender *appender  = new log4cpp::FileAppender("default", "logs/log4cpp-bench-mt.log");
+    log4cpp::PatternLayout *layout = new log4cpp::PatternLayout();
+    layout->setConversionPattern("{%Y-%m-%d %H:%M:%S.%l}: %p - %m %n");
+    appender->setLayout(layout);
+
+    log4cpp::Category& root = log4cpp::Category::getRoot();
+    root.addAppender(appender);
+    root.setPriority(log4cpp::Priority::INFO);
+
+    std::atomic<int> msg_counter{0};
+    std::vector<std::thread> threads;
+
+    auto start = clock::now();
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]() {
+            while (true)
+            {
+                int counter = ++msg_counter;
+                if (counter > howmany)
+                    break;
+                root << log4cpp::Priority::INFO << "log4cpp message #" << counter << ": This is some text for your pleasure";
+            }
+        }));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    root.shutdown();
+    return 0;
+}
diff --git a/bench/log4cpp-bench.cpp b/bench/log4cpp-bench.cpp
new file mode 100644
index 00000000..a21526c8
--- /dev/null
+++ b/bench/log4cpp-bench.cpp
@@ -0,0 +1,48 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+
+#include "log4cpp/Category.hh"
+#include "log4cpp/Appender.hh"
+#include "log4cpp/FileAppender.hh"
+#include "log4cpp/Layout.hh"
+#include "log4cpp/BasicLayout.hh"
+#include "log4cpp/Priority.hh"
+#include "log4cpp/PatternLayout.hh"
+
+int main(int, char *[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int howmany = 1000000;
+
+    log4cpp::Appender *appender  = new log4cpp::FileAppender("default", "logs/log4cpp-bench.log");
+    log4cpp::PatternLayout *layout = new log4cpp::PatternLayout();
+    layout->setConversionPattern("%d{%Y-%m-%d %H:%M:%S.%l}: %p - %m %n");
+    appender->setLayout(layout);
+
+    log4cpp::Category& root = log4cpp::Category::getRoot();
+    root.addAppender(appender);
+    root.setPriority(log4cpp::Priority::INFO);
+
+    auto start = clock::now();
+    for (int i = 0; i < howmany; ++i)
+        root << log4cpp::Priority::INFO << "log4cpp message #" << i << ": This is some text for your pleasure";
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    root.shutdown();
+    return 0;
+}
diff --git a/bench/p7-bench-mt.cpp b/bench/p7-bench-mt.cpp
new file mode 100644
index 00000000..a3195208
--- /dev/null
+++ b/bench/p7-bench-mt.cpp
@@ -0,0 +1,97 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <atomic>
+#include <chrono>
+#include <iostream>
+#include <thread>
+#include <vector>
+#include <memory>
+#include <functional>
+
+#include "P7_Trace.h"
+
+
+int main(int argc, char *argv[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int thread_count = 10;
+    if (argc > 1)
+        thread_count = std::atoi(argv[1]);
+
+    int howmany = 1000000;
+
+    IP7_Trace::hModule module = NULL;
+
+    //create P7 client object
+    std::unique_ptr<IP7_Client, std::function<void (IP7_Client *)>> client(
+        P7_Create_Client(TM("/P7.Pool=1024 /P7.Sink=FileTxt /P7.Dir=logs/p7-bench-mt")),
+        [&](IP7_Client *ptr){
+            if (ptr)
+                ptr->Release();
+        });
+
+    if (!client)
+    {
+        std::cout << "Can't create IP7_Client" << std::endl;
+        return 1;
+    }
+
+    //create P7 trace object 1
+    std::unique_ptr<IP7_Trace, std::function<void (IP7_Trace *)>> trace(
+        P7_Create_Trace(client.get(), TM("Trace channel 1")),
+        [&](IP7_Trace *ptr){
+            if (ptr)
+                ptr->Release();
+        });
+
+    if (!trace)
+    {
+        std::cout << "Can't create IP7_Trace" << std::endl;
+        return 1;
+    }
+
+    trace->Register_Thread(TM("Application"), 0);
+    trace->Register_Module(TM("Main"), &module);
+
+    std::atomic<int> msg_counter{0};
+    std::vector<std::thread> threads;
+
+    auto start = clock::now();
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]() {
+            trace->Register_Thread(TM("Application"), t+1);
+            while (true)
+            {
+                int counter = ++msg_counter;
+                if (counter > howmany)
+                    break;
+                trace->P7_INFO(module, TM("p7 message #%d: This is some text for your pleasure"), counter);
+            }
+            trace->Register_Thread(TM("Application"), t+1);
+        }));
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    trace->Unregister_Thread(0);
+
+    return 0;
+}
diff --git a/bench/p7-bench.cpp b/bench/p7-bench.cpp
new file mode 100644
index 00000000..15513ca5
--- /dev/null
+++ b/bench/p7-bench.cpp
@@ -0,0 +1,70 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#include <chrono>
+#include <iostream>
+#include <memory>
+#include <functional>
+
+#include "P7_Trace.h"
+
+
+int main(int, char *[])
+{
+    using namespace std::chrono;
+    using clock = steady_clock;
+
+    int howmany = 1000000;
+
+    IP7_Trace::hModule module = NULL;
+
+    //create P7 client object
+    std::unique_ptr<IP7_Client, std::function<void (IP7_Client *)>> client(
+        P7_Create_Client(TM("/P7.Pool=1024 /P7.Sink=FileTxt /P7.Dir=logs/p7-bench")),
+        [&](IP7_Client *ptr){
+            if (ptr)
+                ptr->Release();
+        });
+
+    if (!client)
+    {
+        std::cout << "Can't create IP7_Client" << std::endl;
+        return 1;
+    }
+
+    //create P7 trace object 1
+    std::unique_ptr<IP7_Trace, std::function<void (IP7_Trace *)>> trace(
+        P7_Create_Trace(client.get(), TM("Trace channel 1")),
+        [&](IP7_Trace *ptr){
+            if (ptr)
+                ptr->Release();
+        });
+
+    if (!trace)
+    {
+        std::cout << "Can't create IP7_Trace" << std::endl;
+        return 1;
+    }
+
+    trace->Register_Thread(TM("Application"), 0);
+    trace->Register_Module(TM("Main"), &module);
+
+    auto start = clock::now();
+    for (int i = 0; i < howmany; ++i)
+        trace->P7_INFO(module, TM("p7 message #%d: This is some text for your pleasure"), i);
+
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
+    trace->Unregister_Thread(0);
+
+    return 0;
+}

From 70ad1aa40942f5fe6cfb8a49643dba13528ab2b9 Mon Sep 17 00:00:00 2001
From: Alexander Kiselev <kiselev.alexander@gmail.com>
Date: Mon, 19 Mar 2018 19:22:02 +0300
Subject: [PATCH 2/3] Changes: boost, easylogging, g2log, glog, spdlog.

---
 .gitignore                     |   1 +
 bench/Makefile                 |  51 ++++++++++++++++++++++++---------
 bench/boost-bench-mt.cpp       |  20 +++++++++++--
 bench/boost-bench.cpp          |  21 ++++++++++++--
 bench/easylogging-bench-mt.cpp |  23 ++++++++++++---
 bench/easylogging-bench.cpp    |  22 ++++++++++++--
 bench/g2log-async.cpp          |   2 +-
 bench/glog-bench-mt.cpp        |  16 ++++++++++-
 bench/glog-bench.cpp           |  18 +++++++++++-
 bench/mem                      |  19 ++++++++++++
 bench/p7-bench                 | Bin 0 -> 14704 bytes
 bench/spdlog-async.cpp         |  12 ++++----
 bench/spdlog-bench-mt.cpp      |  26 ++++++++++++-----
 bench/spdlog-bench.cpp         |  25 ++++++++++++----
 bench/spdlog-null-async.cpp    |   2 +-
 15 files changed, 212 insertions(+), 46 deletions(-)
 create mode 100755 bench/mem
 create mode 100755 bench/p7-bench

diff --git a/.gitignore b/.gitignore
index 2f3cb33d..b1a41919 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,5 @@
 # Auto generated files
+build/*
 *.slo
 *.lo
 *.o
diff --git a/bench/Makefile b/bench/Makefile
index 418a5285..c619a5ae 100644
--- a/bench/Makefile
+++ b/bench/Makefile
@@ -3,7 +3,15 @@ CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../includ
 CXX_RELEASE_FLAGS = -O3 -flto -DNDEBUG
 
 
-binaries=spdlog-bench spdlog-bench-mt spdlog-async spdlog-null-async boost-bench boost-bench-mt glog-bench glog-bench-mt g2log-async easylogging-bench easylogging-bench-mt
+#         g2log-async
+binaries=spdlog-bench spdlog-bench-mt spdlog-async spdlog-null-async \
+         boost-bench boost-bench-mt \
+         glog-bench glog-bench-mt \
+         g3log-async \
+         p7-bench p7-bench-mt \
+         log4cpp-bench log4cpp-bench-mt \
+         log4cplus-bench log4cplus-bench-mt \
+         easylogging-bench easylogging-bench-mt
 
 all: $(binaries)
 
@@ -16,13 +24,10 @@ spdlog-bench-mt: spdlog-bench-mt.cpp
 spdlog-async: spdlog-async.cpp
 	$(CXX) spdlog-async.cpp -o spdlog-async  $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
 
-
 spdlog-null-async: spdlog-null-async.cpp
 	$(CXX) spdlog-null-async.cpp -o spdlog-null-async $(CXXFLAGS) $(CXX_RELEASE_FLAGS)
 
-	
-	
-BOOST_FLAGS	= -DBOOST_LOG_DYN_LINK  -I/usr/include -lboost_log  -lboost_log_setup -lboost_filesystem -lboost_system -lboost_thread -lboost_regex -lboost_date_time -lboost_chrono
+BOOST_FLAGS	= -DBOOST_LOG_DYN_LINK -I$(HOME)/include -I/usr/include -L$(HOME)/lib -lboost_log_setup -lboost_log -lboost_filesystem -lboost_system -lboost_thread -lboost_regex -lboost_date_time -lboost_chrono
 
 boost-bench: boost-bench.cpp
 	$(CXX) boost-bench.cpp -o boost-bench $(CXXFLAGS) $(BOOST_FLAGS) $(CXX_RELEASE_FLAGS)
@@ -30,21 +35,43 @@ boost-bench: boost-bench.cpp
 boost-bench-mt: boost-bench-mt.cpp
 	$(CXX) boost-bench-mt.cpp -o boost-bench-mt $(CXXFLAGS) $(BOOST_FLAGS) $(CXX_RELEASE_FLAGS)	
 
-
-GLOG_FLAGS = -lglog
+GLOG_FLAGS = -I$(HOME)/include -L$(HOME)/lib -lglog
 glog-bench: glog-bench.cpp
 	$(CXX) glog-bench.cpp -o glog-bench $(CXXFLAGS) $(GLOG_FLAGS) $(CXX_RELEASE_FLAGS)
 	
 glog-bench-mt: glog-bench-mt.cpp
 	$(CXX) glog-bench-mt.cpp -o glog-bench-mt $(CXXFLAGS) $(GLOG_FLAGS) $(CXX_RELEASE_FLAGS)	
 
-
-G2LOG_FLAGS = -I/home/gabi/devel/g2log/g2log/src -L/home/gabi/devel/g2log/g2log -llib_g2logger 
+G2LOG_FLAGS = -I$(HOME)/include -L$(HOME)/lib -llib_g2logger 
 g2log-async: g2log-async.cpp
 	$(CXX) g2log-async.cpp -o g2log-async $(CXXFLAGS) $(G2LOG_FLAGS) $(CXX_RELEASE_FLAGS)
 	
+G3LOG_FLAGS = -I$(HOME)/include -L$(HOME)/lib -lg3logger
+g3log-async: g3log-async.cpp
+	$(CXX) g3log-async.cpp -o g3log-async $(CXXFLAGS) $(G3LOG_FLAGS) $(CXX_RELEASE_FLAGS)
 
-EASYL_FLAGS = -I../../easylogging/src/
+P7_FLAGS = -I$(HOME)/P7/Headers -I$(HOME)/include -L$(HOME)/lib -lP7
+p7-bench: p7-bench.cpp
+	$(CXX) p7-bench.cpp -o p7-bench $(CXXFLAGS) $(P7_FLAGS) $(CXX_RELEASE_FLAGS)
+
+p7-bench-mt: p7-bench-mt.cpp
+	$(CXX) p7-bench-mt.cpp -o p7-bench-mt $(CXXFLAGS) $(P7_FLAGS) $(CXX_RELEASE_FLAGS)
+
+LOG4CPP_FLAGS = -I$(HOME)/include -L$(HOME)/lib -llog4cpp
+log4cpp-bench: log4cpp-bench.cpp
+	$(CXX) log4cpp-bench.cpp -o log4cpp-bench $(CXXFLAGS) $(LOG4CPP_FLAGS) $(CXX_RELEASE_FLAGS)
+
+log4cpp-bench-mt: log4cpp-bench-mt.cpp
+	$(CXX) log4cpp-bench-mt.cpp -o log4cpp-bench-mt $(CXXFLAGS) $(LOG4CPP_FLAGS) $(CXX_RELEASE_FLAGS)
+
+LOG4CPLUS_FLAGS = -I$(HOME)/include -L$(HOME)/lib -llog4cplus
+log4cplus-bench: log4cplus-bench.cpp
+	$(CXX) log4cplus-bench.cpp -o log4cplus-bench $(CXXFLAGS) $(LOG4CPLUS_FLAGS) $(CXX_RELEASE_FLAGS)
+
+log4cplus-bench-mt: log4cplus-bench-mt.cpp
+	$(CXX) log4cplus-bench-mt.cpp -o log4cplus-bench-mt $(CXXFLAGS) $(LOG4CPLUS_FLAGS) $(CXX_RELEASE_FLAGS)
+
+EASYL_FLAGS = -I$(HOME)/easyloggingpp/src
 easylogging-bench: easylogging-bench.cpp
 	$(CXX) easylogging-bench.cpp -o easylogging-bench $(CXXFLAGS) $(EASYL_FLAGS) $(CXX_RELEASE_FLAGS)
 easylogging-bench-mt: easylogging-bench-mt.cpp
@@ -55,8 +82,4 @@ easylogging-bench-mt: easylogging-bench-mt.cpp
 clean:
 	rm -f *.o logs/* $(binaries)
 
-
 rebuild: clean all
-
-
-
diff --git a/bench/boost-bench-mt.cpp b/bench/boost-bench-mt.cpp
index 73219b91..3a6eeea8 100644
--- a/bench/boost-bench-mt.cpp
+++ b/bench/boost-bench-mt.cpp
@@ -4,6 +4,8 @@
 //
 
 #include <atomic>
+#include <chrono>
+#include <iostream>
 #include <thread>
 #include <vector>
 
@@ -23,7 +25,7 @@ namespace keywords = boost::log::keywords;
 
 void init()
 {
-    logging::add_file_log(keywords::file_name = "logs/boost-sample_%N.log", /*< file name pattern >*/
+    logging::add_file_log(keywords::file_name = "logs/boost-bench-mt_%N.log", /*< file name pattern >*/
         keywords::auto_flush = false, keywords::format = "[%TimeStamp%]: %Message%");
 
     logging::core::get()->set_filter(logging::trivial::severity >= logging::trivial::info);
@@ -33,6 +35,9 @@ using namespace std;
 
 int main(int argc, char *argv[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
+
     int thread_count = 10;
     if (argc > 1)
         thread_count = atoi(argv[1]);
@@ -49,6 +54,7 @@ int main(int argc, char *argv[])
     std::atomic<int> msg_counter{0};
     vector<thread> threads;
 
+    auto start = clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
@@ -65,7 +71,17 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
 
     return 0;
 }
diff --git a/bench/boost-bench.cpp b/bench/boost-bench.cpp
index cb432578..334fcb93 100644
--- a/bench/boost-bench.cpp
+++ b/bench/boost-bench.cpp
@@ -2,6 +2,10 @@
 // Copyright(c) 2015 Gabi Melman.
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
+
+#include <chrono>
+#include <iostream>
+
 #include <boost/log/core.hpp>
 #include <boost/log/expressions.hpp>
 #include <boost/log/sinks/text_file_backend.hpp>
@@ -18,22 +22,35 @@ namespace keywords = boost::log::keywords;
 
 void init()
 {
-    logging::add_file_log(keywords::file_name = "logs/boost-sample_%N.log", /*< file name pattern >*/
+    logging::add_file_log(keywords::file_name = "logs/boost-bench_%N.log", /*< file name pattern >*/
         keywords::auto_flush = false, keywords::format = "[%TimeStamp%]: %Message%");
 
     logging::core::get()->set_filter(logging::trivial::severity >= logging::trivial::info);
 }
 
-int main(int argc, char *[])
+int main(int, char *[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
+
     int howmany = 1000000;
     init();
     logging::add_common_attributes();
 
     using namespace logging::trivial;
     src::severity_logger_mt<severity_level> lg;
+
+    auto start = clock::now();
     for (int i = 0; i < howmany; ++i)
         BOOST_LOG_SEV(lg, info) << "boost message #" << i << ": This is some text for your pleasure";
 
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
     return 0;
 }
diff --git a/bench/easylogging-bench-mt.cpp b/bench/easylogging-bench-mt.cpp
index 00f507c6..cfcf3348 100644
--- a/bench/easylogging-bench-mt.cpp
+++ b/bench/easylogging-bench-mt.cpp
@@ -4,17 +4,22 @@
 //
 
 #include <atomic>
+#include <chrono>
+#include <iostream>
 #include <thread>
 #include <vector>
 
-#define _ELPP_THREAD_SAFE
+#define ELPP_THREAD_SAFE
 #include "easylogging++.h"
-_INITIALIZE_EASYLOGGINGPP
+#include "easylogging++.cc"
+INITIALIZE_EASYLOGGINGPP
 
 using namespace std;
 
 int main(int argc, char *argv[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
 
     int thread_count = 10;
     if (argc > 1)
@@ -23,12 +28,13 @@ int main(int argc, char *argv[])
     int howmany = 1000000;
 
     // Load configuration from file
-    el::Configurations conf("easyl.conf");
+    el::Configurations conf("easyl-mt.conf");
     el::Loggers::reconfigureLogger("default", conf);
 
     std::atomic<int> msg_counter{0};
     vector<thread> threads;
 
+    auto start = clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
@@ -45,7 +51,16 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
 
     return 0;
 }
diff --git a/bench/easylogging-bench.cpp b/bench/easylogging-bench.cpp
index 5306435f..06b66134 100644
--- a/bench/easylogging-bench.cpp
+++ b/bench/easylogging-bench.cpp
@@ -3,19 +3,37 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
-#include "easylogging++.h"
+#include <chrono>
+#include <iostream>
 
-_INITIALIZE_EASYLOGGINGPP
+#include "easylogging++.h"
+#include "easylogging++.cc"
+INITIALIZE_EASYLOGGINGPP
 
 int main(int, char *[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
+
     int howmany = 1000000;
 
     // Load configuration from file
     el::Configurations conf("easyl.conf");
     el::Loggers::reconfigureLogger("default", conf);
 
+    el::Logger* defaultLogger = el::Loggers::getLogger("default");
+
+    auto start = clock::now();
     for (int i = 0; i < howmany; ++i)
         LOG(INFO) << "easylog message #" << i << ": This is some text for your pleasure";
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
     return 0;
 }
diff --git a/bench/g2log-async.cpp b/bench/g2log-async.cpp
index 97cac5dc..ad21a0e5 100644
--- a/bench/g2log-async.cpp
+++ b/bench/g2log-async.cpp
@@ -47,7 +47,7 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
 
     duration<float> delta = clock::now() - start;
     float deltaf = delta.count();
diff --git a/bench/glog-bench-mt.cpp b/bench/glog-bench-mt.cpp
index 5e43de78..2f0aef19 100644
--- a/bench/glog-bench-mt.cpp
+++ b/bench/glog-bench-mt.cpp
@@ -4,6 +4,8 @@
 //
 
 #include <atomic>
+#include <chrono>
+#include <iostream>
 #include <thread>
 #include <vector>
 
@@ -13,6 +15,8 @@ using namespace std;
 
 int main(int argc, char *argv[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
 
     int thread_count = 10;
     if (argc > 1)
@@ -27,6 +31,7 @@ int main(int argc, char *argv[])
     std::atomic<int> msg_counter{0};
     vector<thread> threads;
 
+    auto start = clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
@@ -43,7 +48,16 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
 
     return 0;
 }
diff --git a/bench/glog-bench.cpp b/bench/glog-bench.cpp
index 2a8db891..6b4445a9 100644
--- a/bench/glog-bench.cpp
+++ b/bench/glog-bench.cpp
@@ -3,17 +3,33 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
+#include <chrono>
+#include <iostream>
+
 #include "glog/logging.h"
 
+
 int main(int, char *argv[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
+
     int howmany = 1000000;
 
     FLAGS_logtostderr = 0;
     FLAGS_log_dir = "logs";
     google::InitGoogleLogging(argv[0]);
+    auto start = clock::now();
     for (int i = 0; i < howmany; ++i)
-        LOG(INFO) << "glog message # " << i << ": This is some text for your pleasure";
+        LOG(INFO) << "glog message #" << i << ": This is some text for your pleasure";
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
 
     return 0;
 }
diff --git a/bench/mem b/bench/mem
new file mode 100755
index 00000000..c49744e7
--- /dev/null
+++ b/bench/mem
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+if [ $# -lt 1 ]; then
+  echo "usage: $0 <program>"
+fi
+
+PROG=$1
+
+if [ ! -x "$PROG" ]; then
+  echo $PROG not found or not executable.
+  exit 1
+fi
+
+$* &
+PID=$!
+
+while `kill -0 $PID 2>/dev/null`; do
+  ps -eo size,pid,user,pcpu,command --sort -size | awk '{ line=1 ; hr=$1/1024 ; printf("%13.2f Mb ",hr); } { for ( x=4 ; x<=NF ; x++ ) { printf("%s ",$x) } print "" }' | grep -v grep | grep -v $0 | grep $PROG
+done
diff --git a/bench/p7-bench b/bench/p7-bench
new file mode 100755
index 0000000000000000000000000000000000000000..566ec56b04ab3c6f4147b140ac46c0785d7607de
GIT binary patch
literal 14704
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

literal 0
HcmV?d00001

diff --git a/bench/spdlog-async.cpp b/bench/spdlog-async.cpp
index 0db4f6c6..1c0ce41d 100644
--- a/bench/spdlog-async.cpp
+++ b/bench/spdlog-async.cpp
@@ -15,22 +15,22 @@ using namespace std;
 
 int main(int argc, char *argv[])
 {
-
     using namespace std::chrono;
     using clock = steady_clock;
-    namespace spd = spdlog;
 
     int thread_count = 10;
     if (argc > 1)
         thread_count = ::atoi(argv[1]);
+
     int howmany = 1000000;
 
-    spd::set_async_mode(1048576);
-    auto logger = spdlog::create<spd::sinks::simple_file_sink_mt>("file_logger", "logs/spd-bench-async.txt", false);
-    logger->set_pattern("[%Y-%b-%d %T.%e]: %v");
+    spdlog::set_async_mode(1048576);
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
+    logger->set_pattern("[%Y-%b-%d %T.%e]: %f");
 
     std::atomic<int> msg_counter{0};
     vector<thread> threads;
+
     auto start = clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
@@ -48,7 +48,7 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
 
     duration<float> delta = clock::now() - start;
     float deltaf = delta.count();
diff --git a/bench/spdlog-bench-mt.cpp b/bench/spdlog-bench-mt.cpp
index 5feb7044..d6dfeb51 100644
--- a/bench/spdlog-bench-mt.cpp
+++ b/bench/spdlog-bench-mt.cpp
@@ -3,16 +3,21 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
-#include "spdlog/spdlog.h"
 #include <atomic>
+#include <chrono>
+#include <iostream>
 #include <cstdlib>
 #include <thread>
 #include <vector>
 
+#include "spdlog/spdlog.h"
+
 using namespace std;
 
 int main(int argc, char *argv[])
 {
+    using namespace std::chrono;
+    using clock = steady_clock;
 
     int thread_count = 10;
     if (argc > 1)
@@ -20,15 +25,13 @@ int main(int argc, char *argv[])
 
     int howmany = 1000000;
 
-    namespace spd = spdlog;
-
-    auto logger = spdlog::create<spd::sinks::simple_file_sink_mt>("file_logger", "logs/spd-bench-mt.txt", false);
-
-    logger->set_pattern("[%Y-%b-%d %T.%e]: %v");
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-mt.log", false);
+    logger->set_pattern("[%Y-%b-%d %T.%f]: %v");
 
     std::atomic<int> msg_counter{0};
     std::vector<thread> threads;
 
+    auto start = clock::now();
     for (int t = 0; t < thread_count; ++t)
     {
         threads.push_back(std::thread([&]() {
@@ -45,7 +48,16 @@ int main(int argc, char *argv[])
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Threads: " << thread_count << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
 
     return 0;
 }
diff --git a/bench/spdlog-bench.cpp b/bench/spdlog-bench.cpp
index 8d122249..e241fa5e 100644
--- a/bench/spdlog-bench.cpp
+++ b/bench/spdlog-bench.cpp
@@ -3,17 +3,32 @@
 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
 //
 
+#include <chrono>
+#include <iostream>
+
 #include "spdlog/spdlog.h"
 
 int main(int, char *[])
 {
-    int howmany = 1000000;
-    namespace spd = spdlog;
-    /// Create a file rotating logger with 5mb size max and 3 rotated files
-    auto logger = spdlog::create<spd::sinks::simple_file_sink_st>("file_logger", "logs/spd-bench-st.txt", false);
+    using namespace std::chrono;
+    using clock = steady_clock;
 
-    logger->set_pattern("[%Y-%b-%d %T.%e]: %v");
+    int howmany = 1000000;
+
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_st>("file_logger", "logs/spdlog-bench.log", false);
+    logger->set_pattern("[%Y-%b-%d %T.%f]: %v");
+
+    auto start = clock::now();
     for (int i = 0; i < howmany; ++i)
         logger->info("spdlog message #{} : This is some text for your pleasure", i);
+
+    duration<float> delta = clock::now() - start;
+    float deltaf = delta.count();
+    auto rate = howmany / deltaf;
+
+    std::cout << "Total: " << howmany << std::endl;
+    std::cout << "Delta = " << deltaf << " seconds" << std::endl;
+    std::cout << "Rate = " << rate << "/sec" << std::endl;
+
     return 0;
 }
diff --git a/bench/spdlog-null-async.cpp b/bench/spdlog-null-async.cpp
index df07f834..e9b33c9d 100644
--- a/bench/spdlog-null-async.cpp
+++ b/bench/spdlog-null-async.cpp
@@ -93,7 +93,7 @@ size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_cou
     for (auto &t : threads)
     {
         t.join();
-    };
+    }
 
     auto delta = system_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();

From fd1c4d78775a5a3ad5d5cc3f95469b9501cc39af Mon Sep 17 00:00:00 2001
From: Alexander Kiselev <kiselev.alexander@gmail.com>
Date: Mon, 19 Mar 2018 20:03:47 +0300
Subject: [PATCH 3/3] Fix: unknown conversion specifier 'Y'

---
 bench/log4cpp-bench-mt.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bench/log4cpp-bench-mt.cpp b/bench/log4cpp-bench-mt.cpp
index 82f3a40f..dc6a5f58 100644
--- a/bench/log4cpp-bench-mt.cpp
+++ b/bench/log4cpp-bench-mt.cpp
@@ -31,7 +31,7 @@ int main(int argc, char * argv[])
 
     log4cpp::Appender *appender  = new log4cpp::FileAppender("default", "logs/log4cpp-bench-mt.log");
     log4cpp::PatternLayout *layout = new log4cpp::PatternLayout();
-    layout->setConversionPattern("{%Y-%m-%d %H:%M:%S.%l}: %p - %m %n");
+    layout->setConversionPattern("%d{%Y-%m-%d %H:%M:%S.%l}: %p - %m %n");
     appender->setLayout(layout);
 
     log4cpp::Category& root = log4cpp::Category::getRoot();