a really simple C++ abstraction around pthread_t...

[Chris M. Thomasson]

I use the following technique in all of my C++ projects; here is the example
code with error checking omitted for brevity:
_______________ _______________ _______________ _______________ _____
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>
extern "C" void* thread_entry(vo id*);

class thread_base {
pthread_t m_tid;
friend void* thread_entry(vo id*);
virtual void on_active() = 0;

public:
virtual ~thread_base() = 0;

void active_run() {
pthread_create( &m_tid, NULL, thread_entry, this);
}

void active_join() {
pthread_join(m_ tid, NULL);
}
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
reinterpret_cas t<thread_base*> (state)->on_active();
return 0;
}

template<typena me T>
struct active : public T {
active() : T() {
this->active_run() ;
}

~active() {
this->active_join( );
}

template<typena me T_p1>
active(T_p1 p1) : T(p1) {
this->active_run() ;
}

template<typena me T_p1, typename T_p2>
active(T_p1 p1, T_p2 p2) : T(p1, p2) {
this->active_run() ;
}

// [and on and on for more params...]
};


/* Simple Usage Example
_______________ _______________ _______________ _______________ __*/
#include <string>
#include <cstdio>
class worker : public thread_base {
std::string const m_name;

void on_active() {
std::printf("(% p)->worker(%s)::on _thread_entry() \n",
(void*)this, m_name.c_str()) ;
}

public:
worker(std::str ing const& name)
: m_name(name) {
std::printf("(% p)->worker(%s)::my _thread()\n",
(void*)this, m_name.c_str()) ;
}

~worker() {
std::printf("(% p)->worker(%s)::~m y_thread()\n",
(void*)this, m_name.c_str()) ;
}
};
class another_worker : public thread_base {
unsigned const m_id;
std::string const m_name;

void on_active() {
std::printf("(% p)->my_thread(%u/%s)::on_thread_ entry()\n",
(void*)this, m_id, m_name.c_str()) ;
}

public:
another_worker( unsigned const id, std::string const& name)
: m_id(id), m_name(name) {
}
};
int main(void) {
{
active<workerwo rkers[] = {
"Chris",
"John",
"Jane",
"Steve",
"Richard",
"Lisa"
};

active<another_ workerother_wor kers[] = {
active<another_ worker>(21, "Larry"),
active<another_ worker>(87, "Paul"),
active<another_ worker>(43, "Peter"),
active<another_ worker>(12, "Shelly"),
};
}

std::puts("\n\n \n_____________ _____\nhit <ENTERto exit...");
std::fflush(std out);
std::getchar();
return 0;
}
_______________ _______________ _______________ _______________ _____


I personally like this technique better than Boost. I find it more straight
forward and perhaps more object oriented, the RAII nature of the `active'
helper class does not hurt either. Also, I really do think its more
"efficient" than Boost in the way it creates threads because it does not
copy anything...

IMHO, the really nice thing about it would have to be the `active' helper
class. It allows me to run and join any object from the ctor/dtor that
exposes a common interface of (T::active_run/join). Also, it allows me to
pass a variable number of arguments to the object it wraps directly through
its ctor; this is fairly convenient indeed...
Any suggestions on how I can improve this construct?

[Szabolcs Ferenczi]

On Oct 30, 10:39*pm, "Chris M. Thomasson" <[e-mail] lidwrote:

I use the following technique in all of my C++ projects; here is the example
code with error checking omitted for brevity:
_______________ _______________ _______________ _______________ _____
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>

extern "C" void* thread_entry(vo id*);

class thread_base {
* pthread_t m_tid;
* friend void* thread_entry(vo id*);
* virtual void on_active() = 0;

public:
* virtual ~thread_base() = 0;

* void active_run() {
* * pthread_create( &m_tid, NULL, thread_entry, this);
* }

* void active_join() {
* * pthread_join(m_ tid, NULL);
* }

};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
* reinterpret_cas t<thread_base*> (state)->on_active();
* return 0;

}

template<typena me T>
struct active : public T {
* active() : T() {
* * this->active_run() ;
* }

* ~active() {
* * this->active_join( );
* }

* template<typena me T_p1>
* active(T_p1 p1) : T(p1) {
* * this->active_run() ;
* }

* template<typena me T_p1, typename T_p2>
* active(T_p1 p1, T_p2 p2) : T(p1, p2) {
* * this->active_run() ;
* }

* // [and on and on for more params...]

};

/* Simple Usage Example
_______________ _______________ _______________ _______________ __*/
#include <string>
#include <cstdio>

class worker : public thread_base {
* std::string const m_name;

* void on_active() {
* * std::printf("(% p)->worker(%s)::on _thread_entry() \n",
* * * (void*)this, m_name.c_str()) ;
* }

public:
* worker(std::str ing const& name)
* * : m_name(name) {
* * std::printf("(% p)->worker(%s)::my _thread()\n",
* * * (void*)this, m_name.c_str()) ;
* }

* ~worker() {
* * std::printf("(% p)->worker(%s)::~m y_thread()\n",
* * *(void*)this, m_name.c_str()) ;
* }

};

class another_worker : public thread_base {
* unsigned const m_id;
* std::string const m_name;

* void on_active() {
* * std::printf("(% p)->my_thread(%u/%s)::on_thread_ entry()\n",
* * * (void*)this, m_id, m_name.c_str()) ;
* }

public:
* another_worker( unsigned const id, std::string const& name)
* * : m_id(id), m_name(name) {
* }

};

int main(void) {
* {
* * active<workerwo rkers[] = {
* * * "Chris",
* * * "John",
* * * "Jane",
* * * "Steve",
* * * "Richard",
* * * "Lisa"
* * };

* * active<another_ workerother_wor kers[] = {
* * * active<another_ worker>(21, "Larry"),
* * * active<another_ worker>(87, "Paul"),
* * * active<another_ worker>(43, "Peter"),
* * * active<another_ worker>(12, "Shelly"),
* * };
* }

* std::puts("\n\n \n_____________ _____\nhit <ENTERto exit...");
* std::fflush(std out);
* std::getchar();
* return 0;}

_______________ _______________ _______________ _______________ _____

I personally like this technique better than Boost. I find it more straight
forward and perhaps more object oriented, the RAII nature of the `active'
helper class does not hurt either. Also, I really do think its more
"efficient" than Boost in the way it creates threads because it does not
copy anything...

IMHO, the really nice thing about it would have to be the `active' helper
class. It allows me to run and join any object from the ctor/dtor that
exposes a common interface of (T::active_run/join). Also, it allows me to
pass a variable number of arguments to the object it wraps directly through
its ctor; this is fairly convenient indeed...

Any suggestions on how I can improve this construct?

Now it is better that you have taken the advice about the terminology
(active):

http://groups.google.com/group/comp....915b5211cce641

Best Regards,
Szabolcs

[Chris M. Thomasson]

"Szabolcs Ferenczi" <sz************ ***@gmail.comwr ote in message
news:de******** *************** ***********@u29 g2000pro.google groups.com...
On Oct 30, 10:39 pm, "Chris M. Thomasson" <[e-mail] lidwrote:

I use the following technique in all of my C++ projects; here is the
example
code with error checking omitted for brevity:
_______________ _______________ _______________ _______________ _____

[...]

_______________ _______________ _______________ _______________ _____

I personally like this technique better than Boost. I find it more
straight
forward and perhaps more object oriented, the RAII nature of the
`active'
helper class does not hurt either. Also, I really do think its more
"efficient" than Boost in the way it creates threads because it does not
copy anything...

IMHO, the really nice thing about it would have to be the `active'
helper
class. It allows me to run and join any object from the ctor/dtor that
exposes a common interface of (T::active_run/join). Also, it allows me
to
pass a variable number of arguments to the object it wraps directly
through
its ctor; this is fairly convenient indeed...

Any suggestions on how I can improve this construct?

Now it is better that you have taken the advice about the terminology
(active):

http://groups.google.com/group/comp....915b5211cce641

Yeah; I think your right.

[Chris M. Thomasson]

"Chris M. Thomasson" <[e-mail] dwrote in message
news:dI******** ****@newsfe01.i ad...

>I use the following technique in all of my C++ projects; here is the
example code with error checking omitted for brevity:
_______________ _______________ _______________ _______________ _____

[...]

_______________ _______________ _______________ _______________ _____

[...]

Any suggestions on how I can improve this construct?

One addition I forgot to add would be creating an explict `guard' helper
object within the `active' helper object so that one can create objects and
intervene between its ctor and when it actually gets ran... Here is full
example code showing this moment:
_______________ _______________ _______________ _______________ _____
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>
extern "C" void* thread_entry(vo id*);

class thread_base {
pthread_t m_tid;
friend void* thread_entry(vo id*);
virtual void on_active() = 0;

public:
virtual ~thread_base() = 0;

void active_run() {
pthread_create( &m_tid, NULL, thread_entry, this);
}

void active_join() {
pthread_join(m_ tid, NULL);
}
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
reinterpret_cas t<thread_base*> (state)->on_active();
return 0;
}
template<typena me T>
struct active : public T {
struct guard {
T& m_object;

guard(T& object) : m_object(object ) {
m_object.active _run();
}

~guard() {
m_object.active _join();
}
};

active() : T() {
this->active_run() ;
}

~active() {
this->active_join( );
}

template<typena me T_p1>
active(T_p1 p1) : T(p1) {
this->active_run() ;
}

template<typena me T_p1, typename T_p2>
active(T_p1 p1, T_p2 p2) : T(p1, p2) {
this->active_run() ;
}

// [and on and on for more params...]
};


/* Simple Usage Example
_______________ _______________ _______________ _______________ __*/
#include <string>
#include <cstdio>
class worker : public thread_base {
std::string const m_name;

void on_active() {
std::printf("(% p)->worker(%s)::on _active()\n",
(void*)this, m_name.c_str()) ;
}

public:
worker(std::str ing const& name)
: m_name(name) {
std::printf("(% p)->worker(%s)::my _thread()\n",
(void*)this, m_name.c_str()) ;
}

~worker() {
std::printf("(% p)->worker(%s)::~m y_thread()\n",
(void*)this, m_name.c_str()) ;
}
};
class another_worker : public thread_base {
unsigned const m_id;
std::string const m_name;

void on_active() {
std::printf("(% p)->another_worker (%u/%s)::on_active( )\n",
(void*)this, m_id, m_name.c_str()) ;
}

public:
another_worker( unsigned const id, std::string const& name)
: m_id(id), m_name(name) {
}
};
int main(void) {
{
worker w1("Amy");
worker w2("Kim");
worker w3("Chris");
another_worker aw1(123, "Kelly");
another_worker aw2(12345, "Tim");
another_worker aw3(87676, "John");

active<thread_b ase>::guard w12_aw12[] = {
w1, w2, w3,
aw1, aw2, aw3
};

active<workerwo rkers[] = {
"Jim",
"Dave",
"Regis"
};

active<another_ workerother_wor kers[] = {
active<another_ worker>(999, "Jane"),
active<another_ worker>(888, "Ben"),
active<another_ worker>(777, "Larry")
};
}

std::puts("\n\n \n_____________ _____\nhit <ENTERto exit...");
std::fflush(std out);
std::getchar();
return 0;
}
_______________ _______________ _______________ _______________ _____


Take notice of the following code snippet residing within main:
worker w1("Amy");
worker w2("Kim");
worker w3("Chris");
another_worker aw1(123, "Kelly");
another_worker aw2(12345, "Tim");
another_worker aw3(87676, "John");

active<thread_b ase>::guard w12_aw12[] = {
w1, w2, w3,
aw1, aw2, aw3
};
This shows how one can make use of the guard object. The objects are fully
constructed, and they allow you do go ahead and do whatever you need to do
with them _before_ you actually run/join them. This can be a very convenient
ability.

[Adem]

"Chris M. Thomasson" wrote

"Chris M. Thomasson" wrote

I use the following technique in all of my C++ projects; here is the
example code with error checking omitted for brevity:

[...]

Any suggestions on how I can improve this construct?

One addition I forgot to add would be creating an explict `guard' helper
object within the `active' helper object so that one can create objects and
intervene between its ctor and when it actually gets ran... Here is full
example code showing this moment:
_______________ _______________ _______________ _______________ _____
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>
extern "C" void* thread_entry(vo id*);

class thread_base {
pthread_t m_tid;
friend void* thread_entry(vo id*);
virtual void on_active() = 0;

public:
virtual ~thread_base() = 0;

void active_run() {
pthread_create( &m_tid, NULL, thread_entry, this);
}

void active_join() {
pthread_join(m_ tid, NULL);
}
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
reinterpret_cas t<thread_base*> (state)->on_active();
return 0;
}
template<typena me T>
struct active : public T {
struct guard {
T& m_object;

guard(T& object) : m_object(object ) {
m_object.active _run();
}

~guard() {
m_object.active _join();
}
};

active() : T() {
this->active_run() ;
}

<snip>

Hmm. is it ok to stay within the ctor for the whole
duration of the lifetime of the object?
IMO the ctor should be used only for initializing the object,
but not for executing or calling the "main loop" of the object
because the object is fully created only after the ctor has finished,
isn't it?

[Chris M. Thomasson]

"Adem" <fo***********@ alicewho.comwro te in message
news:ge******** **@aioe.org...

"Chris M. Thomasson" wrote

[...]

>template<typen ame T>
struct active : public T {
struct guard {
T& m_object;

guard(T& object) : m_object(object ) {
m_object.active _run();
}

~guard() {
m_object.active _join();
}
};

active() : T() {

// at this point, T is constructed.

> this->active_run() ;

// the procedure above only concerns T.

> }

<snip>

Hmm. is it ok to stay within the ctor for the whole
duration of the lifetime of the object?

In this case it is because the object `T' is fully constructed before its
`active_run' procedure is invoked.

IMO the ctor should be used only for initializing the object,
but not for executing or calling the "main loop" of the object
because the object is fully created only after the ctor has finished,
isn't it?

Normally your correct. However, the `active' object has nothing to do with
the "main loop" of the object it wraps. See following discussion for further
context:

http://groups.google.com/group/comp....cae1851bb5f215

The OP of that thread was trying to start the thread within the ctor of the
threading base-class. This invokes a race-condition such that the derived
class can be called without its ctor being completed. The `active' helper
template gets around that by automating the calls to `active_run/join' on a
completely formed object T.

[Szabolcs Ferenczi]

On Oct 31, 3:40*pm, "Adem" <for-usenet...@alice who.comwrote:

"Chris M. Thomasson" wrote

"Chris M. Thomasson" wrote

>I use the following technique in all of my C++ projects; here is the
>example code with error checking omitted for brevity:

[...]

Any suggestions on how I can improve this construct?

One addition I forgot to add would be creating an explict `guard' helper
object within the `active' helper object so that one can create objectsand
intervene between its ctor and when it actually gets ran... Here is full
example code showing this moment:
_______________ _______________ _______________ _______________ _____
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>

extern "C" void* thread_entry(vo id*);

class thread_base {
* pthread_t m_tid;
* friend void* thread_entry(vo id*);
* virtual void on_active() = 0;

public:
* virtual ~thread_base() = 0;

* void active_run() {
* * pthread_create( &m_tid, NULL, thread_entry, this);
* }

* void active_join() {
* * pthread_join(m_ tid, NULL);
* }
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
* reinterpret_cas t<thread_base*> (state)->on_active();
* return 0;
}

template<typena me T>
struct active : public T {
* struct guard {
* * T& m_object;

* * guard(T& object) : m_object(object ) {
* * * m_object.active _run();
* * }

* * ~guard() {
* * * m_object.active _join();
* * }
* };

* active() : T() {
* * this->active_run() ;
* }

<snip>

--

Hmm. is it ok to stay within the ctor for the whole
duration of the lifetime of the object?

It does not stay within the constructor since the constructor
completes after starting a thread.

IMO the ctor should be used only for initializing the object,

That is what is happening. Part of the initialisation is launching a
thread.

but not for executing or calling the "main loop" of the object

The C++ model allows any method calls from the constructor.

12.6.2.9
"Member functions (including virtual member functions, 10.3) can be
called for an object under construction."
http://www.open-std.org/jtc1/sc22/wg...2008/n2798.pdf

because the object is fully created only after the ctor has finished,
isn't it?

Yes, it is. In this case the object is fully constructed since the
thread is started in the wrapper after the object has been fully
constructed.

If you are interested in the arguments and counter arguments, you can
check the discussion thread where this construction has emerged:

"What's the connection between objects and threads?"
http://groups.google.com/group/comp....cae1851bb5f215

Best Regards,
Szabolcs

[Szabolcs Ferenczi]

On Oct 30, 10:39*pm, "Chris M. Thomasson" <[e-mail] lidwrote:

Any suggestions on how I can improve this construct?

I think this construction is good enough for the moment. Now we should
turn to enhancing the communication part for shared objects in C++0x.

You know that Boost provides the scoped lock which has some advantage
over the explicit lock/unlock in Pthreads.

Furthermore, C++0x includes already some higher level wrapper
construct for making the wait for condition variables more natural or
user friendly. I refer to the wait wrapper, which expects the
predicate:

<quote>
template <class Predicate>
void wait(unique_loc k<mutex>& lock, Predicate pred);
Effects:
As if:
while (!pred())
wait(lock);
</quote>
http://www.open-std.org/jtc1/sc22/wg...008/n2497.html
</quote>

Actually, this wrapper could be combined with the scoped lock to get a
very high level construction in C++0x.

Well, ideally if they would dear to introduce some keywords in C++0x,
a bounded buffer could be expressed something like this.

template< typename T >
monitor class BoundedBuffer {
const unsigned int m_max;
std::deque<Tb;
public:
BoundedBuffer(c onst int n) : m_max(n) {}
void put(const T n) {
when (b.size() < m_max) {
b.push_back(n);
}
}
T get() {
T aux;
when (!b.empty()) {
aux = b.front();
b.pop_front();
}
return aux;
}
}

However, neither the `monitor' nor the `when' is not going to be
introduced in C++0x. The `when' would have the semantics of the
Conditional Critical Region.

Actually, something similar could be achieved with higher level
wrapper constructions that would result in program fragments like this
(I am not sure about the syntax, I did a simple transformation there):

template< typename T >
class BoundedBuffer : public Monitor {
const unsigned int m_max;
std::deque<Tb;
public:
BoundedBuffer(c onst int n) : m_max(n) {}
void put(const T n) {
{ When guard(b.size() < m_max);
b.push_back(n);
}
}
T get() {
T aux;
{ When guard(!b.empty( ));
aux = b.front();
b.pop_front();
}
return aux;
}
}

Here the super class would contain the necessary harness (mutex,
condvar) and the RAII object named `guard' could be similar to the
Boost scoped lock, it would provide locking and unlocking but in
addition it would wait in the constructor until the predicate is
satisfied. Something like this:

class When {
....
public:
When(...) {
// lock
// cv.wait(&lock, pred);
}
~When() {
// cv.broadcast
// unlock
}
};

The question is how would you hack the classes `Monitor' and `When' so
that active objects could be combined with this kind of monitor data
structure to complete the canonical example of producers-consumers.
Forget about efficiency concerns for now.

Best Regards,
Szabolcs

[Chris M. Thomasson]

"Szabolcs Ferenczi" <sz************ ***@gmail.comwr ote in message
news:83******** *************** ***********@o4g 2000pra.googleg roups.com...
On Oct 30, 10:39 pm, "Chris M. Thomasson" <[e-mail] lidwrote:

Any suggestions on how I can improve this construct?

I think this construction is good enough for the moment. Now we should
turn to enhancing the communication part for shared objects in C++0x.

Okay.

[...]

The question is how would you hack the classes `Monitor' and `When' so
that active objects could be combined with this kind of monitor data
structure to complete the canonical example of producers-consumers.
Forget about efficiency concerns for now.

Here is a heck of a hack, in the form of a fully working program, for you
take a look at Szabolcs:
_______________ _______________ _______________ _______________ ___________
/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>
extern "C" void* thread_entry(vo id*);

class thread_base {
pthread_t m_tid;
friend void* thread_entry(vo id*);
virtual void on_active() = 0;

public:
virtual ~thread_base() = 0;

void active_run() {
pthread_create( &m_tid, NULL, thread_entry, this);
}

void active_join() {
pthread_join(m_ tid, NULL);
}
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
reinterpret_cas t<thread_base*> (state)->on_active();
return 0;
}
template<typena me T>
struct active : public T {
struct guard {
T& m_object;

guard(T& object) : m_object(object ) {
m_object.active _run();
}

~guard() {
m_object.active _join();
}
};

active() : T() {
this->active_run() ;
}

~active() {
this->active_join( );
}

template<typena me T_p1>
active(T_p1 p1) : T(p1) {
this->active_run() ;
}

template<typena me T_p1, typename T_p2>
active(T_p1 p1, T_p2 p2) : T(p1, p2) {
this->active_run() ;
}

// [and on and on for more params...]
};
/* Simple Moniter
_______________ _______________ _______________ _______________ __*/
class moniter {
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;

public:
moniter() {
pthread_mutex_i nit(&m_mutex, NULL);
pthread_cond_in it(&m_cond, NULL);
}

~moniter() {
pthread_cond_de stroy(&m_cond);
pthread_mutex_d estroy(&m_mutex );
}

struct lock_guard {
moniter& m_moniter;

lock_guard(moni ter& moniter_) : m_moniter(monit er_) {
m_moniter.lock( );
}

~lock_guard() {
m_moniter.unloc k();
}
};

void lock() {
pthread_mutex_l ock(&m_mutex);
}

void unlock() {
pthread_mutex_u nlock(&m_mutex) ;
}

void wait() {
pthread_cond_wa it(&m_cond, &m_mutex);
}

void signal() {
pthread_cond_si gnal(&m_cond);
}

void broadcast() {
pthread_cond_si gnal(&m_cond);
}
};
#define when_x(mp_pred, mp_line) \
lock_guard guard_##mp_line (*this); \
while (! (mp_pred)) this->wait();

#define when(mp_pred) when_x(mp_pred, __LINE__)




/* Simple Usage Example
_______________ _______________ _______________ _______________ __*/
#include <cstdio>
#include <deque>
#define PRODUCE 10000
#define BOUND 100
#define YIELD 2
template<typena me T>
struct bounded_buffer : public moniter {
unsigned const m_max;
std::deque<Tm_b uffer;

public:
bounded_buffer( unsigned const max_) : m_max(max_) {}

void push(T const& obj) {
when (m_buffer.size( ) < m_max) {
m_buffer.push_b ack(obj);
signal();
}
}

T pop() {
T obj;
when (! m_buffer.empty( )) {
obj = m_buffer.front( );
m_buffer.pop_fr ont();
}
return obj;
}
};
class producer : public thread_base {
bounded_buffer< unsigned>& m_buffer;

void on_active() {
for (unsigned i = 0; i < PRODUCE; ++i) {
m_buffer.push(i + 1);
std::printf("pr oduced %u\n", i + 1);
if (! (i % YIELD)) { sched_yield(); }
}
}

public:
producer(bounde d_buffer<unsign ed>* buffer) : m_buffer(*buffe r) {}
};
struct consumer : public thread_base {
bounded_buffer< unsigned>& m_buffer;

void on_active() {
unsigned i;
do {
i = m_buffer.pop();
std::printf("co nsumed %u\n", i);
if (! (i % YIELD)) { sched_yield(); }
} while (i != PRODUCE);
}

public:
consumer(bounde d_buffer<unsign ed>* buffer) : m_buffer(*buffe r) {}
};


int main(void) {
{
bounded_buffer< unsignedb(BOUND );
active<producer p(&b);
active<consumer c(&b);
}

std::puts("\n\n \n_____________ _____\nhit <ENTERto exit...");
std::fflush(std out);
std::getchar();
return 0;
}
_______________ _______________ _______________ _______________ ___________



Please take notice of the following class, which compiles fine:
template<typena me T>
struct bounded_buffer : public moniter {
unsigned const m_max;
std::deque<Tm_b uffer;

public:
bounded_buffer( unsigned const max_) : m_max(max_) {}

void push(T const& obj) {
when (m_buffer.size( ) < m_max) {
m_buffer.push_b ack(obj);
signal();
}
}

T pop() {
T obj;
when (! m_buffer.empty( )) {
obj = m_buffer.front( );
m_buffer.pop_fr ont();
}
return obj;
}
};


Well, is that kind of what you had in mind? I make this possible by hacking
the following macro together:
#define when_x(mp_pred, mp_line) \
lock_guard guard_##mp_line (*this); \
while (! (mp_pred)) this->wait();

#define when(mp_pred) when_x(mp_pred, __LINE__)


It works, but its a heck of a hack! ;^D

Anyway, what do you think of this approach? I add my own "keyword".. . lol.

[Chris M. Thomasson]

of course I have created a possible DEADLOCK condition! I totally forgot to
have the bounded_buffer signal/broadcast after it pops something! Here is
the FIXED version:


/* Simple Thread Object
_______________ _______________ _______________ _______________ __*/
#include <pthread.h>
extern "C" void* thread_entry(vo id*);

class thread_base {
pthread_t m_tid;
friend void* thread_entry(vo id*);
virtual void on_active() = 0;

public:
virtual ~thread_base() = 0;

void active_run() {
pthread_create( &m_tid, NULL, thread_entry, this);
}

void active_join() {
pthread_join(m_ tid, NULL);
}
};

thread_base::~t hread_base() {}

void* thread_entry(vo id* state) {
reinterpret_cas t<thread_base*> (state)->on_active();
return 0;
}
template<typena me T>
struct active : public T {
struct guard {
T& m_object;

guard(T& object) : m_object(object ) {
m_object.active _run();
}

~guard() {
m_object.active _join();
}
};

active() : T() {
this->active_run() ;
}

~active() {
this->active_join( );
}

template<typena me T_p1>
active(T_p1 p1) : T(p1) {
this->active_run() ;
}

template<typena me T_p1, typename T_p2>
active(T_p1 p1, T_p2 p2) : T(p1, p2) {
this->active_run() ;
}

// [and on and on for more params...]
};
/* Simple Moniter
_______________ _______________ _______________ _______________ __*/
class moniter {
pthread_mutex_t m_mutex;
pthread_cond_t m_cond;

public:
moniter() {
pthread_mutex_i nit(&m_mutex, NULL);
pthread_cond_in it(&m_cond, NULL);
}

~moniter() {
pthread_cond_de stroy(&m_cond);
pthread_mutex_d estroy(&m_mutex );
}

struct lock_guard {
moniter& m_moniter;

lock_guard(moni ter& moniter_) : m_moniter(monit er_) {
m_moniter.lock( );
}

~lock_guard() {
m_moniter.unloc k();
}
};

void lock() {
pthread_mutex_l ock(&m_mutex);
}

void unlock() {
pthread_mutex_u nlock(&m_mutex) ;
}

void wait() {
pthread_cond_wa it(&m_cond, &m_mutex);
}

void signal() {
pthread_cond_si gnal(&m_cond);
}

void broadcast() {
pthread_cond_si gnal(&m_cond);
}
};
#define when_x(mp_pred, mp_line) \
lock_guard guard_##mp_line (*this); \
while (! (mp_pred)) this->wait();

#define when(mp_pred) when_x(mp_pred, __LINE__)




/* Simple Usage Example
_______________ _______________ _______________ _______________ __*/
#include <cstdio>
#include <deque>
#define PRODUCE 10000
#define BOUND 100
#define YIELD 2
template<typena me T>
struct bounded_buffer : public moniter {
unsigned const m_max;
std::deque<Tm_b uffer;

public:
bounded_buffer( unsigned const max_) : m_max(max_) {}

void push(T const& obj) {
when (m_buffer.size( ) < m_max) {
m_buffer.push_b ack(obj);
broadcast();
}
}

T pop() {
T obj;
when (! m_buffer.empty( )) {
obj = m_buffer.front( );
m_buffer.pop_fr ont();
broadcast();
}
return obj;
}
};
class producer : public thread_base {
bounded_buffer< unsigned>& m_buffer;

void on_active() {
for (unsigned i = 0; i < PRODUCE; ++i) {
m_buffer.push(i + 1);
std::printf("pr oduced %u\n", i + 1);
if (! (i % YIELD)) { sched_yield(); }
}
}

public:
producer(bounde d_buffer<unsign ed>* buffer) : m_buffer(*buffe r) {}
};
struct consumer : public thread_base {
bounded_buffer< unsigned>& m_buffer;

void on_active() {
unsigned i;
do {
i = m_buffer.pop();
std::printf("co nsumed %u\n", i);
if (! (i % YIELD)) { sched_yield(); }
} while (i != PRODUCE);
}

public:
consumer(bounde d_buffer<unsign ed>* buffer) : m_buffer(*buffe r) {}
};


int main(void) {
{
bounded_buffer< unsignedb(BOUND );
active<producer p(&b);
active<consumer c(&b);
}

std::puts("\n\n \n_____________ _____\nhit <ENTERto exit...");
std::fflush(std out);
std::getchar();
return 0;
}


I am VERY sorry for this boneheaded mistake!!! OUCH!!!! BTW, the reason I
broadcast is so the bounded_buffer class can be used by multiple producers
and consumers.