TeaSpeak/spdlog
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

replaced flush_interval with auto_flush boolean

Browse Source
This commit is contained in:
gabime 2014-11-25 00:23:55 +02:00
parent c948f15822
commit 68ee9a7ada
5 changed files with 40 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
example/bench.cpp
View File

@ -52,7 +52,7 @@ int main(int argc, char* argv[])
int howmany = 1000000; int howmany = 1000000;
int threads = 10; int threads = 10;
int flush_interval = 0; bool auto_flush = true;
int file_size = 30 * 1024 * 1024; int file_size = 30 * 1024 * 1024;
int rotating_files = 5; int rotating_files = 5;
@ -63,39 +63,38 @@ int main(int argc, char* argv[])
howmany = atoi(argv[1]); howmany = atoi(argv[1]);
if (argc > 2) if (argc > 2)
threads = atoi(argv[2]); threads = atoi(argv[2]);
/*
cout << "*******************************************************************************\n"; cout << "*******************************************************************************\n";
cout << "Single thread, " << format(howmany) << " iterations, flush every " << flush_interval << " lines"<< endl; cout << "Single thread, " << format(howmany) << " iterations, auto flush=" << auto_flush << endl;
cout << "*******************************************************************************\n"; cout << "*******************************************************************************\n";
auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st", file_size, rotating_files, flush_interval); auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st", file_size, rotating_files, auto_flush);
bench(howmany, rotating_st); bench(howmany, rotating_st);
auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st", flush_interval); auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st", auto_flush);
bench(howmany, daily_st); bench(howmany, daily_st);
bench(howmany, spdlog::create<null_sink_st>("null_st")); bench(howmany, spdlog::create<null_sink_st>("null_st"));
cout << "\n*******************************************************************************\n"; cout << "\n*******************************************************************************\n";
cout << threads << " threads sharing same logger, " << format(howmany) << " iterations, flush every " << flush_interval << " lines" << endl; cout << threads << " threads sharing same logger, " << format(howmany) << " iterations, auto_flush=" << auto_flush << endl;
cout << "*******************************************************************************\n"; cout << "*******************************************************************************\n";
auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt", file_size, rotating_files, flush_interval); auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt", file_size, rotating_files, auto_flush);
bench_mt(howmany, rotating_mt, threads); bench_mt(howmany, rotating_mt, threads);
auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt", flush_interval); auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt", auto_flush);
bench_mt(howmany, daily_mt, threads); bench_mt(howmany, daily_mt, threads);
bench(howmany, spdlog::create<null_sink_st>("null_mt")); bench(howmany, spdlog::create<null_sink_st>("null_mt"));
cout << "\n*******************************************************************************\n"; cout << "\n*******************************************************************************\n";
cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations, flush every " << flush_interval << " lines" << endl; cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations, auto_flush=" << auto_flush << endl;
e cout << "*******************************************************************************\n"; cout << "*******************************************************************************\n";
*/
spdlog::set_async_mode(2500); spdlog::set_async_mode(2500);
auto daily_st_async = spdlog::daily_logger_st("daily_async", "logs/daily_async", flush_interval); auto daily_st_async = spdlog::daily_logger_st("daily_async", "logs/daily_async", auto_flush);
bench_mt(howmany, daily_st_async, threads); bench_mt(howmany, daily_st_async, threads);
spdlog::stop(); spdlog::stop();
} }

18
include/spdlog/details/file_helper.h
View File

@ -26,7 +26,7 @@
// Helper class for file sink // Helper class for file sink
// When failing to open a file, retry several times(5) with small delay between the tries(10 ms) // When failing to open a file, retry several times(5) with small delay between the tries(10 ms)
// Flush to file every X writes (or never if X==0) // Can be set to auto flush on every line
// Throw spdlog_ex exception on errors // Throw spdlog_ex exception on errors
#include <cstdio> #include <cstdio>
@ -49,10 +49,10 @@ public:
const int open_tries = 5; const int open_tries = 5;
const int open_interval = 10; const int open_interval = 10;
explicit file_helper(const std::size_t flush_inverval): explicit file_helper(bool auto_flush):
_fd(nullptr), _fd(nullptr),
_flush_inverval(flush_inverval), _auto_flush(auto_flush)
_flush_countdown(flush_inverval) {}; {};
file_helper(const file_helper&) = delete; file_helper(const file_helper&) = delete;
file_helper& operator=(const file_helper&) = delete; file_helper& operator=(const file_helper&) = delete;
@ -104,11 +104,9 @@ public:
if(std::fwrite(buf.data(), sizeof(char), size, _fd) != size) if(std::fwrite(buf.data(), sizeof(char), size, _fd) != size)
throw spdlog_ex("Failed writing to file " + _filename); throw spdlog_ex("Failed writing to file " + _filename);
if(--_flush_countdown == 0) if(_auto_flush)
{
std::fflush(_fd); std::fflush(_fd);
_flush_countdown = _flush_inverval;
}
} }
const std::string& filename() const const std::string& filename() const
@ -133,8 +131,8 @@ public:
private: private:
FILE* _fd; FILE* _fd;
std::string _filename; std::string _filename;
const std::size_t _flush_inverval; bool _auto_flush;
std::size_t _flush_countdown;
}; };
} }

16
include/spdlog/details/spdlog_impl.h
View File

@ -39,24 +39,24 @@ inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
// Create multi/single threaded rotating file logger // Create multi/single threaded rotating file logger
inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, size_t flush_inverval) inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool auto_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, "txt", max_file_size, max_files, flush_inverval); return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, "txt", max_file_size, max_files, auto_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, size_t flush_inverval) inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool auto_flush)
{ {
return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, "txt", max_file_size, max_files, flush_inverval); return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, "txt", max_file_size, max_files, auto_flush);
} }
// Create file logger which creates new file at midnight): // Create file logger which creates new file at midnight):
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, size_t flush_inverval) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, bool auto_flush)
{ {
return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", flush_inverval); return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", auto_flush);
} }
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, size_t flush_inverval) inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, bool auto_flush)
{ {
return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", flush_inverval); return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", auto_flush);
} }

12
include/spdlog/sinks/file_sinks.h
View File

@ -45,8 +45,8 @@ class simple_file_sink : public base_sink<Mutex>
{ {
public: public:
explicit simple_file_sink(const std::string &filename, explicit simple_file_sink(const std::string &filename,
const std::size_t flush_inverval=0): bool auto_flush=false):
_file_helper(flush_inverval) _file_helper(auto_flush)
{ {
_file_helper.open(filename); _file_helper.open(filename);
} }
@ -72,13 +72,13 @@ class rotating_file_sink : public base_sink<Mutex>
public: public:
rotating_file_sink(const std::string &base_filename, const std::string &extension, rotating_file_sink(const std::string &base_filename, const std::string &extension,
std::size_t max_size, std::size_t max_files, std::size_t max_size, std::size_t max_files,
std::size_t flush_inverval=0): bool auto_flush=false):
_base_filename(base_filename), _base_filename(base_filename),
_extension(extension), _extension(extension),
_max_size(max_size), _max_size(max_size),
_max_files(max_files), _max_files(max_files),
_current_size(0), _current_size(0),
_file_helper(flush_inverval) _file_helper(auto_flush)
{ {
_file_helper.open(calc_filename(_base_filename, 0, _extension)); _file_helper.open(calc_filename(_base_filename, 0, _extension));
} }
@ -158,11 +158,11 @@ class daily_file_sink:public base_sink<Mutex>
public: public:
explicit daily_file_sink(const std::string& base_filename, explicit daily_file_sink(const std::string& base_filename,
const std::string& extension, const std::string& extension,
const std::size_t flush_inverval=0): bool auto_flush=false):
_base_filename(base_filename), _base_filename(base_filename),
_extension(extension), _extension(extension),
_midnight_tp (_calc_midnight_tp() ), _midnight_tp (_calc_midnight_tp() ),
_file_helper(flush_inverval) _file_helper(auto_flush)
{ {
_file_helper.open(calc_filename(_base_filename, _extension)); _file_helper.open(calc_filename(_base_filename, _extension));
} }

8
include/spdlog/spdlog.h
View File

@ -70,14 +70,14 @@ void set_sync_mode();
// //
// Create multi/single threaded rotating file logger // Create multi/single threaded rotating file logger
// //
std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, size_t flush_inverval = 0); std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool auto_fush = false);
std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, size_t flush_inverval = 0); std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool auto_fush = false);
// //
// Create file logger which creates new file at midnight): // Create file logger which creates new file at midnight):
// //
std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, size_t flush_inverval = 0); std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, bool auto_fush = false);
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, size_t flush_inverval = 0); std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, bool auto_fush = false);
// //