The barrier ensures that the thread must spawn before the caller exits.
Some of the code already used a mutex to accomplish this,
however cygwin chokes when a mutex is locked twice by the same thread.
Mutex implementations were replaced with the barrier implementation.
Also the barrier implementation is far cleaner.
Added push with haste.
Call with haste first in the wait methods to avoid time compare/wait when not needed.
Added new calls to the libusb and udp zero copy impls
tests pass
The bounded buffer now uses the detail idiom to hide implementation to inline better.
The whole sptr/make idiom was removed from bounded buffer to just construct directly.
The code using bounded buffer was changed for the new api:
replaces access operators and calls to the factory function.
the device address gives a key, value pair of infinite optional capabilities
added a cast option to the device address to cast string to type T
added call to the zero_copy_if to get send and recv frame sizes
changed the usrp2 impl to calculate recv/send spp from the data transport
- recv buffers have a release call
- safe make function for recv buffers (buff + release callback)
- send buffer commits now have a void return
- safe make function for send buffers (buff + commit callback)
The reason for the void return from commit is that ssize_t num_bytes was never returning anything of use.
That is for all of the zero copy implementations so far, commit cannot really error (being asynchronous).
libusb zero copy impl was reworked to support the new interface.
USRP1 io_impl with the psuedo managed buffer was replaced with safe_make.
Also, usrp1 io_impl was simplified greatly due to commit returning void now.
UDP zero copy asio was disabled (in this commit, until its reworked).
Phony send and recv interfaces were removed completely.
converted all size_t timeout_ms to double timeout
bounded and alignment buffer now take double timeout
added timeout to device::send and zero_copy_if::get_send_buff
Heavy work on the zero copy interface and endpoint wrappers to properly use the async io.
The global libusb session starts a thread to run the event handler,
the async callbacks push completed transfers onto a thread-safe bounded buffer.
The managed buffer creation routines use the bounded buffer to efficiently pop off completed transfers.
works on linux, throws a weird exception on cleanup
