Tag: boost

Coroutines in C++/Boost

January 19, 2016 by gonwan·0 Comments

Starting with 1.56, boost/asio provides asio::spawn() to work with coroutines. Just paste the sample code here, with minor modifications:

#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <iostream>
using namespace std;
using boost::asio::ip::tcp;


class session: public boost::enable_shared_from_this<session>
{
public:
    explicit session(boost::asio::io_service &io_service)
        : socket_(io_service), timer_(io_service), strand_(io_service)
    {
    }
    tcp::socket &socket()
    {
        return socket_;
    }
    void go()
    {
        boost::asio::spawn(strand_, boost::bind(&session::echo, shared_from_this(), _1));
        boost::asio::spawn(strand_, boost::bind(&session::timeout, shared_from_this(), _1));
    }
private:
    void echo(boost::asio::yield_context yield)
    {
        try {
            char data[128];
            while (true) {
                timer_.expires_from_now(boost::posix_time::seconds(10));
                size_t n = socket_.async_read_some(boost::asio::buffer(data), yield);
                boost::asio::async_write(socket_, boost::asio::buffer(data, n), yield);
            }
        } catch (exception &) {
            socket_.close();
            timer_.cancel();
        }
    }
    void timeout(boost::asio::yield_context yield)
    {
        while (socket_.is_open()) {
            boost::system::error_code ignored_ec;
            timer_.async_wait(yield[ignored_ec]);
            if (timer_.expires_from_now() <= boost::posix_time::seconds(0)) {
                socket_.close();
            }
        }
    }
    tcp::socket socket_;
    boost::asio::deadline_timer timer_;
    boost::asio::io_service::strand strand_;
};

void do_accept(boost::asio::io_service &io_service, unsigned short port, boost::asio::yield_context yield)
{
    tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), port));
    while (true) {
        boost::system::error_code ec;
        boost::shared_ptr<session> new_session(new session(io_service));
        acceptor.async_accept(new_session->socket(), yield[ec]);
        if (!ec) {
            new_session->go();
        }
    }
}

int main()
{
    try {
        boost::asio::io_service io_service;
        boost::asio::spawn(io_service, boost::bind(do_accept, boost::ref(io_service), 2222, _1));
        io_service.run();
    } catch (exception &e) {
        cerr << "Exception: " << e.what() << endl;
    }
    return 0;
}

#include <boost/asio.hpp>

#include <boost/asio/spawn.hpp>

#include <boost/bind.hpp>

#include <boost/shared_ptr.hpp>

#include <boost/enable_shared_from_this.hpp>

#include <iostream>

using namespace std;

using boost::asio::ip::tcp;

class session: public boost::enable_shared_from_this<session>

{

public:

explicit session(boost::asio::io_service &io_service)

: socket_(io_service), timer_(io_service), strand_(io_service)

{

}

tcp::socket &socket()

{

return socket_;

}

void go()

{

boost::asio::spawn(strand_, boost::bind(&session::echo, shared_from_this(), _1));

boost::asio::spawn(strand_, boost::bind(&session::timeout, shared_from_this(), _1));

}

private:

void echo(boost::asio::yield_context yield)

{

try {

char data[128];

while (true) {

timer_.expires_from_now(boost::posix_time::seconds(10));

size_t n = socket_.async_read_some(boost::asio::buffer(data), yield);

boost::asio::async_write(socket_, boost::asio::buffer(data, n), yield);

}

} catch (exception &) {

socket_.close();

timer_.cancel();

}

void timeout(boost::asio::yield_context yield)

{

while (socket_.is_open()) {

boost::system::error_code ignored_ec;

timer_.async_wait(yield[ignored_ec]);

if (timer_.expires_from_now() <= boost::posix_time::seconds(0)) {

socket_.close();

}

tcp::socket socket_;

boost::asio::deadline_timer timer_;

boost::asio::io_service::strand strand_;

};

void do_accept(boost::asio::io_service &io_service, unsigned short port, boost::asio::yield_context yield)

{

tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), port));

while (true) {

boost::system::error_code ec;

boost::shared_ptr<session> new_session(new session(io_service));

acceptor.async_accept(new_session->socket(), yield[ec]);

if (!ec) {

new_session->go();

}

int main()

{

try {

boost::asio::io_service io_service;

boost::asio::spawn(io_service, boost::bind(do_accept, boost::ref(io_service), 2222, _1));

io_service.run();

} catch (exception &e) {

cerr << "Exception: " << e.what() << endl;

}

return 0;

}

The Python in my previous article can be used to work with the code above. I also tried to write a TCP server with only boost::coroutines classes. select() is used, since I want the code to be platform independent. NOTE: with coroutines, we have only _one_ thread.

#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#include <windows.h>
#pragma comment(lib, "ws2_32.lib")
#pragma warning(disable: 4996)
#define sock_send(s, str, len)      send(s, str, len, 0)
#define sock_close(s)               closesocket(s)
#else
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/socket.h>
#define sock_send(s, str, len)      send(s, str, len, MSG_NOSIGNAL)
#define sock_close(s)               close(s)
#endif
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <boost/bind.hpp>
#include <boost/coroutine/all.hpp>
#include <boost/shared_ptr.hpp>
using namespace std;


#ifdef _WIN32
struct Win32SocketWrapper
{
    Win32SocketWrapper()
    {
        WSADATA wsaData;
        WSAStartup(0x0202, &wsaData);
    }
    ~Win32SocketWrapper()
    {
        WSACleanup();
    }
} g_win32_socket_wrapper;
#endif


class session
{
    typedef boost::coroutines::symmetric_coroutine<void> coro_t;
public:
    explicit session(int sock)
        : socket_(sock)
    {
        echo_coro_ = coro_t::call_type(boost::bind(&session::echo, this, _1));
    }
    int socket()
    {
        return socket_;
    }
    void go()
    {
        echo_coro_();
    }
    void echo(coro_t::yield_type &yield)
    {
        int rc;
        char buffer[128];
        while (true) {
            memset(buffer, 0, sizeof(buffer));
            yield(); rc = recv(socket_, buffer, sizeof(buffer), 0);
            if (rc == 0 || rc == -1) { /* close or error */
                printf("socket[%d] closed, rc=%d..\n", socket_, rc);
                sock_close(socket_);
                socket_ = -1;
                /* do not release here, or the whole coroutine context will be invalid.. */
                break;
            } else {
                sock_send(socket_, buffer, rc);
            }
        }
    }
private:
    int socket_;
    coro_t::call_type echo_coro_;
};

void event_loop(int server_sock)
{
    list<boost::shared_ptr<session> > session_list;
    int rc, maxfd, client_sock;
    fd_set rdset;
    struct sockaddr_in client_addr;
    size_t addr_size = sizeof(struct sockaddr_in);

    while (true) {
        FD_ZERO(&rdset);
        FD_SET(server_sock, &rdset);
        maxfd = server_sock;
        list<boost::shared_ptr<session> >::iterator it = session_list.begin();
        while (it != session_list.end()) {
            if ((*it)->socket() == -1) {
                session_list.erase(it++);
            } else {
                FD_SET((*it)->socket(), &rdset);
                if (maxfd < (*it)->socket()) {
                    maxfd = (*it)->socket();
                }
                ++it;
            }
        }
        /* max fd value plus 1 */
        rc = select(maxfd+1, &rdset, 0, 0, NULL);
        if (rc == -1) {
            continue;
        } else {
            if (FD_ISSET(server_sock, &rdset)) {
                client_sock = (int)accept(server_sock, (struct sockaddr *)&client_addr, (socklen_t *)&addr_size);
                printf("socket[%d] accepted: %s:%d..\n", client_sock, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));
                boost::shared_ptr<session> new_session(new session(client_sock));
                new_session->go(); /* go first */
                session_list.push_back(new_session);
            }
            for (list<boost::shared_ptr<session> >::iterator it = session_list.begin(); it != session_list.end(); ++it) {
                if (FD_ISSET((*it)->socket(), &rdset)) {
                    (*it)->go();
                }
            }
        }
    }
}

int main() 
{
    int rc, server_sock;
    struct sockaddr_in server_addr;

    server_sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(2222);
    rc = bind(server_sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));
    if (rc < 0) {
        fprintf(stderr, "bind: %s.\n", strerror(errno));
        return -1;
    }
    listen(server_sock, 5);
    /* loop */
    event_loop(server_sock);
    sock_close(server_sock);
    return 0;
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

#ifdef _WIN32

#include <winsock2.h>

#include <ws2tcpip.h>

#include <windows.h>

#pragma comment(lib, "ws2_32.lib")

#pragma warning(disable: 4996)

#define sock_send(s, str, len) send(s, str, len, 0)

#define sock_close(s) closesocket(s)

#else

#include <arpa/inet.h>

#include <sys/types.h>

#include <sys/socket.h>

#define sock_send(s, str, len) send(s, str, len, MSG_NOSIGNAL)

#define sock_close(s) close(s)

#endif

#include <cerrno>

#include <cstdio>

#include <cstring>

#include <iostream>

#include <list>

#include <boost/bind.hpp>

#include <boost/coroutine/all.hpp>

#include <boost/shared_ptr.hpp>

using namespace std;

#ifdef _WIN32

struct Win32SocketWrapper

{

Win32SocketWrapper()

{

WSADATA wsaData;

WSAStartup(0x0202, &wsaData);

}

~Win32SocketWrapper()

{

WSACleanup();

}

} g_win32_socket_wrapper;

#endif

class session

{

typedef boost::coroutines::symmetric_coroutine<void> coro_t;

public:

explicit session(int sock)

: socket_(sock)

{

echo_coro_ = coro_t::call_type(boost::bind(&session::echo, this, _1));

}

int socket()

{

return socket_;

}

void go()

{

echo_coro_();

}

void echo(coro_t::yield_type &yield)

{

int rc;

char buffer[128];

while (true) {

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

yield(); rc = recv(socket_, buffer, sizeof(buffer), 0);

if (rc == 0 || rc == -1) { /* close or error */

printf("socket[%d] closed, rc=%d..\n", socket_, rc);

sock_close(socket_);

socket_ = -1;

/* do not release here, or the whole coroutine context will be invalid.. */

break;

} else {

sock_send(socket_, buffer, rc);

}

private:

int socket_;

coro_t::call_type echo_coro_;

};

void event_loop(int server_sock)

{

list<boost::shared_ptr<session> > session_list;

int rc, maxfd, client_sock;

fd_set rdset;

struct sockaddr_in client_addr;

size_t addr_size = sizeof(struct sockaddr_in);

while (true) {

FD_ZERO(&rdset);

FD_SET(server_sock, &rdset);

maxfd = server_sock;

list<boost::shared_ptr<session> >::iterator it = session_list.begin();

while (it != session_list.end()) {

if ((*it)->socket() == -1) {

session_list.erase(it++);

} else {

FD_SET((*it)->socket(), &rdset);

if (maxfd < (*it)->socket()) {

maxfd = (*it)->socket();

}

++it;

}

/* max fd value plus 1 */

rc = select(maxfd+1, &rdset, 0, 0, NULL);

if (rc == -1) {

continue;

} else {

if (FD_ISSET(server_sock, &rdset)) {

client_sock = (int)accept(server_sock, (struct sockaddr *)&client_addr, (socklen_t *)&addr_size);

printf("socket[%d] accepted: %s:%d..\n", client_sock, inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

boost::shared_ptr<session> new_session(new session(client_sock));

new_session->go(); /* go first */

session_list.push_back(new_session);

}

for (list<boost::shared_ptr<session> >::iterator it = session_list.begin(); it != session_list.end(); ++it) {

if (FD_ISSET((*it)->socket(), &rdset)) {

(*it)->go();

}

int main()

{

int rc, server_sock;

struct sockaddr_in server_addr;

server_sock = (int)socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

server_addr.sin_family = AF_INET;

server_addr.sin_addr.s_addr = htonl(INADDR_ANY);

server_addr.sin_port = htons(2222);

rc = bind(server_sock, (struct sockaddr *)&server_addr, sizeof(struct sockaddr_in));

if (rc < 0) {

fprintf(stderr, "bind: %s.\n", strerror(errno));

return -1;

}

listen(server_sock, 5);

/* loop */

event_loop(server_sock);

sock_close(server_sock);

return 0;

}

Basic Usage of Boost MultiIndex Containers

December 28, 2015 by gonwan·0 Comments

Just take a simple note here.
The Boost Multi-index Containers Library provides a class template named multi_index_container which enables the construction of containers maintaining one or more indices with different sorting and access semantics.

#include <string>
#include <ostream>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/tag.hpp>
#include <boost/lambda/lambda.hpp>
using namespace std;
using namespace boost::multi_index;


struct auth
{
    string m_name;
    string m_pass;
    auth(const string &name, const string &pass)
        : m_name(name), m_pass(pass) { }
    bool operator<(const auth &o) const { return m_name < o.m_name; }
    friend ostream &operator<<(ostream &os, const auth &a) { os << "(" << a.m_name << ", " << a.m_pass << ")"; return os; }
};

struct employee
{
    int m_id;
    auth m_auth;
    int m_hire;
    int m_resign;
    employee(int id, const string &name, const string &pass, int hire, int resign)
        : m_id(id), m_auth(name, pass), m_hire(hire), m_resign(resign) { }
    bool operator<(const employee &o) const { return m_id < o.m_id; }
    friend ostream &operator<<(ostream &os, const employee &e) { os << "(" << e.m_id << ", " << e.m_auth << ", " << e.m_hire << ", " << e.m_resign << ")"; return os; }
};


struct auth_t { };

struct change_resign {
    int m_resign;
    change_resign(int r) : m_resign(r) { }
    void operator()(employee &e) { e.m_resign = m_resign; }
};

typedef multi_index_container<
    employee,
    indexed_by<
        /* sort by employee::operator< */
        ordered_unique<identity<employee> >,
        /* sort by less<int> on m_hire */
        ordered_non_unique<member<employee, int, &employee::m_hire> >,
        /* sort by less<auth> on m_auth */
        ordered_non_unique<tag<auth_t>, member<employee, auth, &employee::m_auth> >
    >
> employee_set;

int main()
{
    employee_set es;
    es.insert(employee(1, "555", "555pass", 2012, 0));
    es.insert(employee(2, "444", "444pass", 2011, 0));
    es.insert(employee(3, "333", "333pass", 2013, 0));
    es.insert(employee(4, "222", "222pass", 2015, 0));
    es.insert(employee(5, "555", "555pass", 2014, 0)); /* dup */
    typedef employee_set::nth_index<1>::type hire_index_t;
    typedef employee_set::index<auth_t>::type auth_index_t;
    cout << "Get a view to index #1 (m_hire).." << endl;
    hire_index_t &hire_index = es.get<1>();
    std::copy(hire_index.begin(), hire_index.end(), ostream_iterator<employee>(cout, "\n"));
    cout << "Get a view to index tag auth_t (m_auth).." << endl;
    const auth_index_t &auth_index = es.get<auth_t>();
    std::copy(auth_index.begin(), auth_index.end(), ostream_iterator<employee>(cout, "\n"));
    cout << "Find.." << endl;
    hire_index_t::iterator it = hire_index.find(2015);
#if 0
    employee t = *it;
    t.m_resign = 2048;
    hire_index.replace(it, t);
#else
    hire_index.modify_key(it, boost::lambda::_1=1111);
    int old_resign = it->m_resign;
    hire_index.modify(it, change_resign(2048), change_resign(old_resign));
#endif
    cout << (*it) << endl;
    cout << "Find all.." << endl;
    pair<auth_index_t::const_iterator, auth_index_t::const_iterator> pr = auth_index.equal_range(auth("555", ""));
    std::copy(pr.first, pr.second, ostream_iterator<employee>(cout, "\n"));
    return 0;
}

#include <string>

#include <ostream>

#include <boost/multi_index_container.hpp>

#include <boost/multi_index/ordered_index.hpp>

#include <boost/multi_index/identity.hpp>

#include <boost/multi_index/member.hpp>

#include <boost/multi_index/tag.hpp>

#include <boost/lambda/lambda.hpp>

using namespace std;

using namespace boost::multi_index;

struct auth

{

string m_name;

string m_pass;

auth(const string &name, const string &pass)

: m_name(name), m_pass(pass) { }

bool operator<(const auth &o) const { return m_name < o.m_name; }

friend ostream &operator<<(ostream &os, const auth &a) { os << "(" << a.m_name << ", " << a.m_pass << ")"; return os; }

};

struct employee

{

int m_id;

auth m_auth;

int m_hire;

int m_resign;

employee(int id, const string &name, const string &pass, int hire, int resign)

: m_id(id), m_auth(name, pass), m_hire(hire), m_resign(resign) { }

bool operator<(const employee &o) const { return m_id < o.m_id; }

friend ostream &operator<<(ostream &os, const employee &e) { os << "(" << e.m_id << ", " << e.m_auth << ", " << e.m_hire << ", " << e.m_resign << ")"; return os; }

};

struct auth_t { };

struct change_resign {

int m_resign;

change_resign(int r) : m_resign(r) { }

void operator()(employee &e) { e.m_resign = m_resign; }

};

typedef multi_index_container<

employee,

indexed_by<

/* sort by employee::operator< */

ordered_unique<identity<employee> >,

/* sort by less<int> on m_hire */

ordered_non_unique<member<employee, int, &employee::m_hire> >,

/* sort by less<auth> on m_auth */

ordered_non_unique<tag<auth_t>, member<employee, auth, &employee::m_auth> >

> employee_set;

int main()

{

employee_set es;

es.insert(employee(1, "555", "555pass", 2012, 0));

es.insert(employee(2, "444", "444pass", 2011, 0));

es.insert(employee(3, "333", "333pass", 2013, 0));

es.insert(employee(4, "222", "222pass", 2015, 0));

es.insert(employee(5, "555", "555pass", 2014, 0)); /* dup */

typedef employee_set::nth_index<1>::type hire_index_t;

typedef employee_set::index<auth_t>::type auth_index_t;

cout << "Get a view to index #1 (m_hire).." << endl;

hire_index_t &hire_index = es.get<1>();

std::copy(hire_index.begin(), hire_index.end(), ostream_iterator<employee>(cout, "\n"));

cout << "Get a view to index tag auth_t (m_auth).." << endl;

const auth_index_t &auth_index = es.get<auth_t>();

std::copy(auth_index.begin(), auth_index.end(), ostream_iterator<employee>(cout, "\n"));

cout << "Find.." << endl;

hire_index_t::iterator it = hire_index.find(2015);

#if 0

employee t = *it;

t.m_resign = 2048;

hire_index.replace(it, t);

#else

hire_index.modify_key(it, boost::lambda::_1=1111);

int old_resign = it->m_resign;

hire_index.modify(it, change_resign(2048), change_resign(old_resign));

#endif

cout << (*it) << endl;

cout << "Find all.." << endl;

pair<auth_index_t::const_iterator, auth_index_t::const_iterator> pr = auth_index.equal_range(auth("555", ""));

std::copy(pr.first, pr.second, ostream_iterator<employee>(cout, "\n"));

return 0;

}

Output:

Get a view to index #1 (m_hire)..
(2, (444, 444pass), 2011, 0)
(1, (555, 555pass), 2012, 0)
(3, (333, 333pass), 2013, 0)
(5, (555, 555pass), 2014, 0)
(4, (222, 222pass), 2015, 0)
Get a view to index tag auth_t (m_auth)..
(4, (222, 222pass), 2015, 0)
(3, (333, 333pass), 2013, 0)
(2, (444, 444pass), 2011, 0)
(1, (555, 555pass), 2012, 0)
(5, (555, 555pass), 2014, 0)
Find..
(4, (222, 222pass), 1111, 2048)
Find all..
(1, (555, 555pass), 2012, 0)
(5, (555, 555pass), 2014, 0)

Get a view to index #1 (m_hire)..

(2, (444, 444pass), 2011, 0)

(1, (555, 555pass), 2012, 0)

(3, (333, 333pass), 2013, 0)

(5, (555, 555pass), 2014, 0)

(4, (222, 222pass), 2015, 0)

Get a view to index tag auth_t (m_auth)..

(4, (222, 222pass), 2015, 0)

(3, (333, 333pass), 2013, 0)

(2, (444, 444pass), 2011, 0)

(1, (555, 555pass), 2012, 0)

(5, (555, 555pass), 2014, 0)

Find..

(4, (222, 222pass), 1111, 2048)

Find all..

(1, (555, 555pass), 2012, 0)

(5, (555, 555pass), 2014, 0)

To use with pointer values, only limited change needed as highlighted:

#include <string>
#include <ostream>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/identity.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/tag.hpp>
#include <boost/lambda/lambda.hpp>
using namespace std;
using namespace boost::multi_index;


struct auth
{
    string m_name;
    string m_pass;
    auth(const string &name, const string &pass)
        : m_name(name), m_pass(pass) { }
    bool operator<(const auth &o) const { return m_name < o.m_name; }
    friend ostream &operator<<(ostream &os, const auth &a) { os << "(" << a.m_name << ", " << a.m_pass << ")"; return os; }
};

struct employee
{
    int m_id;
    auth m_auth;
    int m_hire;
    int m_resign;
    employee(int id, const string &name, const string &pass, int hire, int resign)
        : m_id(id), m_auth(name, pass), m_hire(hire), m_resign(resign) { }
    bool operator<(const employee &o) const { return m_id < o.m_id; }
    friend ostream &operator<<(ostream &os, const employee *e) { os << "(" << e->m_id << ", " << e->m_auth << ", " << e->m_hire << ", " << e->m_resign << ")"; return os; }
};


struct auth_t { };

struct change_resign {
    int m_resign;
    change_resign(int r) : m_resign(r) { }
    void operator()(employee *e) { e->m_resign = m_resign; }
};

typedef multi_index_container<
    employee *,
    indexed_by<
        /* sort by employee::operator< */
        ordered_unique<identity<employee> >,
        /* sort by less<int> on m_hire */
        ordered_non_unique<member<employee, int, &employee::m_hire> >,
        /* sort by less<auth> on m_auth */
        ordered_non_unique<tag<auth_t>, member<employee, auth, &employee::m_auth> >
    >
> employee_set;

int main()
{
    employee_set es;
    es.insert(new employee(1, "555", "555pass", 2012, 0));
    es.insert(new employee(2, "444", "444pass", 2011, 0));
    es.insert(new employee(3, "333", "333pass", 2013, 0));
    es.insert(new employee(4, "222", "222pass", 2015, 0));
    es.insert(new employee(5, "555", "555pass", 2014, 0)); /* dup */
    typedef employee_set::nth_index<1>::type hire_index_t;
    typedef employee_set::index<auth_t>::type auth_index_t;
    cout << "Get a view to index #1 (m_hire).." << endl;
    hire_index_t &hire_index = es.get<1>();
    std::copy(hire_index.begin(), hire_index.end(), ostream_iterator<employee *>(cout, "\n"));
    cout << "Get a view to index tag auth_t (m_auth).." << endl;
    const auth_index_t &auth_index = es.get<auth_t>();
    std::copy(auth_index.begin(), auth_index.end(), ostream_iterator<employee *>(cout, "\n"));
    cout << "Find.." << endl;
    hire_index_t::iterator it = hire_index.find(2015);
#if 0
    employee *t = *it;
    t->m_auth.m_name = "888";
    /* must use replace() to notify changes in indexed fields */
    hire_index.replace(it, t);
#else
    hire_index.modify_key(it, boost::lambda::_1=1111);
    int old_resign = (*it)->m_resign;
    hire_index.modify(it, change_resign(2048), change_resign(old_resign));
#endif
    cout << (*it) << endl;
    cout << "Find all.." << endl;
    pair<auth_index_t::const_iterator, auth_index_t::const_iterator> pr = auth_index.equal_range(auth("555", ""));
    std::copy(pr.first, pr.second, ostream_iterator<employee *>(cout, "\n"));
    /* clear */
    for (employee_set::const_iterator it = es.begin(); it != es.end(); ++it) {
        delete *it;
    }
    employee_set().swap(es);
    return 0;
}

#include <string>

#include <ostream>

#include <boost/multi_index_container.hpp>

#include <boost/multi_index/ordered_index.hpp>

#include <boost/multi_index/identity.hpp>

#include <boost/multi_index/member.hpp>

#include <boost/multi_index/tag.hpp>

#include <boost/lambda/lambda.hpp>

using namespace std;

using namespace boost::multi_index;

struct auth

{

string m_name;

string m_pass;

auth(const string &name, const string &pass)

: m_name(name), m_pass(pass) { }

bool operator<(const auth &o) const { return m_name < o.m_name; }

friend ostream &operator<<(ostream &os, const auth &a) { os << "(" << a.m_name << ", " << a.m_pass << ")"; return os; }

};

struct employee

{

int m_id;

auth m_auth;

int m_hire;

int m_resign;

employee(int id, const string &name, const string &pass, int hire, int resign)

: m_id(id), m_auth(name, pass), m_hire(hire), m_resign(resign) { }

bool operator<(const employee &o) const { return m_id < o.m_id; }

friend ostream &operator<<(ostream &os, const employee *e) { os << "(" << e->m_id << ", " << e->m_auth << ", " << e->m_hire << ", " << e->m_resign << ")"; return os; }

};

struct auth_t { };

struct change_resign {

int m_resign;

change_resign(int r) : m_resign(r) { }

void operator()(employee *e) { e->m_resign = m_resign; }

};

typedef multi_index_container<

employee *,

indexed_by<

/* sort by employee::operator< */

ordered_unique<identity<employee> >,

/* sort by less<int> on m_hire */

ordered_non_unique<member<employee, int, &employee::m_hire> >,

/* sort by less<auth> on m_auth */

ordered_non_unique<tag<auth_t>, member<employee, auth, &employee::m_auth> >

> employee_set;

int main()

{

employee_set es;

es.insert(new employee(1, "555", "555pass", 2012, 0));

es.insert(new employee(2, "444", "444pass", 2011, 0));

es.insert(new employee(3, "333", "333pass", 2013, 0));

es.insert(new employee(4, "222", "222pass", 2015, 0));

es.insert(new employee(5, "555", "555pass", 2014, 0)); /* dup */

typedef employee_set::nth_index<1>::type hire_index_t;

typedef employee_set::index<auth_t>::type auth_index_t;

cout << "Get a view to index #1 (m_hire).." << endl;

hire_index_t &hire_index = es.get<1>();

std::copy(hire_index.begin(), hire_index.end(), ostream_iterator<employee *>(cout, "\n"));

cout << "Get a view to index tag auth_t (m_auth).." << endl;

const auth_index_t &auth_index = es.get<auth_t>();

std::copy(auth_index.begin(), auth_index.end(), ostream_iterator<employee *>(cout, "\n"));

cout << "Find.." << endl;

hire_index_t::iterator it = hire_index.find(2015);

#if 0

employee *t = *it;

t->m_auth.m_name = "888";

/* must use replace() to notify changes in indexed fields */

hire_index.replace(it, t);

#else

hire_index.modify_key(it, boost::lambda::_1=1111);

int old_resign = (*it)->m_resign;

hire_index.modify(it, change_resign(2048), change_resign(old_resign));

#endif

cout << (*it) << endl;

cout << "Find all.." << endl;

pair<auth_index_t::const_iterator, auth_index_t::const_iterator> pr = auth_index.equal_range(auth("555", ""));

std::copy(pr.first, pr.second, ostream_iterator<employee *>(cout, "\n"));

/* clear */

for (employee_set::const_iterator it = es.begin(); it != es.end(); ++it) {

delete *it;

}

employee_set().swap(es);

return 0;

}

Spurious Wakeups

November 20, 2014 by gonwan·0 Comments

http://vladimir_prus.blogspot.com/2005/07/spurious-wakeups.html

One of the two basic synchronisation primitives in multithreaded programming is called “condition variables”. Here’s a small example:

bool something_happened;
boost::mutex m;
boost::condition_variable c;
void thread1() {
    boost::mutex::scoped_lock(m);
    while (!something_happened) {
        c.wait(m);
    }
}
void thread2() {
    // do lots of work
    boost::mutex::scoped_lock(m);
    something_happened = true;
    c.notify_one();
}

bool something_happened;

boost::mutex m;

boost::condition_variable c;

void thread1() {

boost::mutex::scoped_lock(m);

while (!something_happened) {

c.wait(m);

}

void thread2() {

// do lots of work

boost::mutex::scoped_lock(m);

something_happened = true;

c.notify_one();

}

Here, the call to “c.wait()” unlocks the mutex (allowing the other thread to eventually lock it), and suspends the calling thread. When another thread calls ‘notify’, the first thread wakes up, locks the mutex again (implicitly, inside ‘wait’), sees that variable is set to ‘true’ and goes on.

But why do we need the while loop, can’t we write:

    if (!something_happened) {
        c.wait(m);
    }

if (!something_happened) {

c.wait(m);

}

We can’t. And the killer reason is that ‘wait’ can return without any ‘notify’ call. That’s called spurious wakeup and is explicitly allowed by POSIX. Essentially, return from ‘wait’ only indicates that the shared data might have changed, so that data must be evaluated again.

Okay, so why this is not fixed yet? The first reason is that nobody wants to fix it. Wrapping call to ‘wait’ in a loop is very desired for several other reasons. But those reasons require explanation, while spurious wakeup is a hammer that can be applied to any first year student without fail.

The second reason is that fixing this is supposed to be hard. Most sources I’ve seen say that fixing that would require very large overhead on certain architectures. Strangely, no details were ever given, which made me wonder if avoiding spurious wakeups is simple, but all the threading experts secretly decided to tell everybody it’s hard.

After asking on comp.programming.thread, I at least know the reason for Linux (thanks to Ben Hutchings). Internally, wait is implemented as a call to the ‘futex’ system call. Each blocking system call on Linux returns abruptly when the process receives a signal — because calling signal handler from kernel call is tricky. What if the signal handler calls some other system function? And a new signal arrives? It’s easy to run out of kernel stack for a process. Exactly because each system call can be interrupted, when glibc calls any blocking function, like ‘read’, it does it in a loop, and if ‘read’ returns EINTR, calls ‘read’ again.

Can the same trick be used to conditions? No, because the moment we return from ‘futex’ call, another thread can send us notification. And since we’re not waiting inside ‘futex’, we’ll miss the notification(A third thread can get it, and change the value of predicate. — gonwan). So, we need to return to the caller, and have it reevaluate the predicate. If another thread indeed set it to true, we’ll break out of the loop.

So much for spurious wakeups on Linux. But I’m still very interested to know what the original reasons were.

==============================
Also see the explanation for spurious wakeups on the linux man page: pthread_cond_signal.
Last note: PulseEvent() in windows(manual-reset) = pthread_cond_signal() in linux, while SetEvent() in windows(auto-reset) = pthread_cond_broadcast() in linux, see here and here. And spurious wakeups are also possible on windows when using condition variables.

Exception Safety with shared_ptr

February 10, 2014 by gonwan·0 Comments

Code snippet:

#include <iostream>
#include <boost/shared_ptr.hpp>

class A {
public:
    A() { std::cout << "in A::A()." << std::endl; }
    ~A() { std::cout << "in A::~A()." << std::endl; }
};

class B {
public:
    B() { std::cout << "in B::B()." << std::endl; throw 1024; }
    ~B() { std::cout << "in B::~B()." << std::endl; }
};

class C {
public:
    C() : m_a(new A), m_b(new B) { }
#ifndef _USE_SHARED_PTR
    ~C() { delete m_b; delete m_a; }
#endif
private:
#ifndef _USE_SHARED_PTR
    A *m_a;
    B *m_b;
#else
    boost::shared_ptr<A> m_a;
    boost::shared_ptr<B> m_b;
#endif
};

int main() {
    try { C c; } catch (...) { }
    return 0;
}

#include <iostream>

#include <boost/shared_ptr.hpp>

class A {

public:

A() { std::cout << "in A::A()." << std::endl; }

~A() { std::cout << "in A::~A()." << std::endl; }

};

class B {

public:

B() { std::cout << "in B::B()." << std::endl; throw 1024; }

~B() { std::cout << "in B::~B()." << std::endl; }

};

class C {

public:

C() : m_a(new A), m_b(new B) { }

#ifndef _USE_SHARED_PTR

~C() { delete m_b; delete m_a; }

#endif

private:

#ifndef _USE_SHARED_PTR

A *m_a;

B *m_b;

#else

boost::shared_ptr<A> m_a;

boost::shared_ptr<B> m_b;

#endif

};

int main() {

try { C c; } catch (...) { }

return 0;

}

Output:

binson@binson-precise:~$ g++ ptr.cpp -o ptr
binson@binson-precise:~$ ./ptr
in A::A().
in B::B().
binson@binson-precise:~$ g++ -D_USE_SHARED_PTR ptr.cpp -o ptr
binson@binson-precise:~$ ./ptr
in A::A().
in B::B().
in A::~A().

binson@binson-precise:~$ g++ ptr.cpp -o ptr

binson@binson-precise:~$ ./ptr

in A::A().

in B::B().

binson@binson-precise:~$ g++ -D_USE_SHARED_PTR ptr.cpp -o ptr

binson@binson-precise:~$ ./ptr

in A::A().

in B::B().

in A::~A().

Exception safety is ensured, when using shared_ptr. Memory allocated by m_a is freed even when an exception is thrown. The trick is: the destructor of class shared_ptr is invoked after the destructor of class C.

Writing UTF-8 String Using ofstream in C++

August 21, 2013 by gonwan·0 Comments

I’ve googled a lot to find the answer. But none really solve the problem simply and gracefully, even on stackoverflow. So we’ll do ourselves here 🙂

Actually, std::string supports operation using multibytes characters. This is the base of our solution:

static const char g_cs[] = "\xE4\xBD\xA0\xE5\xA5\xBD";

bool test_std_string()
{
    ofstream ofs("a.txt");
    ofs << string(g_cs) << endl;
    ofs.close();
    string s;
    ifstream ifs("a.txt");
    ifs >> s;
#if _WIN32
    wstring ws = utf8_to_ucs2(s);
    MessageBoxW(NULL, ws.c_str(), L"test_std_string", MB_OK);
#else
    cout << s << endl;
#endif
    return true;
}

static const char g_cs[] = "\xE4\xBD\xA0\xE5\xA5\xBD";

bool test_std_string()

{

ofstream ofs("a.txt");

ofs << string(g_cs) << endl;

ofs.close();

string s;

ifstream ifs("a.txt");

ifs >> s;

#if _WIN32

wstring ws = utf8_to_ucs2(s);

MessageBoxW(NULL, ws.c_str(), L"test_std_string", MB_OK);

#else

cout << s << endl;

#endif

return true;

}

g_cs is a Chinese word(“你好” which means hello) encoded in UTF-8. The code works under both Windows(WinXP+VS2005) and Linux(Ubuntu12.04+gcc4.6). You may wanna open a.txt to check whether the string is correctly written.

NOTE: Under Linux, we print the string directly since the default console encoding is UTF-8, and we can view the string. While under Window, the console DOES NOT support UTF-8(codepage 65001) encoding. Printing to it simply causes typo. We just convert it to a std::wstring and use MessageBox() API to check the result. I will cover the encoding issue in windows console in my next post, maybe.

I began to investigate the problem, since I cannot find a solution to read/write a UTF-8 string to XML file using boost::property_tree. Actually, it’s a bug and is already fixed in boost 1.47 and later versions. Unfortunately, Ubuntu 12.04 came with boost 1.46.1. When reading non-ASCII characters, some bytes are incorrectly skipped. The failure function is boost::property_tree::detail::rapidxml::internal::get_index(). My test code looks like:

static const char g_xml[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
    "<aaa>\n"
        "<bbb>\xE4\xBD\xA0\xE5\xA5\xBD</bbb>\n"
        "<bbb>\xE7\xA5\x9E\xE9\xA9\xAC</bbb>\n"
    "</aaa>\n";

bool test_boost_ptree()
{
    /* write to file */
    FILE *f = fopen("a.xml", "w");
    fwrite(g_xml, sizeof(g_xml)-1, 1, f);
    fclose(f);
    /* read and modify */
    const char cstr[] = "\xE4\xB8\xB8\xE5\xAD\x90\xE9\x85\xB1";
    try {
        boost::property_tree::ptree pt;
        int flags = boost::property_tree::xml_parser::trim_whitespace;
        boost::property_tree::read_xml("a.xml", pt, flags, std::locale());
        boost::property_tree::ptree pt2 = pt.get_child("aaa").add("bbb", string(cstr));
        boost::property_tree::xml_writer_settings<char> settings(' ', 2);
        boost::property_tree::write_xml("b.xml", pt, std::locale(), settings);
    } catch (boost::property_tree::xml_parser_error &) {
        return false;
    } catch (boost::property_tree::ptree_bad_path &) {
        return false;
    }
    /* read again */
    try {
        boost::property_tree::ptree pt;
        int flags = boost::property_tree::xml_parser::trim_whitespace;
        boost::property_tree::read_xml("b.xml", pt, flags, std::locale());
        string s = pt.get<string>("aaa.bbb");
#if _WIN32
        wstring ws = utf8_to_ucs2(s);
        MessageBoxW(NULL, ws.c_str(), L"test_boost_ptree", MB_OK);
#else
        cout << s << endl;
#endif
    } catch (boost::property_tree::xml_parser_error &) {
        return false;
    } catch (boost::property_tree::ptree_bad_path &) {
        return false;
    }
    return true;
}

static const char g_xml[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"

"<aaa>\n"

"<bbb>\xE4\xBD\xA0\xE5\xA5\xBD</bbb>\n"

"<bbb>\xE7\xA5\x9E\xE9\xA9\xAC</bbb>\n"

"</aaa>\n";

bool test_boost_ptree()

{

/* write to file */

FILE *f = fopen("a.xml", "w");

fwrite(g_xml, sizeof(g_xml)-1, 1, f);

fclose(f);

/* read and modify */

const char cstr[] = "\xE4\xB8\xB8\xE5\xAD\x90\xE9\x85\xB1";

try {

boost::property_tree::ptree pt;

int flags = boost::property_tree::xml_parser::trim_whitespace;

boost::property_tree::read_xml("a.xml", pt, flags, std::locale());

boost::property_tree::ptree pt2 = pt.get_child("aaa").add("bbb", string(cstr));

boost::property_tree::xml_writer_settings<char> settings(' ', 2);

boost::property_tree::write_xml("b.xml", pt, std::locale(), settings);

} catch (boost::property_tree::xml_parser_error &) {

return false;

} catch (boost::property_tree::ptree_bad_path &) {

return false;

}

/* read again */

try {

boost::property_tree::ptree pt;

int flags = boost::property_tree::xml_parser::trim_whitespace;

boost::property_tree::read_xml("b.xml", pt, flags, std::locale());

string s = pt.get<string>("aaa.bbb");

#if _WIN32

wstring ws = utf8_to_ucs2(s);

MessageBoxW(NULL, ws.c_str(), L"test_boost_ptree", MB_OK);

#else

cout << s << endl;

#endif

} catch (boost::property_tree::xml_parser_error &) {

return false;

} catch (boost::property_tree::ptree_bad_path &) {

return false;

}

return true;

}

Almost the same structure with the previous function. And finally the utf8_to_ucs2() function:

#ifdef _WIN32
wstring utf8_to_ucs2(const string &input)
{
    wchar_t *pwc;
    wstring output;
    int len = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), (int)input.length(), NULL, 0);
    pwc = new wchar_t[len+1];
    ZeroMemory(pwc, sizeof(wchar_t)*(len+1));
    MultiByteToWideChar(CP_UTF8, 0, input.c_str(), (int)input.length(), pwc, len+1);
    output = pwc;
    delete pwc;
    return output;
}
#endif

#ifdef _WIN32

wstring utf8_to_ucs2(const string &input)

{

wchar_t *pwc;

wstring output;

int len = MultiByteToWideChar(CP_UTF8, 0, input.c_str(), (int)input.length(), NULL, 0);

pwc = new wchar_t[len+1];

ZeroMemory(pwc, sizeof(wchar_t)*(len+1));

MultiByteToWideChar(CP_UTF8, 0, input.c_str(), (int)input.length(), pwc, len+1);

output = pwc;

delete pwc;

return output;

}

#endif

Please add header files yourselves to make it compile 🙂

0x2B|~0x2B

My broken wings still strong enough to cross the ocean with.

Tag: boost

Coroutines in C++/Boost

Basic Usage of Boost MultiIndex Containers

Spurious Wakeups

Exception Safety with shared_ptr

Writing UTF-8 String Using ofstream in C++