Merge branch 'master' into wip/burx_support

* master: (39 commits)
  Add gru.hexshort to deal with short hex constants
  Assign USB PID for Hans de Bok
  Add missing buffer allocator hint to gr_ofdm_sampler.cc
  Really fix the missing include for boost::bind
  gr-wxgui: Added additional color table entries
  Missed updates for omnithread/mblock removal
  Remove omnithreads library.
  Remove mblock library.  We hardly knew 'ye.
  Convert gr-audio-portaudio to Boost via gruel
  Further updates for removing omnithreads
  Update build configuration for OSX omnithreads changeover
  Add missing include file for boost::bind
  Convert gcell to use boost::threads instead of omnithread.
  Fix sequence error indication after stopping then restarting streaming on USRP2.
  initial move from mld_threads to gruel:: namespace threads and such
  Initial changes to remove mld_thread and instead use gruel:: namespace classes
  Fixing doxygen warnings from arb_resampler. Also, removed set_taps from public
  Fixing doxygen warnings from channelizer block.
  Fixing documentation to get rid of doxygen warnings.
  Adding documentation for fff version of othe PFB clock sync algorithm.
  ...

7 files changed, 106 insertions, 395 deletions

diff --git a/usrp/host/lib/Makefile.am b/usrp/host/lib/Makefile.am
index 1fff1548b..f01ff8a0a 100644
--- a/usrp/host/lib/Makefile.am
+++ b/usrp/host/lib/Makefile.am
@@ -1,7 +1,7 @@
 #
 #  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
@@ -31,10 +31,10 @@ libusrp_la_common_LIBADD = 		\
 	$(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)
@@ -70,7 +70,6 @@ darwin_CODE =				\
 	circular_buffer.h		\
 	circular_linked_list.h		\
 	darwin_libusb.h			\
-	mld_threads.h			\
 	usrp_prims_libusb0.cc		
 
 
diff --git a/usrp/host/lib/circular_buffer.h b/usrp/host/lib/circular_buffer.h
index 6d491fb6f..48758bf87 100644
--- a/usrp/host/lib/circular_buffer.h
+++ b/usrp/host/lib/circular_buffer.h
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio.
  *
@@ -23,7 +23,7 @@
 #ifndef _CIRCULAR_BUFFER_H_
 #define _CIRCULAR_BUFFER_H_
 
-#include "mld_threads.h"
+#include <gruel/thread.h>
 #include <iostream>
 #include <stdexcept>
 
@@ -37,7 +37,8 @@
 #define DEBUG(X) do{} while(0);
 #endif
 
-template <class T> class circular_buffer
+template <class T>
+class circular_buffer
 {
 private:
 // the buffer to use
@@ -48,8 +49,9 @@ private:
   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;
@@ -94,16 +96,14 @@ public:
   };
 
   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);
   };
 
@@ -120,13 +120,13 @@ public:
     // 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 ();
   };
 
 /*
@@ -167,9 +167,8 @@ public:
     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
@@ -178,11 +177,11 @@ public:
       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);
 	  }
@@ -208,8 +207,7 @@ public:
       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);
   };
 
@@ -255,19 +253,18 @@ public:
       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);
 	}
@@ -276,11 +273,11 @@ public:
     } 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);
 	}
@@ -303,17 +300,15 @@ public:
     *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 ();
   };
 };
 
diff --git a/usrp/host/lib/circular_linked_list.h b/usrp/host/lib/circular_linked_list.h
index 97fe2c1a8..bbed5e49b 100644
--- a/usrp/host/lib/circular_linked_list.h
+++ b/usrp/host/lib/circular_linked_list.h
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio.
  *
@@ -23,7 +23,7 @@
 #ifndef _CIRCULAR_LINKED_LIST_H_
 #define _CIRCULAR_LINKED_LIST_H_
 
-#include <mld_threads.h>
+#include <gruel/thread.h>
 #include <stdexcept>
 
 #define __INLINE__ inline
@@ -110,8 +110,8 @@ template <class T> class circular_linked_list {
 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) {
@@ -150,8 +150,8 @@ public:
       }
     }
     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 () {
@@ -163,19 +163,21 @@ public:
     }
     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;
@@ -196,13 +198,12 @@ public:
       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
@@ -221,11 +222,8 @@ public:
 
     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; };
@@ -233,7 +231,7 @@ public:
   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) {
@@ -242,10 +240,6 @@ public:
       if (d_iterate == d_current)
 	d_iterate = NULL;
     }
-#if 0
-// unlock the mutex for thread safety
-    d_internal->unlock ();
-#endif
     return (l_this);
   };
 
@@ -261,7 +255,7 @@ public:
   __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); };
 };
diff --git a/usrp/host/lib/db_wbxng.cc b/usrp/host/lib/db_wbxng.cc
index b35a9cb35..bd836dfe3 100644
--- a/usrp/host/lib/db_wbxng.cc
+++ b/usrp/host/lib/db_wbxng.cc
@@ -80,7 +80,9 @@ wbxng_base::set_freq(double freq)
     actual_baseband_freq is the RF frequency that corresponds to DC in the IF.
   */
 
-  freq_t int_freq = freq_t(freq);
+  // clamp freq
+  freq_t int_freq = freq_t(std::max(freq_min(), std::min(freq, freq_max())));
+
   bool ok = d_common->_set_freq(int_freq*2);
   double freq_result = (double) d_common->_get_freq()/2.0;
   struct freq_result_t args = {ok, freq_result};
diff --git a/usrp/host/lib/fusb_darwin.cc b/usrp/host/lib/fusb_darwin.cc
index 95c4878aa..d2966c115 100644
--- a/usrp/host/lib/fusb_darwin.cc
+++ b/usrp/host/lib/fusb_darwin.cc
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio.
  *
@@ -24,9 +24,6 @@
 #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>
@@ -85,10 +82,12 @@ fusb_ephandle_darwin::fusb_ephandle_darwin (fusb_devhandle_darwin* dh,
     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 ()
@@ -116,6 +115,10 @@ 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;
@@ -200,14 +203,14 @@ fusb_ephandle_darwin::start ()
 
   // 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")
@@ -225,12 +228,12 @@ fusb_ephandle_darwin::run_thread (void* arg)
   // 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;
 
@@ -250,41 +253,39 @@ fusb_ephandle_darwin::run_thread (void* arg)
 // 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
@@ -295,9 +296,6 @@ fusb_ephandle_darwin::run_thread (void* arg)
     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
@@ -311,23 +309,23 @@ fusb_ephandle_darwin::read_thread (void* arg)
 
   // 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;
@@ -341,10 +339,6 @@ fusb_ephandle_darwin::read_thread (void* arg)
   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
@@ -569,8 +563,7 @@ fusb_ephandle_darwin::stop ()
   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")
diff --git a/usrp/host/lib/fusb_darwin.h b/usrp/host/lib/fusb_darwin.h
index 735e5f16d..4d18177be 100644
--- a/usrp/host/lib/fusb_darwin.h
+++ b/usrp/host/lib/fusb_darwin.h
@@ -1,6 +1,6 @@
 /* -*- c++ -*- */
 /*
- * Copyright 2006,2009 Free Software Foundation, Inc.
+ * Copyright 2006,2009,2010 Free Software Foundation, Inc.
  * 
  * This file is part of GNU Radio.
  *
@@ -150,8 +150,8 @@ class fusb_ephandle_darwin : public fusb_ephandle
 {
 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;
 
@@ -174,8 +174,11 @@ public:
   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
 
diff --git a/usrp/host/lib/mld_threads.h b/usrp/host/lib/mld_threads.h
deleted file mode 100644
index 322f557b6..000000000
--- a/usrp/host/lib/mld_threads.h
+++ /dev/null
@@ -1,275 +0,0 @@
-/* -*- 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_ */