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

"Chris M. Thomasson" <no@spam.invalid> wrote in message
news:yjKOk.682$kd5.147@newsfe01.iad...


ARGHGHGGHGHGHH!

I make two other extreme hardcore RETARDED mistakes! Notice how the
procedure `monitor::broadcast()' fuc%ing calls `pthread_cond_signal()'
instead of `pthread_cond_broadcast()' !!!!!!!!

Also, I misspell Monitor!!!!

DAMNIT!!!

[...]

I am really pissed off now! GRRRR!!! Here is current version that
actually broadcasts!!!:

/* Simple Thread Object
______________________________________________________________*/
#include <pthread.h>

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

class thread_base {
  pthread_t m_tid;
  friend void* thread_entry(void*);
  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::~thread_base() {}

void* thread_entry(void* state) {
  reinterpret_cast<thread_base*>(state)->on_active();
  return 0;
}

template<typename 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<typename T_p1>
  active(T_p1 p1) : T(p1) {
    this->active_run();
  }

  template<typename 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 Monitor
______________________________________________________________*/
class monitor {
  pthread_mutex_t m_mutex;
  pthread_cond_t m_cond;

public:
  monitor() {
    pthread_mutex_init(&m_mutex, NULL);
    pthread_cond_init(&m_cond, NULL);
  }

  ~monitor() {
    pthread_cond_destroy(&m_cond);
    pthread_mutex_destroy(&m_mutex);
  }

  struct lock_guard {
    monitor& m_monitor;

    lock_guard(monitor& monitor_) : m_monitor(monitor_) {
      m_monitor.lock();
    }

    ~lock_guard() {
      m_monitor.unlock();
    }
  };

  void lock() {
    pthread_mutex_lock(&m_mutex);
  }

  void unlock() {
    pthread_mutex_unlock(&m_mutex);
  }

  void wait() {
    pthread_cond_wait(&m_cond, &m_mutex);
  }

  void signal() {
    pthread_cond_signal(&m_cond);
  }

  void broadcast() {
    pthread_cond_broadcast(&m_cond);
  }
};

#define when_x(mp_pred, mp_line) \
  monitor::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 100000
#define BOUND 1000
#define YIELD 4

template<typename T>
struct bounded_buffer : private monitor {
  unsigned const m_max;
  std::deque<T> m_buffer;

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

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

  T pop() {
    T obj;
    when (! m_buffer.empty()) {
      obj = m_buffer.front();
      m_buffer.pop_front();
      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("produced %u\n", i + 1);
      if (! (i % YIELD)) { sched_yield(); }
    }
  }

public:
  producer(bounded_buffer<unsigned>* buffer) : m_buffer(*buffer) {}
};

struct consumer : public thread_base {
  bounded_buffer<unsigned>& m_buffer;

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

public:
  consumer(bounded_buffer<unsigned>* buffer) : m_buffer(*buffer) {}
};

int main(void) {
  {
    bounded_buffer<unsigned> b(BOUND);
    active<producer> p[] = { &b, &b, &b, &b, &b, &b };
    active<consumer> c[] = { &b, &b, &b, &b, &b, &b };
  }

  std::puts("\n\n\n__________________\nhit <ENTER> to exit...");
  std::fflush(stdout);
  std::getchar();
  return 0;
}

SHI%!

;^(.......