Use blocking queue

tests/CMakeLists.txt

@@ -7,7 +7,8 @@ set(SPDLOG_UTESTS_SOURCES
     file_helper.cpp
     file_log.cpp
     test_misc.cpp
-	test_pattern_formatter
+	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"
+#include "spdlog/async.h"
+#include "spdlog/sinks/simple_file_sink.h"
+
+//std::unique_ptr<spdlog::async_logger> create_logger(size_t tp_queue_size, size_t tp_threads)
+//{
+//	auto tp = std::make_shared<details::thread_pool>(8192, 1);
+//	auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+//}
+
+TEST_CASE("basic async test ", "[async]")
+{
+	using namespace spdlog;
+	auto test_sink = std::make_shared<sinks::test_sink_mt>();
+	size_t queue_size = 128;
+	size_t messages = 256;
+	{
+		auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+		auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+		for (size_t i = 0; i < messages; i++)
+		{
+			logger->info("Hello message #{}", i);
+		}
+		logger->flush();
+	}
+	REQUIRE(test_sink->msg_counter() == messages);
+	REQUIRE(test_sink->flushed_msg_counter() == messages);
+}
+
+TEST_CASE("discard policy ", "[async]")
+{
+	using namespace spdlog;
+	auto test_sink = std::make_shared<sinks::test_sink_mt>();
+	size_t queue_size = 2;
+	size_t messages = 1024;
+	{
+		auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+		auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::discard_log_msg);
+		for (size_t i = 0; i < messages; i++)
+		{
+			logger->info("Hello message #{}", i);
+		}
+	}
+	
+	REQUIRE(test_sink->msg_counter() < messages);
+	REQUIRE(test_sink->flushed_msg_counter() < messages);
+}
+
+TEST_CASE("flush", "[async]")
+{
+	using namespace spdlog;
+	auto test_sink = std::make_shared<sinks::test_sink_mt>();
+	size_t queue_size = 256;
+	size_t messages = 256;
+	{
+		auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+		auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+		for (size_t i = 0; i < messages; i++)
+		{
+			logger->info("Hello message #{}", i);
+		}
+		
+		logger->flush();
+	}
+	std::this_thread::sleep_for(std::chrono::milliseconds(250));
+	REQUIRE(test_sink->msg_counter() == messages);
+	REQUIRE(test_sink->flushed_msg_counter() == messages);	
+}
+
+TEST_CASE("multi threads", "[async]")
+{
+	using namespace spdlog;
+	auto test_sink = std::make_shared<sinks::test_sink_mt>();
+	size_t queue_size = 128;
+	size_t messages = 256;
+	size_t n_threads = 10;
+	{
+		auto tp = std::make_shared<details::thread_pool>(queue_size, 1);
+		auto logger = std::make_shared<async_logger>("as", test_sink, tp, async_overflow_policy::block_retry);
+
+		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->flush();
+
+	}
+		
+	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;	
+	spdlog::init_thread_pool(queue_size, n_threads);
+	auto logger= spdlog::basic_logger_mt<spdlog::create_async>("as", "logs/async_test.log", true);
+	
+	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");
+	std::this_thread::sleep_for(std::chrono::seconds(1));
+	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

@@ -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">