#
# USRP - Universal Software Radio Peripheral
#
-# Copyright (C) 2003,2004,2006,2007,2008,2009 Free Software Foundation, Inc.
+# Copyright (C) 2003,2004,2006,2007,2008,2009,2010 Free Software Foundation, Inc.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
$(BOOST_THREAD_LIB) \
../misc/libmisc.la
-# darwin fusb requires omnithreads
+# darwin fusb requires gruel (for threading)
if FUSB_TECH_darwin
-AM_CPPFLAGS = $(common_INCLUDES) $(OMNITHREAD_INCLUDES) $(BOOST_CPPFLAGS) $(WITH_INCLUDES)
-libusrp_la_LIBADD = $(libusrp_la_common_LIBADD) $(OMNITHREAD_LA)
+AM_CPPFLAGS = $(common_INCLUDES) $(GRUEL_INCLUDES) $(BOOST_CPPFLAGS) $(WITH_INCLUDES)
+libusrp_la_LIBADD = $(libusrp_la_common_LIBADD) $(GRUEL_LA)
libusrp_la_LDFLAGS = $(libusrp_la_common_LDFLAGS) -framework CoreFoundation
else
AM_CPPFLAGS = $(common_INCLUDES) $(BOOST_CPPFLAGS) $(WITH_INCLUDES)
circular_buffer.h \
circular_linked_list.h \
darwin_libusb.h \
- mld_threads.h \
usrp_prims_libusb0.cc
/* -*- c++ -*- */
/*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio.
*
#ifndef _CIRCULAR_BUFFER_H_
#define _CIRCULAR_BUFFER_H_
-#include "mld_threads.h"
+#include <gruel/thread.h>
#include <iostream>
#include <stdexcept>
#define DEBUG(X) do{} while(0);
#endif
-template <class T> class circular_buffer
+template <class T>
+class circular_buffer
{
private:
// the buffer to use
size_t d_n_avail_write_I, d_n_avail_read_I;
// stuff to control access to class internals
- mld_mutex_ptr d_internal;
- mld_condition_ptr d_readBlock, d_writeBlock;
+ gruel::mutex* d_internal;
+ gruel::condition_variable* d_readBlock;
+ gruel::condition_variable* d_writeBlock;
// booleans to decide how to control reading, writing, and aborting
bool d_doWriteBlock, d_doFullRead, d_doAbort;
};
inline size_t n_avail_write_items () {
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
size_t retVal = d_n_avail_write_I;
- d_internal->unlock ();
return (retVal);
};
inline size_t n_avail_read_items () {
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
size_t retVal = d_n_avail_read_I;
- d_internal->unlock ();
return (retVal);
};
// create a mutex to handle contention of shared resources;
// any routine needed access to shared resources uses lock()
// before doing anything, then unlock() when finished.
- d_internal = new mld_mutex ();
+ d_internal = new gruel::mutex ();
// link the internal mutex to the read and write conditions;
// when wait() is called, the internal mutex will automatically
- // be unlock()'ed. Upon return (from a signal() to the condition),
+ // be unlock()'ed. Upon return (from a notify_one() to the condition),
// the internal mutex will be lock()'ed.
- d_readBlock = new mld_condition (d_internal);
- d_writeBlock = new mld_condition (d_internal);
+ d_readBlock = new gruel::condition_variable ();
+ d_writeBlock = new gruel::condition_variable ();
};
/*
if (!buf)
throw std::runtime_error ("circular_buffer::enqueue(): "
"input buffer is NULL.\n");
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
if (d_doAbort) {
- d_internal->unlock ();
return (2);
}
// set the return value to 1: success; change if needed
if (d_doWriteBlock) {
while (bufLen_I > d_n_avail_write_I) {
DEBUG (std::cerr << "enqueue: #len > #a, waiting." << std::endl);
- // wait will automatically unlock() the internal mutex
- d_writeBlock->wait ();
- // and lock() it here.
+ // wait; will automatically unlock() the internal mutex via
+ // the scoped lock
+ d_writeBlock->wait (l);
+ // and auto re-lock() it here.
if (d_doAbort) {
- d_internal->unlock ();
DEBUG (std::cerr << "enqueue: #len > #a, aborting." << std::endl);
return (2);
}
d_writeNdx_I += n_now_I;
d_n_avail_read_I += bufLen_I;
d_n_avail_write_I -= bufLen_I;
- d_readBlock->signal ();
- d_internal->unlock ();
+ d_readBlock->notify_one ();
return (retval);
};
throw std::runtime_error ("circular_buffer::dequeue()");
}
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
if (d_doAbort) {
- d_internal->unlock ();
return (2);
}
if (d_doFullRead) {
while (d_n_avail_read_I < l_bufLen_I) {
DEBUG (std::cerr << "dequeue: #a < #len, waiting." << std::endl);
- // wait will automatically unlock() the internal mutex
- d_readBlock->wait ();
- // and lock() it here.
+ // wait; will automatically unlock() the internal mutex via
+ // the scoped lock
+ d_readBlock->wait (l);
+ // and re-lock() it here.
if (d_doAbort) {
- d_internal->unlock ();
DEBUG (std::cerr << "dequeue: #a < #len, aborting." << std::endl);
return (2);
}
} else {
while (d_n_avail_read_I == 0) {
DEBUG (std::cerr << "dequeue: #a == 0, waiting." << std::endl);
- // wait will automatically unlock() the internal mutex
- d_readBlock->wait ();
- // and lock() it here.
+ // wait; will automatically unlock() the internal mutex via
+ // the scoped lock
+ d_readBlock->wait (l);
+ // and re-lock() it here.
if (d_doAbort) {
- d_internal->unlock ();
DEBUG (std::cerr << "dequeue: #a == 0, aborting." << std::endl);
return (2);
}
*bufLen_I = l_bufLen_I;
d_n_avail_read_I -= l_bufLen_I;
d_n_avail_write_I += l_bufLen_I;
- d_writeBlock->signal ();
- d_internal->unlock ();
+ d_writeBlock->notify_one ();
return (1);
};
void abort () {
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
d_doAbort = true;
- d_writeBlock->signal ();
- d_readBlock->signal ();
- d_internal->unlock ();
+ d_writeBlock->notify_one ();
+ d_readBlock->notify_one ();
};
};
/* -*- c++ -*- */
/*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio.
*
#ifndef _CIRCULAR_LINKED_LIST_H_
#define _CIRCULAR_LINKED_LIST_H_
-#include <mld_threads.h>
+#include <gruel/thread.h>
#include <stdexcept>
#define __INLINE__ inline
private:
s_node_ptr d_current, d_iterate, d_available, d_inUse;
size_t d_n_nodes, d_n_used;
- mld_mutex_ptr d_internal;
- mld_condition_ptr d_ioBlock;
+ gruel::mutex* d_internal;
+ gruel::condition_variable* d_ioBlock;
public:
circular_linked_list (size_t n_nodes) {
}
}
d_available = d_current = l_prev;
- d_ioBlock = new mld_condition ();
- d_internal = d_ioBlock->mutex ();
+ d_ioBlock = new gruel::condition_variable ();
+ d_internal = new gruel::mutex ();
};
~circular_linked_list () {
}
delete d_ioBlock;
d_ioBlock = NULL;
+ delete d_internal;
+ d_internal = NULL;
d_available = d_inUse = d_iterate = d_current = NULL;
d_n_used = d_n_nodes = 0;
};
s_node_ptr find_next_available_node () {
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
// find an available node
s_node_ptr l_node = d_available;
DEBUG (std::cerr << "w ");
while (! l_node) {
DEBUG (std::cerr << "x" << std::endl);
// the ioBlock condition will automatically unlock() d_internal
- d_ioBlock->wait ();
+ d_ioBlock->wait (l);
// and lock() is here
DEBUG (std::cerr << "y" << std::endl);
l_node = d_available;
l_node->insert_before (d_inUse);
d_n_used++;
l_node->set_not_available ();
- d_internal->unlock ();
return (l_node);
};
void make_node_available (s_node_ptr l_node) {
if (!l_node) return;
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
DEBUG (std::cerr << "::m_n_a: #u = " << num_used()
<< ", node = " << l_node << std::endl);
// remove this node from the inUse list
DEBUG (std::cerr << "s" << d_n_used);
// signal the condition when new data arrives
- d_ioBlock->signal ();
+ d_ioBlock->notify_one ();
DEBUG (std::cerr << "t ");
-
-// unlock the mutex for thread safety
- d_internal->unlock ();
};
__INLINE__ void iterate_start () { d_iterate = d_current; };
s_node_ptr iterate_next () {
#if 0
// lock the mutex for thread safety
- d_internal->lock ();
+ gruel::scoped_lock l (*d_internal);
#endif
s_node_ptr l_this = NULL;
if (d_iterate) {
if (d_iterate == d_current)
d_iterate = NULL;
}
-#if 0
-// unlock the mutex for thread safety
- d_internal->unlock ();
-#endif
return (l_this);
};
__INLINE__ void num_used_dec (void) {
if (d_n_used != 0) --d_n_used;
// signal the condition that new data has arrived
- d_ioBlock->signal ();
+ d_ioBlock->notify_one ();
};
__INLINE__ bool in_use () { return (d_n_used != 0); };
};
/* -*- c++ -*- */
/*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio.
*
#include "config.h"
#endif
-// tell mld_threads to NOT use omni_threads,
-// but rather Darwin's pthreads
-#define _USE_OMNI_THREADS_
#define DO_DEBUG 0
#include <usb.h>
l_buf = NULL;
}
- d_readRunning = new mld_mutex ();
- d_runThreadRunning = new mld_mutex ();
- d_runBlock = new mld_condition ();
- d_readBlock = new mld_condition ();
+ d_readRunning = new gruel::mutex ();
+ d_runThreadRunning = new gruel::mutex ();
+ d_runBlock = new gruel::condition_variable ();
+ d_readBlock = new gruel::condition_variable ();
+ d_runBlock_mutex = new gruel::mutex ();
+ d_readBlock_mutex = new gruel::mutex ();
}
fusb_ephandle_darwin::~fusb_ephandle_darwin ()
d_readRunning = NULL;
delete d_runThreadRunning;
d_runThreadRunning = NULL;
+ delete d_runBlock_mutex;
+ d_runBlock_mutex = NULL;
+ delete d_readBlock_mutex;
+ d_readBlock_mutex = NULL;
delete d_runBlock;
d_runBlock = NULL;
delete d_readBlock;
// lock the runBlock mutex, before creating the run thread.
// this guarantees that we can control execution between these 2 threads
- d_runBlock->mutex ()->lock ();
+ gruel::scoped_lock l (*d_runBlock_mutex);
// create the run thread, which allows OSX to process I/O separately
- d_runThread = new mld_thread (run_thread, this);
+ d_runThread = new gruel::thread (run_thread, this);
// wait until the run thread (and possibky read thread) are -really-
// going; this will unlock the mutex before waiting for a signal ()
- d_runBlock->wait ();
+ d_runBlock->wait (l);
if (usb_debug) {
std::cerr << "fusb_ephandle_darwin::start: " << (d_input_p ? "read" : "write")
// lock the run thread running mutex; if ::stop() is called, it will
// first abort() the pipe then wait for the run thread to finish,
// via a lock() on this mutex
- mld_mutex_ptr l_runThreadRunning = This->d_runThreadRunning;
- l_runThreadRunning->lock ();
+ gruel::mutex* l_runThreadRunning = This->d_runThreadRunning;
+ gruel::scoped_lock l0 (*l_runThreadRunning);
- mld_mutex_ptr l_readRunning = This->d_readRunning;
- mld_condition_ptr l_readBlock = This->d_readBlock;
- mld_mutex_ptr l_readBlock_mutex = l_readBlock->mutex ();
+ gruel::mutex* l_readRunning = This->d_readRunning;
+ gruel::condition_variable* l_readBlock = This->d_readBlock;
+ gruel::mutex* l_readBlock_mutex = This->d_readBlock_mutex;
bool l_input_p = This->d_input_p;
// get run loop reference, to allow other threads to stop
This->d_CFRunLoopRef = CFRunLoopGetCurrent ();
- mld_thread_ptr l_rwThread = NULL;
+ gruel::thread* l_rwThread = NULL;
if (l_input_p) {
// lock the readBlock mutex, before creating the read thread.
// this guarantees that we can control execution between these 2 threads
- l_readBlock_mutex->lock ();
+ gruel::scoped_lock l1 (*l_readBlock_mutex);
// create the read thread, which just issues all of the starting
// async read commands, then returns
- l_rwThread = new mld_thread (read_thread, arg);
+ l_rwThread = new gruel::thread (read_thread, arg);
// wait until the the read thread is -really- going; this will
// unlock the read block mutex before waiting for a signal ()
- l_readBlock->wait ();
+ l_readBlock->wait (l1);
}
- // now signal the run condition to release and finish ::start().
+ {
+ // now signal the run condition to release and finish ::start().
- // lock the runBlock mutex first; this will force waiting until the
- // ->wait() command is issued in ::start()
- mld_mutex_ptr l_run_block_mutex = This->d_runBlock->mutex ();
- l_run_block_mutex->lock ();
+ // lock the runBlock mutex first; this will force waiting until the
+ // ->wait() command is issued in ::start()
+ gruel::mutex* l_run_block_mutex = This->d_runBlock_mutex;
+ gruel::scoped_lock l2 (*l_run_block_mutex);
- // now that the lock is in place, signal the parent thread that
- // things are running
- This->d_runBlock->signal ();
-
- // release the run_block mutex, just in case
- l_run_block_mutex->unlock ();
+ // now that the lock is in place, signal the parent thread that
+ // things are running
+ This->d_runBlock->notify_one ();
+ }
// run the loop
CFRunLoopRun ();
if (l_input_p) {
// wait for read_thread () to finish, if needed
- l_readRunning->lock ();
- l_readRunning->unlock ();
+ gruel::scoped_lock l3 (*l_readRunning);
}
// remove run loop stuff
std::cerr << "fusb_ephandle_darwin::run_thread: finished for "
<< (l_input_p ? "read" : "write") << "." << std::endl;
}
-
- // release the run thread running mutex
- l_runThreadRunning->unlock ();
}
void
// before doing anything else, lock the read running mutex. this
// mutex does flow control between this thread and the run_thread
- mld_mutex_ptr l_readRunning = This->d_readRunning;
- l_readRunning->lock ();
+ gruel::mutex* l_readRunning = This->d_readRunning;
+ gruel::scoped_lock l0 (*l_readRunning);
// signal the read condition from run_thread() to continue
// lock the readBlock mutex first; this will force waiting until the
// ->wait() command is issued in ::run_thread()
- mld_condition_ptr l_readBlock = This->d_readBlock;
- mld_mutex_ptr l_read_block_mutex = l_readBlock->mutex ();
- l_read_block_mutex->lock ();
+ gruel::condition_variable* l_readBlock = This->d_readBlock;
+ gruel::mutex* l_read_block_mutex = This->d_readBlock_mutex;
- // now that the lock is in place, signal the parent thread that
- // things are running here
- l_readBlock->signal ();
+ {
+ gruel::scoped_lock l1 (*l_read_block_mutex);
- // release the run_block mutex, just in case
- l_read_block_mutex->unlock ();
+ // now that the lock is in place, signal the parent thread that
+ // things are running here
+ l_readBlock->notify_one ();
+ }
// queue up all of the available read requests
s_queue_ptr l_queue = This->d_queue;
if (usb_debug) {
std::cerr << "fusb_ephandle_darwin::read_thread: finished." << std::endl;
}
-
- // release the read running mutex, to let the parent thread knows
- // that this thread is finished
- l_readRunning->unlock ();
}
void
CFRunLoopStop (d_CFRunLoopRef);
// wait for the runThread to stop
- d_runThreadRunning->lock ();
- d_runThreadRunning->unlock ();
+ gruel::scoped_lock l (*d_runThreadRunning);
if (usb_debug) {
std::cerr << "fusb_ephandle_darwin::stop: " << (d_input_p ? "read" : "write")
/* -*- c++ -*- */
/*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
*
* This file is part of GNU Radio.
*
{
private:
fusb_devhandle_darwin* d_devhandle;
- mld_thread_ptr d_runThread;
- mld_mutex_ptr d_runThreadRunning;
+ gruel::thread* d_runThread;
+ gruel::mutex* d_runThreadRunning;
CFRunLoopRef d_CFRunLoopRef;
s_queue_ptr d_queue;
circular_buffer<char>* d_buffer;
size_t d_bufLenBytes;
- mld_mutex_ptr d_readRunning;
- mld_condition_ptr d_runBlock, d_readBlock;
+ gruel::mutex* d_readRunning;
+ gruel::mutex* d_runBlock_mutex;
+ gruel::mutex* d_readBlock_mutex;
+ gruel::condition_variable* d_runBlock;
+ gruel::condition_variable* d_readBlock;
// CREATORS
+++ /dev/null
-/* -*- c++ -*- */
-/*
- * Copyright 2006 Free Software Foundation, Inc.
- *
- * This file is part of GNU Radio.
- *
- * Primary Author: Michael Dickens, NCIP Lab, University of Notre Dame
- *
- * GNU Radio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 3, or (at your option)
- * any later version.
- *
- * GNU Radio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with GNU Radio; see the file COPYING. If not, write to
- * the Free Software Foundation, Inc., 51 Franklin Street,
- * Boston, MA 02110-1301, USA.
- */
-
-#ifndef _INCLUDED_MLD_THREADS_H_
-#define _INCLUDED_MLD_THREADS_H_
-
-/* classes which allow for either pthreads or omni_threads */
-
-#define __macos__
-#ifdef _USE_OMNI_THREADS_
-#include <gnuradio/omnithread.h>
-#else
-#include <pthread.h>
-#endif
-
-#include <stdexcept>
-
-#define __INLINE__ inline
-
-#ifndef DO_DEBUG
-#define DO_DEBUG 0
-#endif
-
-#if DO_DEBUG
-#define DEBUG(X) do{X} while(0);
-#else
-#define DEBUG(X) do{} while(0);
-#endif
-
-class mld_condition_t;
-
-class mld_mutex_t {
-#ifdef _USE_OMNI_THREADS_
- typedef omni_mutex l_mutex, *l_mutex_ptr;
-#else
- typedef pthread_mutex_t l_mutex, *l_mutex_ptr;
-#endif
-
- friend class mld_condition_t;
-
-private:
- l_mutex_ptr d_mutex;
-
-protected:
- inline l_mutex_ptr mutex () { return (d_mutex); };
-
-public:
- __INLINE__ mld_mutex_t () {
-#ifdef _USE_OMNI_THREADS_
- d_mutex = new omni_mutex ();
-#else
- d_mutex = (l_mutex_ptr) new l_mutex;
- int l_ret = pthread_mutex_init (d_mutex, NULL);
- if (l_ret != 0) {
- fprintf (stderr, "Error %d creating mutex.\n", l_ret);
- throw std::runtime_error ("mld_mutex_t::mld_mutex_t()\n");
- }
-#endif
- };
-
- __INLINE__ ~mld_mutex_t () {
- unlock ();
-#ifndef _USE_OMNI_THREADS_
- int l_ret = pthread_mutex_destroy (d_mutex);
- if (l_ret != 0) {
- fprintf (stderr, "mld_mutex_t::~mld_mutex_t(): "
- "Error %d destroying mutex.\n", l_ret);
- }
-#endif
- delete d_mutex;
- d_mutex = NULL;
- };
-
- __INLINE__ void lock () {
-#ifdef _USE_OMNI_THREADS_
- d_mutex->lock ();
-#else
- int l_ret = pthread_mutex_lock (d_mutex);
- if (l_ret != 0) {
- fprintf (stderr, "mld_mutex_t::lock(): "
- "Error %d locking mutex.\n", l_ret);
- }
-#endif
- };
-
- __INLINE__ void unlock () {
-#ifdef _USE_OMNI_THREADS_
- d_mutex->unlock ();
-#else
- int l_ret = pthread_mutex_unlock (d_mutex);
- if (l_ret != 0) {
- fprintf (stderr, "mld_mutex_t::unlock(): "
- "Error %d locking mutex.\n", l_ret);
- }
-#endif
- };
-
- __INLINE__ bool trylock () {
-#ifdef _USE_OMNI_THREADS_
- int l_ret = d_mutex->trylock ();
-#else
- int l_ret = pthread_mutex_unlock (d_mutex);
-#endif
- return (l_ret == 0 ? true : false);
- };
-
- inline void acquire () { lock(); };
- inline void release () { unlock(); };
- inline void wait () { lock(); };
- inline void post () { unlock(); };
-};
-
-typedef mld_mutex_t mld_mutex, *mld_mutex_ptr;
-
-class mld_condition_t {
-#ifdef _USE_OMNI_THREADS_
- typedef omni_condition l_condition, *l_condition_ptr;
-#else
- typedef pthread_cond_t l_condition, *l_condition_ptr;
-#endif
-
-private:
- l_condition_ptr d_condition;
- mld_mutex_ptr d_mutex;
- bool d_i_own_mutex;
-
-public:
- __INLINE__ mld_condition_t (mld_mutex_ptr mutex = NULL) {
- if (mutex) {
- d_i_own_mutex = false;
- d_mutex = mutex;
- } else {
- d_i_own_mutex = true;
- d_mutex = new mld_mutex ();
- }
-#ifdef _USE_OMNI_THREADS_
- d_condition = new omni_condition (d_mutex->mutex ());
-#else
- d_condition = (l_condition_ptr) new l_condition;
- int l_ret = pthread_cond_init (d_condition, NULL);
- if (l_ret != 0) {
- fprintf (stderr, "Error %d creating condition.\n", l_ret);
- throw std::runtime_error ("mld_condition_t::mld_condition_t()\n");
- }
-#endif
- };
-
- __INLINE__ ~mld_condition_t () {
- signal ();
-#ifndef _USE_OMNI_THREADS_
- int l_ret = pthread_cond_destroy (d_condition);
- if (l_ret != 0) {
- fprintf (stderr, "mld_condition_t::mld_condition_t(): "
- "Error %d destroying condition.\n", l_ret);
- }
-#endif
- delete d_condition;
- d_condition = NULL;
- if (d_i_own_mutex)
- delete d_mutex;
- d_mutex = NULL;
- };
-
- __INLINE__ mld_mutex_ptr mutex () {return (d_mutex);};
-
- __INLINE__ void signal () {
- DEBUG (fprintf (stderr, "a "););
-
-#ifdef _USE_OMNI_THREADS_
- d_condition->signal ();
-#else
- int l_ret = pthread_cond_signal (d_condition);
- if (l_ret != 0) {
- fprintf (stderr, "mld_condition_t::signal(): "
- "Error %d.\n", l_ret);
- }
-#endif
- DEBUG (fprintf (stderr, "b "););
- };
-
- __INLINE__ void wait () {
- DEBUG (fprintf (stderr, "c "););
-#ifdef _USE_OMNI_THREADS_
- d_condition->wait ();
-#else
- int l_ret = pthread_cond_wait (d_condition, d_mutex->mutex ());
- if (l_ret != 0) {
- fprintf (stderr, "mld_condition_t::wait(): "
- "Error %d.\n", l_ret);
- }
-#endif
- DEBUG (fprintf (stderr, "d "););
- };
-};
-
-typedef mld_condition_t mld_condition, *mld_condition_ptr;
-
-class mld_thread_t {
-#ifdef _USE_OMNI_THREADS_
- typedef omni_thread l_thread, *l_thread_ptr;
-#else
- typedef pthread_t l_thread, *l_thread_ptr;
-#endif
-
-private:
-#ifndef _USE_OMNI_THREADS_
- l_thread d_thread;
- void (*d_start_routine)(void*);
- void *d_arg;
-#else
- l_thread_ptr d_thread;
-#endif
-
-#ifndef _USE_OMNI_THREADS_
- static void* local_start_routine (void *arg) {
- mld_thread_t* This = (mld_thread_t*) arg;
- (*(This->d_start_routine))(This->d_arg);
- return (NULL);
- };
-#endif
-
-public:
- __INLINE__ mld_thread_t (void (*start_routine)(void *), void *arg) {
-#ifdef _USE_OMNI_THREADS_
- d_thread = new omni_thread (start_routine, arg);
- d_thread->start ();
-#else
- d_start_routine = start_routine;
- d_arg = arg;
- int l_ret = pthread_create (&d_thread, NULL, local_start_routine, this);
- if (l_ret != 0) {
- fprintf (stderr, "Error %d creating thread.\n", l_ret);
- throw std::runtime_error ("mld_thread_t::mld_thread_t()\n");
- }
-#endif
- };
-
- __INLINE__ ~mld_thread_t () {
-#ifdef _USE_OMNI_THREADS_
-// delete d_thread;
- d_thread = NULL;
-#else
- int l_ret = pthread_detach (d_thread);
- if (l_ret != 0) {
- fprintf (stderr, "Error %d detaching thread.\n", l_ret);
- throw std::runtime_error ("mld_thread_t::~mld_thread_t()\n");
- }
-#endif
- };
-};
-
-typedef mld_thread_t mld_thread, *mld_thread_ptr;
-
-#endif /* _INCLUDED_MLD_THREADS_H_ */
projects / debian / gnuradio / commitdiff