Tag: boost

Logging in Multithreaded Environment Using Thread-Local Storage

April 12, 2013 by gonwan·0 Comments

Generally, A logger is a singleton class. The declaration may look like:

#ifndef _LOGGER_H
#define _LOGGER_H

#include <string>

class Logger
{
private:
    Logger() { }
public:
    static void Init(const std::string &name);
    static Logger *GetInstance();
    void Write(const char *format, ...);
private:
    static std::string ms_name;
    static Logger *ms_this_logger;
};

#endif

#ifndef _LOGGER_H

#define _LOGGER_H

#include <string>

class Logger

{

private:

Logger() { }

public:

static void Init(const std::string &name);

static Logger *GetInstance();

void Write(const char *format, ...);

private:

static std::string ms_name;

static Logger *ms_this_logger;

};

#endif

The Init function is used to set log name or maybe other configuration information. And We can use the Write function to write logs.

Well, in a multithreaded environment, locks must be added to prevent concurrent issues and keep the output log in order. And sometimes we want to have separate log configurations. How can we implement it without breaking the original interfaces?

One easy way is to maintain a list of all available Logger instances, so that we can find and use a unique Logger in each thread. The approach is somehow like the one used in log4j. But log4j reads configuration files to initialize loggers, while our configuration information is set in runtime.

Another big issue is that we must add a new parameter to the GetInstance function to tell our class which Logger to return. The change breaks interfaces.

By utilizing TLS (thread-local storage), we can easily solve the above issues. Every logger will be thread-local, say every thread has its own logger instance which is stored in its thread context. Here comes the declaration for our new Logger class, boost::thread_specific_ptr from boost library is used to simplify our TLS operations:

#ifndef _LOGGER2_H
#define _LOGGER2_H

#include <string>
#include <boost/thread.hpp>

class Logger
{
private:
    Logger() { }
public:
    static void Init(const std::string &name);
    static Logger *GetInstance();
    void Write(const char *format, ...);
private:
    static boost::thread_specific_ptr<std::string> ms_name;
    static boost::thread_specific_ptr<Logger> ms_this_logger;
};

#endif

#ifndef _LOGGER2_H

#define _LOGGER2_H

#include <string>

#include <boost/thread.hpp>

class Logger

{

private:

Logger() { }

public:

static void Init(const std::string &name);

static Logger *GetInstance();

void Write(const char *format, ...);

private:

static boost::thread_specific_ptr<std::string> ms_name;

static boost::thread_specific_ptr<Logger> ms_this_logger;

};

#endif

Simply use boost::thread_specific_ptr to wrap the original 2 static variables, and they will be in TLS automatically, that’s all. The implementation:

#include "logger2.h"
#include <stdio.h>
#include <stdarg.h>
#include <string.h>

using namespace std;

boost::thread_specific_ptr<string> Logger::ms_name;
boost::thread_specific_ptr<Logger> Logger::ms_this_logger;

void Logger::Init(const string &name)
{
    if (!name.empty()) {
        ms_name.reset(new std::string(name));
    }
}

Logger *Logger::GetInstance()
{
    if (ms_this_logger.get() == NULL) {
        ms_this_logger.reset(new Logger);
    }
    return ms_this_logger.get();
}

void Logger::Write(const char *format, ...)
{
    va_list arglist;
    char buffer[1024];
    va_start(arglist, format);
    memset(buffer, 0, sizeof(buffer));
    vsnprintf(buffer, sizeof(buffer), format, arglist);
    va_end(arglist);
    printf("[%s] %s\n", ms_name.get()->c_str(), buffer);
}

#include "logger2.h"

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

using namespace std;

boost::thread_specific_ptr<string> Logger::ms_name;

boost::thread_specific_ptr<Logger> Logger::ms_this_logger;

void Logger::Init(const string &name)

{

if (!name.empty()) {

ms_name.reset(new std::string(name));

}

Logger *Logger::GetInstance()

{

if (ms_this_logger.get() == NULL) {

ms_this_logger.reset(new Logger);

}

return ms_this_logger.get();

}

void Logger::Write(const char *format, ...)

{

va_list arglist;

char buffer[1024];

va_start(arglist, format);

memset(buffer, 0, sizeof(buffer));

vsnprintf(buffer, sizeof(buffer), format, arglist);

va_end(arglist);

printf("[%s] %s\n", ms_name.get()->c_str(), buffer);

}

Our test code:

#include <boost/date_time.hpp>
#include <boost/thread.hpp>
/*
 * actually, we do not matter which header file to include,
 * since they have compatible public interface, compatible ABI.
 */
//#include "logger.h"
#include "logger2.h"

using namespace std;

class Thread
{
public:
    Thread(const char *name) : m_name(name) { }
    void operator()()
    {
        /* set logger name in thread */
        Logger::Init(m_name);
        /* call GetInstance() and Write() in other functions with thread-local enabled */
        Logger *logger = Logger::GetInstance();
        for (int i = 0; i < 3; i++) {
            logger->Write("Hello %d", i);
            boost::this_thread::sleep(boost::posix_time::seconds(1));
        }
    }
private:
    string m_name;
};

int main()
{
    boost::thread t1(Thread("name1"));
    boost::thread t2(Thread("name2"));
    t1.join();
    t2.join();
    return 0;
}

#include <boost/date_time.hpp>

#include <boost/thread.hpp>

* actually, we do not matter which header file to include,

* since they have compatible public interface, compatible ABI.

//#include "logger.h"

#include "logger2.h"

using namespace std;

class Thread

{

public:

Thread(const char *name) : m_name(name) { }

void operator()()

{

/* set logger name in thread */

Logger::Init(m_name);

/* call GetInstance() and Write() in other functions with thread-local enabled */

Logger *logger = Logger::GetInstance();

for (int i = 0; i < 3; i++) {

logger->Write("Hello %d", i);

boost::this_thread::sleep(boost::posix_time::seconds(1));

}

private:

string m_name;

};

int main()

{

boost::thread t1(Thread("name1"));

boost::thread t2(Thread("name2"));

t1.join();

t2.join();

return 0;

}

Output when using the original Logger may look like:

[name1] Hello 0
[name2] Hello 0
[name2] Hello 1
[name2] Hello 1
[name2] Hello 2
[name2] Hello 2

[name1] Hello 0

[name2] Hello 0

[name2] Hello 1

[name2] Hello 2

When using the TLS version, it may look like:

[name1] Hello 0
[name2] Hello 0
[name1] Hello 1
[name2] Hello 1
[name1] Hello 2
[name2] Hello 2

[name1] Hello 0

[name2] Hello 0

[name1] Hello 1

[name2] Hello 1

[name1] Hello 2

[name2] Hello 2

Everything is in order now. You may want to know what OS API boost uses to achieve TLS. I’ll show you the details in boost 1.43:

# windows implementation
boost::thread_specific_ptr::reset()
  --> boost::detail::set_tss_data()
  --> boost::detail::get_or_make_current_thread_data()
  --> boost::detail::get_current_thread_data()
  --> ::TlsGetValue()
# see:
# ${BOOST}/boost/thread/tss.hpp
# ${BOOST}/lib/thread/src/win32/thread.cpp

# windows implementation

boost::thread_specific_ptr::reset()

--> boost::detail::set_tss_data()

--> boost::detail::get_or_make_current_thread_data()

--> boost::detail::get_current_thread_data()

--> ::TlsGetValue()

# see:

# ${BOOST}/boost/thread/tss.hpp

# ${BOOST}/lib/thread/src/win32/thread.cpp

# *nix implementation
boost::thread_specific_ptr::reset()
  --> boost::detail::set_tss_data()
  --> boost::detail::add_new_tss_node()
  --> boost::detail::get_or_make_current_thread_data()
  --> boost::detail::get_current_thread_data()
  --> ::pthread_getspecific()
# see:
# ${BOOST}/boost/thread/tss.hpp
# ${BOOST}/lib/thread/src/pthread/thread.cpp

# *nix implementation

boost::thread_specific_ptr::reset()

--> boost::detail::set_tss_data()

--> boost::detail::add_new_tss_node()

--> boost::detail::get_or_make_current_thread_data()

--> boost::detail::get_current_thread_data()

--> ::pthread_getspecific()

# see:

# ${BOOST}/boost/thread/tss.hpp

# ${BOOST}/lib/thread/src/pthread/thread.cpp

The underlying API is TlsGetValue under windows and pthread_getspecific under *nix platforms.

Smart Pointers in C++0x and Boost (2)

August 14, 2011 by gonwan·0 Comments

1. Environment

– windows xp
– gcc-4.4
– boost-1.43

2. auto_ptr

A smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic garbage collection or bounds checking. There’s auto_ptr in C++03 library for general use. But it’s not so easy to deal with it. You may encounter pitfalls or limitations. The main drawback of auto_ptr is that it has the transfer-of-ownership semantic. I just walk through it. Please read comments in code carefully:

int *test_auto_ptr_exp() {
    auto_ptr<int> p(new int(1));
    throw runtime_error("auto_ptr test exception.");
    /* exception-safe, p is free even when an exception is thrown. */
    return p.get();
}

void test_auto_ptr_basic() {
    auto_ptr<int> p1(new int(1));
    auto_ptr<int> p2(new int(2));
    auto_ptr<int> p3(p1);
    auto_ptr<int> p4;
    p4 = p2;
    if (p1.get()) {  /* NULL */
        cout << "*p1=" << *p1 << endl;
    }
    if (p2.get()) {  /* NULL */
        cout << "*p2=" << *p2 << endl;
    }
    if (p3.get()) {  /* ownership already transferred from p1 to p3 */
        cout << "*p3=" << *p3 << endl;
    }
    if (p4.get()) {  /* ownership already transferred from p2 to p4 */
        cout << "*p4=" << *p4 << endl;
    }
    /* ERROR: void is a type of template specialization */
    //auto_ptr<void> ptr5(new int(3));
}

void test_auto_ptr_errors() {
    /* ERROR: statically allocated object */
    const char *str = "Hello";
    auto_ptr<const char> p1(str);
    /* ERROR: two auto_ptrs refer to the same object */
    int *pi = new int(5);
    auto_ptr<int> p2(pi);
    auto_ptr<int> p3(p2.get());
    p2.~auto_ptr();  /* now p3 is not available too */
    /* ERROR: hold a pointer to a dynamically allocated array */
    /* When destroyed, it only deletes first single object. */
    auto_ptr<int> (new int[10]);
    /* ERROR: store an auto_ptr in a container */
    //vector<auto_ptr<int> > vec;
    //vec.push_back(auto_ptr<int>(new int(1)));
    //vec.push_back(auto_ptr<int>(new int(2)));
    //auto_ptr<int> p4(vec[0]);  /* vec[0] is assigned NULL */
    //auto_ptr<int> p5;
    //p5 = vec[1];  /* vec[1] is assigned NULL */
}

int *test_auto_ptr_exp() {

auto_ptr<int> p(new int(1));

throw runtime_error("auto_ptr test exception.");

/* exception-safe, p is free even when an exception is thrown. */

return p.get();

}

void test_auto_ptr_basic() {

auto_ptr<int> p1(new int(1));

auto_ptr<int> p2(new int(2));

auto_ptr<int> p3(p1);

auto_ptr<int> p4;

p4 = p2;

if (p1.get()) { /* NULL */

cout << "*p1=" << *p1 << endl;

}

if (p2.get()) { /* NULL */

cout << "*p2=" << *p2 << endl;

}

if (p3.get()) { /* ownership already transferred from p1 to p3 */

cout << "*p3=" << *p3 << endl;

}

if (p4.get()) { /* ownership already transferred from p2 to p4 */

cout << "*p4=" << *p4 << endl;

}

/* ERROR: void is a type of template specialization */

//auto_ptr<void> ptr5(new int(3));

}

void test_auto_ptr_errors() {

/* ERROR: statically allocated object */

const char *str = "Hello";

auto_ptr<const char> p1(str);

/* ERROR: two auto_ptrs refer to the same object */

int *pi = new int(5);

auto_ptr<int> p2(pi);

auto_ptr<int> p3(p2.get());

p2.~auto_ptr(); /* now p3 is not available too */

/* ERROR: hold a pointer to a dynamically allocated array */

/* When destroyed, it only deletes first single object. */

auto_ptr<int> (new int[10]);

/* ERROR: store an auto_ptr in a container */

//vector<auto_ptr<int> > vec;

//vec.push_back(auto_ptr<int>(new int(1)));

//vec.push_back(auto_ptr<int>(new int(2)));

//auto_ptr<int> p4(vec[0]); /* vec[0] is assigned NULL */

//auto_ptr<int> p5;

//p5 = vec[1]; /* vec[1] is assigned NULL */

}

3. unique_ptr

To resolve the drawbacks, C++0x deprecates usage of auto_ptr, and unique_ptr is the replacement. unique_ptr makes use of a new C++ langauge feature called rvalue reference which is similar to our current (left) reference (&), but spelled (&&). GCC implemented this feature in 4.3, but unique_ptr is only available begin from 4.4.

What is rvalue?

rvalues are temporaries that evaporate at the end of the full-expression in which they live (“at the semicolon”). For example, 1729, x + y, std::string(“meow”), and x++ are all rvalues.

While, lvalues name objects that persist beyond a single expression. For example, obj, *ptr, ptr[index], and ++x are all lvalues.

NOTE: It’s important to remember: lvalueness versus rvalueness is a property of expressions, not of objects.

We may have another whole post to address the rvalue feature. Now, let’s take a look of the basic usage. Please carefully reading the comments:

unique_ptr<int> get_unique_ptr(int i) {
    return unique_ptr<int> (new int(i));
}

void use_unique_ptr(unique_ptr<int> p) {
    /* p is deleted when finish running this function. */
}

void test_unique_ptr_basic() {
    unique_ptr<int> p(new int(1));
    /*
     * One can make a copy of an rvalue unique_ptr.
     * But one can not make a copy of an lvalue unique_ptr.
     * Note the defaulted and deleted functions usage in source code(c++0x).
     */
    //unique_ptr<int> p2 = p;  /* error */
    //use_unique_ptr(p);       /* error */
    use_unique_ptr(move(p));
    use_unique_ptr(get_unique_ptr(3));
}

unique_ptr<int> get_unique_ptr(int i) {

return unique_ptr<int> (new int(i));

}

void use_unique_ptr(unique_ptr<int> p) {

/* p is deleted when finish running this function. */

}

void test_unique_ptr_basic() {

unique_ptr<int> p(new int(1));

* One can make a copy of an rvalue unique_ptr.

* But one can not make a copy of an lvalue unique_ptr.

* Note the defaulted and deleted functions usage in source code(c++0x).

//unique_ptr<int> p2 = p; /* error */

//use_unique_ptr(p); /* error */

use_unique_ptr(move(p));

use_unique_ptr(get_unique_ptr(3));

}

One can ONLY make a copy of an rvalue unique_ptr. This confirms no ownership issues occur like that of auto_ptr. Since temporary values cannot be referenced after the current expression, it is impossible for two unique_ptr to refer to a same pointer. You may also noticed the move function. We will also discuss it in a later post.

Some more snippet:

struct aclass {
    aclass() { cout << "in aclass::ctor()" << endl; }
    ~aclass() { cout << "in aclass::dtor()" << endl; }
};

struct aclass_deleter {
    void operator()(void *p) {
        delete static_cast<aclass *> (p);
    }
};

template<class T>
struct array_deleter {
    void operator()(T *array) {
        delete[] array;
    }
};

typedef array_deleter<aclass> aclass_array_deleter;
typedef unique_ptr<aclass, aclass_array_deleter> aclass_array_ptr;

void test_unique_ptr_custom_deleter() {
    /*
     * Hold a pointer to a dynamically allocated array.
     * aaptr & aaptr2 are deleted when finish running this function.
     */
    aclass_array_ptr aaptr(new aclass[3]);
    unique_ptr<aclass[]> aaptr2(new aclass[3]);  /* default_deleter<T[]> */
    /* allow void pointer, but a custom deleter must be used. */
    unique_ptr<void, aclass_deleter> p3(new aclass);
}

struct aclass {

aclass() { cout << "in aclass::ctor()" << endl; }

~aclass() { cout << "in aclass::dtor()" << endl; }

};

struct aclass_deleter {

void operator()(void *p) {

delete static_cast<aclass *> (p);

}

};

template<class T>

struct array_deleter {

void operator()(T *array) {

delete[] array;

}

};

typedef array_deleter<aclass> aclass_array_deleter;

typedef unique_ptr<aclass, aclass_array_deleter> aclass_array_ptr;

void test_unique_ptr_custom_deleter() {

* Hold a pointer to a dynamically allocated array.

* aaptr & aaptr2 are deleted when finish running this function.

aclass_array_ptr aaptr(new aclass[3]);

unique_ptr<aclass[]> aaptr2(new aclass[3]); /* default_deleter<T[]> */

/* allow void pointer, but a custom deleter must be used. */

unique_ptr<void, aclass_deleter> p3(new aclass);

}

unique_ptr can hold pointers to an array. unique_ptr defines deleters to free memory of its internal pointer. There are pre-defined default_deleter using delete and delete[](array) for general deallocation. You can also define your customized ones. In addition, a void type can be used.

NOTE: To compile the code, you must specify the -std=c++0x flag.

4. shared_ptr

A shared_ptr is used to represent shared ownership; that is, when two pieces of code needs access to some data but neither has exclusive ownership (in the sense of being responsible for destroying the object). A shared_ptr is a kind of counted pointer where the object pointed to is deleted when the use count goes to zero.

Following snippet shows the use count changes when using shared_ptr. The use count changes from 0 to 3, then changes back to 0:

struct bclass {
    int i;
    bclass(int i) { this->i = i; }
    virtual ~bclass() { cout << "in bclass::dtor() with i=" << i << endl; }
};

struct cclass: bclass {
    cclass(int i) : bclass(i) { }
    virtual ~cclass() { cout << "in cclass::dtor() with i=" << i << endl; }
};

void use_shared_ptr(shared_ptr<int> p) {
    cout << "count=" << p.use_count() << endl;
}

void test_shared_ptr_basic() {
    shared_ptr<int> p;
    cout << "count=" << p.use_count() << endl;
    p.reset(new int(1));
    cout << "count=" << p.use_count() << endl;
    shared_ptr<int> p2 = p;
    cout << "count=" << p.use_count() << endl;
    use_shared_ptr(p2);
    cout << "count=" << p.use_count() << endl;
    p2.~shared_ptr();
    cout << "count=" << p.use_count() << endl;
    p2.~shared_ptr();
    cout << "count=" << p.use_count() << endl;
}

struct bclass {

int i;

bclass(int i) { this->i = i; }

virtual ~bclass() { cout << "in bclass::dtor() with i=" << i << endl; }

};

struct cclass: bclass {

cclass(int i) : bclass(i) { }

virtual ~cclass() { cout << "in cclass::dtor() with i=" << i << endl; }

};

void use_shared_ptr(shared_ptr<int> p) {