Asynchronous thread-safe logging in C++ (no mutex) - c++

Question

I'm actually looking for a way to do an asynchronous and thread-safe logging in my C++.
I have already explored thread-safe logging solutions like log4cpp, log4cxx, Boost:log or rlog, but it seems that all of them use a mutex. And as far as I know, mutex is a synchronous solution, which means that all threads are locked as they try to write their messages while other does.
Do you know a solution?

Answer 1

I think your statement is wrong: using mutex is not necessary equivalent to a synchronous solution. Yes, Mutex is for synchronization control but it can be used for many different thing. We can use mutex in, for example, a producer consumer queue while the logging is still happening asynchronously.
Honestly I haven't looked into the implementation of these logging library but it should be feasible to make a asynchronous appender (for log4j like lib) which logger writes to an producer consumer queue and another worker thread is responsible to write to a file (or even delegate to another appender), in case it is not provided.
Edit:
Just have had a brief scan in log4cxx, it does provide an AsyncAppender which does what I suggested: buffers the incoming logging event, and delegate to attached appender asynchronously.

Answer 2

I'd recomment avoiding the problem by using only one thread for logging. For passing the necessary data to log, you can use lock-free fifo queue (thread safe as long as producer and consumer are strictly separated and only one thread has each role -- therefore you will need one queue for each producer.)
Example of fast lock-free queue is included:
queue.h:
#ifndef QUEUE_H
#define QUEUE_H
template<typename T> class Queue
{
public:
virtual void Enqueue(const T &element) = 0;
virtual T Dequeue() = 0;
virtual bool Empty() = 0;
};
hybridqueue.h:
#ifndef HYBRIDQUEUE_H
#define HYBRIDQUEUE_H
#include "queue.h"
template <typename T, int size> class HybridQueue : public Queue<T>
{
public:
virtual bool Empty();
virtual T Dequeue();
virtual void Enqueue(const T& element);
HybridQueue();
virtual ~HybridQueue();
private:
struct ItemList
{
int start;
T list[size];
int end;
ItemList volatile * volatile next;
};
ItemList volatile * volatile start;
char filler[256];
ItemList volatile * volatile end;
};
/**
* Implementation
*
*/
#include <stdio.h>
template <typename T, int size> bool HybridQueue<T, size>::Empty()
{
return (this->start == this->end) && (this->start->start == this->start->end);
}
template <typename T, int size> T HybridQueue<T, size>::Dequeue()
{
if(this->Empty())
{
return NULL;
}
if(this->start->start >= size)
{
ItemList volatile * volatile old;
old = this->start;
this->start = this->start->next;
delete old;
}
T tmp;
tmp = this->start->list[this->start->start];
this->start->start++;
return tmp;
}
template <typename T, int size> void HybridQueue<T, size>::Enqueue(const T& element)
{
if(this->end->end >= size) {
this->end->next = new ItemList();
this->end->next->start = 0;
this->end->next->list[0] = element;
this->end->next->end = 1;
this->end = this->end->next;
}
else
{
this->end->list[this->end->end] = element;
this->end->end++;
}
}
template <typename T, int size> HybridQueue<T, size>::HybridQueue()
{
this->start = this->end = new ItemList();
this->start->start = this->start->end = 0;
}
template <typename T, int size> HybridQueue<T, size>::~HybridQueue()
{
}
#endif // HYBRIDQUEUE_H

Answer 3

If I get your question right you are concerned about doing I/O operation (probably write to a file) in a logger's critical section.
Boost:log lets you define a custom writer object. You can define operator() to call async I/O or pass a message to your logging thread (which is doing I/Os).
http://www.torjo.com/log2/doc/html/workflow.html#workflow_2b

Answer 4

No libraries will do this as far as I know - it's too complex. You'll have to roll your own, and here's an idea which I just had, create a per thread log file, ensure that the first item in each entry is a timestamp, and then merge the logs after then run and sort (by timestamp) to get a final log file.
You can use some thread local storage may be (say a FILE handle AFAIK it won't be possible to store a stream object in thread local storage) and look this handle up on each log line and write to that specific file.
All this complexity vs locking the mutex? I don't know the performance requirements of your application, but if it is sensitive - why would you be logging (excessively)? Think of other ways to obtain the information you require without logging?
Also one other thing to consider is to use the mutex for the least amount of time possible, i.e. construct your log entry first and then just before writing to the file, acquire the lock.

Answer 5

In a Windows program, we use a user-defined Windows message. First, memory is allocated for the log entry on the heap. Then PostMessage is called, with the pointer as the LPARAM, and the record size as the WPARAM. The receiver window extracts the record, displays it, and saves it in the log file. Then PostMessage returns, and the allocated memory is deallocated by the sender. This approach is thread-safe, and you don't have to use mutexes. Concurrency is handled by the message queue mechanism of Windows. Not very elegant, but works.

Answer 6

Lock-free algorithms are not necessarily the fastest ones. Define your boundaries. How many threads are there for logging? How much will be written in a single log operation at most?
I/O bound operations are much much slower than thread context switching due to blocking/awaking threads. Using lock-free/spinning lock algorithm with 10 writing threads will bring a heavy load to CPU.
Shortly, block other threads when you are writing to a file.