updated version number to 0.17.0

Update step_logger

.gitignore

@@ -1,5 +1,5 @@
 # Auto generated files
-build/*
+build/*
 *.slo
 *.lo
 *.o
@@ -65,4 +65,7 @@ install_manifest.txt
 /tests/logs/*
 
 # idea
-.idea/
+.idea/
+
+# vscode
+.vscode/

CMakeLists.txt

@@ -4,7 +4,7 @@
 #
 
 cmake_minimum_required(VERSION 3.1)
-project(spdlog VERSION 0.16.3 LANGUAGES CXX)
+project(spdlog VERSION 0.17.0 LANGUAGES CXX)
 include(CTest)
 include(CMakeDependentOption)
 include(GNUInstallDirs)

README.md

@@ -30,7 +30,7 @@ Very fast, header only, C++ logging library. [![Build Status](https://travis-ci.
 * Headers only, just copy and use.
 * Feature rich [call style](#usage-example) using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Optional printf syntax support.
-* Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec.
+* Asynchronous mode (optional)
 * [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
 * Conditional Logging
 * Multi/Single threaded loggers.
@@ -54,9 +54,9 @@ Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of
 
 |threads|boost log 1.54|glog   |easylogging |spdlog|
 |-------|:-------:|:-----:|----------:|------:|
-|1|       4.169s  |1.066s |0.975s     |0.302s|
-|10|     6.180s   |3.032s |2.857s     |0.968s|
-|100|     5.981s  |1.139s |4.512s     |0.497s|
+|1|       4.169s  |1.066s |0.975s     |0.392s|
+|10|     6.180s   |3.032s |2.857s     |0.773s|
+|100|     5.981s  |1.139s |4.512s     |0.587s|
 
 
 #### Asynchronous mode
@@ -64,9 +64,9 @@ Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes
 
 |threads|g2log <sup>async logger</sup>   |spdlog <sup>async mode</sup>|
 |:-------|:-----:|-------------------------:|
-|1|       1.850s |0.216s |
-|10|      0.943s  |0.173s|
-|100|      0.959s |0.202s|
+|1|       1.850s |0.39s |
+|10|      0.943s  |0.416s|
+|100|      0.959s |0.413s|
 
 
 
@@ -170,7 +170,7 @@ int main(int, char*[])
 
 void async_example()
 {
-    size_t q_size = 4096; //queue size must be power of 2
+    size_t q_size = 4096; 
     spd::set_async_mode(q_size);
     auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
     for (int i = 0; i < 100; ++i)

bench/spdlog-async.cpp

@@ -25,8 +25,8 @@ int main(int argc, char *argv[])
 
     int howmany = 1000000;
 
-    spdlog::set_async_mode(1048576);
-    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", false);
+    spdlog::set_async_mode(1000000);
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("file_logger", "logs/spdlog-bench-async.log", true);
     logger->set_pattern("[%Y-%m-%d %T.%F]: %L %t %v");
 
     std::cout << "To stop, press <Enter>" << std::endl;

example/bench.cpp

@@ -100,7 +100,7 @@ void bench(int howmany, std::shared_ptr<spdlog::logger> log)
 
     auto delta = system_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    cout << format(int(howmany / delta_d)) << "/sec" << endl;
+    cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }
 
 void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
@@ -130,5 +130,5 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
 
     auto delta = system_clock::now() - start;
     auto delta_d = duration_cast<duration<double>>(delta).count();
-    cout << format(int(howmany / delta_d)) << "/sec" << endl;
+    cout << "Elapsed: " << delta_d << "\t" << format(int(howmany / delta_d)) << "/sec" << endl;
 }

example/example.cpp

@@ -105,7 +105,7 @@ int main(int, char *[])
 
 void async_example()
 {
-    size_t q_size = 4096; // queue size must be power of 2
+    size_t q_size = 4096;
     spdlog::set_async_mode(q_size);
     auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
     for (int i = 0; i < 100; ++i)

example/example.sln

@@ -1,10 +1,83 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 14
-VisualStudioVersion = 14.0.25420.1
+# Visual Studio 15
+VisualStudioVersion = 15.0.27428.2037
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example", "example.vcxproj", "{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "spdlog", "spdlog", "{319A0767-E66D-4DD0-8BEF-E29E891BA836}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\async_logger.h = ..\include\spdlog\async_logger.h
+		..\include\spdlog\common.h = ..\include\spdlog\common.h
+		..\include\spdlog\formatter.h = ..\include\spdlog\formatter.h
+		..\include\spdlog\logger.h = ..\include\spdlog\logger.h
+		..\include\spdlog\spdlog.h = ..\include\spdlog\spdlog.h
+		..\include\spdlog\tweakme.h = ..\include\spdlog\tweakme.h
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "contrib", "contrib", "{F1B153FB-7638-4F2B-B6FF-F56859D381F9}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\contrib\README.md = ..\include\spdlog\contrib\README.md
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sinks", "sinks", "{9B3669F7-6D70-4699-9067-451E9298BA53}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\contrib\sinks\.gitignore = ..\include\spdlog\contrib\sinks\.gitignore
+		..\include\spdlog\contrib\sinks\step_file_sink.h = ..\include\spdlog\contrib\sinks\step_file_sink.h
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "details", "details", "{579FDBF1-8FCD-4F1D-99F1-540F2EFF95E0}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\details\async_log_helper.h = ..\include\spdlog\details\async_log_helper.h
+		..\include\spdlog\details\async_logger_impl.h = ..\include\spdlog\details\async_logger_impl.h
+		..\include\spdlog\details\file_helper.h = ..\include\spdlog\details\file_helper.h
+		..\include\spdlog\details\log_msg.h = ..\include\spdlog\details\log_msg.h
+		..\include\spdlog\details\logger_impl.h = ..\include\spdlog\details\logger_impl.h
+		..\include\spdlog\details\mpmc_blocking_q.h = ..\include\spdlog\details\mpmc_blocking_q.h
+		..\include\spdlog\details\null_mutex.h = ..\include\spdlog\details\null_mutex.h
+		..\include\spdlog\details\os.h = ..\include\spdlog\details\os.h
+		..\include\spdlog\details\pattern_formatter_impl.h = ..\include\spdlog\details\pattern_formatter_impl.h
+		..\include\spdlog\details\registry.h = ..\include\spdlog\details\registry.h
+		..\include\spdlog\details\spdlog_impl.h = ..\include\spdlog\details\spdlog_impl.h
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "fmt", "fmt", "{2034E575-9375-4AE7-B667-AF4A359F1483}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\fmt\fmt.h = ..\include\spdlog\fmt\fmt.h
+		..\include\spdlog\fmt\ostr.h = ..\include\spdlog\fmt\ostr.h
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "bundled", "bundled", "{16763E99-3CC7-4C46-8F79-259356FF0B37}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\fmt\bundled\format.cc = ..\include\spdlog\fmt\bundled\format.cc
+		..\include\spdlog\fmt\bundled\format.h = ..\include\spdlog\fmt\bundled\format.h
+		..\include\spdlog\fmt\bundled\LICENSE.rst = ..\include\spdlog\fmt\bundled\LICENSE.rst
+		..\include\spdlog\fmt\bundled\ostream.cc = ..\include\spdlog\fmt\bundled\ostream.cc
+		..\include\spdlog\fmt\bundled\ostream.h = ..\include\spdlog\fmt\bundled\ostream.h
+		..\include\spdlog\fmt\bundled\posix.cc = ..\include\spdlog\fmt\bundled\posix.cc
+		..\include\spdlog\fmt\bundled\posix.h = ..\include\spdlog\fmt\bundled\posix.h
+		..\include\spdlog\fmt\bundled\printf.cc = ..\include\spdlog\fmt\bundled\printf.cc
+		..\include\spdlog\fmt\bundled\printf.h = ..\include\spdlog\fmt\bundled\printf.h
+		..\include\spdlog\fmt\bundled\time.h = ..\include\spdlog\fmt\bundled\time.h
+	EndProjectSection
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "sinks", "sinks", "{13310FA4-52E7-46BA-B071-B72B1D8E44D9}"
+	ProjectSection(SolutionItems) = preProject
+		..\include\spdlog\sinks\android_sink.h = ..\include\spdlog\sinks\android_sink.h
+		..\include\spdlog\sinks\ansicolor_sink.h = ..\include\spdlog\sinks\ansicolor_sink.h
+		..\include\spdlog\sinks\base_sink.h = ..\include\spdlog\sinks\base_sink.h
+		..\include\spdlog\sinks\dist_sink.h = ..\include\spdlog\sinks\dist_sink.h
+		..\include\spdlog\sinks\file_sinks.h = ..\include\spdlog\sinks\file_sinks.h
+		..\include\spdlog\sinks\msvc_sink.h = ..\include\spdlog\sinks\msvc_sink.h
+		..\include\spdlog\sinks\null_sink.h = ..\include\spdlog\sinks\null_sink.h
+		..\include\spdlog\sinks\ostream_sink.h = ..\include\spdlog\sinks\ostream_sink.h
+		..\include\spdlog\sinks\sink.h = ..\include\spdlog\sinks\sink.h
+		..\include\spdlog\sinks\stdout_sinks.h = ..\include\spdlog\sinks\stdout_sinks.h
+		..\include\spdlog\sinks\syslog_sink.h = ..\include\spdlog\sinks\syslog_sink.h
+		..\include\spdlog\sinks\wincolor_sink.h = ..\include\spdlog\sinks\wincolor_sink.h
+		..\include\spdlog\sinks\windebug_sink.h = ..\include\spdlog\sinks\windebug_sink.h
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Win32 = Debug|Win32
@@ -23,4 +96,15 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{F1B153FB-7638-4F2B-B6FF-F56859D381F9} = {319A0767-E66D-4DD0-8BEF-E29E891BA836}
+		{9B3669F7-6D70-4699-9067-451E9298BA53} = {F1B153FB-7638-4F2B-B6FF-F56859D381F9}
+		{579FDBF1-8FCD-4F1D-99F1-540F2EFF95E0} = {319A0767-E66D-4DD0-8BEF-E29E891BA836}
+		{2034E575-9375-4AE7-B667-AF4A359F1483} = {319A0767-E66D-4DD0-8BEF-E29E891BA836}
+		{16763E99-3CC7-4C46-8F79-259356FF0B37} = {2034E575-9375-4AE7-B667-AF4A359F1483}
+		{13310FA4-52E7-46BA-B071-B72B1D8E44D9} = {319A0767-E66D-4DD0-8BEF-E29E891BA836}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8C12721F-513C-4922-B2F8-B9F2403412B4}
+	EndGlobalSection
 EndGlobal

example/example.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -13,56 +13,23 @@
   <ItemGroup>
     <ClCompile Include="example.cpp" />
   </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="..\include\spdlog\async_logger.h" />
-    <ClInclude Include="..\include\spdlog\common.h" />
-    <ClInclude Include="..\include\spdlog\details\async_logger_impl.h" />
-    <ClInclude Include="..\include\spdlog\details\async_log_helper.h" />
-    <ClInclude Include="..\include\spdlog\details\file_helper.h" />
-    <ClInclude Include="..\include\spdlog\details\logger_impl.h" />
-    <ClInclude Include="..\include\spdlog\details\log_msg.h" />
-    <ClInclude Include="..\include\spdlog\details\mpmc_bounded_q.h" />
-    <ClInclude Include="..\include\spdlog\details\null_mutex.h" />
-    <ClInclude Include="..\include\spdlog\details\os.h" />
-    <ClInclude Include="..\include\spdlog\details\pattern_formatter_impl.h" />
-    <ClInclude Include="..\include\spdlog\details\registry.h" />
-    <ClInclude Include="..\include\spdlog\details\spdlog_impl.h" />
-    <ClInclude Include="..\include\spdlog\fmt\fmt.h" />
-    <ClInclude Include="..\include\spdlog\fmt\ostr.h" />
-    <ClInclude Include="..\include\spdlog\formatter.h" />
-    <ClInclude Include="..\include\spdlog\logger.h" />
-    <ClInclude Include="..\include\spdlog\sinks\android_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\ansicolor_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\base_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\dist_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\file_sinks.h" />
-    <ClInclude Include="..\include\spdlog\sinks\msvc_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\null_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\ostream_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\stdout_sinks.h" />
-    <ClInclude Include="..\include\spdlog\sinks\syslog_sink.h" />
-    <ClInclude Include="..\include\spdlog\sinks\wincolor_sink.h" />
-    <ClInclude Include="..\include\spdlog\spdlog.h" />
-    <ClInclude Include="..\include\spdlog\tweakme.h" />
-  </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectGuid>{9E5AB93A-0CCE-4BAC-9FCB-0FC9CB5EB8D2}</ProjectGuid>
     <Keyword>Win32Proj</Keyword>
     <RootNamespace>.</RootNamespace>
-    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
+    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v120</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>

include/spdlog/common.h

@@ -5,7 +5,7 @@
 
 #pragma once
 
-#define SPDLOG_VERSION "0.16.4-rc"
+#define SPDLOG_VERSION "0.17.0"
 
 #include "tweakme.h"
 

include/spdlog/contrib/sinks/step_file_sink.h

@@ -0,0 +1,163 @@
+#pragma once
+
+#include "../../details/file_helper.h"
+#include "../../details/null_mutex.h"
+#include "../../fmt/fmt.h"
+#include "../../sinks/base_sink.h"
+
+#include <algorithm>
+#include <cerrno>
+#include <chrono>
+#include <cstdio>
+#include <ctime>
+#include <mutex>
+#include <string>
+
+// Example for spdlog.h
+//
+// Create a file logger which creates new files with a specified time step and fixed file size:
+//
+// std::shared_ptr<logger> step_logger_mt(const std::string &logger_name, const filename_t &filename, unsigned seconds = 60, const
+// filename_t &tmp_ext = ".tmp", unsigned max_file_size = std::numeric_limits<unsigned>::max()); std::shared_ptr<logger>
+// step_logger_st(const std::string &logger_name, const filename_t &filename, unsigned seconds = 60, const filename_t &tmp_ext = ".tmp",
+// unsigned max_file_size = std::numeric_limits<unsigned>::max());
+
+// Example for spdlog_impl.h
+// Create a file logger that creates new files with a specified increment
+// inline std::shared_ptr<spdlog::logger> spdlog::step_logger_mt(
+//     const std::string &logger_name, const filename_t &filename_fmt, unsigned seconds, const filename_t &tmp_ext, unsigned max_file_size)
+// {
+//     return create<spdlog::sinks::step_file_sink_mt>(logger_name, filename_fmt, seconds, tmp_ext, max_file_size);
+// }
+
+// inline std::shared_ptr<spdlog::logger> spdlog::step_logger_st(
+//     const std::string &logger_name, const filename_t &filename_fmt, unsigned seconds, const filename_t &tmp_ext, unsigned max_file_size)
+// {
+//     return create<spdlog::sinks::step_file_sink_st>(logger_name, filename_fmt, seconds, tmp_ext, max_file_size);
+// }
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Default generator of step log file names.
+ */
+struct default_step_file_name_calculator
+{
+    // Create filename for the form filename_YYYY-MM-DD_hh-mm-ss.ext
+    static std::tuple<filename_t, filename_t> calc_filename(const filename_t &filename, const filename_t &tmp_ext)
+    {
+        std::tm tm = spdlog::details::os::localtime();
+        filename_t basename, ext;
+        std::tie(basename, ext) = details::file_helper::split_by_extenstion(filename);
+        std::conditional<std::is_same<filename_t::value_type, char>::value, fmt::MemoryWriter, fmt::WMemoryWriter>::type w;
+        w.write(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}-{:02d}{}"), basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+            tm.tm_hour, tm.tm_min, tm.tm_sec, tmp_ext);
+        return std::make_tuple(w.str(), ext);
+    }
+};
+
+/*
+ * Rotating file sink based on size and a specified time step
+ */
+template<class Mutex, class FileNameCalc = default_step_file_name_calculator>
+class step_file_sink SPDLOG_FINAL : public base_sink<Mutex>
+{
+public:
+    step_file_sink(filename_t base_filename, unsigned step_seconds, filename_t tmp_ext, unsigned max_size)
+        : _base_filename(std::move(base_filename))
+        , _tmp_ext(std::move(tmp_ext))
+        , _step_seconds(step_seconds)
+        , _max_size(max_size)
+    {
+        if (step_seconds == 0)
+        {
+            throw spdlog_ex("step_file_sink: Invalid time step in ctor");
+        }
+        if (max_size == 0)
+        {
+            throw spdlog_ex("step_file_sink: Invalid max log size in ctor");
+        }
+
+        _tp = _next_tp();
+        std::tie(_current_filename, _ext) = FileNameCalc::calc_filename(_base_filename, _tmp_ext);
+
+        if (_tmp_ext == _ext)
+        {
+            throw spdlog_ex("step_file_sink: The temporary extension matches the specified in ctor");
+        }
+
+        _file_helper.open(_current_filename);
+        _current_size = _file_helper.size(); // expensive. called only once
+    }
+
+    ~step_file_sink()
+    {
+        try
+        {
+            close_current_file();
+        }
+        catch (...)
+        {
+        }
+    }
+
+protected:
+    void _sink_it(const details::log_msg &msg) override
+    {
+        _current_size += msg.formatted.size();
+        if (std::chrono::system_clock::now() >= _tp || _current_size > _max_size)
+        {
+            close_current_file();
+
+            std::tie(_current_filename, std::ignore) = FileNameCalc::calc_filename(_base_filename, _tmp_ext);
+            _file_helper.open(_current_filename);
+            _tp = _next_tp();
+            _current_size = msg.formatted.size();
+        }
+        _file_helper.write(msg);
+    }
+
+    void _flush() override
+    {
+        _file_helper.flush();
+    }
+
+private:
+    std::chrono::system_clock::time_point _next_tp()
+    {
+        return std::chrono::system_clock::now() + _step_seconds;
+    }
+
+    void close_current_file()
+    {
+        using details::os::filename_to_str;
+
+        filename_t src = _current_filename, target;
+        std::tie(target, std::ignore) = details::file_helper::split_by_extenstion(src);
+        target += _ext;
+
+        if (details::file_helper::file_exists(src) && details::os::rename(src, target) != 0)
+        {
+            throw spdlog_ex("step_file_sink: failed renaming " + filename_to_str(src) + " to " + filename_to_str(target), errno);
+        }
+    }
+
+    const filename_t _base_filename;
+    const filename_t _tmp_ext;
+    const std::chrono::seconds _step_seconds;
+    const unsigned _max_size;
+
+    std::chrono::system_clock::time_point _tp;
+    filename_t _current_filename;
+    filename_t _ext;
+    unsigned _current_size;
+
+    details::file_helper _file_helper;
+};
+
+using step_file_sink_mt = step_file_sink<std::mutex>;
+using step_file_sink_st = step_file_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog

include/spdlog/details/async_log_helper.h

@@ -14,14 +14,16 @@
 
 #include "../common.h"
 #include "../details/log_msg.h"
-#include "../details/mpmc_bounded_q.h"
+#include "../details/mpmc_blocking_q.h"
 #include "../details/os.h"
 #include "../formatter.h"
 #include "../sinks/sink.h"
 
 #include <chrono>
+#include <condition_variable>
 #include <exception>
 #include <functional>
+#include <iostream>
 #include <memory>
 #include <string>
 #include <thread>
@@ -43,8 +45,7 @@ class async_log_helper
     };
 
     struct async_msg
-    {
-        std::string logger_name;
+    {        
         level::level_enum level;
         log_clock::time_point time;
         size_t thread_id;
@@ -63,27 +64,8 @@ class async_log_helper
         {
         }
 
-        async_msg(async_msg &&other) SPDLOG_NOEXCEPT : logger_name(std::move(other.logger_name)),
-                                                       level(std::move(other.level)),
-                                                       time(std::move(other.time)),
-                                                       thread_id(other.thread_id),
-                                                       txt(std::move(other.txt)),
-                                                       msg_type(std::move(other.msg_type)),
-                                                       msg_id(other.msg_id)
-        {
-        }
-
-        async_msg &operator=(async_msg &&other) SPDLOG_NOEXCEPT
-        {
-            logger_name = std::move(other.logger_name);
-            level = other.level;
-            time = std::move(other.time);
-            thread_id = other.thread_id;
-            txt = std::move(other.txt);
-            msg_type = other.msg_type;
-            msg_id = other.msg_id;
-            return *this;
-        }
+        async_msg(async_msg &&other) = default;
+        async_msg &operator=(async_msg &&other) = default;
 
         // never copy or assign. should only be moved..
         async_msg(const async_msg &) = delete;
@@ -98,18 +80,16 @@ class async_log_helper
             , msg_type(async_msg_type::log)
             , msg_id(m.msg_id)
         {
-#ifndef SPDLOG_NO_NAME
-            logger_name = *m.logger_name;
-#endif
         }
 
         // copy into log_msg
-        void fill_log_msg(log_msg &msg)
+        void fill_log_msg(log_msg &msg, std::string* logger_name)
         {
-            msg.logger_name = &logger_name;
+            msg.logger_name = logger_name;
             msg.level = level;
             msg.time = time;
             msg.thread_id = thread_id;
+            msg.raw.clear();
             msg.raw << txt;
             msg.msg_id = msg_id;
         }
@@ -121,10 +101,15 @@ public:
 
     using clock = std::chrono::steady_clock;
 
-    async_log_helper(formatter_ptr formatter, std::vector<sink_ptr> sinks, size_t queue_size, const log_err_handler err_handler,
-        const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, std::function<void()> worker_warmup_cb = nullptr,
-        const std::chrono::milliseconds &flush_interval_ms = std::chrono::milliseconds::zero(),
-        std::function<void()> worker_teardown_cb = nullptr);
+    async_log_helper(std::string logger_name,
+                     formatter_ptr formatter,
+                     std::vector<sink_ptr> sinks,
+                     size_t queue_size,
+                     const log_err_handler err_handler,
+                     const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
+                     std::function<void()> worker_warmup_cb = nullptr,
+                     const std::chrono::milliseconds &flush_interval_ms = std::chrono::milliseconds::zero(),
+                     std::function<void()> worker_teardown_cb = nullptr);
 
     void log(const details::log_msg &msg);
 
@@ -136,11 +121,12 @@ public:
 
     void set_formatter(formatter_ptr msg_formatter);
 
-    void flush(bool wait_for_q);
+    void flush();
 
     void set_error_handler(spdlog::log_err_handler err_handler);
 
 private:
+	std::string _logger_name;
     formatter_ptr _formatter;
     std::vector<std::shared_ptr<sinks::sink>> _sinks;
 
@@ -149,9 +135,7 @@ private:
 
     log_err_handler _err_handler;
 
-    bool _flush_requested;
-
-    bool _terminate_requested;
+    std::chrono::time_point<log_clock> _last_flush;
 
     // overflow policy
     const async_overflow_policy _overflow_policy;
@@ -165,25 +149,26 @@ private:
     // worker thread teardown callback
     const std::function<void()> _worker_teardown_cb;
 
+    std::mutex null_mutex_;
+    // null_mutex null_mutex_;
+    std::condition_variable_any not_empty_cv_;
+    std::condition_variable_any not_full_cv_;
+
     // worker thread
     std::thread _worker_thread;
 
-    void push_msg(async_msg &&new_msg);
+    void enqueue_msg(async_msg &&new_msg, async_overflow_policy policy);
 
     // worker thread main loop
     void worker_loop();
 
-    // pop next message from the queue and process it. will set the last_pop to the pop time
+    // dequeue next message from the queue and process it.
     // return false if termination of the queue is required
-    bool process_next_msg(log_clock::time_point &last_pop, log_clock::time_point &last_flush);
+    bool process_next_msg();
 
-    void handle_flush_interval(log_clock::time_point &now, log_clock::time_point &last_flush);
+    void handle_flush_interval();
 
-    // sleep,yield or return immediately using the time passed since last message as a hint
-    static void sleep_or_yield(const spdlog::log_clock::time_point &now, const log_clock::time_point &last_op_time);
-
-    // wait until the queue is empty
-    void wait_empty_q();
+    void flush_sinks();
 };
 } // namespace details
 } // namespace spdlog
@@ -191,15 +176,21 @@ private:
 ///////////////////////////////////////////////////////////////////////////////
 // async_sink class implementation
 ///////////////////////////////////////////////////////////////////////////////
-inline spdlog::details::async_log_helper::async_log_helper(formatter_ptr formatter, std::vector<sink_ptr> sinks, size_t queue_size,
-    log_err_handler err_handler, const async_overflow_policy overflow_policy, std::function<void()> worker_warmup_cb,
-    const std::chrono::milliseconds &flush_interval_ms, std::function<void()> worker_teardown_cb)
-    : _formatter(std::move(formatter))
+inline spdlog::details::async_log_helper::async_log_helper(std::string logger_name, 
+                                                           formatter_ptr formatter, 
+                                                           std::vector<sink_ptr> sinks,
+                                                           size_t queue_size,
+                                                           log_err_handler err_handler, 
+                                                           const async_overflow_policy overflow_policy,
+                                                           std::function<void()> worker_warmup_cb,
+                                                           const std::chrono::milliseconds &flush_interval_ms,
+                                                           std::function<void()> worker_teardown_cb)
+    : _logger_name(std::move(logger_name)) 
+	, _formatter(std::move(formatter))
     , _sinks(std::move(sinks))
     , _q(queue_size)
     , _err_handler(std::move(err_handler))
-    , _flush_requested(false)
-    , _terminate_requested(false)
+    , _last_flush(os::now())
     , _overflow_policy(overflow_policy)
     , _worker_warmup_cb(std::move(worker_warmup_cb))
     , _flush_interval_ms(flush_interval_ms)
@@ -208,13 +199,12 @@ inline spdlog::details::async_log_helper::async_log_helper(formatter_ptr formatt
     _worker_thread = std::thread(&async_log_helper::worker_loop, this);
 }
 
-// Send to the worker thread termination message(level=off)
-// and wait for it to finish gracefully
+// send to the worker thread terminate message, and join it.
 inline spdlog::details::async_log_helper::~async_log_helper()
 {
     try
     {
-        push_msg(async_msg(async_msg_type::terminate));
+        enqueue_msg(async_msg(async_msg_type::terminate), async_overflow_policy::block_retry);
         _worker_thread.join();
     }
     catch (...) // don't crash in destructor
@@ -222,34 +212,30 @@ inline spdlog::details::async_log_helper::~async_log_helper()
     }
 }
 
-// Try to push and block until succeeded (if the policy is not to discard when the queue is full)
+// try to push and block until succeeded (if the policy is not to discard when the queue is full)
 inline void spdlog::details::async_log_helper::log(const details::log_msg &msg)
 {
-    push_msg(async_msg(msg));
+    enqueue_msg(async_msg(msg), _overflow_policy);
 }
 
-inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg &&new_msg)
+inline void spdlog::details::async_log_helper::enqueue_msg(details::async_log_helper::async_msg &&new_msg, async_overflow_policy policy)
 {
-    if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
+
+    // block until succeeded pushing to the queue
+    if (policy == async_overflow_policy::block_retry)
     {
-        auto last_op_time = details::os::now();
-        auto now = last_op_time;
-        do
-        {
-            now = details::os::now();
-            sleep_or_yield(now, last_op_time);
-        } while (!_q.enqueue(std::move(new_msg)));
+        _q.enqueue(std::move(new_msg));
+    }
+    else
+    {
+        _q.enqueue_nowait(std::move(new_msg));
     }
 }
 
 // optionally wait for the queue be empty and request flush from the sinks
-inline void spdlog::details::async_log_helper::flush(bool wait_for_q)
+inline void spdlog::details::async_log_helper::flush()
 {
-    push_msg(async_msg(async_msg_type::flush));
-    if (wait_for_q)
-    {
-        wait_empty_q(); // return when queue is empty
-    }
+    enqueue_msg(async_msg(async_msg_type::flush), _overflow_policy);
 }
 
 inline void spdlog::details::async_log_helper::worker_loop()
@@ -258,14 +244,12 @@ inline void spdlog::details::async_log_helper::worker_loop()
     {
         _worker_warmup_cb();
     }
-    auto last_pop = details::os::now();
-    auto last_flush = last_pop;
     auto active = true;
     while (active)
     {
         try
         {
-            active = process_next_msg(last_pop, last_flush);
+            active = process_next_msg();
         }
         catch (const std::exception &ex)
         {
@@ -284,61 +268,42 @@ inline void spdlog::details::async_log_helper::worker_loop()
 
 // process next message in the queue
 // return true if this thread should still be active (while no terminate msg was received)
-inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_point &last_pop, log_clock::time_point &last_flush)
+inline bool spdlog::details::async_log_helper::process_next_msg()
 {
     async_msg incoming_async_msg;
-
-    if (_q.dequeue(incoming_async_msg))
+    bool dequeued = _q.dequeue_for(incoming_async_msg, std::chrono::seconds(2));
+    if (!dequeued)
     {
-        last_pop = details::os::now();
-        switch (incoming_async_msg.msg_type)
-        {
-        case async_msg_type::flush:
-            _flush_requested = true;
-            break;
-
-        case async_msg_type::terminate:
-            _flush_requested = true;
-            _terminate_requested = true;
-            break;
-
-        default:
-            log_msg incoming_log_msg;
-            incoming_async_msg.fill_log_msg(incoming_log_msg);
-            _formatter->format(incoming_log_msg);
-            for (auto &s : _sinks)
-            {
-                if (s->should_log(incoming_log_msg.level))
-                {
-                    s->log(incoming_log_msg);
-                }
-            }
-        }
+        handle_flush_interval();
         return true;
     }
 
-    // Handle empty queue..
-    // This is the only place where the queue can terminate or flush to avoid losing messages already in the queue
-    auto now = details::os::now();
-    handle_flush_interval(now, last_flush);
-    sleep_or_yield(now, last_pop);
-    return !_terminate_requested;
-}
-
-// flush all sinks if _flush_interval_ms has expired
-inline void spdlog::details::async_log_helper::handle_flush_interval(log_clock::time_point &now, log_clock::time_point &last_flush)
-{
-    auto should_flush =
-        _flush_requested || (_flush_interval_ms != std::chrono::milliseconds::zero() && now - last_flush >= _flush_interval_ms);
-    if (should_flush)
+    switch (incoming_async_msg.msg_type)
     {
+    case async_msg_type::flush:
+        flush_sinks();
+        return true;
+
+    case async_msg_type::terminate:
+        flush_sinks();
+        return false;
+
+    default:
+        log_msg incoming_log_msg;
+        incoming_async_msg.fill_log_msg(incoming_log_msg, &_logger_name);
+        _formatter->format(incoming_log_msg);
         for (auto &s : _sinks)
         {
-            s->flush();
+            if (s->should_log(incoming_log_msg.level))
+            {
+                s->log(incoming_log_msg);
+            }
         }
-        now = last_flush = details::os::now();
-        _flush_requested = false;
+        handle_flush_interval();
+        return true;
     }
+    assert(false);
+    return true; // should not be reached
 }
 
 inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_formatter)
@@ -346,48 +311,32 @@ inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_f
     _formatter = std::move(msg_formatter);
 }
 
-// spin, yield or sleep. use the time passed since last message as a hint
-inline void spdlog::details::async_log_helper::sleep_or_yield(
-    const spdlog::log_clock::time_point &now, const spdlog::log_clock::time_point &last_op_time)
-{
-    using std::chrono::microseconds;
-    using std::chrono::milliseconds;
-
-    auto time_since_op = now - last_op_time;
-
-    // spin upto 50 micros
-    if (time_since_op <= microseconds(50))
-    {
-        return;
-    }
-
-    // yield upto 150 micros
-    if (time_since_op <= microseconds(100))
-    {
-        return std::this_thread::yield();
-    }
-
-    // sleep for 20 ms upto 200 ms
-    if (time_since_op <= milliseconds(200))
-    {
-        return details::os::sleep_for_millis(20);
-    }
-
-    // sleep for 500 ms
-    return details::os::sleep_for_millis(500);
-}
-
-// wait for the queue to be empty
-inline void spdlog::details::async_log_helper::wait_empty_q()
-{
-    auto last_op = details::os::now();
-    while (!_q.is_empty())
-    {
-        sleep_or_yield(details::os::now(), last_op);
-    }
-}
-
 inline void spdlog::details::async_log_helper::set_error_handler(spdlog::log_err_handler err_handler)
 {
     _err_handler = std::move(err_handler);
 }
+
+// flush all sinks if _flush_interval_ms has expired.
+inline void spdlog::details::async_log_helper::handle_flush_interval()
+{
+    if (_flush_interval_ms == std::chrono::milliseconds::zero())
+    {
+        return;
+    }
+    auto delta = details::os::now() - _last_flush;
+    ;
+    if (delta >= _flush_interval_ms)
+    {
+        flush_sinks();
+    }
+}
+
+// flush all sinks if _flush_interval_ms has expired. only called if queue is empty
+inline void spdlog::details::async_log_helper::flush_sinks()
+{
+    for (auto &s : _sinks)
+    {
+        s->flush();
+    }
+    _last_flush = os::now();
+}

include/spdlog/details/async_logger_impl.h

@@ -22,7 +22,7 @@ inline spdlog::async_logger::async_logger(const std::string &logger_name, const
     const std::chrono::milliseconds &flush_interval_ms, const std::function<void()> &worker_teardown_cb)
     : logger(logger_name, begin, end)
     , _async_log_helper(new details::async_log_helper(
-          _formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
+          logger_name, _formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
 {
 }
 
@@ -44,7 +44,7 @@ inline spdlog::async_logger::async_logger(const std::string &logger_name, sink_p
 
 inline void spdlog::async_logger::flush()
 {
-    _async_log_helper->flush(true);
+    _async_log_helper->flush();
 }
 
 // Error handler
@@ -80,7 +80,7 @@ inline void spdlog::async_logger::_sink_it(details::log_msg &msg)
         _async_log_helper->log(msg);
         if (_should_flush_on(msg))
         {
-            _async_log_helper->flush(false); // do async flush
+            _async_log_helper->flush(); // do async flush
         }
     }
     catch (const std::exception &ex)

include/spdlog/details/logger_impl.h

@@ -6,7 +6,6 @@
 #pragma once
 
 #include "../logger.h"
-#include "../sinks/stdout_sinks.h"
 
 #include <memory>
 #include <string>
@@ -345,13 +344,11 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg)
     {
         return;
     }
+    _last_err_time = now;
     auto tm_time = details::os::localtime(now);
     char date_buf[100];
     std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
-    details::log_msg err_msg;
-    err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::default_eol);
-    sinks::stderr_sink_mt::instance()->log(err_msg);
-    _last_err_time = now;
+    fmt::print(stderr, "[*** LOG ERROR ***] [{}] [{}] {}\n", date_buf, name(), msg);
 }
 
 inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg)

include/spdlog/details/mpmc_blocking_q.h

@@ -0,0 +1,84 @@
+#pragma once
+
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+// async log helper :
+// multi producer-multi consumer blocking queue
+// enqueue(..) - will block until room found to put the new message
+// enqueue_nowait(..) - will return immediatly with false if no room left in the queue
+// dequeue_for(..) - will block until the queue is not empty or timeout passed
+
+#include <condition_variable>
+#include <mutex>
+#include <queue>
+
+namespace spdlog {
+namespace details {
+
+template<typename T>
+class mpmc_bounded_queue
+{
+public:
+    using item_type = T;
+    explicit mpmc_bounded_queue(size_t max_items)
+        : max_items_(max_items)
+    {
+    }
+
+    // try to enqueue and block if no room left
+    void enqueue(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            pop_cv_.wait(lock, [this] { return this->q_.size() < this->max_items_; });
+            q_.push(std::move(item));
+        }
+        push_cv_.notify_one();
+    }
+
+    // try to enqueue and return immdeialty false if no room left
+    bool enqueue_nowait(T &&item)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (q_.size() == this->max_items_)
+            {
+                return false;
+            }
+            q_.push(std::forward<T>(item));
+        }
+        push_cv_.notify_one();
+        return true;
+    }
+
+    // try to dequeue item. if no item found. wait upto timeout and try again
+    // Return true, if succeeded dequeue item, false otherwise
+    bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
+    {
+        {
+            std::unique_lock<std::mutex> lock(queue_mutex_);
+            if (!push_cv_.wait_for(lock, wait_duration, [this] { return this->q_.size() > 0; }))
+            {
+                return false;
+            }
+
+            popped_item = std::move(q_.front());
+            q_.pop();
+        }
+        pop_cv_.notify_one();
+        return true;
+    }
+
+private:
+    size_t max_items_;
+    std::mutex queue_mutex_;
+    std::condition_variable push_cv_;
+    std::condition_variable pop_cv_;
+
+    std::queue<T> q_;
+};
+} // namespace details
+} // namespace spdlog

include/spdlog/details/mpmc_bounded_q.h

@@ -1,183 +0,0 @@
-/*
-A modified version of Bounded MPMC queue by Dmitry Vyukov.
-
-Original code from:
-http://www.1024cores.net/home/lock-free-algorithms/queues/bounded-mpmc-queue
-
-licensed by Dmitry Vyukov under the terms below:
-
-Simplified BSD license
-
-Copyright (c) 2010-2011 Dmitry Vyukov. All rights reserved.
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice, this list of
-conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list
-of conditions and the following disclaimer in the documentation and/or other materials
-provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY DMITRY VYUKOV "AS IS" AND ANY EXPRESS OR IMPLIED
-WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
-SHALL DMITRY VYUKOV OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
-OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation are those of the authors and
-should not be interpreted as representing official policies, either expressed or implied, of Dmitry Vyukov.
-*/
-
-/*
-The code in its current form adds the license below:
-
-Copyright(c) 2015 Gabi Melman.
-Distributed under the MIT License (http://opensource.org/licenses/MIT)
-
-*/
-
-#pragma once
-
-#include "../common.h"
-
-#include <atomic>
-#include <utility>
-
-namespace spdlog {
-namespace details {
-
-template<typename T>
-class mpmc_bounded_queue
-{
-public:
-    using item_type = T;
-
-    explicit mpmc_bounded_queue(size_t buffer_size)
-        : max_size_(buffer_size)
-        , buffer_(new cell_t[buffer_size])
-        , buffer_mask_(buffer_size - 1)
-    {
-        // queue size must be power of two
-        if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
-        {
-            throw spdlog_ex("async logger queue size must be power of two");
-        }
-
-        for (size_t i = 0; i != buffer_size; i += 1)
-        {
-            buffer_[i].sequence_.store(i, std::memory_order_relaxed);
-        }
-        enqueue_pos_.store(0, std::memory_order_relaxed);
-        dequeue_pos_.store(0, std::memory_order_relaxed);
-    }
-
-    ~mpmc_bounded_queue()
-    {
-        delete[] buffer_;
-    }
-
-    mpmc_bounded_queue(mpmc_bounded_queue const &) = delete;
-    void operator=(mpmc_bounded_queue const &) = delete;
-
-    bool enqueue(T &&data)
-    {
-        cell_t *cell;
-        size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq = cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos);
-            if (dif == 0)
-            {
-                if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                {
-                    break;
-                }
-            }
-            else if (dif < 0)
-            {
-                return false;
-            }
-            else
-            {
-                pos = enqueue_pos_.load(std::memory_order_relaxed);
-            }
-        }
-        cell->data_ = std::move(data);
-        cell->sequence_.store(pos + 1, std::memory_order_release);
-        return true;
-    }
-
-    bool dequeue(T &data)
-    {
-        cell_t *cell;
-        size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
-        for (;;)
-        {
-            cell = &buffer_[pos & buffer_mask_];
-            size_t seq = cell->sequence_.load(std::memory_order_acquire);
-            intptr_t dif = static_cast<intptr_t>(seq) - static_cast<intptr_t>(pos + 1);
-            if (dif == 0)
-            {
-                if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
-                {
-                    break;
-                }
-            }
-            else if (dif < 0)
-            {
-                return false;
-            }
-            else
-            {
-                pos = dequeue_pos_.load(std::memory_order_relaxed);
-            }
-        }
-        data = std::move(cell->data_);
-        cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
-        return true;
-    }
-
-    bool is_empty()
-    {
-        size_t front, front1, back;
-        // try to take a consistent snapshot of front/tail.
-        do
-        {
-            front = enqueue_pos_.load(std::memory_order_acquire);
-            back = dequeue_pos_.load(std::memory_order_acquire);
-            front1 = enqueue_pos_.load(std::memory_order_relaxed);
-        } while (front != front1);
-        return back == front;
-    }
-
-private:
-    struct cell_t
-    {
-        std::atomic<size_t> sequence_;
-        T data_;
-    };
-
-    size_t const max_size_;
-
-    static size_t const cacheline_size = 64;
-    using cacheline_pad_t = char[cacheline_size];
-
-    cacheline_pad_t pad0_;
-    cell_t *const buffer_;
-    size_t const buffer_mask_;
-    cacheline_pad_t pad1_;
-    std::atomic<size_t> enqueue_pos_;
-    cacheline_pad_t pad2_;
-    std::atomic<size_t> dequeue_pos_;
-    cacheline_pad_t pad3_;
-};
-
-} // namespace details
-} // namespace spdlog

tests/CMakeLists.txt

@@ -6,8 +6,9 @@ set(SPDLOG_UTESTS_SOURCES
     errors.cpp
     file_helper.cpp
     file_log.cpp
-    test_misc.cpp
-	test_pattern_formatter
+    test_misc.cpp   
+	test_pattern_formatter.cpp
+    test_async.cpp
     includes.h
     registry.cpp
     test_macros.cpp

tests/test_async.cpp

@@ -0,0 +1,134 @@
+#include "includes.h"
+#include "test_sink.h"
+
+template<class T>
+std::string log_info(const T &what, spdlog::level::level_enum logger_level = spdlog::level::info)
+{
+
+    std::ostringstream oss;
+    auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
+
+    spdlog::logger oss_logger("oss", oss_sink);
+    oss_logger.set_level(logger_level);
+    oss_logger.set_pattern("%v");
+    oss_logger.info(what);
+
+    return oss.str().substr(0, oss.str().length() - strlen(spdlog::details::os::default_eol));
+}
+
+TEST_CASE("basic async test ", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 128;
+    size_t messages = 256;
+    auto logger = spdlog::create_async("as", test_sink, 128, spdlog::async_overflow_policy::block_retry);
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message #{}", i);
+    }
+
+    // the dtor wait for all messages in the queue to get processed
+    logger.reset();
+    spdlog::drop("as");
+    REQUIRE(test_sink->msg_counter() == messages);
+    REQUIRE(test_sink->flushed_msg_counter() == messages);
+}
+
+TEST_CASE("discard policy ", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 2;
+    size_t messages = 1024;
+    spdlog::drop("as");
+    auto logger = spdlog::create_async("as", test_sink, queue_size, spdlog::async_overflow_policy::discard_log_msg);
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message #{}", i);
+    }
+
+    // the dtor wait for all messages in the queue to get processed
+    logger.reset();
+    spdlog::drop("as");
+    REQUIRE(test_sink->msg_counter() < messages);
+    REQUIRE(test_sink->flushed_msg_counter() < messages);
+}
+
+TEST_CASE("flush", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 256;
+    size_t messages = 256;
+    spdlog::drop("as");
+    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, queue_size);
+    for (size_t i = 0; i < messages; i++)
+    {
+        logger->info("Hello message #{}", i);
+    }
+
+    // the dtor wait for all messages in the queue to get processed
+    logger->flush();
+    std::this_thread::sleep_for(std::chrono::milliseconds(250));
+    REQUIRE(test_sink->msg_counter() == messages);
+    REQUIRE(test_sink->flushed_msg_counter() == messages);
+
+    REQUIRE(test_sink->flushed_msg_counter() == messages);
+}
+
+TEST_CASE("multi threads", "[async]")
+{
+    auto test_sink = std::make_shared<spdlog::sinks::test_sink_mt>();
+    size_t queue_size = 128;
+    size_t messages = 256;
+    size_t n_threads = 10;
+    auto logger = std::make_shared<spdlog::async_logger>("as", test_sink, queue_size);
+
+    std::vector<std::thread> threads;
+    for (size_t i = 0; i < n_threads; i++)
+    {
+        threads.emplace_back([logger, messages] {
+            for (size_t j = 0; j < messages; j++)
+            {
+                logger->info("Hello message #{}", j);
+            }
+        });
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+
+    // the dtor wait for all messages in the queue to get processed
+    logger.reset();
+    REQUIRE(test_sink->msg_counter() == messages * n_threads);
+    REQUIRE(test_sink->flushed_msg_counter() == messages * n_threads);
+}
+
+TEST_CASE("to_file", "[async]")
+{
+
+    prepare_logdir();
+    size_t queue_size = 512;
+    size_t messages = 512;
+    size_t n_threads = 4;
+    auto file_sink = std::make_shared<spdlog::sinks::simple_file_sink_mt>("logs/async_test.log", true);
+    auto logger = spdlog::create_async("as", file_sink, queue_size);
+    std::vector<std::thread> threads;
+    for (size_t i = 0; i < n_threads; i++)
+    {
+        threads.emplace_back([logger, messages] {
+            for (size_t j = 0; j < messages; j++)
+            {
+                logger->info("Hello message #{}", j);
+            }
+        });
+    }
+
+    for (auto &t : threads)
+    {
+        t.join();
+    }
+    logger.reset();
+    spdlog::drop("as");
+    REQUIRE(count_lines("logs/async_test.log") == messages * n_threads);
+}

tests/test_sink.h

@@ -0,0 +1,48 @@
+//
+// Copyright(c) 2018 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/base_sink.h"
+
+#include <mutex>
+
+namespace spdlog {
+namespace sinks {
+
+template<class Mutex>
+class test_sink : public base_sink<Mutex>
+{
+public:
+    size_t msg_counter()
+    {
+        return msg_counter_;
+    }
+
+    size_t flushed_msg_counter()
+    {
+        return flushed_msg_counter_;
+    }
+
+protected:
+    void _sink_it(const details::log_msg &) override
+    {
+        msg_counter_++;
+    }
+
+    void _flush() override
+    {
+        flushed_msg_counter_ += msg_counter_;
+    }
+    size_t msg_counter_{0};
+    size_t flushed_msg_counter_{0};
+};
+
+using test_sink_mt = test_sink<std::mutex>;
+using test_sink_st = test_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog

tests/tests.vcxproj

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|Win32">
       <Configuration>Debug</Configuration>
@@ -27,26 +27,26 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>Application</ConfigurationType>
     <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v140</PlatformToolset>
+    <PlatformToolset>v141</PlatformToolset>
     <WholeProgramOptimization>true</WholeProgramOptimization>
     <CharacterSet>MultiByte</CharacterSet>
   </PropertyGroup>
@@ -129,6 +129,7 @@
     <ClCompile Include="errors.cpp" />
     <ClCompile Include="file_helper.cpp" />
     <ClCompile Include="file_log.cpp" />
+    <ClCompile Include="test_async.cpp" />
     <ClCompile Include="test_misc.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="registry.cpp" />

tests/tests.vcxproj.filters

@@ -42,6 +42,9 @@
     <ClCompile Include="test_misc.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="test_async.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="includes.h">

tests/utils.cpp

@@ -8,6 +8,7 @@ void prepare_logdir()
     system("del /F /Q logs\\*");
 #else
     auto rv = system("mkdir -p logs");
+    (void)rv;
     rv = system("rm -f logs/*");
     (void)rv;
 #endif