mirror of
https://github.com/gabime/spdlog.git
synced 2024-12-25 10:01:33 +08:00
removed un needed mutex, and added copy ctors to line logger and friends
This commit is contained in:
parent
514526ed7a
commit
d60e971dec
@ -1,6 +1,6 @@
|
||||
SRC_DIR=../../src
|
||||
|
||||
_SOURCES = factory.cpp formatters.cpp line_logger.cpp os.cpp
|
||||
_SOURCES = factory.cpp formatters.cpp os.cpp
|
||||
|
||||
SOURCES = $(patsubst %,$(SRC_DIR)/%,$(_SOURCES))
|
||||
OBJS_RELEASE = $(patsubst %.cpp,release/%.o,$(_SOURCES))
|
||||
@ -8,7 +8,7 @@ OBJS_DEBUG = $(patsubst %.cpp,debug/%.o,$(_SOURCES))
|
||||
|
||||
|
||||
CXX = g++
|
||||
CXXFLAGS = -march=native -Wall -std=c++11 -pthread -I../../include
|
||||
CXXFLAGS = -march=native -Wall -Wextra -Wshadow -pedantic -std=c++11 -pthread -I../../include
|
||||
CXX_RELEASE_FLAGS = -O2 -flto -g
|
||||
CXX_DEBUG_FLAGS= -g
|
||||
|
||||
|
@ -2,72 +2,80 @@
|
||||
|
||||
#include<streambuf>
|
||||
#include<string>
|
||||
namespace c11log {
|
||||
namespace details {
|
||||
namespace c11log
|
||||
{
|
||||
namespace details
|
||||
{
|
||||
|
||||
class str_devicebuf:public std::streambuf {
|
||||
class str_devicebuf:public std::streambuf
|
||||
{
|
||||
public:
|
||||
str_devicebuf() = default;
|
||||
~str_devicebuf() = default;
|
||||
str_devicebuf(const str_devicebuf&) = delete;
|
||||
str_devicebuf& operator=(const str_devicebuf&) = delete;
|
||||
str_devicebuf() = default;
|
||||
~str_devicebuf() = default;
|
||||
str_devicebuf(const str_devicebuf& other):std::streambuf(),_str(other._str) {}
|
||||
str_devicebuf& operator=(const str_devicebuf other)
|
||||
{
|
||||
if(this != &other)
|
||||
_str = other._str;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const std::string& str_ref() const
|
||||
{
|
||||
return _str;
|
||||
}
|
||||
const std::string& str_ref() const {
|
||||
return _str;
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
_str.clear();
|
||||
}
|
||||
void clear() {
|
||||
_str.clear();
|
||||
}
|
||||
|
||||
protected:
|
||||
virtual int sync() override
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
virtual int sync() override {
|
||||
return 0;
|
||||
}
|
||||
|
||||
virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override
|
||||
{
|
||||
_str.append(s, static_cast<unsigned int>(count));
|
||||
return count;
|
||||
}
|
||||
virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override {
|
||||
_str.append(s, static_cast<unsigned int>(count));
|
||||
return count;
|
||||
}
|
||||
|
||||
virtual int_type overflow(int_type ch) override
|
||||
{
|
||||
if (ch != traits_type::eof())
|
||||
_str.append((char*)&ch, 1);
|
||||
return 1;
|
||||
}
|
||||
virtual int_type overflow(int_type ch) override {
|
||||
if (ch != traits_type::eof())
|
||||
_str.append((char*)&ch, 1);
|
||||
return 1;
|
||||
}
|
||||
private:
|
||||
std::string _str;
|
||||
std::string _str;
|
||||
};
|
||||
|
||||
class fast_oss:public std::ostream {
|
||||
class fast_oss:public std::ostream
|
||||
{
|
||||
public:
|
||||
fast_oss():std::ostream(&_dev){}
|
||||
~fast_oss() = default;
|
||||
fast_oss(const fast_oss&) = delete;
|
||||
fast_oss operator=(const fast_oss&) = delete;
|
||||
|
||||
fast_oss():std::ostream(&_dev) {}
|
||||
~fast_oss() = default;
|
||||
fast_oss(const fast_oss& other):std::basic_ios<char>(), std::ostream(),_dev(other._dev) {}
|
||||
fast_oss operator=(const fast_oss& other)
|
||||
{
|
||||
if(&other != this)
|
||||
_dev = other._dev;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const std::string& str_ref() const
|
||||
{
|
||||
return _dev.str_ref();
|
||||
}
|
||||
const std::string& str_ref() const
|
||||
{
|
||||
return _dev.str_ref();
|
||||
}
|
||||
|
||||
const std::string str() const
|
||||
{
|
||||
return _dev.str_ref();
|
||||
}
|
||||
const std::string str() const
|
||||
{
|
||||
return _dev.str_ref();
|
||||
}
|
||||
|
||||
void clear()
|
||||
{
|
||||
_dev.clear();
|
||||
}
|
||||
void clear()
|
||||
{
|
||||
_dev.clear();
|
||||
}
|
||||
private:
|
||||
str_devicebuf _dev;
|
||||
str_devicebuf _dev;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -1,30 +1,48 @@
|
||||
#pragma once
|
||||
|
||||
#include "../level.h"
|
||||
#include "../logger.h"
|
||||
#include "fast_oss.h"
|
||||
|
||||
namespace c11log {
|
||||
namespace c11log
|
||||
{
|
||||
class logger;
|
||||
namespace details {
|
||||
namespace details
|
||||
{
|
||||
|
||||
class line_logger {
|
||||
class line_logger
|
||||
{
|
||||
public:
|
||||
line_logger(logger* callback_logger, level::level_enum msg_level);
|
||||
line_logger(logger* callback_logger):_callback_logger(nullptr) {};
|
||||
line_logger(const line_logger&){};
|
||||
~line_logger();
|
||||
line_logger(logger* callback_logger, level::level_enum msg_level) {
|
||||
callback_logger->formatter_->format_header(callback_logger->logger_name_,
|
||||
msg_level,
|
||||
c11log::formatters::clock::now(),
|
||||
_oss);
|
||||
}
|
||||
line_logger(logger*):_callback_logger(nullptr) {};
|
||||
line_logger(const line_logger& other):
|
||||
_callback_logger(other._callback_logger),
|
||||
_oss(other._oss),
|
||||
_level(other._level) {};
|
||||
line_logger& operator=(const line_logger&) = delete;
|
||||
~line_logger() {
|
||||
if (_callback_logger) {
|
||||
_oss << '\n';
|
||||
_callback_logger->log_it_(_oss.str_ref());
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
line_logger& operator<<(const T& msg)
|
||||
{
|
||||
if (_callback_logger)
|
||||
_oss << msg;
|
||||
return *this;
|
||||
}
|
||||
template<typename T>
|
||||
line_logger& operator<<(const T& msg) {
|
||||
if (_callback_logger)
|
||||
_oss << msg;
|
||||
return *this;
|
||||
}
|
||||
|
||||
private:
|
||||
logger* _callback_logger;
|
||||
details::fast_oss _oss;
|
||||
logger* _callback_logger;
|
||||
details::fast_oss _oss;
|
||||
level::level_enum _level;
|
||||
|
||||
};
|
||||
} //Namespace details
|
||||
|
@ -10,157 +10,155 @@
|
||||
|
||||
#include "level.h"
|
||||
#include "sinks/base_sink.h"
|
||||
#include "details/line_logger.h"
|
||||
#include "details/factory.h"
|
||||
|
||||
namespace c11log
|
||||
{
|
||||
namespace details
|
||||
{
|
||||
class line_logger;
|
||||
}
|
||||
|
||||
|
||||
|
||||
namespace c11log {
|
||||
|
||||
class logger {
|
||||
class logger
|
||||
{
|
||||
public:
|
||||
|
||||
typedef std::shared_ptr<sinks::base_sink> sink_ptr_t;
|
||||
typedef std::vector<sink_ptr_t> sinks_vector_t;
|
||||
typedef std::shared_ptr<sinks::base_sink> sink_ptr_t;
|
||||
typedef std::vector<sink_ptr_t> sinks_vector_t;
|
||||
|
||||
explicit logger(const std::string& name) : logger_name_(name),
|
||||
formatter_(std::make_unique<formatters::default_formatter>())
|
||||
{
|
||||
atomic_level_.store(level::INFO);
|
||||
}
|
||||
explicit logger(const std::string& name) : logger_name_(name),
|
||||
formatter_(std::make_unique<formatters::default_formatter>()) {
|
||||
atomic_level_.store(level::INFO);
|
||||
}
|
||||
|
||||
~logger() = default;
|
||||
~logger() = default;
|
||||
|
||||
logger(const logger&) = delete;
|
||||
logger& operator=(const logger&) = delete;
|
||||
logger(const logger&) = delete;
|
||||
logger& operator=(const logger&) = delete;
|
||||
|
||||
void set_name(const std::string& name);
|
||||
const std::string& get_name();
|
||||
void add_sink(sink_ptr_t sink_ptr);
|
||||
void remove_sink(sink_ptr_t sink_ptr);
|
||||
void set_formatter(std::unique_ptr<formatters::formatter> formatter);
|
||||
void set_level(c11log::level::level_enum level);
|
||||
c11log::level::level_enum get_level() const;
|
||||
bool should_log(c11log::level::level_enum level) const;
|
||||
void set_name(const std::string& name);
|
||||
const std::string& get_name();
|
||||
void add_sink(sink_ptr_t sink_ptr);
|
||||
void remove_sink(sink_ptr_t sink_ptr);
|
||||
void set_formatter(std::unique_ptr<formatters::formatter> formatter);
|
||||
void set_level(c11log::level::level_enum level);
|
||||
c11log::level::level_enum get_level() const;
|
||||
bool should_log(c11log::level::level_enum level) const;
|
||||
|
||||
details::line_logger log(level::level_enum level);
|
||||
details::line_logger debug();
|
||||
details::line_logger info();
|
||||
details::line_logger warn();
|
||||
details::line_logger error();
|
||||
details::line_logger fatal();
|
||||
details::line_logger log(level::level_enum level);
|
||||
details::line_logger debug();
|
||||
details::line_logger info();
|
||||
details::line_logger warn();
|
||||
details::line_logger error();
|
||||
details::line_logger fatal();
|
||||
|
||||
private:
|
||||
friend details::line_logger;
|
||||
friend details::line_logger;
|
||||
|
||||
|
||||
std::string logger_name_ = "";
|
||||
std::unique_ptr<c11log::formatters::formatter> formatter_;
|
||||
sinks_vector_t sinks_;
|
||||
std::mutex mutex_;
|
||||
std::atomic_int atomic_level_;
|
||||
std::string logger_name_ = "";
|
||||
std::unique_ptr<c11log::formatters::formatter> formatter_;
|
||||
sinks_vector_t sinks_;
|
||||
std::mutex mutex_;
|
||||
std::atomic_int atomic_level_;
|
||||
|
||||
void log_it_(const std::string& msg);
|
||||
void log_it_(const std::string& msg);
|
||||
|
||||
};
|
||||
|
||||
logger& get_logger(const std::string& name);
|
||||
}
|
||||
|
||||
#include "details/line_logger.h"
|
||||
//
|
||||
// Logger inline impl
|
||||
//
|
||||
inline c11log::details::line_logger c11log::logger::log(c11log::level::level_enum msg_level)
|
||||
{
|
||||
|
||||
if (msg_level >= atomic_level_.load())
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
return details::line_logger(this, msg_level);
|
||||
}
|
||||
else
|
||||
{
|
||||
return details::line_logger(nullptr);
|
||||
}
|
||||
if (msg_level >= atomic_level_) {
|
||||
return details::line_logger(this, msg_level);
|
||||
} else {
|
||||
return details::line_logger(nullptr);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
inline c11log::details::line_logger c11log::logger::debug()
|
||||
{
|
||||
return log(c11log::level::DEBUG);
|
||||
return log(c11log::level::DEBUG);
|
||||
}
|
||||
inline c11log::details::line_logger c11log::logger::info()
|
||||
{
|
||||
return log(c11log::level::INFO);
|
||||
return log(c11log::level::INFO);
|
||||
}
|
||||
inline c11log::details::line_logger c11log::logger::warn()
|
||||
{
|
||||
return log(c11log::level::WARNING);
|
||||
return log(c11log::level::WARNING);
|
||||
}
|
||||
inline c11log::details::line_logger c11log::logger::error()
|
||||
{
|
||||
return log(level::ERROR);
|
||||
return log(level::ERROR);
|
||||
}
|
||||
inline c11log::details::line_logger c11log::logger::fatal()
|
||||
{
|
||||
return log(c11log::level::FATAL);
|
||||
return log(c11log::level::FATAL);
|
||||
}
|
||||
|
||||
inline void c11log::logger::set_name(const std::string& name)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
logger_name_ = name;
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
logger_name_ = name;
|
||||
}
|
||||
|
||||
inline const std::string& c11log::logger::get_name()
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
return logger_name_;
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
return logger_name_;
|
||||
}
|
||||
|
||||
inline void c11log::logger::add_sink(sink_ptr_t sink_ptr)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
sinks_.push_back(sink_ptr);
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
sinks_.push_back(sink_ptr);
|
||||
}
|
||||
|
||||
inline void c11log::logger::remove_sink(sink_ptr_t sink_ptr)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink_ptr), sinks_.end());
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sink_ptr), sinks_.end());
|
||||
}
|
||||
|
||||
inline void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
formatter_ = std::move(formatter);
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
formatter_ = std::move(formatter);
|
||||
}
|
||||
|
||||
inline void c11log::logger::set_level(c11log::level::level_enum level)
|
||||
{
|
||||
atomic_level_.store(level);
|
||||
atomic_level_.store(level);
|
||||
}
|
||||
|
||||
inline c11log::level::level_enum c11log::logger::get_level() const
|
||||
{
|
||||
return static_cast<c11log::level::level_enum>(atomic_level_.load());
|
||||
return static_cast<c11log::level::level_enum>(atomic_level_.load());
|
||||
}
|
||||
|
||||
inline bool c11log::logger::should_log(c11log::level::level_enum level) const
|
||||
{
|
||||
return level >= atomic_level_.load();
|
||||
return level >= atomic_level_.load();
|
||||
}
|
||||
inline void c11log::logger::log_it_(const std::string& msg)
|
||||
{
|
||||
level::level_enum level = static_cast<level::level_enum>(atomic_level_.load());
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
for (auto &sink : sinks_)
|
||||
sink->log(msg, level);
|
||||
level::level_enum level = static_cast<level::level_enum>(atomic_level_.load());
|
||||
std::lock_guard<std::mutex> lock(mutex_);
|
||||
for (auto &sink : sinks_)
|
||||
sink->log(msg, level);
|
||||
}
|
||||
|
||||
// Static factory function
|
||||
inline c11log::logger& c11log::get_logger(const std::string& name)
|
||||
{
|
||||
return *(c11log::details::factory::instance().get_logger(name));
|
||||
return *(c11log::details::factory::instance().get_logger(name));
|
||||
}
|
||||
|
@ -37,7 +37,7 @@ protected:
|
||||
|
||||
class null_sink:public base_sink {
|
||||
protected:
|
||||
void sink_it_(const std::string& msg) override
|
||||
void sink_it_(const std::string& ) override
|
||||
{}
|
||||
};
|
||||
}
|
||||
|
@ -1,27 +1,28 @@
|
||||
// stdafx.h : include file for standard system include files,
|
||||
// or project specific include files that are used frequently, but
|
||||
// are changed infrequently
|
||||
//
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include "targetver.h"
|
||||
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <chrono>
|
||||
#include <ctime>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
#ifndef _MSC_VER
|
||||
namespace std {
|
||||
template<typename T, typename ...Args>
|
||||
std::unique_ptr<T> make_unique( Args&& ...args )
|
||||
{
|
||||
return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
// stdafx.h : include file for standard system include files,
|
||||
// or project specific include files that are used frequently, but
|
||||
// are changed infrequently
|
||||
//
|
||||
#pragma once
|
||||
|
||||
#ifdef _MSC_VER
|
||||
#include "targetver.h"
|
||||
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
|
||||
#endif
|
||||
|
||||
#include <string>
|
||||
#include <chrono>
|
||||
#include <ctime>
|
||||
#include <memory>
|
||||
#include <iostream>
|
||||
|
||||
|
||||
#ifndef _MSC_VER
|
||||
namespace std
|
||||
{
|
||||
template<typename T, typename ...Args>
|
||||
std::unique_ptr<T> make_unique( Args&& ...args )
|
||||
{
|
||||
return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
@ -19,5 +19,6 @@ c11log::details::factory::logger_ptr c11log::details::factory::get_logger(const
|
||||
c11log::details::factory & c11log::details::factory::instance()
|
||||
{
|
||||
static c11log::details::factory instance;
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
@ -1,21 +0,0 @@
|
||||
#include "stdafx.h"
|
||||
#include "c11log/logger.h"
|
||||
|
||||
c11log::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level) :
|
||||
_callback_logger(callback_logger)
|
||||
{
|
||||
if (callback_logger) {
|
||||
callback_logger->formatter_->format_header(callback_logger->logger_name_,
|
||||
msg_level,
|
||||
c11log::formatters::clock::now(),
|
||||
_oss);
|
||||
}
|
||||
}
|
||||
|
||||
c11log::details::line_logger::~line_logger()
|
||||
{
|
||||
if (_callback_logger) {
|
||||
_oss << '\n';
|
||||
_callback_logger->log_it_(_oss.str_ref());
|
||||
}
|
||||
}
|
41
src/test.cpp
41
src/test.cpp
@ -20,38 +20,37 @@ using std::string;
|
||||
using std::chrono::seconds;
|
||||
using Q = c11log::details::blocking_queue<string>;
|
||||
|
||||
void pusher(Q* q)
|
||||
void pusher(Q* )
|
||||
{
|
||||
auto &logger = c11log::get_logger("async");
|
||||
while(active)
|
||||
{
|
||||
logger.info()<<"Hello logger!";
|
||||
++push_count;
|
||||
++push_count;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
void testq(int size, int pushers, int poppers)
|
||||
{
|
||||
|
||||
active = true;
|
||||
Q q{static_cast<Q::size_type>(size)};
|
||||
|
||||
active = true;
|
||||
Q q{static_cast<Q::size_type>(size)};
|
||||
|
||||
/*
|
||||
for(int i = 0; i < poppers; i++)
|
||||
testq(qsize, pushers, poppers);
|
||||
*/
|
||||
*/
|
||||
for(int i = 0; i < pushers; i++)
|
||||
new std::thread(std::bind(pusher, &q));
|
||||
|
||||
|
||||
while(active)
|
||||
{
|
||||
using std::endl;
|
||||
using std::cout;
|
||||
using utils::format;
|
||||
|
||||
|
||||
push_count = 0;
|
||||
pop_count = 0;
|
||||
std::this_thread::sleep_for(seconds(1));
|
||||
@ -59,8 +58,8 @@ void testq(int size, int pushers, int poppers)
|
||||
//cout << "Pops/sec =\t" << format(pop_count.load()) << endl << endl;
|
||||
//cout << "Total/sec =\t" << format(push_count+pop_count) << endl;
|
||||
cout << "Queue size =\t" << format(q.size()) << endl;
|
||||
cout << "---------------------------------------------------------------------" << endl;
|
||||
}
|
||||
cout << "---------------------------------------------------------------------" << endl;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -75,26 +74,24 @@ int main(int argc, char* argv[])
|
||||
int qsize = atoi(argv[1]);
|
||||
int pushers = atoi(argv[2]);
|
||||
int poppers = atoi(argv[3]);
|
||||
|
||||
|
||||
//testq(qsize, pushers, poppers);
|
||||
|
||||
|
||||
|
||||
|
||||
using namespace std::chrono;
|
||||
|
||||
|
||||
|
||||
|
||||
auto null_sink = std::make_shared<c11log::sinks::null_sink>();
|
||||
auto stdout_sink = std::make_shared<c11log::sinks::stdout_sink>();
|
||||
auto async = std::make_shared<c11log::sinks::async_sink>(1000);
|
||||
auto fsink = std::make_shared<c11log::sinks::rotating_file_sink>("newlog", "txt", 1024*1024*10 , 2);
|
||||
//auto fsink = std::make_shared<c11log::sinks::daily_file_sink>("daily", "txt");
|
||||
|
||||
async->add_sink(fsink);
|
||||
|
||||
async->add_sink(null_sink);
|
||||
auto &logger = c11log::get_logger("async");
|
||||
logger.add_sink(async);
|
||||
|
||||
|
||||
testq(qsize, pushers, poppers);
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
Loading…
Reference in New Issue
Block a user