lib: transport: apply clang-format

This is a continuation of 967be2a4.

$ find host/lib/transport -iname *.hpp -o -iname *.cpp |\
    xargs clang-format -i -style=file

Skipping host/lib/transport/nirio/ because of build errors.
$ git checkout host/lib/transport/nirio

25 files changed, 2745 insertions, 2326 deletions

diff --git a/host/lib/transport/buffer_pool.cpp b/host/lib/transport/buffer_pool.cpp
index 5d1ce37ab..c481b9d02 100644
--- a/host/lib/transport/buffer_pool.cpp
+++ b/host/lib/transport/buffer_pool.cpp
@@ -22,31 +22,35 @@ boost::detail::atomic_count managed_buffer::s_buffer_count(0);
 #endif // UHD_TXRX_DEBUG_PRINTS
 
 //! pad the byte count to a multiple of alignment
-static size_t pad_to_boundary(const size_t bytes, const size_t alignment){
-    return bytes + (alignment - bytes)%alignment;
+static size_t pad_to_boundary(const size_t bytes, const size_t alignment)
+{
+    return bytes + (alignment - bytes) % alignment;
 }
 
-buffer_pool::~buffer_pool(void){
+buffer_pool::~buffer_pool(void)
+{
     /* NOP */
 }
 
 /***********************************************************************
  * Buffer pool implementation
  **********************************************************************/
-class buffer_pool_impl : public buffer_pool{
+class buffer_pool_impl : public buffer_pool
+{
 public:
-    buffer_pool_impl(
-        const std::vector<ptr_type> &ptrs,
-        boost::shared_array<char> mem
-    ): _ptrs(ptrs), _mem(mem){
+    buffer_pool_impl(const std::vector<ptr_type>& ptrs, boost::shared_array<char> mem)
+        : _ptrs(ptrs), _mem(mem)
+    {
         /* NOP */
     }
 
-    ptr_type at(const size_t index) const{
+    ptr_type at(const size_t index) const
+    {
         return _ptrs.at(index);
     }
 
-    size_t size(void) const{
+    size_t size(void) const
+    {
         return _ptrs.size();
     }
 
@@ -59,26 +63,23 @@ private:
  * Buffer pool factor function
  **********************************************************************/
 buffer_pool::sptr buffer_pool::make(
-    const size_t num_buffs,
-    const size_t buff_size,
-    const size_t alignment
-){
-    //1) pad the buffer size to be a multiple of alignment
-    //2) pad the overall memory size for room after alignment
-    //3) allocate the memory in one block of sufficient size
+    const size_t num_buffs, const size_t buff_size, const size_t alignment)
+{
+    // 1) pad the buffer size to be a multiple of alignment
+    // 2) pad the overall memory size for room after alignment
+    // 3) allocate the memory in one block of sufficient size
     const size_t padded_buff_size = pad_to_boundary(buff_size, alignment);
-    boost::shared_array<char> mem(new char[padded_buff_size*num_buffs + alignment-1]);
+    boost::shared_array<char> mem(new char[padded_buff_size * num_buffs + alignment - 1]);
 
-    //Fill a vector with boundary-aligned points in the memory
+    // Fill a vector with boundary-aligned points in the memory
     const size_t mem_start = pad_to_boundary(size_t(mem.get()), alignment);
     std::vector<ptr_type> ptrs(num_buffs);
-    for (size_t i = 0; i < num_buffs; i++){
-        ptrs[i] = ptr_type(mem_start + padded_buff_size*i);
+    for (size_t i = 0; i < num_buffs; i++) {
+        ptrs[i] = ptr_type(mem_start + padded_buff_size * i);
     }
 
-    //Create a new buffer pool implementation with:
+    // Create a new buffer pool implementation with:
     // - the pre-computed pointers, and
     // - the reference to allocated memory.
     return sptr(new buffer_pool_impl(ptrs, mem));
 }
-
diff --git a/host/lib/transport/chdr.cpp b/host/lib/transport/chdr.cpp
index 36f380d62..ff3b6475a 100644
--- a/host/lib/transport/chdr.cpp
+++ b/host/lib/transport/chdr.cpp
@@ -5,23 +5,23 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
+#include <uhd/exception.hpp>
 #include <uhd/transport/chdr.hpp>
 #include <uhd/utils/byteswap.hpp>
-#include <uhd/exception.hpp>
 
-//define the endian macros to convert integers
+// define the endian macros to convert integers
 #ifdef BOOST_BIG_ENDIAN
-    #define BE_MACRO(x) (x)
-    #define LE_MACRO(x) uhd::byteswap(x)
+#    define BE_MACRO(x) (x)
+#    define LE_MACRO(x) uhd::byteswap(x)
 #else
-    #define BE_MACRO(x) uhd::byteswap(x)
-    #define LE_MACRO(x) (x)
+#    define BE_MACRO(x) uhd::byteswap(x)
+#    define LE_MACRO(x) (x)
 #endif
 
 using namespace uhd::transport::vrt;
 
-static const uint32_t HDR_FLAG_TSF = (1 << 29);
-static const uint32_t HDR_FLAG_EOB = (1 << 28);
+static const uint32_t HDR_FLAG_TSF   = (1 << 29);
+static const uint32_t HDR_FLAG_EOB   = (1 << 28);
 static const uint32_t HDR_FLAG_ERROR = (1 << 28);
 static const uint32_t HDR_FLAG_FCACK = (1 << 28);
 
@@ -30,24 +30,25 @@ static const uint32_t HDR_FLAG_FCACK = (1 << 28);
 /***************************************************************************/
 /*! Translate the contents of \p if_packet_info into a 32-Bit word and return it.
  */
-UHD_INLINE uint32_t _hdr_pack_chdr(
-        if_packet_info_t &if_packet_info
-) {
+UHD_INLINE uint32_t _hdr_pack_chdr(if_packet_info_t& if_packet_info)
+{
     // Set fields in if_packet_info
     if_packet_info.num_header_words32 = 2 + (if_packet_info.has_tsf ? 2 : 0);
     if_packet_info.num_packet_words32 =
-            if_packet_info.num_header_words32 +
-            if_packet_info.num_payload_words32;
+        if_packet_info.num_header_words32 + if_packet_info.num_payload_words32;
 
     uint16_t pkt_length =
         if_packet_info.num_payload_bytes + (4 * if_packet_info.num_header_words32);
-    uint32_t chdr = 0
+    uint32_t chdr =
+        0
         // 2 Bits: Packet type
         | (if_packet_info.packet_type << 30)
         // 1 Bit: Has time
         | (if_packet_info.has_tsf ? HDR_FLAG_TSF : 0)
         // 1 Bit: EOB or Error or FC ACK
-        | ((if_packet_info.eob or if_packet_info.error or if_packet_info.fc_ack) ? HDR_FLAG_EOB : 0)
+        | ((if_packet_info.eob or if_packet_info.error or if_packet_info.fc_ack)
+                  ? HDR_FLAG_EOB
+                  : 0)
         // 12 Bits: Sequence number
         | ((if_packet_info.packet_count & 0xFFF) << 16)
         // 16 Bits: Total packet length
@@ -55,10 +56,8 @@ UHD_INLINE uint32_t _hdr_pack_chdr(
     return chdr;
 }
 
-void chdr::if_hdr_pack_be(
-        uint32_t *packet_buff,
-        if_packet_info_t &if_packet_info
-) {
+void chdr::if_hdr_pack_be(uint32_t* packet_buff, if_packet_info_t& if_packet_info)
+{
     // Write header and update if_packet_info
     packet_buff[0] = BE_MACRO(_hdr_pack_chdr(if_packet_info));
 
@@ -72,10 +71,8 @@ void chdr::if_hdr_pack_be(
     }
 }
 
-void chdr::if_hdr_pack_le(
-        uint32_t *packet_buff,
-        if_packet_info_t &if_packet_info
-) {
+void chdr::if_hdr_pack_le(uint32_t* packet_buff, if_packet_info_t& if_packet_info)
+{
     // Write header and update if_packet_info
     packet_buff[0] = LE_MACRO(_hdr_pack_chdr(if_packet_info));
 
@@ -93,27 +90,28 @@ void chdr::if_hdr_pack_le(
 /***************************************************************************/
 /* Unpacking                                                               */
 /***************************************************************************/
-UHD_INLINE void _hdr_unpack_chdr(
-        const uint32_t chdr,
-        if_packet_info_t &if_packet_info
-) {
+UHD_INLINE void _hdr_unpack_chdr(const uint32_t chdr, if_packet_info_t& if_packet_info)
+{
     // Set constant members
     if_packet_info.link_type = if_packet_info_t::LINK_TYPE_CHDR;
-    if_packet_info.has_cid = false;
-    if_packet_info.has_sid = true;
-    if_packet_info.has_tsi = false;
-    if_packet_info.has_tlr = false;
-    if_packet_info.sob = false;
+    if_packet_info.has_cid   = false;
+    if_packet_info.has_sid   = true;
+    if_packet_info.has_tsi   = false;
+    if_packet_info.has_tlr   = false;
+    if_packet_info.sob       = false;
 
     // Set configurable members
-    if_packet_info.has_tsf = (chdr & HDR_FLAG_TSF) > 0;
+    if_packet_info.has_tsf     = (chdr & HDR_FLAG_TSF) > 0;
     if_packet_info.packet_type = if_packet_info_t::packet_type_t((chdr >> 30) & 0x3);
-    if_packet_info.eob = (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_DATA)
-                         && ((chdr & HDR_FLAG_EOB) > 0);
-    if_packet_info.error = (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_RESP)
-                         && ((chdr & HDR_FLAG_ERROR) > 0);
-    if_packet_info.fc_ack = (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_FC)
-                         && ((chdr & HDR_FLAG_FCACK) > 0);
+    if_packet_info.eob =
+        (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_DATA)
+        && ((chdr & HDR_FLAG_EOB) > 0);
+    if_packet_info.error =
+        (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_RESP)
+        && ((chdr & HDR_FLAG_ERROR) > 0);
+    if_packet_info.fc_ack =
+        (if_packet_info.packet_type == if_packet_info_t::PACKET_TYPE_FC)
+        && ((chdr & HDR_FLAG_FCACK) > 0);
     if_packet_info.packet_count = (chdr >> 16) & 0xFFF;
 
     // Set packet length variables
@@ -122,7 +120,7 @@ UHD_INLINE void _hdr_unpack_chdr(
     } else {
         if_packet_info.num_header_words32 = 2;
     }
-    size_t pkt_size_bytes = (chdr & 0xFFFF);
+    size_t pkt_size_bytes  = (chdr & 0xFFFF);
     size_t pkt_size_word32 = (pkt_size_bytes / 4) + ((pkt_size_bytes % 4) ? 1 : 0);
     // Check lengths match:
     if (pkt_size_word32 < if_packet_info.num_header_words32) {
@@ -131,14 +129,14 @@ UHD_INLINE void _hdr_unpack_chdr(
     if (if_packet_info.num_packet_words32 < pkt_size_word32) {
         throw uhd::value_error("Bad CHDR or packet fragment");
     }
-    if_packet_info.num_payload_bytes = pkt_size_bytes - (4 * if_packet_info.num_header_words32);
-    if_packet_info.num_payload_words32 = pkt_size_word32 - if_packet_info.num_header_words32;
+    if_packet_info.num_payload_bytes =
+        pkt_size_bytes - (4 * if_packet_info.num_header_words32);
+    if_packet_info.num_payload_words32 =
+        pkt_size_word32 - if_packet_info.num_header_words32;
 }
 
-void chdr::if_hdr_unpack_be(
-        const uint32_t *packet_buff,
-        if_packet_info_t &if_packet_info
-) {
+void chdr::if_hdr_unpack_be(const uint32_t* packet_buff, if_packet_info_t& if_packet_info)
+{
     // Read header and update if_packet_info
     uint32_t chdr = BE_MACRO(packet_buff[0]);
     _hdr_unpack_chdr(chdr, if_packet_info);
@@ -148,16 +146,13 @@ void chdr::if_hdr_unpack_be(
 
     // Read time (has_tsf was updated earlier)
     if (if_packet_info.has_tsf) {
-        if_packet_info.tsf = 0
-            | uint64_t(BE_MACRO(packet_buff[2])) << 32
-            | BE_MACRO(packet_buff[3]);
+        if_packet_info.tsf = 0 | uint64_t(BE_MACRO(packet_buff[2])) << 32
+                             | BE_MACRO(packet_buff[3]);
     }
 }
 
-void chdr::if_hdr_unpack_le(
-        const uint32_t *packet_buff,
-        if_packet_info_t &if_packet_info
-) {
+void chdr::if_hdr_unpack_le(const uint32_t* packet_buff, if_packet_info_t& if_packet_info)
+{
     // Read header and update if_packet_info
     uint32_t chdr = LE_MACRO(packet_buff[0]);
     _hdr_unpack_chdr(chdr, if_packet_info);
@@ -167,9 +162,7 @@ void chdr::if_hdr_unpack_le(
 
     // Read time (has_tsf was updated earlier)
     if (if_packet_info.has_tsf) {
-        if_packet_info.tsf = 0
-            | uint64_t(LE_MACRO(packet_buff[2])) << 32
-            | LE_MACRO(packet_buff[3]);
+        if_packet_info.tsf = 0 | uint64_t(LE_MACRO(packet_buff[2])) << 32
+                             | LE_MACRO(packet_buff[3]);
     }
 }
-
diff --git a/host/lib/transport/dpdk_zero_copy.cpp b/host/lib/transport/dpdk_zero_copy.cpp
index 2e95efd81..51c9b9dba 100644
--- a/host/lib/transport/dpdk_zero_copy.cpp
+++ b/host/lib/transport/dpdk_zero_copy.cpp
@@ -6,106 +6,104 @@
 
 #include "dpdk_zero_copy.hpp"
 #include <uhd/config.hpp>
-#include <uhd/utils/static.hpp>
 #include <uhd/utils/log.hpp>
+#include <uhd/utils/static.hpp>
 #include <uhdlib/transport/uhd-dpdk.h>
-#include <boost/make_shared.hpp>
+#include <arpa/inet.h>
 #include <sys/syslog.h>
+#include <boost/make_shared.hpp>
 #include <stack>
-#include <arpa/inet.h>
 
 namespace uhd { namespace transport {
 
 namespace {
-    static constexpr uint64_t USEC = 1000000;
-    // FIXME: Make configurable and have uhd-dpdk library track buffer sizes
-    static constexpr size_t DEFAULT_FRAME_SIZE = 8000;
+static constexpr uint64_t USEC = 1000000;
+// FIXME: Make configurable and have uhd-dpdk library track buffer sizes
+static constexpr size_t DEFAULT_FRAME_SIZE = 8000;
 
-    inline char * eal_add_opt(std::vector<const char*>& argv, size_t n,
-                              char *dst, const char *opt, const char *arg)
-    {
-        char *ptr = dst;
-        strncpy(ptr, opt, n);
-        argv.push_back(ptr);
-        ptr += strlen(opt) + 1;
-        n -= ptr - dst;
-        strncpy(ptr, arg, n);
-        argv.push_back(ptr);
-        ptr += strlen(arg) + 1;
-        return ptr;
-    }
+inline char* eal_add_opt(
+    std::vector<const char*>& argv, size_t n, char* dst, const char* opt, const char* arg)
+{
+    char* ptr = dst;
+    strncpy(ptr, opt, n);
+    argv.push_back(ptr);
+    ptr += strlen(opt) + 1;
+    n -= ptr - dst;
+    strncpy(ptr, arg, n);
+    argv.push_back(ptr);
+    ptr += strlen(arg) + 1;
+    return ptr;
 }
+} // namespace
 
 uhd_dpdk_ctx::uhd_dpdk_ctx(void) : _init_done(false) {}
 
 uhd_dpdk_ctx::~uhd_dpdk_ctx(void) {}
 
 /* Initialize uhd-dpdk (and do only once) */
-void uhd_dpdk_ctx::init(const dict<std::string, std::string> &eal_args,
-                        unsigned int num_ports, int *port_thread_mapping,
-                        int num_mbufs, int mbuf_cache_size, size_t mtu)
+void uhd_dpdk_ctx::init(const dict<std::string, std::string>& eal_args,
+    unsigned int num_ports,
+    int* port_thread_mapping,
+    int num_mbufs,
+    int mbuf_cache_size,
+    size_t mtu)
 {
     std::lock_guard<std::mutex> lock(_init_mutex);
     if (!_init_done) {
         _mtu = mtu;
         /* Build up argc and argv */
-        std::vector<const char *> argv;
+        std::vector<const char*> argv;
         argv.push_back("uhd-dpdk");
-        char *args = new char[4096];
-        char *opt = args;
-        char *end = args + sizeof(args);
-        for (std::string &key : eal_args.keys()) {
+        char* args = new char[4096];
+        char* opt  = args;
+        char* end  = args + sizeof(args);
+        for (std::string& key : eal_args.keys()) {
             std::string val = eal_args[key];
             if (key == "coremask") {
-                opt = eal_add_opt(argv, end - opt, opt, "-c",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "-c", val.c_str());
             } else if (key == "corelist") {
                 /* NOTE: This arg may have commas, so limited to config file */
-                opt = eal_add_opt(argv, end - opt, opt, "-l",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "-l", val.c_str());
             } else if (key == "coremap") {
-                opt = eal_add_opt(argv, end - opt, opt, "--lcores",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "--lcores", val.c_str());
             } else if (key == "master-lcore") {
-                opt = eal_add_opt(argv, end - opt, opt, "--master-lcore",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "--master-lcore", val.c_str());
             } else if (key == "pci-blacklist") {
-                opt = eal_add_opt(argv, end - opt, opt, "-b",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "-b", val.c_str());
             } else if (key == "pci-whitelist") {
-                opt = eal_add_opt(argv, end - opt, opt, "-w",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "-w", val.c_str());
             } else if (key == "log-level") {
-                opt = eal_add_opt(argv, end - opt, opt, "--log-level",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "--log-level", val.c_str());
             } else if (key == "huge-dir") {
-                opt = eal_add_opt(argv, end - opt, opt, "--huge-dir",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "--huge-dir", val.c_str());
             } else if (key == "file-prefix") {
-                opt = eal_add_opt(argv, end - opt, opt, "--file-prefix",
-                                  val.c_str());
+                opt = eal_add_opt(argv, end - opt, opt, "--file-prefix", val.c_str());
             }
         }
-        uhd_dpdk_init(argv.size(), argv.data(), num_ports, port_thread_mapping, num_mbufs,
-                      mbuf_cache_size, _mtu);
+        uhd_dpdk_init(argv.size(),
+            argv.data(),
+            num_ports,
+            port_thread_mapping,
+            num_mbufs,
+            mbuf_cache_size,
+            _mtu);
         delete args;
         _init_done = true;
     }
 }
 
-int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr,
-                              unsigned int &port_id)
+int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr, unsigned int& port_id)
 {
     UHD_ASSERT_THROW(is_init_done());
     int num_ports = uhd_dpdk_port_count();
     for (int i = 0; i < num_ports; i++) {
-        struct eth_addr port_mac_addr = uhd_dpdk_get_eth_addr((unsigned int) i);
+        struct eth_addr port_mac_addr = uhd_dpdk_get_eth_addr((unsigned int)i);
         for (int j = 0; j < 6; j++) {
             if (mac_addr[j] != port_mac_addr.addr[j]) {
                 break;
             }
             if (j == 5) {
-                port_id = (unsigned int) i;
+                port_id = (unsigned int)i;
                 return 0;
             }
         }
@@ -113,23 +111,23 @@ int uhd_dpdk_ctx::get_port_id(std::array<uint8_t, 6> mac_addr,
     return -1;
 }
 
-int uhd_dpdk_ctx::get_route(const std::string &addr) const
+int uhd_dpdk_ctx::get_route(const std::string& addr) const
 {
-    const uint32_t dst_ipv4 = (uint32_t) inet_addr(addr.c_str());
+    const uint32_t dst_ipv4      = (uint32_t)inet_addr(addr.c_str());
     const unsigned int num_ports = uhd_dpdk_port_count();
     for (unsigned int port = 0; port < num_ports; port++) {
         uint32_t src_ipv4;
         uint32_t netmask;
         uhd_dpdk_get_ipv4_addr(port, &src_ipv4, &netmask);
         if ((src_ipv4 & netmask) == (dst_ipv4 & netmask)) {
-            return (int) port;
-	}
+            return (int)port;
+        }
     }
     return -ENODEV;
 }
 
-int uhd_dpdk_ctx::set_ipv4_addr(unsigned int port_id, uint32_t ipv4_addr,
-                                uint32_t netmask)
+int uhd_dpdk_ctx::set_ipv4_addr(
+    unsigned int port_id, uint32_t ipv4_addr, uint32_t netmask)
 {
     return uhd_dpdk_set_ipv4_addr(port_id, ipv4_addr, netmask);
 }
@@ -140,23 +138,25 @@ bool uhd_dpdk_ctx::is_init_done(void)
 }
 
 
-class dpdk_zero_copy_msb : public managed_send_buffer {
+class dpdk_zero_copy_msb : public managed_send_buffer
+{
 public:
-    dpdk_zero_copy_msb(struct uhd_dpdk_socket *sock,
-                      std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> &free_bufs)
-                      : _sock(sock), _buf(nullptr), _free_bufs(free_bufs) {};
+    dpdk_zero_copy_msb(struct uhd_dpdk_socket* sock,
+        std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>>& free_bufs)
+        : _sock(sock), _buf(nullptr), _free_bufs(free_bufs){};
 
     ~dpdk_zero_copy_msb(void) {}
 
     void release(void)
     {
         if (_buf) {
-            _buf->pkt_len = _length;
+            _buf->pkt_len  = _length;
             _buf->data_len = _length;
-            int num_tx = uhd_dpdk_send(_sock, &_buf, 1);
+            int num_tx     = uhd_dpdk_send(_sock, &_buf, 1);
             if (num_tx == 0) {
                 /* Drop packet and free buffer (do not share sockets!) */
-                UHD_LOG_ERROR("DPDK", "Invalid shared socket usage detected. Dropping packet...");
+                UHD_LOG_ERROR(
+                    "DPDK", "Invalid shared socket usage detected. Dropping packet...");
                 uhd_dpdk_free_buf(_buf);
             }
             // Push back into pool
@@ -170,21 +170,21 @@ public:
         if (bufs != 1 || !_buf)
             return sptr();
 
-        return make(this, uhd_dpdk_buf_to_data(_sock, _buf),
-                    DEFAULT_FRAME_SIZE);
+        return make(this, uhd_dpdk_buf_to_data(_sock, _buf), DEFAULT_FRAME_SIZE);
     }
 
 private:
-    struct uhd_dpdk_socket *_sock;
-    struct rte_mbuf *_buf;
-    std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> &_free_bufs;
+    struct uhd_dpdk_socket* _sock;
+    struct rte_mbuf* _buf;
+    std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>>& _free_bufs;
 };
 
-class dpdk_zero_copy_mrb : public managed_recv_buffer {
+class dpdk_zero_copy_mrb : public managed_recv_buffer
+{
 public:
-    dpdk_zero_copy_mrb(struct uhd_dpdk_socket *sock,
-                      std::stack<dpdk_zero_copy_mrb *, std::vector<dpdk_zero_copy_mrb *>> &free_bufs)
-                      : _sock(sock), _buf(nullptr), _free_bufs(free_bufs) {};
+    dpdk_zero_copy_mrb(struct uhd_dpdk_socket* sock,
+        std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>>& free_bufs)
+        : _sock(sock), _buf(nullptr), _free_bufs(free_bufs){};
     ~dpdk_zero_copy_mrb(void) {}
 
     void release(void)
@@ -197,7 +197,7 @@ public:
 
     sptr get_new(double timeout)
     {
-        int bufs = uhd_dpdk_recv(_sock, &_buf, 1, (int) (timeout*USEC));
+        int bufs = uhd_dpdk_recv(_sock, &_buf, 1, (int)(timeout * USEC));
         if (bufs != 1 || _buf == nullptr) {
             // Push back into pool if we didn't get a real buffer
             _free_bufs.push(this);
@@ -210,32 +210,32 @@ public:
             return sptr();
         }
 
-        return make(this, uhd_dpdk_buf_to_data(_sock, _buf),
-                    uhd_dpdk_get_len(_sock, _buf));
+        return make(
+            this, uhd_dpdk_buf_to_data(_sock, _buf), uhd_dpdk_get_len(_sock, _buf));
     }
 
 private:
-    struct uhd_dpdk_socket *_sock;
-    struct rte_mbuf *_buf;
-    std::stack<dpdk_zero_copy_mrb *, std::vector<dpdk_zero_copy_mrb *>> &_free_bufs;
+    struct uhd_dpdk_socket* _sock;
+    struct rte_mbuf* _buf;
+    std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>>& _free_bufs;
 };
 
-class dpdk_zero_copy_impl : public dpdk_zero_copy {
+class dpdk_zero_copy_impl : public dpdk_zero_copy
+{
 public:
-
-    dpdk_zero_copy_impl(struct uhd_dpdk_ctx &ctx,
-                        const unsigned int dpdk_port_id,
-                        const std::string &addr,
-                        const std::string &remote_port,
-                        const std::string &local_port,
-                        const zero_copy_xport_params& xport_params)
-                          : _num_send_frames(xport_params.num_send_frames),
-                            _send_frame_size(xport_params.send_frame_size),
-                            _num_recv_frames(xport_params.num_recv_frames),
-                            _recv_frame_size(xport_params.recv_frame_size),
-                            _port_id(dpdk_port_id),
-                            _rx_empty_count(0),
-                            _tx_empty_count(0)
+    dpdk_zero_copy_impl(struct uhd_dpdk_ctx& ctx,
+        const unsigned int dpdk_port_id,
+        const std::string& addr,
+        const std::string& remote_port,
+        const std::string& local_port,
+        const zero_copy_xport_params& xport_params)
+        : _num_send_frames(xport_params.num_send_frames)
+        , _send_frame_size(xport_params.send_frame_size)
+        , _num_recv_frames(xport_params.num_recv_frames)
+        , _recv_frame_size(xport_params.recv_frame_size)
+        , _port_id(dpdk_port_id)
+        , _rx_empty_count(0)
+        , _tx_empty_count(0)
     {
         // TODO: Handle xport_params
         UHD_ASSERT_THROW(xport_params.recv_frame_size > 0);
@@ -247,30 +247,28 @@ public:
 
         const int num_ports = uhd_dpdk_port_count();
         UHD_ASSERT_THROW(num_ports > 0);
-        UHD_ASSERT_THROW(dpdk_port_id < (unsigned int) num_ports);
+        UHD_ASSERT_THROW(dpdk_port_id < (unsigned int)num_ports);
 
         // Convert ipv4 addr from string to uint32_t, network format
-        uint32_t dst_ipv4 = (uint32_t) inet_addr(addr.c_str());
+        uint32_t dst_ipv4 = (uint32_t)inet_addr(addr.c_str());
         // Convert port from string to uint16_t, network format
         uint16_t dst_port = htons(std::stoi(remote_port, NULL, 0));
         uint16_t src_port = htons(std::stoi(local_port, NULL, 0));
 
         // Create RX socket first
-        struct uhd_dpdk_sockarg_udp sockarg = {
-            .is_tx = false,
-            .local_port = src_port,
-            .remote_port = dst_port,
-            .dst_addr = dst_ipv4
-        };
+        struct uhd_dpdk_sockarg_udp sockarg = {.is_tx = false,
+            .local_port                               = src_port,
+            .remote_port                              = dst_port,
+            .dst_addr                                 = dst_ipv4};
         _rx_sock = uhd_dpdk_sock_open(dpdk_port_id, UHD_DPDK_SOCK_UDP, &sockarg);
         UHD_ASSERT_THROW(_rx_sock != nullptr);
 
         // Backfill the local port, in case it was auto-assigned
         uhd_dpdk_udp_get_info(_rx_sock, &sockarg);
 
-        sockarg.is_tx = true;
+        sockarg.is_tx       = true;
         sockarg.remote_port = dst_port;
-        sockarg.dst_addr = dst_ipv4;
+        sockarg.dst_addr    = dst_ipv4;
         _tx_sock = uhd_dpdk_sock_open(dpdk_port_id, UHD_DPDK_SOCK_UDP, &sockarg);
         UHD_ASSERT_THROW(_tx_sock != nullptr);
 
@@ -282,9 +280,10 @@ public:
             _msb_pool.push(new dpdk_zero_copy_msb(_tx_sock, _msb_pool));
         }
 
-        UHD_LOG_TRACE("DPDK", "Created transports between " << addr << ":"
-                               << remote_port << " and NIC(" << dpdk_port_id
-                               << "):" << ntohs(sockarg.local_port));
+        UHD_LOG_TRACE("DPDK",
+            "Created transports between " << addr << ":" << remote_port << " and NIC("
+                                          << dpdk_port_id
+                                          << "):" << ntohs(sockarg.local_port));
     }
 
     ~dpdk_zero_copy_impl(void)
@@ -293,18 +292,23 @@ public:
         size_t count;
         uhd_dpdk_udp_get_info(_rx_sock, &sockarg);
         uhd_dpdk_get_drop_count(_rx_sock, &count);
-        UHD_LOG_TRACE("DPDK", "Closing transports between " << sockarg.dst_addr << ":"
-                               << ntohs(sockarg.remote_port) << " and local:"
-                               << ntohs(sockarg.local_port));
-        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                              << " Dropped "<< count << " packets");
+        UHD_LOG_TRACE("DPDK",
+            "Closing transports between " << sockarg.dst_addr << ":"
+                                          << ntohs(sockarg.remote_port)
+                                          << " and local:" << ntohs(sockarg.local_port));
+        UHD_LOG_TRACE("DPDK",
+            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                << " Dropped " << count << " packets");
         uhd_dpdk_get_xfer_count(_rx_sock, &count);
-        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                              << " Received "<< count << " packets");
-        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                              << "RX empty count is " << _rx_empty_count);
-        UHD_LOG_TRACE("DPDK", "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
-                              << "TX empty count is " << _tx_empty_count);
+        UHD_LOG_TRACE("DPDK",
+            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                << " Received " << count << " packets");
+        UHD_LOG_TRACE("DPDK",
+            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                << "RX empty count is " << _rx_empty_count);
+        UHD_LOG_TRACE("DPDK",
+            "(" << ntohs(sockarg.remote_port) << "," << ntohs(sockarg.local_port) << ") "
+                << "TX empty count is " << _tx_empty_count);
         uhd_dpdk_sock_close(_rx_sock);
         uhd_dpdk_sock_close(_tx_sock);
     }
@@ -316,7 +320,7 @@ public:
             return managed_recv_buffer::sptr();
         }
 
-        dpdk_zero_copy_mrb *mrb = _mrb_pool.top();
+        dpdk_zero_copy_mrb* mrb = _mrb_pool.top();
         _mrb_pool.pop();
         managed_recv_buffer::sptr buff = mrb->get_new(timeout);
         if (!buff)
@@ -341,7 +345,7 @@ public:
             return managed_send_buffer::sptr();
         }
 
-        dpdk_zero_copy_msb *msb = _msb_pool.top();
+        dpdk_zero_copy_msb* msb = _msb_pool.top();
         _msb_pool.pop();
         managed_send_buffer::sptr buff = msb->get_new(timeout);
         if (!buff)
@@ -369,14 +373,11 @@ public:
     std::string get_local_addr(void) const
     {
         uint32_t ipv4_addr;
-        int status = uhd_dpdk_get_ipv4_addr(_port_id, &ipv4_addr, NULL);
-        auto retval = std::to_string(ipv4_addr >> 0 & 0xff) +
-                      "." +
-                      std::to_string(ipv4_addr >> 8 & 0xff) +
-                      "." +
-                      std::to_string(ipv4_addr >> 16 & 0xff) +
-                      "." +
-                      std::to_string(ipv4_addr >> 24 & 0xff);
+        int status  = uhd_dpdk_get_ipv4_addr(_port_id, &ipv4_addr, NULL);
+        auto retval = std::to_string(ipv4_addr >> 0 & 0xff) + "."
+                      + std::to_string(ipv4_addr >> 8 & 0xff) + "."
+                      + std::to_string(ipv4_addr >> 16 & 0xff) + "."
+                      + std::to_string(ipv4_addr >> 24 & 0xff);
         return retval;
     }
 
@@ -386,9 +387,10 @@ public:
         uhd_dpdk_get_drop_count(_rx_sock, &drop_count);
         return drop_count;
     }
+
 private:
-    struct uhd_dpdk_socket *_rx_sock;
-    struct uhd_dpdk_socket *_tx_sock;
+    struct uhd_dpdk_socket* _rx_sock;
+    struct uhd_dpdk_socket* _tx_sock;
     const size_t _num_send_frames;
     const size_t _send_frame_size;
     const size_t _num_recv_frames;
@@ -397,22 +399,20 @@ private:
     unsigned int _rx_empty_count;
     unsigned int _tx_empty_count;
 
-    std::stack<dpdk_zero_copy_mrb *, std::vector<dpdk_zero_copy_mrb *>> _mrb_pool;
-    std::stack<dpdk_zero_copy_msb *, std::vector<dpdk_zero_copy_msb *>> _msb_pool;
+    std::stack<dpdk_zero_copy_mrb*, std::vector<dpdk_zero_copy_mrb*>> _mrb_pool;
+    std::stack<dpdk_zero_copy_msb*, std::vector<dpdk_zero_copy_msb*>> _msb_pool;
 };
 
-dpdk_zero_copy::sptr dpdk_zero_copy::make(
-    struct uhd_dpdk_ctx &ctx,
+dpdk_zero_copy::sptr dpdk_zero_copy::make(struct uhd_dpdk_ctx& ctx,
     const unsigned int dpdk_port_id,
-    const std::string &addr,
-    const std::string &remote_port,
-    const std::string &local_port,
-    const zero_copy_xport_params &default_buff_args,
-    const device_addr_t &hints)
+    const std::string& addr,
+    const std::string& remote_port,
+    const std::string& local_port,
+    const zero_copy_xport_params& default_buff_args,
+    const device_addr_t& hints)
 {
-    return dpdk_zero_copy::sptr(
-        new dpdk_zero_copy_impl(ctx, dpdk_port_id, addr, remote_port, local_port, default_buff_args)
-    );
+    return dpdk_zero_copy::sptr(new dpdk_zero_copy_impl(
+        ctx, dpdk_port_id, addr, remote_port, local_port, default_buff_args));
 }
 
-}}
+}} // namespace uhd::transport
diff --git a/host/lib/transport/dpdk_zero_copy.hpp b/host/lib/transport/dpdk_zero_copy.hpp
index a4b5b4879..f90e73d0e 100644
--- a/host/lib/transport/dpdk_zero_copy.hpp
+++ b/host/lib/transport/dpdk_zero_copy.hpp
@@ -8,19 +8,20 @@
 #define DPDK_ZERO_COPY_HPP
 
 #include <uhd/config.hpp>
+#include <uhd/transport/zero_copy.hpp>
 #include <uhd/types/device_addr.hpp>
-#include <uhd/utils/static.hpp>
 #include <uhd/utils/log.hpp>
-#include <uhd/transport/zero_copy.hpp>
+#include <uhd/utils/static.hpp>
 #include <boost/shared_ptr.hpp>
+#include <mutex>
 #include <string>
 #include <vector>
-#include <mutex>
 
 
 namespace uhd { namespace transport {
 
-class uhd_dpdk_ctx : boost::noncopyable {
+class uhd_dpdk_ctx : boost::noncopyable
+{
 public:
     UHD_SINGLETON_FCN(uhd_dpdk_ctx, get);
 
@@ -35,9 +36,12 @@ public:
      * \param mbuf_cache_size Size of per-core packet buffer cache from mempool
      * \param mtu MTU of NIC ports
      */
-    void init(const dict<std::string, std::string> &eal_args, unsigned int num_ports,
-              int *port_thread_mapping, int num_mbufs, int mbuf_cache_size,
-              size_t mtu);
+    void init(const dict<std::string, std::string>& eal_args,
+        unsigned int num_ports,
+        int* port_thread_mapping,
+        int num_mbufs,
+        int mbuf_cache_size,
+        size_t mtu);
 
     /*!
      * Get port ID from provided MAC address
@@ -45,14 +49,14 @@ public:
      * \param port_id Int to write ID of port corresponding to MAC address
      * \return 0 if match found, else no match
      */
-    int get_port_id(std::array<uint8_t, 6> mac_addr, unsigned int &port_id);
+    int get_port_id(std::array<uint8_t, 6> mac_addr, unsigned int& port_id);
 
     /*!
      * Get port ID for routing packet destined for given address
      * \param addr Destination address
      * \return port ID from routing table
      */
-    int get_route(const std::string &addr) const;
+    int get_route(const std::string& addr) const;
 
     /*!
      * Set IPv4 address and subnet mask of given NIC port
@@ -80,19 +84,18 @@ private:
 /*!
  * A zero copy transport interface to the dpdk DMA library.
  */
-class dpdk_zero_copy : public virtual zero_copy_if {
+class dpdk_zero_copy : public virtual zero_copy_if
+{
 public:
     typedef boost::shared_ptr<dpdk_zero_copy> sptr;
 
-    static sptr make(
-        struct uhd_dpdk_ctx &ctx,
+    static sptr make(struct uhd_dpdk_ctx& ctx,
         const unsigned int dpdk_port_id,
-        const std::string &addr,
-        const std::string &remote_port,
-        const std::string &local_port, /* 0 = auto-assign */
-        const zero_copy_xport_params &default_buff_args,
-        const device_addr_t &hints
-    );
+        const std::string& addr,
+        const std::string& remote_port,
+        const std::string& local_port, /* 0 = auto-assign */
+        const zero_copy_xport_params& default_buff_args,
+        const device_addr_t& hints);
 
     virtual uint16_t get_local_port(void) const = 0;
 
@@ -101,6 +104,6 @@ public:
     virtual uint32_t get_drop_count(void) const = 0;
 };
 
-}}
+}} // namespace uhd::transport
 
 #endif /* DPDK_ZERO_COPY_HPP */
diff --git a/host/lib/transport/if_addrs.cpp b/host/lib/transport/if_addrs.cpp
index 109619601..a1cb6909f 100644
--- a/host/lib/transport/if_addrs.cpp
+++ b/host/lib/transport/if_addrs.cpp
@@ -6,47 +6,54 @@
 //
 
 #include <uhd/transport/if_addrs.hpp>
-#include <boost/asio/ip/address_v4.hpp>
 #include <stdint.h>
+#include <boost/asio/ip/address_v4.hpp>
 #include <iostream>
 
 /***********************************************************************
  * Interface address discovery through ifaddrs api
  **********************************************************************/
 #ifdef HAVE_GETIFADDRS
-#include <ifaddrs.h>
+#    include <ifaddrs.h>
 
-static boost::asio::ip::address_v4 sockaddr_to_ip_addr(sockaddr *addr){
-    return boost::asio::ip::address_v4(ntohl(
-        reinterpret_cast<sockaddr_in*>(addr)->sin_addr.s_addr
-    ));
+static boost::asio::ip::address_v4 sockaddr_to_ip_addr(sockaddr* addr)
+{
+    return boost::asio::ip::address_v4(
+        ntohl(reinterpret_cast<sockaddr_in*>(addr)->sin_addr.s_addr));
 }
 
-std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void)
+{
     std::vector<if_addrs_t> if_addrs;
-    struct ifaddrs *ifap;
-    if (getifaddrs(&ifap) == 0){
-        for (struct ifaddrs *iter = ifap; iter != nullptr; iter = iter->ifa_next){
-            //ensure that the entries are valid
-            if (iter->ifa_addr == nullptr) continue;
-            if (iter->ifa_addr->sa_family != AF_INET) continue;
-            if (iter->ifa_netmask->sa_family != AF_INET) continue;
-            if (iter->ifa_broadaddr->sa_family != AF_INET) continue;
-
-            //append a new set of interface addresses
+    struct ifaddrs* ifap;
+    if (getifaddrs(&ifap) == 0) {
+        for (struct ifaddrs* iter = ifap; iter != nullptr; iter = iter->ifa_next) {
+            // ensure that the entries are valid
+            if (iter->ifa_addr == nullptr)
+                continue;
+            if (iter->ifa_addr->sa_family != AF_INET)
+                continue;
+            if (iter->ifa_netmask->sa_family != AF_INET)
+                continue;
+            if (iter->ifa_broadaddr->sa_family != AF_INET)
+                continue;
+
+            // append a new set of interface addresses
             if_addrs_t if_addr;
-            if_addr.inet = sockaddr_to_ip_addr(iter->ifa_addr).to_string();
-            if_addr.mask = sockaddr_to_ip_addr(iter->ifa_netmask).to_string();
+            if_addr.inet  = sockaddr_to_ip_addr(iter->ifa_addr).to_string();
+            if_addr.mask  = sockaddr_to_ip_addr(iter->ifa_netmask).to_string();
             if_addr.bcast = sockaddr_to_ip_addr(iter->ifa_broadaddr).to_string();
 
-            //correct the bcast address when its same as the gateway
-            if (if_addr.inet == if_addr.bcast or sockaddr_to_ip_addr(iter->ifa_broadaddr) == boost::asio::ip::address_v4(0)){
-                //manually calculate broadcast address
-                //https://svn.boost.org/trac/boost/ticket/5198
-                const uint32_t addr = sockaddr_to_ip_addr(iter->ifa_addr).to_ulong();
-                const uint32_t mask = sockaddr_to_ip_addr(iter->ifa_netmask).to_ulong();
+            // correct the bcast address when its same as the gateway
+            if (if_addr.inet == if_addr.bcast
+                or sockaddr_to_ip_addr(iter->ifa_broadaddr)
+                       == boost::asio::ip::address_v4(0)) {
+                // manually calculate broadcast address
+                // https://svn.boost.org/trac/boost/ticket/5198
+                const uint32_t addr  = sockaddr_to_ip_addr(iter->ifa_addr).to_ulong();
+                const uint32_t mask  = sockaddr_to_ip_addr(iter->ifa_netmask).to_ulong();
                 const uint32_t bcast = (addr & mask) | ~mask;
-                if_addr.bcast = boost::asio::ip::address_v4(bcast).to_string();
+                if_addr.bcast        = boost::asio::ip::address_v4(bcast).to_string();
             }
 
             if_addrs.push_back(if_addr);
@@ -62,34 +69,44 @@ std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
  * Interface address discovery through windows api
  **********************************************************************/
 #ifdef HAVE_SIO_GET_INTERFACE_LIST
-#include <winsock2.h>
+#    include <winsock2.h>
 
-std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void)
+{
     std::vector<if_addrs_t> if_addrs;
     SOCKET sd = WSASocket(AF_INET, SOCK_DGRAM, 0, 0, 0, 0);
     if (sd == SOCKET_ERROR) {
-        std::cerr << "Failed to get a socket. Error " << WSAGetLastError() <<
-            std::endl; return if_addrs;
+        std::cerr << "Failed to get a socket. Error " << WSAGetLastError() << std::endl;
+        return if_addrs;
     }
 
     INTERFACE_INFO InterfaceList[20];
     unsigned long nBytesReturned;
-    if (WSAIoctl(sd, SIO_GET_INTERFACE_LIST, 0, 0, &InterfaceList,
-			sizeof(InterfaceList), &nBytesReturned, 0, 0) == SOCKET_ERROR) {
-        std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError() <<
-				std::endl;
-		return if_addrs;
+    if (WSAIoctl(sd,
+            SIO_GET_INTERFACE_LIST,
+            0,
+            0,
+            &InterfaceList,
+            sizeof(InterfaceList),
+            &nBytesReturned,
+            0,
+            0)
+        == SOCKET_ERROR) {
+        std::cerr << "Failed calling WSAIoctl: error " << WSAGetLastError() << std::endl;
+        return if_addrs;
     }
 
     int nNumInterfaces = nBytesReturned / sizeof(INTERFACE_INFO);
     for (int i = 0; i < nNumInterfaces; ++i) {
-        uint32_t iiAddress = ntohl(reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiAddress).sin_addr.s_addr);
-        uint32_t iiNetmask = ntohl(reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiNetmask).sin_addr.s_addr);
+        uint32_t iiAddress = ntohl(
+            reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiAddress).sin_addr.s_addr);
+        uint32_t iiNetmask = ntohl(
+            reinterpret_cast<sockaddr_in&>(InterfaceList[i].iiNetmask).sin_addr.s_addr);
         uint32_t iiBroadcastAddress = (iiAddress & iiNetmask) | ~iiNetmask;
 
         if_addrs_t if_addr;
-        if_addr.inet = boost::asio::ip::address_v4(iiAddress).to_string();
-        if_addr.mask = boost::asio::ip::address_v4(iiNetmask).to_string();
+        if_addr.inet  = boost::asio::ip::address_v4(iiAddress).to_string();
+        if_addr.mask  = boost::asio::ip::address_v4(iiNetmask).to_string();
         if_addr.bcast = boost::asio::ip::address_v4(iiBroadcastAddress).to_string();
         if_addrs.push_back(if_addr);
     }
@@ -104,7 +121,8 @@ std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
  **********************************************************************/
 #ifdef HAVE_IF_ADDRS_DUMMY
 
-std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void){
+std::vector<uhd::transport::if_addrs_t> uhd::transport::get_if_addrs(void)
+{
     return std::vector<if_addrs_t>();
 }
 
diff --git a/host/lib/transport/liberio_zero_copy.cpp b/host/lib/transport/liberio_zero_copy.cpp
index 0999d78cf..989480382 100644
--- a/host/lib/transport/liberio_zero_copy.cpp
+++ b/host/lib/transport/liberio_zero_copy.cpp
@@ -7,33 +7,34 @@
 
 #include "liberio_zero_copy.hpp"
 #include <uhd/config.hpp>
-#include <uhd/utils/static.hpp>
 #include <uhd/utils/log.hpp>
+#include <uhd/utils/static.hpp>
 #include <liberio/liberio.h>
-#include <boost/make_shared.hpp>
 #include <sys/syslog.h>
+#include <boost/make_shared.hpp>
 #include <mutex>
 
 namespace uhd { namespace transport {
 
 static const uint64_t USEC = 1000000;
 
-static void liberio_log_cb(int severity, const char *msg, void *)
+static void liberio_log_cb(int severity, const char* msg, void*)
 {
     switch (severity) {
-    case LOG_WARNING:
-        UHD_LOG_WARNING("LIBERIO", msg);
-        return;
-    case LOG_NOTICE:
-    case LOG_INFO:
-        UHD_LOG_INFO("LIBERIO", msg);
-        return;
-    default:
-        UHD_LOG_INFO("LIBERIO", msg);
+        case LOG_WARNING:
+            UHD_LOG_WARNING("LIBERIO", msg);
+            return;
+        case LOG_NOTICE:
+        case LOG_INFO:
+            UHD_LOG_INFO("LIBERIO", msg);
+            return;
+        default:
+            UHD_LOG_INFO("LIBERIO", msg);
     };
 }
 
-class liberio_context_holder {
+class liberio_context_holder
+{
 public:
     liberio_context_holder(void)
     {
@@ -41,22 +42,27 @@ public:
         liberio_ctx_register_logger(_ctx, &liberio_log_cb, nullptr);
     }
 
-    ~liberio_context_holder(void) { liberio_ctx_put(_ctx); }
+    ~liberio_context_holder(void)
+    {
+        liberio_ctx_put(_ctx);
+    }
 
     liberio_ctx* get(void)
     {
         liberio_ctx_get(_ctx);
         return _ctx;
     }
+
 private:
-    liberio_ctx *_ctx;
+    liberio_ctx* _ctx;
 };
 
 UHD_SINGLETON_FCN(liberio_context_holder, get_liberio_context_holder);
 
-class liberio_zero_copy_msb : public virtual managed_send_buffer {
+class liberio_zero_copy_msb : public virtual managed_send_buffer
+{
 public:
-    liberio_zero_copy_msb(liberio_chan *chan) : _chan(chan), _buf(nullptr) {}
+    liberio_zero_copy_msb(liberio_chan* chan) : _chan(chan), _buf(nullptr) {}
     ~liberio_zero_copy_msb(void)
     {
         liberio_chan_put(_chan);
@@ -70,7 +76,7 @@ public:
         }
     }
 
-    sptr get_new(double timeout, size_t &index)
+    sptr get_new(double timeout, size_t& index)
     {
         _buf = liberio_chan_buf_dequeue(_chan, timeout * USEC);
         if (!_buf)
@@ -78,18 +84,18 @@ public:
 
         index++;
 
-        return make(this, liberio_buf_get_mem(_buf, 0),
-                    liberio_buf_get_len(_buf, 0));
+        return make(this, liberio_buf_get_mem(_buf, 0), liberio_buf_get_len(_buf, 0));
     }
 
 private:
-    liberio_chan *_chan;
-    liberio_buf *_buf;
+    liberio_chan* _chan;
+    liberio_buf* _buf;
 };
 
-class liberio_zero_copy_mrb : public virtual managed_recv_buffer {
+class liberio_zero_copy_mrb : public virtual managed_recv_buffer
+{
 public:
-    liberio_zero_copy_mrb(liberio_chan *chan) : _chan(chan), _buf(nullptr) {}
+    liberio_zero_copy_mrb(liberio_chan* chan) : _chan(chan), _buf(nullptr) {}
     ~liberio_zero_copy_mrb(void)
     {
         liberio_chan_put(_chan);
@@ -101,7 +107,7 @@ public:
             liberio_chan_buf_enqueue(_chan, _buf);
     }
 
-    sptr get_new(double timeout, size_t &index)
+    sptr get_new(double timeout, size_t& index)
     {
         _buf = liberio_chan_buf_dequeue(_chan, timeout * USEC);
         if (!_buf)
@@ -109,65 +115,55 @@ public:
 
         index++;
 
-        return make(this, liberio_buf_get_mem(_buf, 0),
-                    liberio_buf_get_payload(_buf, 0));
+        return make(this, liberio_buf_get_mem(_buf, 0), liberio_buf_get_payload(_buf, 0));
     }
 
 private:
-    liberio_chan *_chan;
-    liberio_buf *_buf;
+    liberio_chan* _chan;
+    liberio_buf* _buf;
 };
 
-class liberio_zero_copy_impl : public liberio_zero_copy {
+class liberio_zero_copy_impl : public liberio_zero_copy
+{
 public:
-
-    liberio_zero_copy_impl(const std::string &tx_path,
-                           const std::string &rx_path,
-                           const zero_copy_xport_params& xport_params)
-                          : _tx_buf_size(xport_params.send_frame_size),
-                            _rx_buf_size(xport_params.recv_frame_size),
-                            _next_recv_buff_index(0),
-                            _next_send_buff_index(0)
+    liberio_zero_copy_impl(const std::string& tx_path,
+        const std::string& rx_path,
+        const zero_copy_xport_params& xport_params)
+        : _tx_buf_size(xport_params.send_frame_size)
+        , _rx_buf_size(xport_params.recv_frame_size)
+        , _next_recv_buff_index(0)
+        , _next_send_buff_index(0)
     {
         UHD_ASSERT_THROW(xport_params.recv_frame_size > 0);
         UHD_ASSERT_THROW(xport_params.send_frame_size > 0);
         UHD_ASSERT_THROW(xport_params.num_send_frames > 0);
         UHD_ASSERT_THROW(xport_params.num_recv_frames > 0);
 
-        liberio_ctx *ctx = get_liberio_context_holder().get();
+        liberio_ctx* ctx = get_liberio_context_holder().get();
 
         /* we hold a reference, that we'd drop immediately after,
          * so no requirement to get another one here ...
          */
-        _tx_chan = liberio_ctx_alloc_chan(ctx, tx_path.c_str(), TX,
-                           USRP_MEMORY_MMAP);
+        _tx_chan = liberio_ctx_alloc_chan(ctx, tx_path.c_str(), TX, USRP_MEMORY_MMAP);
 
         UHD_ASSERT_THROW(_tx_chan);
         liberio_chan_stop_streaming(_tx_chan);
         liberio_chan_request_buffers(_tx_chan, 0);
         UHD_ASSERT_THROW(
-            !liberio_chan_set_fixed_size(_tx_chan, 0,
-                xport_params.send_frame_size
-            )
-        );
+            !liberio_chan_set_fixed_size(_tx_chan, 0, xport_params.send_frame_size));
         UHD_ASSERT_THROW(
-            !liberio_chan_request_buffers(
-                _tx_chan, xport_params.num_send_frames
-            )
-        );
+            !liberio_chan_request_buffers(_tx_chan, xport_params.num_send_frames));
         _num_send_bufs = liberio_chan_get_num_bufs(_tx_chan);
 
         for (size_t i = 0; i < xport_params.num_send_frames; i++) {
             liberio_chan_get(_tx_chan);
-            _msb_pool.push_back(
-                boost::make_shared<liberio_zero_copy_msb>(_tx_chan));
+            _msb_pool.push_back(boost::make_shared<liberio_zero_copy_msb>(_tx_chan));
         }
 
         /* we hold a reference, that we'd drop immediately after,
          * so no requirement to get another one here ...
          */
-        _rx_chan = liberio_ctx_alloc_chan(ctx, rx_path.c_str(),
-                          RX, USRP_MEMORY_MMAP);
+        _rx_chan = liberio_ctx_alloc_chan(ctx, rx_path.c_str(), RX, USRP_MEMORY_MMAP);
         UHD_ASSERT_THROW(_rx_chan);
 
         /* done with the local reference, the channel keeps its own */
@@ -177,18 +173,14 @@ public:
         liberio_chan_stop_streaming(_rx_chan);
         liberio_chan_request_buffers(_rx_chan, 0);
         UHD_ASSERT_THROW(
-            !liberio_chan_set_fixed_size(_rx_chan, 0,
-                xport_params.recv_frame_size
-            )
-        );
-        UHD_ASSERT_THROW(!liberio_chan_request_buffers(
-                _rx_chan, xport_params.num_recv_frames));
+            !liberio_chan_set_fixed_size(_rx_chan, 0, xport_params.recv_frame_size));
+        UHD_ASSERT_THROW(
+            !liberio_chan_request_buffers(_rx_chan, xport_params.num_recv_frames));
         _num_recv_bufs = liberio_chan_get_num_bufs(_rx_chan);
 
         for (size_t i = 0; i < xport_params.num_recv_frames; i++) {
             liberio_chan_get(_rx_chan);
-            _mrb_pool.push_back(
-                boost::make_shared<liberio_zero_copy_mrb>(_rx_chan));
+            _mrb_pool.push_back(boost::make_shared<liberio_zero_copy_mrb>(_rx_chan));
         }
 
         UHD_ASSERT_THROW(!liberio_chan_enqueue_all(_rx_chan));
@@ -208,8 +200,7 @@ public:
         std::lock_guard<std::mutex> lock(_rx_mutex);
         if (_next_recv_buff_index == _num_recv_bufs)
             _next_recv_buff_index = 0;
-        return _mrb_pool[_next_recv_buff_index]->get_new(
-            timeout, _next_recv_buff_index);
+        return _mrb_pool[_next_recv_buff_index]->get_new(timeout, _next_recv_buff_index);
     }
 
     size_t get_num_recv_frames(void) const
@@ -223,12 +214,11 @@ public:
     }
 
     managed_send_buffer::sptr get_send_buff(double timeout = 0.1)
-    { 
+    {
         std::lock_guard<std::mutex> lock(_tx_mutex);
         if (_next_send_buff_index == _num_send_bufs)
             _next_send_buff_index = 0;
-        return _msb_pool[_next_send_buff_index]->get_new(
-            timeout, _next_send_buff_index);
+        return _msb_pool[_next_send_buff_index]->get_new(timeout, _next_send_buff_index);
     }
 
     size_t get_num_send_frames(void) const
@@ -242,29 +232,27 @@ public:
     }
 
 private:
-    liberio_chan *_tx_chan;
+    liberio_chan* _tx_chan;
     const size_t _tx_buf_size;
     size_t _num_send_bufs;
-    liberio_chan *_rx_chan;
+    liberio_chan* _rx_chan;
     const size_t _rx_buf_size;
     size_t _num_recv_bufs;
 
-    std::vector<boost::shared_ptr<liberio_zero_copy_mrb> > _mrb_pool;
+    std::vector<boost::shared_ptr<liberio_zero_copy_mrb>> _mrb_pool;
     size_t _next_recv_buff_index;
-    std::vector<boost::shared_ptr<liberio_zero_copy_msb> > _msb_pool;
+    std::vector<boost::shared_ptr<liberio_zero_copy_msb>> _msb_pool;
     size_t _next_send_buff_index;
     std::mutex _rx_mutex;
     std::mutex _tx_mutex;
 };
 
-liberio_zero_copy::sptr liberio_zero_copy::make(
-    const std::string &tx_path,
-    const std::string &rx_path,
-    const zero_copy_xport_params &default_buff_args)
+liberio_zero_copy::sptr liberio_zero_copy::make(const std::string& tx_path,
+    const std::string& rx_path,
+    const zero_copy_xport_params& default_buff_args)
 {
     return liberio_zero_copy::sptr(
-        new liberio_zero_copy_impl(tx_path, rx_path, default_buff_args)
-    );
+        new liberio_zero_copy_impl(tx_path, rx_path, default_buff_args));
 }
 
-}}
+}} // namespace uhd::transport
diff --git a/host/lib/transport/liberio_zero_copy.hpp b/host/lib/transport/liberio_zero_copy.hpp
index 1dfa3af71..b41b6416c 100644
--- a/host/lib/transport/liberio_zero_copy.hpp
+++ b/host/lib/transport/liberio_zero_copy.hpp
@@ -8,30 +8,28 @@
 #ifndef LIBERIO_HPP
 #define LIBERIO_HPP
 
-#include <string>
-#include <vector>
-
 #include <uhd/config.hpp>
 #include <uhd/transport/zero_copy.hpp>
 #include <uhd/types/device_addr.hpp>
 #include <boost/shared_ptr.hpp>
+#include <string>
+#include <vector>
 
 namespace uhd { namespace transport {
 
 /*!
  * A zero copy transport interface to the liberio DMA library.
  */
-class liberio_zero_copy : public virtual zero_copy_if {
+class liberio_zero_copy : public virtual zero_copy_if
+{
 public:
     typedef boost::shared_ptr<liberio_zero_copy> sptr;
 
-    static sptr make(
-        const std::string &tx_path,
-        const std::string &rx_path,
-        const zero_copy_xport_params &default_buff_args
-    );
+    static sptr make(const std::string& tx_path,
+        const std::string& rx_path,
+        const zero_copy_xport_params& default_buff_args);
 };
 
-}}
+}} // namespace uhd::transport
 
 #endif /* LIBERIO_HPP */
diff --git a/host/lib/transport/libusb1_base.cpp b/host/lib/transport/libusb1_base.cpp
index 03d99aa47..83d9fe1df 100644
--- a/host/lib/transport/libusb1_base.cpp
+++ b/host/lib/transport/libusb1_base.cpp
@@ -7,14 +7,13 @@
 
 #include "libusb1_base.hpp"
 #include <uhd/exception.hpp>
-
-#include <uhd/utils/log.hpp>
-#include <uhd/utils/tasks.hpp>
 #include <uhd/types/dict.hpp>
 #include <uhd/types/serial.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/thread/mutex.hpp>
+#include <uhd/utils/log.hpp>
+#include <uhd/utils/tasks.hpp>
 #include <boost/bind.hpp>
+#include <boost/thread/mutex.hpp>
+#include <boost/weak_ptr.hpp>
 #include <cstdlib>
 #include <iostream>
 
@@ -24,75 +23,84 @@ using namespace uhd::transport;
 /***********************************************************************
  * libusb session
  **********************************************************************/
-libusb::session::~session(void) {
+libusb::session::~session(void)
+{
     /* NOP */
 }
 
-class libusb_session_impl : public libusb::session{
+class libusb_session_impl : public libusb::session
+{
 public:
-    libusb_session_impl(void){
+    libusb_session_impl(void)
+    {
         UHD_ASSERT_THROW(libusb_init(&_context) == 0);
         libusb_set_debug(_context, debug_level);
-        task_handler = task::make(boost::bind(&libusb_session_impl::libusb_event_handler_task, this, _context));
+        task_handler = task::make(
+            boost::bind(&libusb_session_impl::libusb_event_handler_task, this, _context));
     }
 
     virtual ~libusb_session_impl(void);
 
-    libusb_context *get_context(void) const{
+    libusb_context* get_context(void) const
+    {
         return _context;
     }
 
 private:
-    libusb_context *_context;
+    libusb_context* _context;
     task::sptr task_handler;
 
     /*
-     * Task to handle libusb events.  There should only be one thread per libusb_context handling events.
-     * Using more than one thread can result in excessive CPU usage in kernel space (presumably from locking/waiting).
-     * The libusb documentation says it is safe, which it is, but it neglects to state the cost in CPU usage.
-     * Just don't do it!
+     * Task to handle libusb events.  There should only be one thread per libusb_context
+     * handling events. Using more than one thread can result in excessive CPU usage in
+     * kernel space (presumably from locking/waiting). The libusb documentation says it is
+     * safe, which it is, but it neglects to state the cost in CPU usage. Just don't do
+     * it!
      */
-    UHD_INLINE void libusb_event_handler_task(libusb_context *context)
+    UHD_INLINE void libusb_event_handler_task(libusb_context* context)
     {
         timeval tv;
-        tv.tv_sec = 0;
+        tv.tv_sec  = 0;
         tv.tv_usec = 100000;
-        int ret = libusb_handle_events_timeout(context, &tv);
-        switch (ret)
-        {
-        case LIBUSB_SUCCESS:
-        case LIBUSB_ERROR_TIMEOUT:
-            break;
-        case LIBUSB_ERROR_NO_DEVICE:
-            throw uhd::io_error(libusb_strerror(LIBUSB_ERROR_NO_DEVICE));
-        default:
-            UHD_LOGGER_ERROR("USB") << __FUNCTION__ << ": " << libusb_strerror((libusb_error)ret) ;
-            break;
+        int ret    = libusb_handle_events_timeout(context, &tv);
+        switch (ret) {
+            case LIBUSB_SUCCESS:
+            case LIBUSB_ERROR_TIMEOUT:
+                break;
+            case LIBUSB_ERROR_NO_DEVICE:
+                throw uhd::io_error(libusb_strerror(LIBUSB_ERROR_NO_DEVICE));
+            default:
+                UHD_LOGGER_ERROR("USB")
+                    << __FUNCTION__ << ": " << libusb_strerror((libusb_error)ret);
+                break;
         }
     }
 };
 
-libusb_session_impl::~libusb_session_impl(void){
+libusb_session_impl::~libusb_session_impl(void)
+{
     task_handler.reset();
     libusb_exit(_context);
 }
 
-libusb::session::sptr libusb::session::get_global_session(void){
+libusb::session::sptr libusb::session::get_global_session(void)
+{
     static boost::weak_ptr<session> global_session;
 
-    //not expired -> get existing session
-    if (not global_session.expired()) return global_session.lock();
+    // not expired -> get existing session
+    if (not global_session.expired())
+        return global_session.lock();
 
-    //create a new global session
+    // create a new global session
     sptr new_global_session(new libusb_session_impl());
     global_session = new_global_session;
 
-    //set logging if envvar is set
-    const char *level_string = getenv("LIBUSB_DEBUG_LEVEL");
-    if (level_string != NULL)
-    {
-        const int level = int(level_string[0] - '0'); //easy conversion to integer
-        if (level >= 0 and level <= 3) libusb_set_debug(new_global_session->get_context(), level);
+    // set logging if envvar is set
+    const char* level_string = getenv("LIBUSB_DEBUG_LEVEL");
+    if (level_string != NULL) {
+        const int level = int(level_string[0] - '0'); // easy conversion to integer
+        if (level >= 0 and level <= 3)
+            libusb_set_debug(new_global_session->get_context(), level);
     }
 
     return new_global_session;
@@ -101,65 +109,75 @@ libusb::session::sptr libusb::session::get_global_session(void){
 /***********************************************************************
  * libusb device
  **********************************************************************/
-libusb::device::~device(void) {
+libusb::device::~device(void)
+{
     /* NOP */
 }
 
-class libusb_device_impl : public libusb::device{
+class libusb_device_impl : public libusb::device
+{
 public:
-    libusb_device_impl(libusb_device *dev){
+    libusb_device_impl(libusb_device* dev)
+    {
         _session = libusb::session::get_global_session();
-        _dev = dev;
+        _dev     = dev;
     }
 
     virtual ~libusb_device_impl(void);
 
-    libusb_device *get(void) const{
+    libusb_device* get(void) const
+    {
         return _dev;
     }
 
 private:
-    libusb::session::sptr _session; //always keep a reference to session
-    libusb_device *_dev;
+    libusb::session::sptr _session; // always keep a reference to session
+    libusb_device* _dev;
 };
 
-libusb_device_impl::~libusb_device_impl(void){
+libusb_device_impl::~libusb_device_impl(void)
+{
     libusb_unref_device(this->get());
 }
 
 /***********************************************************************
  * libusb device list
  **********************************************************************/
-libusb::device_list::~device_list(void){
+libusb::device_list::~device_list(void)
+{
     /* NOP */
 }
 
-class libusb_device_list_impl : public libusb::device_list{
+class libusb_device_list_impl : public libusb::device_list
+{
 public:
-    libusb_device_list_impl(void){
+    libusb_device_list_impl(void)
+    {
         libusb::session::sptr sess = libusb::session::get_global_session();
 
-        //allocate a new list of devices
+        // allocate a new list of devices
         libusb_device** dev_list;
         ssize_t ret = libusb_get_device_list(sess->get_context(), &dev_list);
-        if (ret < 0) throw uhd::os_error("cannot enumerate usb devices");
+        if (ret < 0)
+            throw uhd::os_error("cannot enumerate usb devices");
 
-        //fill the vector of device references
-        for (size_t i = 0; i < size_t(ret); i++) _devs.push_back(
-            libusb::device::sptr(new libusb_device_impl(dev_list[i]))
-        );
+        // fill the vector of device references
+        for (size_t i = 0; i < size_t(ret); i++)
+            _devs.push_back(libusb::device::sptr(new libusb_device_impl(dev_list[i])));
 
-        //free the device list but dont unref (done in ~device)
-        libusb_free_device_list(dev_list, false/*dont unref*/);
+        // free the device list but dont unref (done in ~device)
+        libusb_free_device_list(dev_list, false /*dont unref*/);
     }
 
     virtual ~libusb_device_list_impl(void);
 
-    size_t size(void) const{
+    size_t size(void) const
+    {
         return _devs.size();
     }
 
-    libusb::device::sptr at(size_t i) const{
+    libusb::device::sptr at(size_t i) const
+    {
         return _devs.at(i);
     }
 
@@ -167,96 +185,113 @@ private:
     std::vector<libusb::device::sptr> _devs;
 };
 
-libusb_device_list_impl::~libusb_device_list_impl(void){
+libusb_device_list_impl::~libusb_device_list_impl(void)
+{
     /* NOP */
 }
 
-libusb::device_list::sptr libusb::device_list::make(void){
+libusb::device_list::sptr libusb::device_list::make(void)
+{
     return sptr(new libusb_device_list_impl());
 }
 
 /***********************************************************************
  * libusb device descriptor
  **********************************************************************/
-libusb::device_descriptor::~device_descriptor(void){
+libusb::device_descriptor::~device_descriptor(void)
+{
     /* NOP */
 }
 
-class libusb_device_descriptor_impl : public libusb::device_descriptor{
+class libusb_device_descriptor_impl : public libusb::device_descriptor
+{
 public:
-    libusb_device_descriptor_impl(libusb::device::sptr dev){
+    libusb_device_descriptor_impl(libusb::device::sptr dev)
+    {
         _dev = dev;
         UHD_ASSERT_THROW(libusb_get_device_descriptor(_dev->get(), &_desc) == 0);
     }
 
     virtual ~libusb_device_descriptor_impl(void);
 
-    const libusb_device_descriptor &get(void) const{
+    const libusb_device_descriptor& get(void) const
+    {
         return _desc;
     }
 
-    std::string get_ascii_property(const std::string &what) const
+    std::string get_ascii_property(const std::string& what) const
     {
         uint8_t off = 0;
-        if (what == "serial") off = this->get().iSerialNumber;
-        if (what == "product") off = this->get().iProduct;
-        if (what == "manufacturer") off = this->get().iManufacturer;
-        if (off == 0) return "";
+        if (what == "serial")
+            off = this->get().iSerialNumber;
+        if (what == "product")
+            off = this->get().iProduct;
+        if (what == "manufacturer")
+            off = this->get().iManufacturer;
+        if (off == 0)
+            return "";
 
         libusb::device_handle::sptr handle(
-            libusb::device_handle::get_cached_handle(_dev)
-        );
+            libusb::device_handle::get_cached_handle(_dev));
 
         unsigned char buff[512];
         int ret = libusb_get_string_descriptor_ascii(
-            handle->get(), off, buff, int(sizeof(buff))
-        );
-        if (ret < 0) return ""; //on error, just return empty string
+            handle->get(), off, buff, int(sizeof(buff)));
+        if (ret < 0)
+            return ""; // on error, just return empty string
 
-        std::string string_descriptor((char *)buff, size_t(ret));
+        std::string string_descriptor((char*)buff, size_t(ret));
         byte_vector_t string_vec(string_descriptor.begin(), string_descriptor.end());
         std::string out;
-        for(uint8_t byte:  string_vec){
-            if (byte < 32 or byte > 127) return out;
+        for (uint8_t byte : string_vec) {
+            if (byte < 32 or byte > 127)
+                return out;
             out += byte;
         }
         return out;
     }
 
 private:
-    libusb::device::sptr _dev; //always keep a reference to device
+    libusb::device::sptr _dev; // always keep a reference to device
     libusb_device_descriptor _desc;
 };
 
-libusb_device_descriptor_impl::~libusb_device_descriptor_impl(void){
+libusb_device_descriptor_impl::~libusb_device_descriptor_impl(void)
+{
     /* NOP */
 }
 
-libusb::device_descriptor::sptr libusb::device_descriptor::make(device::sptr dev){
+libusb::device_descriptor::sptr libusb::device_descriptor::make(device::sptr dev)
+{
     return sptr(new libusb_device_descriptor_impl(dev));
 }
 
 /***********************************************************************
  * libusb device handle
  **********************************************************************/
-libusb::device_handle::~device_handle(void){
+libusb::device_handle::~device_handle(void)
+{
     /* NOP */
 }
 
-class libusb_device_handle_impl : public libusb::device_handle{
+class libusb_device_handle_impl : public libusb::device_handle
+{
 public:
-    libusb_device_handle_impl(libusb::device::sptr dev){
+    libusb_device_handle_impl(libusb::device::sptr dev)
+    {
         _dev = dev;
         UHD_ASSERT_THROW(libusb_open(_dev->get(), &_handle) == 0);
     }
 
     virtual ~libusb_device_handle_impl(void);
 
-    libusb_device_handle *get(void) const{
+    libusb_device_handle* get(void) const
+    {
         return _handle;
     }
 
-    void claim_interface(int interface){
+    void claim_interface(int interface)
+    {
         UHD_ASSERT_THROW(libusb_claim_interface(this->get(), interface) == 0);
         _claimed.push_back(interface);
     }
@@ -264,59 +299,61 @@ public:
     void clear_endpoints(unsigned char recv_endpoint, unsigned char send_endpoint)
     {
         int ret;
-        ret = libusb_clear_halt(this->get(), recv_endpoint  | 0x80);
-        UHD_LOGGER_TRACE("USB") << "usb device handle: recv endpoint clear: " << libusb_error_name(ret) ;
+        ret = libusb_clear_halt(this->get(), recv_endpoint | 0x80);
+        UHD_LOGGER_TRACE("USB")
+            << "usb device handle: recv endpoint clear: " << libusb_error_name(ret);
         ret = libusb_clear_halt(this->get(), send_endpoint | 0x00);
-        UHD_LOGGER_TRACE("USB") << "usb device handle: send endpoint clear: " << libusb_error_name(ret) ;
+        UHD_LOGGER_TRACE("USB")
+            << "usb device handle: send endpoint clear: " << libusb_error_name(ret);
     }
 
     void reset_device(void)
     {
         int ret = libusb_reset_device(this->get());
-        UHD_LOGGER_TRACE("USB") << "usb device handle: dev Reset: " << libusb_error_name(ret) ;
+        UHD_LOGGER_TRACE("USB")
+            << "usb device handle: dev Reset: " << libusb_error_name(ret);
     }
 
 private:
-    libusb::device::sptr _dev; //always keep a reference to device
-    libusb_device_handle *_handle;
+    libusb::device::sptr _dev; // always keep a reference to device
+    libusb_device_handle* _handle;
     std::vector<int> _claimed;
 };
 
-libusb_device_handle_impl::~libusb_device_handle_impl(void){
-    //release all claimed interfaces
-    for (size_t i = 0; i < _claimed.size(); i++){
+libusb_device_handle_impl::~libusb_device_handle_impl(void)
+{
+    // release all claimed interfaces
+    for (size_t i = 0; i < _claimed.size(); i++) {
         libusb_release_interface(this->get(), _claimed[i]);
     }
     libusb_close(_handle);
 }
 
-libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::sptr dev){
-    static uhd::dict<libusb_device *, boost::weak_ptr<device_handle> > handles;
+libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::sptr dev)
+{
+    static uhd::dict<libusb_device*, boost::weak_ptr<device_handle>> handles;
 
-    //lock for atomic access to static table above
+    // lock for atomic access to static table above
     static boost::mutex mutex;
     boost::mutex::scoped_lock lock(mutex);
 
-    //not expired -> get existing handle
-    if (handles.has_key(dev->get()) and not handles[dev->get()].expired()){
+    // not expired -> get existing handle
+    if (handles.has_key(dev->get()) and not handles[dev->get()].expired()) {
         return handles[dev->get()].lock();
     }
 
-    //create a new cached handle
-    try{
+    // create a new cached handle
+    try {
         sptr new_handle(new libusb_device_handle_impl(dev));
         handles[dev->get()] = new_handle;
         return new_handle;
-    }
-    catch(const uhd::exception &){
-        #ifdef UHD_PLATFORM_LINUX
-        UHD_LOGGER_ERROR("USB") <<
-            "USB open failed: insufficient permissions.\n"
-            "See the application notes for your device.\n"
-        ;
-        #else
-        UHD_LOGGER_DEBUG("USB") << "USB open failed: device already claimed." ;
-        #endif
+    } catch (const uhd::exception&) {
+#ifdef UHD_PLATFORM_LINUX
+        UHD_LOGGER_ERROR("USB") << "USB open failed: insufficient permissions.\n"
+                                   "See the application notes for your device.\n";
+#else
+        UHD_LOGGER_DEBUG("USB") << "USB open failed: device already claimed.";
+#endif
         throw;
     }
 }
@@ -324,85 +361,105 @@ libusb::device_handle::sptr libusb::device_handle::get_cached_handle(device::spt
 /***********************************************************************
  * libusb special handle
  **********************************************************************/
-libusb::special_handle::~special_handle(void){
+libusb::special_handle::~special_handle(void)
+{
     /* NOP */
 }
 
-class libusb_special_handle_impl : public libusb::special_handle{
+class libusb_special_handle_impl : public libusb::special_handle
+{
 public:
-    libusb_special_handle_impl(libusb::device::sptr dev){
+    libusb_special_handle_impl(libusb::device::sptr dev)
+    {
         _dev = dev;
     }
 
     virtual ~libusb_special_handle_impl(void);
 
-    libusb::device::sptr get_device(void) const{
+    libusb::device::sptr get_device(void) const
+    {
         return _dev;
     }
 
-    std::string get_serial(void) const{
-        return libusb::device_descriptor::make(this->get_device())->get_ascii_property("serial");
+    std::string get_serial(void) const
+    {
+        return libusb::device_descriptor::make(this->get_device())
+            ->get_ascii_property("serial");
     }
 
-    std::string get_manufacturer() const{
-        return libusb::device_descriptor::make(this->get_device())->get_ascii_property("manufacturer");
+    std::string get_manufacturer() const
+    {
+        return libusb::device_descriptor::make(this->get_device())
+            ->get_ascii_property("manufacturer");
     }
 
-    std::string get_product() const{
-        return libusb::device_descriptor::make(this->get_device())->get_ascii_property("product");
+    std::string get_product() const
+    {
+        return libusb::device_descriptor::make(this->get_device())
+            ->get_ascii_property("product");
     }
 
-    uint16_t get_vendor_id(void) const{
+    uint16_t get_vendor_id(void) const
+    {
         return libusb::device_descriptor::make(this->get_device())->get().idVendor;
     }
 
-    uint16_t get_product_id(void) const{
+    uint16_t get_product_id(void) const
+    {
         return libusb::device_descriptor::make(this->get_device())->get().idProduct;
     }
 
-    bool firmware_loaded() {
-        return (get_manufacturer() == "Ettus Research LLC") or
-               (get_manufacturer() == "National Instruments Corp.") or
-               (get_manufacturer() == "Free Software Folks");
+    bool firmware_loaded()
+    {
+        return (get_manufacturer() == "Ettus Research LLC")
+               or (get_manufacturer() == "National Instruments Corp.")
+               or (get_manufacturer() == "Free Software Folks");
     }
 
 private:
-    libusb::device::sptr _dev; //always keep a reference to device
+    libusb::device::sptr _dev; // always keep a reference to device
 };
 
-libusb_special_handle_impl::~libusb_special_handle_impl(void){
+libusb_special_handle_impl::~libusb_special_handle_impl(void)
+{
     /* NOP */
 }
 
-libusb::special_handle::sptr libusb::special_handle::make(device::sptr dev){
+libusb::special_handle::sptr libusb::special_handle::make(device::sptr dev)
+{
     return sptr(new libusb_special_handle_impl(dev));
 }
 
 /***********************************************************************
  * list device handles implementations
  **********************************************************************/
-usb_device_handle::~usb_device_handle(void) {
+usb_device_handle::~usb_device_handle(void)
+{
     /* NOP */
 }
 
 std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
-    uint16_t vid, uint16_t pid
-){
-    return usb_device_handle::get_device_list(std::vector<usb_device_handle::vid_pid_pair_t>(1,usb_device_handle::vid_pid_pair_t(vid,pid)));
+    uint16_t vid, uint16_t pid)
+{
+    return usb_device_handle::get_device_list(
+        std::vector<usb_device_handle::vid_pid_pair_t>(
+            1, usb_device_handle::vid_pid_pair_t(vid, pid)));
 }
 
-std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(const std::vector<usb_device_handle::vid_pid_pair_t>& vid_pid_pair_list)
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
+    const std::vector<usb_device_handle::vid_pid_pair_t>& vid_pid_pair_list)
 {
     std::vector<usb_device_handle::sptr> handles;
     libusb::device_list::sptr dev_list = libusb::device_list::make();
-    for(size_t iter = 0; iter < vid_pid_pair_list.size(); ++iter)
-    {
-       for (size_t i = 0; i < dev_list->size(); i++){
-           usb_device_handle::sptr handle = libusb::special_handle::make(dev_list->at(i));
-           if (handle->get_vendor_id() == vid_pid_pair_list[iter].first and handle->get_product_id() == vid_pid_pair_list[iter].second){
-               handles.push_back(handle);
-           }
-       }
+    for (size_t iter = 0; iter < vid_pid_pair_list.size(); ++iter) {
+        for (size_t i = 0; i < dev_list->size(); i++) {
+            usb_device_handle::sptr handle =
+                libusb::special_handle::make(dev_list->at(i));
+            if (handle->get_vendor_id() == vid_pid_pair_list[iter].first
+                and handle->get_product_id() == vid_pid_pair_list[iter].second) {
+                handles.push_back(handle);
+            }
+        }
     }
     return handles;
 }
diff --git a/host/lib/transport/libusb1_base.hpp b/host/lib/transport/libusb1_base.hpp
index 958248a5c..8ff1cf4cc 100644
--- a/host/lib/transport/libusb1_base.hpp
+++ b/host/lib/transport/libusb1_base.hpp
@@ -9,32 +9,30 @@
 #define INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP
 
 #include <uhd/config.hpp>
-#include <boost/utility.hpp>
-#include <boost/shared_ptr.hpp>
 #include <uhd/transport/usb_device_handle.hpp>
 #include <libusb.h>
+#include <boost/shared_ptr.hpp>
+#include <boost/utility.hpp>
 
 //! Define LIBUSB_CALL when its missing (non-windows)
 #ifndef LIBUSB_CALL
-    #define LIBUSB_CALL
+#    define LIBUSB_CALL
 #endif /*LIBUSB_CALL*/
 
 //! libusb_handle_events_timeout_completed is only in newer API
 #ifndef HAVE_LIBUSB_HANDLE_EVENTS_TIMEOUT_COMPLETED
-    #define libusb_handle_events_timeout_completed(ctx, tx, completed) \
+#    define libusb_handle_events_timeout_completed(ctx, tx, completed) \
         libusb_handle_events_timeout(ctx, tx)
 #endif /* HAVE_LIBUSB_HANDLE_EVENTS_TIMEOUT_COMPLETED */
 
 //! libusb_error_name is only in newer API
 #ifndef HAVE_LIBUSB_ERROR_NAME
-    #define libusb_error_name(code) \
-        str(boost::format("LIBUSB_ERROR_CODE %d") % code)
+#    define libusb_error_name(code) str(boost::format("LIBUSB_ERROR_CODE %d") % code)
 #endif /* HAVE_LIBUSB_ERROR_NAME */
 
 //! libusb_strerror is only in newer API
 #ifndef HAVE_LIBUSB_STRERROR
-    #define libusb_strerror(code) \
-        libusb_error_name(code)
+#    define libusb_strerror(code) libusb_error_name(code)
 #endif /* HAVE_LIBUSB_STRERROR */
 
 /***********************************************************************
@@ -44,135 +42,138 @@
  * also store tables of already allocated structures to avoid multiple
  * occurrences of opened handles (for example).
  **********************************************************************/
-namespace uhd { namespace transport {
-
-namespace libusb {
-
-    /*!
-     * This session class holds a global libusb context for this process.
-     * The get global session call will create a new context if none exists.
-     * When all references to session are destroyed, the context will be freed.
-     */
-    class session : boost::noncopyable {
-    public:
-        typedef boost::shared_ptr<session> sptr;
-
-        virtual ~session(void);
+namespace uhd { namespace transport { namespace libusb {
 
-        /*!
-         *   Level 0: no messages ever printed by the library (default)
-         *   Level 1: error messages are printed to stderr
-         *   Level 2: warning and error messages are printed to stderr
-         *   Level 3: informational messages are printed to stdout, warning
-         *            and error messages are printed to stderr
-         */
-        static const int debug_level = 0;
+/*!
+ * This session class holds a global libusb context for this process.
+ * The get global session call will create a new context if none exists.
+ * When all references to session are destroyed, the context will be freed.
+ */
+class session : boost::noncopyable
+{
+public:
+    typedef boost::shared_ptr<session> sptr;
 
-        //! get a shared pointer to the global session
-        static sptr get_global_session(void);
-
-        //! get the underlying libusb context pointer
-        virtual libusb_context *get_context(void) const = 0;
-    };
+    virtual ~session(void);
 
     /*!
-     * Holds a device pointer with a reference to the session.
+     *   Level 0: no messages ever printed by the library (default)
+     *   Level 1: error messages are printed to stderr
+     *   Level 2: warning and error messages are printed to stderr
+     *   Level 3: informational messages are printed to stdout, warning
+     *            and error messages are printed to stderr
      */
-    class device : boost::noncopyable {
-    public:
-        typedef boost::shared_ptr<device> sptr;
+    static const int debug_level = 0;
 
-        virtual ~device(void);
+    //! get a shared pointer to the global session
+    static sptr get_global_session(void);
 
-        //! get the underlying device pointer
-        virtual libusb_device *get(void) const = 0;
-    };
+    //! get the underlying libusb context pointer
+    virtual libusb_context* get_context(void) const = 0;
+};
 
-    /*!
-     * This device list class holds a device list that will be
-     * automatically freed when the last reference is destroyed.
-     */
-    class device_list : boost::noncopyable {
-    public:
-        typedef boost::shared_ptr<device_list> sptr;
+/*!
+ * Holds a device pointer with a reference to the session.
+ */
+class device : boost::noncopyable
+{
+public:
+    typedef boost::shared_ptr<device> sptr;
 
-        virtual ~device_list(void);
+    virtual ~device(void);
 
-        //! make a new device list
-        static sptr make(void);
+    //! get the underlying device pointer
+    virtual libusb_device* get(void) const = 0;
+};
 
-        //! the number of devices in this list
-        virtual size_t size() const = 0;
+/*!
+ * This device list class holds a device list that will be
+ * automatically freed when the last reference is destroyed.
+ */
+class device_list : boost::noncopyable
+{
+public:
+    typedef boost::shared_ptr<device_list> sptr;
 
-        //! get the device pointer at a particular index
-        virtual device::sptr at(size_t index) const = 0;
-    };
+    virtual ~device_list(void);
 
-    /*!
-     * Holds a device descriptor and a reference to the device.
-     */
-    class device_descriptor : boost::noncopyable {
-    public:
-        typedef boost::shared_ptr<device_descriptor> sptr;
+    //! make a new device list
+    static sptr make(void);
 
-        virtual ~device_descriptor(void);
+    //! the number of devices in this list
+    virtual size_t size() const = 0;
 
-        //! make a new descriptor from a device reference
-        static sptr make(device::sptr);
+    //! get the device pointer at a particular index
+    virtual device::sptr at(size_t index) const = 0;
+};
 
-        //! get the underlying device descriptor
-        virtual const libusb_device_descriptor &get(void) const = 0;
+/*!
+ * Holds a device descriptor and a reference to the device.
+ */
+class device_descriptor : boost::noncopyable
+{
+public:
+    typedef boost::shared_ptr<device_descriptor> sptr;
 
-        virtual std::string get_ascii_property(const std::string &what) const = 0;
-    };
+    virtual ~device_descriptor(void);
 
-    /*!
-     * Holds a device handle and a reference to the device.
-     */
-    class device_handle : boost::noncopyable {
-    public:
-        typedef boost::shared_ptr<device_handle> sptr;
+    //! make a new descriptor from a device reference
+    static sptr make(device::sptr);
 
-        virtual ~device_handle(void);
+    //! get the underlying device descriptor
+    virtual const libusb_device_descriptor& get(void) const = 0;
 
-        //! get a cached handle or make a new one given the device
-        static sptr get_cached_handle(device::sptr);
+    virtual std::string get_ascii_property(const std::string& what) const = 0;
+};
 
-        //! get the underlying device handle
-        virtual libusb_device_handle *get(void) const = 0;
+/*!
+ * Holds a device handle and a reference to the device.
+ */
+class device_handle : boost::noncopyable
+{
+public:
+    typedef boost::shared_ptr<device_handle> sptr;
 
-        /*!
-         * Open USB interfaces for control using magic value
-         * IN interface:      2
-         * OUT interface:     1
-         * Control interface: 0
-         */
-        virtual void claim_interface(int) = 0;
+    virtual ~device_handle(void);
 
-        virtual void clear_endpoints(unsigned char recv_endpoint, unsigned char send_endpoint) = 0;
+    //! get a cached handle or make a new one given the device
+    static sptr get_cached_handle(device::sptr);
 
-        virtual void reset_device(void) = 0;
-    };
+    //! get the underlying device handle
+    virtual libusb_device_handle* get(void) const = 0;
 
     /*!
-     * The special handle is our internal implementation of the
-     * usb device handle which is used publicly to identify a device.
+     * Open USB interfaces for control using magic value
+     * IN interface:      2
+     * OUT interface:     1
+     * Control interface: 0
      */
-    class special_handle : public usb_device_handle {
-    public:
-        typedef boost::shared_ptr<special_handle> sptr;
+    virtual void claim_interface(int) = 0;
+
+    virtual void clear_endpoints(
+        unsigned char recv_endpoint, unsigned char send_endpoint) = 0;
+
+    virtual void reset_device(void) = 0;
+};
 
-        virtual ~special_handle(void);
+/*!
+ * The special handle is our internal implementation of the
+ * usb device handle which is used publicly to identify a device.
+ */
+class special_handle : public usb_device_handle
+{
+public:
+    typedef boost::shared_ptr<special_handle> sptr;
 
-        //! make a new special handle from device
-        static sptr make(device::sptr);
+    virtual ~special_handle(void);
 
-        //! get the underlying device reference
-        virtual device::sptr get_device(void) const = 0;
-    };
+    //! make a new special handle from device
+    static sptr make(device::sptr);
 
-}
+    //! get the underlying device reference
+    virtual device::sptr get_device(void) const = 0;
+};
 
-}} //namespace
+}}} // namespace uhd::transport::libusb
 
 #endif /* INCLUDED_LIBUHD_TRANSPORT_LIBUSB_HPP */
diff --git a/host/lib/transport/libusb1_control.cpp b/host/lib/transport/libusb1_control.cpp
index 2a338bba1..10ab53553 100644
--- a/host/lib/transport/libusb1_control.cpp
+++ b/host/lib/transport/libusb1_control.cpp
@@ -11,17 +11,19 @@
 
 using namespace uhd::transport;
 
-usb_control::~usb_control(void){
+usb_control::~usb_control(void)
+{
     /* NOP */
 }
 
 /***********************************************************************
  * libusb-1.0 implementation of USB control transport
  **********************************************************************/
-class libusb_control_impl : public usb_control {
+class libusb_control_impl : public usb_control
+{
 public:
-    libusb_control_impl(libusb::device_handle::sptr handle, const int interface):
-        _handle(handle)
+    libusb_control_impl(libusb::device_handle::sptr handle, const int interface)
+        : _handle(handle)
     {
         _handle->claim_interface(interface);
     }
@@ -29,22 +31,22 @@ public:
     virtual ~libusb_control_impl(void);
 
     int submit(uint8_t request_type,
-               uint8_t request,
-               uint16_t value,
-               uint16_t index,
-               unsigned char *buff,
-               uint16_t length,
-               uint32_t libusb_timeout = 0
-    ){
+        uint8_t request,
+        uint16_t value,
+        uint16_t index,
+        unsigned char* buff,
+        uint16_t length,
+        uint32_t libusb_timeout = 0)
+    {
         boost::mutex::scoped_lock lock(_mutex);
         return libusb_control_transfer(_handle->get(),
-                                       request_type,
-                                       request,
-                                       value,
-                                       index,
-                                       buff,
-                                       length,
-                                       libusb_timeout);
+            request_type,
+            request,
+            value,
+            index,
+            buff,
+            length,
+            libusb_timeout);
     }
 
 private:
@@ -52,15 +54,18 @@ private:
     boost::mutex _mutex;
 };
 
-libusb_control_impl::~libusb_control_impl(void)  {
-  /* NOP */
+libusb_control_impl::~libusb_control_impl(void)
+{
+    /* NOP */
 }
 
 /***********************************************************************
  * USB control public make functions
  **********************************************************************/
-usb_control::sptr usb_control::make(usb_device_handle::sptr handle, const int interface){
-    return sptr(new libusb_control_impl(libusb::device_handle::get_cached_handle(
-        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
-    ), interface));
+usb_control::sptr usb_control::make(usb_device_handle::sptr handle, const int interface)
+{
+    return sptr(new libusb_control_impl(
+        libusb::device_handle::get_cached_handle(
+            boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()),
+        interface));
 }
diff --git a/host/lib/transport/libusb1_zero_copy.cpp b/host/lib/transport/libusb1_zero_copy.cpp
index 9e91ae2fc..5b03aa86f 100644
--- a/host/lib/transport/libusb1_zero_copy.cpp
+++ b/host/lib/transport/libusb1_zero_copy.cpp
@@ -6,35 +6,35 @@
 //
 
 #include "libusb1_base.hpp"
-#include <uhd/transport/usb_zero_copy.hpp>
-#include <uhd/transport/buffer_pool.hpp>
+#include <uhd/exception.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
+#include <uhd/transport/buffer_pool.hpp>
+#include <uhd/transport/usb_zero_copy.hpp>
 #include <uhd/utils/log.hpp>
-#include <uhd/exception.hpp>
+#include <boost/bind.hpp>
+#include <boost/circular_buffer.hpp>
 #include <boost/format.hpp>
 #include <boost/function.hpp>
-#include <boost/bind.hpp>
 #include <boost/make_shared.hpp>
-#include <boost/circular_buffer.hpp>
-#include <boost/thread/mutex.hpp>
 #include <boost/thread/condition_variable.hpp>
+#include <boost/thread/mutex.hpp>
 #include <list>
 
 #ifdef UHD_TXRX_DEBUG_PRINTS
-#include <vector>
-#include <fstream>
-#include <boost/format.hpp>
+#    include <boost/format.hpp>
+#    include <fstream>
+#    include <vector>
 #endif
 
 using namespace uhd;
 using namespace uhd::transport;
 
-static const size_t DEFAULT_NUM_XFERS = 16;     //num xfers
-static const size_t DEFAULT_XFER_SIZE = 32*512; //bytes
+static const size_t DEFAULT_NUM_XFERS = 16; // num xfers
+static const size_t DEFAULT_XFER_SIZE = 32 * 512; // bytes
 
 //! type for sharing the release queue with managed buffers
 class libusb_zero_copy_mb;
-typedef boost::shared_ptr<bounded_buffer<libusb_zero_copy_mb *> > mb_queue_sptr;
+typedef boost::shared_ptr<bounded_buffer<libusb_zero_copy_mb*>> mb_queue_sptr;
 
 /*!
  * The libusb docs state that status and actual length can only be read in the callback.
@@ -44,12 +44,12 @@ struct lut_result_t
 {
     lut_result_t(void)
     {
-        completed = 0;
-        status = LIBUSB_TRANSFER_COMPLETED;
+        completed     = 0;
+        status        = LIBUSB_TRANSFER_COMPLETED;
         actual_length = 0;
 #ifdef UHD_TXRX_DEBUG_PRINTS
         start_time = 0;
-        buff_num = -1;
+        buff_num   = -1;
 #endif
     }
     int completed;
@@ -67,17 +67,22 @@ struct lut_result_t
 };
 
 // Created to be used as an argument to boost::condition_variable::timed_wait() function
-struct lut_result_completed {
+struct lut_result_completed
+{
     const lut_result_t& _result;
-    lut_result_completed(const lut_result_t& result):_result(result) {}
-    bool operator()() const {return (_result.completed ? true : false);}
+    lut_result_completed(const lut_result_t& result) : _result(result) {}
+    bool operator()() const
+    {
+        return (_result.completed ? true : false);
+    }
 };
 
 #ifdef UHD_TXRX_DEBUG_PRINTS
 static std::string dbg_prefix("libusb1_zero_copy,");
-static void libusb1_zerocopy_dbg_print_err(std::string msg){
-	msg = dbg_prefix + msg;
-	fprintf(stderr, "%s\n", msg.c_str());
+static void libusb1_zerocopy_dbg_print_err(std::string msg)
+{
+    msg = dbg_prefix + msg;
+    fprintf(stderr, "%s\n", msg.c_str());
 }
 #endif
 
@@ -87,17 +92,21 @@ static void libusb1_zerocopy_dbg_print_err(std::string msg){
  */
 
 //! helper function: handles all async callbacks
-static void LIBUSB_CALL libusb_async_cb(libusb_transfer *lut)
+static void LIBUSB_CALL libusb_async_cb(libusb_transfer* lut)
 {
-    lut_result_t *r = (lut_result_t *)lut->user_data;
+    lut_result_t* r = (lut_result_t*)lut->user_data;
     boost::lock_guard<boost::mutex> lock(r->mut);
-    r->status = lut->status;
+    r->status        = lut->status;
     r->actual_length = lut->actual_length;
-    r->completed = 1;
-    r->usb_transfer_complete.notify_one();  // wake up thread waiting in wait_for_completion() member function below
+    r->completed     = 1;
+    r->usb_transfer_complete.notify_one(); // wake up thread waiting in
+                                           // wait_for_completion() member function below
 #ifdef UHD_TXRX_DEBUG_PRINTS
     long end_time = boost::get_system_time().time_of_day().total_microseconds();
-    libusb1_zerocopy_dbg_print_err( (boost::format("libusb_async_cb,%s,%i,%i,%i,%ld,%ld") % (r->is_recv ? "rx":"tx") % r->buff_num % r->actual_length % r->status % end_time % r->start_time).str() );
+    libusb1_zerocopy_dbg_print_err(
+        (boost::format("libusb_async_cb,%s,%i,%i,%i,%ld,%ld") % (r->is_recv ? "rx" : "tx")
+            % r->buff_num % r->actual_length % r->status % end_time % r->start_time)
+            .str());
 #endif
 }
 
@@ -109,41 +118,53 @@ static void LIBUSB_CALL libusb_async_cb(libusb_transfer *lut)
 class libusb_zero_copy_mb : public managed_buffer
 {
 public:
-    libusb_zero_copy_mb(libusb_transfer *lut, const size_t frame_size, boost::function<void(libusb_zero_copy_mb *)> release_cb, const bool is_recv, const std::string &name):
-        _release_cb(release_cb), _is_recv(is_recv), _name(name),
-        _ctx(libusb::session::get_global_session()->get_context()),
-        _lut(lut), _frame_size(frame_size) { /* NOP */ }
+    libusb_zero_copy_mb(libusb_transfer* lut,
+        const size_t frame_size,
+        boost::function<void(libusb_zero_copy_mb*)> release_cb,
+        const bool is_recv,
+        const std::string& name)
+        : _release_cb(release_cb)
+        , _is_recv(is_recv)
+        , _name(name)
+        , _ctx(libusb::session::get_global_session()->get_context())
+        , _lut(lut)
+        , _frame_size(frame_size)
+    { /* NOP */
+    }
 
     virtual ~libusb_zero_copy_mb(void);
 
-    void release(void){
-    	_release_cb(this);
+    void release(void)
+    {
+        _release_cb(this);
     }
 
     UHD_INLINE void submit(void)
     {
-        _lut->length = int((_is_recv)? _frame_size : size()); //always set length
+        _lut->length = int((_is_recv) ? _frame_size : size()); // always set length
 #ifdef UHD_TXRX_DEBUG_PRINTS
         result.start_time = boost::get_system_time().time_of_day().total_microseconds();
-        result.buff_num = num();
-        result.is_recv = _is_recv;
+        result.buff_num   = num();
+        result.is_recv    = _is_recv;
 #endif
-	int ret = libusb_submit_transfer(_lut);
+        int ret = libusb_submit_transfer(_lut);
         if (ret != LIBUSB_SUCCESS)
-	  throw uhd::usb_error(ret, str(boost::format(
-            "usb %s submit failed: %s") % _name % libusb_error_name(ret)));
+            throw uhd::usb_error(ret,
+                str(boost::format("usb %s submit failed: %s") % _name
+                    % libusb_error_name(ret)));
     }
 
     template <typename buffer_type>
     UHD_INLINE typename buffer_type::sptr get_new(const double timeout)
     {
-        if (wait_for_completion(timeout))
-        {
+        if (wait_for_completion(timeout)) {
             if (result.status != LIBUSB_TRANSFER_COMPLETED)
                 throw uhd::io_error(str(boost::format("usb %s transfer status: %d")
                                         % _name % libusb_error_name(result.status)));
             result.completed = 0;
-            return make(reinterpret_cast<buffer_type *>(this), _lut->buffer, (_is_recv)? size_t(result.actual_length) : _frame_size);
+            return make(reinterpret_cast<buffer_type*>(this),
+                _lut->buffer,
+                (_is_recv) ? size_t(result.actual_length) : _frame_size);
         }
         return typename buffer_type::sptr();
     }
@@ -164,23 +185,27 @@ public:
             if (timeout < 0.0) {
                 result.usb_transfer_complete.wait(lock);
             } else {
-                const boost::system_time timeout_time = boost::get_system_time() + boost::posix_time::microseconds(long(timeout*1000000));
-                result.usb_transfer_complete.timed_wait(lock, timeout_time, lut_result_completed(result));
+                const boost::system_time timeout_time =
+                    boost::get_system_time()
+                    + boost::posix_time::microseconds(long(timeout * 1000000));
+                result.usb_transfer_complete.timed_wait(
+                    lock, timeout_time, lut_result_completed(result));
             }
         }
         return (result.completed > 0);
     }
 
 private:
-    boost::function<void(libusb_zero_copy_mb *)> _release_cb;
+    boost::function<void(libusb_zero_copy_mb*)> _release_cb;
     const bool _is_recv;
     const std::string _name;
-    libusb_context *_ctx;
-    libusb_transfer *_lut;
+    libusb_context* _ctx;
+    libusb_transfer* _lut;
     const size_t _frame_size;
 };
 
-libusb_zero_copy_mb::~libusb_zero_copy_mb(void) {
+libusb_zero_copy_mb::~libusb_zero_copy_mb(void)
+{
     /* NOP */
 }
 
@@ -190,70 +215,71 @@ libusb_zero_copy_mb::~libusb_zero_copy_mb(void) {
 class libusb_zero_copy_single
 {
 public:
-    libusb_zero_copy_single(
-        libusb::device_handle::sptr handle,
-        const int interface, const unsigned char endpoint,
-        const size_t num_frames, const size_t frame_size
-    ):
-        _handle(handle),
-        _num_frames(num_frames),
-        _frame_size(frame_size),
-        _buffer_pool(buffer_pool::make(_num_frames, _frame_size)),
-        _enqueued(_num_frames), _released(_num_frames),
-        _status(STATUS_RUNNING)
+    libusb_zero_copy_single(libusb::device_handle::sptr handle,
+        const int interface,
+        const unsigned char endpoint,
+        const size_t num_frames,
+        const size_t frame_size)
+        : _handle(handle)
+        , _num_frames(num_frames)
+        , _frame_size(frame_size)
+        , _buffer_pool(buffer_pool::make(_num_frames, _frame_size))
+        , _enqueued(_num_frames)
+        , _released(_num_frames)
+        , _status(STATUS_RUNNING)
     {
         const bool is_recv = (endpoint & 0x80) != 0;
-        const std::string name = str(boost::format("%s%d") % ((is_recv)? "rx" : "tx") % int(endpoint & 0x7f));
+        const std::string name =
+            str(boost::format("%s%d") % ((is_recv) ? "rx" : "tx") % int(endpoint & 0x7f));
         _handle->claim_interface(interface);
 
-        //flush the buffers out of the recv endpoint
-        //limit the flushing to at most one second
-        if (is_recv) for (size_t i = 0; i < 100; i++)
-        {
-            unsigned char buff[512];
-            int transfered = 0;
-            const int status = libusb_bulk_transfer(
-                _handle->get(), // dev_handle
-                endpoint, // endpoint
-                static_cast<unsigned char *>(buff),
-                int(sizeof(buff)),
-                &transfered, //bytes xfered
-                10 //timeout ms
-            );
-            if (status == LIBUSB_ERROR_TIMEOUT) break;
-        }
+        // flush the buffers out of the recv endpoint
+        // limit the flushing to at most one second
+        if (is_recv)
+            for (size_t i = 0; i < 100; i++) {
+                unsigned char buff[512];
+                int transfered   = 0;
+                const int status = libusb_bulk_transfer(_handle->get(), // dev_handle
+                    endpoint, // endpoint
+                    static_cast<unsigned char*>(buff),
+                    int(sizeof(buff)),
+                    &transfered, // bytes xfered
+                    10 // timeout ms
+                );
+                if (status == LIBUSB_ERROR_TIMEOUT)
+                    break;
+            }
 
-        //allocate libusb transfer structs and managed buffers
-        for (size_t i = 0; i < get_num_frames(); i++)
-        {
-            libusb_transfer *lut = libusb_alloc_transfer(0);
+        // allocate libusb transfer structs and managed buffers
+        for (size_t i = 0; i < get_num_frames(); i++) {
+            libusb_transfer* lut = libusb_alloc_transfer(0);
             UHD_ASSERT_THROW(lut != NULL);
 
-            _mb_pool.push_back(boost::make_shared<libusb_zero_copy_mb>(
-                lut, this->get_frame_size(), boost::bind(&libusb_zero_copy_single::enqueue_buffer, this, _1), is_recv, name
-            ));
-
-            libusb_fill_bulk_transfer(
-                lut,                                                    // transfer
-                _handle->get(),                                         // dev_handle
-                endpoint,                                               // endpoint
-                static_cast<unsigned char *>(_buffer_pool->at(i)),      // buffer
-                int(this->get_frame_size()),                            // length
-                libusb_transfer_cb_fn(&libusb_async_cb),                // callback
-                static_cast<void *>(&_mb_pool.back()->result),          // user_data
-                0                                                       // timeout (ms)
+            _mb_pool.push_back(boost::make_shared<libusb_zero_copy_mb>(lut,
+                this->get_frame_size(),
+                boost::bind(&libusb_zero_copy_single::enqueue_buffer, this, _1),
+                is_recv,
+                name));
+
+            libusb_fill_bulk_transfer(lut, // transfer
+                _handle->get(), // dev_handle
+                endpoint, // endpoint
+                static_cast<unsigned char*>(_buffer_pool->at(i)), // buffer
+                int(this->get_frame_size()), // length
+                libusb_transfer_cb_fn(&libusb_async_cb), // callback
+                static_cast<void*>(&_mb_pool.back()->result), // user_data
+                0 // timeout (ms)
             );
 
             _all_luts.push_back(lut);
         }
 
-        //initial release for all buffers
-        for (size_t i = 0; i < get_num_frames(); i++)
-        {
-            libusb_zero_copy_mb &mb = *(_mb_pool[i]);
-            if (is_recv) mb.release();
-            else
-            {
+        // initial release for all buffers
+        for (size_t i = 0; i < get_num_frames(); i++) {
+            libusb_zero_copy_mb& mb = *(_mb_pool[i]);
+            if (is_recv)
+                mb.release();
+            else {
                 mb.result.completed = 1;
                 _enqueued.push_back(&mb);
             }
@@ -262,21 +288,18 @@ public:
 
     ~libusb_zero_copy_single(void)
     {
-        //cancel all transfers
-        for(libusb_transfer *lut:  _all_luts)
-        {
+        // cancel all transfers
+        for (libusb_transfer* lut : _all_luts) {
             libusb_cancel_transfer(lut);
         }
 
-        //process all transfers until timeout occurs
-        for(libusb_zero_copy_mb *mb:  _enqueued)
-        {
+        // process all transfers until timeout occurs
+        for (libusb_zero_copy_mb* mb : _enqueued) {
             mb->wait_for_completion(0.01);
         }
 
-        //free all transfers
-        for(libusb_transfer *lut:  _all_luts)
-        {
+        // free all transfers
+        for (libusb_transfer* lut : _all_luts) {
             libusb_free_transfer(lut);
         }
     }
@@ -293,24 +316,32 @@ public:
         boost::mutex::scoped_lock get_buff_lock(_get_buff_mutex);
 
         boost::mutex::scoped_lock queue_lock(_queue_mutex);
-        if (_enqueued.empty())
-        {
-            _buff_ready_cond.timed_wait(queue_lock, boost::posix_time::microseconds(long(timeout*1e6)));
+        if (_enqueued.empty()) {
+            _buff_ready_cond.timed_wait(
+                queue_lock, boost::posix_time::microseconds(long(timeout * 1e6)));
         }
-        if (_enqueued.empty()) return buff;
-        libusb_zero_copy_mb *front = _enqueued.front();
+        if (_enqueued.empty())
+            return buff;
+        libusb_zero_copy_mb* front = _enqueued.front();
 
         queue_lock.unlock();
         buff = front->get_new<buffer_type>(timeout);
         queue_lock.lock();
 
-        if (buff) _enqueued.pop_front();
+        if (buff)
+            _enqueued.pop_front();
         this->submit_what_we_can();
         return buff;
     }
 
-    UHD_INLINE size_t get_num_frames(void) const { return _num_frames; }
-    UHD_INLINE size_t get_frame_size(void) const { return _frame_size; }
+    UHD_INLINE size_t get_num_frames(void) const
+    {
+        return _num_frames;
+    }
+    UHD_INLINE size_t get_frame_size(void) const
+    {
+        return _frame_size;
+    }
 
 private:
     libusb::device_handle::sptr _handle;
@@ -318,18 +349,18 @@ private:
 
     //! Storage for transfer related objects
     buffer_pool::sptr _buffer_pool;
-    std::vector<boost::shared_ptr<libusb_zero_copy_mb> > _mb_pool;
+    std::vector<boost::shared_ptr<libusb_zero_copy_mb>> _mb_pool;
 
     boost::mutex _queue_mutex;
     boost::condition_variable _buff_ready_cond;
     boost::mutex _get_buff_mutex;
 
     //! why 2 queues? there is room in the future to have > N buffers but only N in flight
-    boost::circular_buffer<libusb_zero_copy_mb *> _enqueued, _released;
+    boost::circular_buffer<libusb_zero_copy_mb*> _enqueued, _released;
 
-    enum {STATUS_RUNNING, STATUS_ERROR} _status;
+    enum { STATUS_RUNNING, STATUS_ERROR } _status;
 
-    void enqueue_buffer(libusb_zero_copy_mb *mb)
+    void enqueue_buffer(libusb_zero_copy_mb* mb)
     {
         boost::mutex::scoped_lock l(_queue_mutex);
         _released.push_back(mb);
@@ -341,15 +372,12 @@ private:
     {
         if (_status == STATUS_ERROR)
             return;
-        while (not _released.empty() and not _enqueued.full())
-        {
+        while (not _released.empty() and not _enqueued.full()) {
             try {
                 _released.front()->submit();
                 _enqueued.push_back(_released.front());
                 _released.pop_front();
-            }
-            catch (uhd::usb_error& e)
-            {
+            } catch (uhd::usb_error& e) {
                 _status = STATUS_ERROR;
                 throw e;
             }
@@ -357,7 +385,7 @@ private:
     }
 
     //! a list of all transfer structs we allocated
-    std::list<libusb_transfer *> _all_luts;
+    std::list<libusb_transfer*> _all_luts;
 };
 
 /***********************************************************************
@@ -365,20 +393,21 @@ private:
  **********************************************************************/
 struct libusb_zero_copy_impl : usb_zero_copy
 {
-    libusb_zero_copy_impl(
-        libusb::device_handle::sptr handle,
+    libusb_zero_copy_impl(libusb::device_handle::sptr handle,
         const int recv_interface,
         const unsigned char recv_endpoint,
         const int send_interface,
         const unsigned char send_endpoint,
-        const device_addr_t &hints
-    ){
-        _recv_impl.reset(new libusb_zero_copy_single(
-            handle, recv_interface, (recv_endpoint & 0x7f) | 0x80,
+        const device_addr_t& hints)
+    {
+        _recv_impl.reset(new libusb_zero_copy_single(handle,
+            recv_interface,
+            (recv_endpoint & 0x7f) | 0x80,
             size_t(hints.cast<double>("num_recv_frames", DEFAULT_NUM_XFERS)),
             size_t(hints.cast<double>("recv_frame_size", DEFAULT_XFER_SIZE))));
-        _send_impl.reset(new libusb_zero_copy_single(
-            handle, send_interface, (send_endpoint & 0x7f) | 0x00,
+        _send_impl.reset(new libusb_zero_copy_single(handle,
+            send_interface,
+            (send_endpoint & 0x7f) | 0x00,
             size_t(hints.cast<double>("num_send_frames", DEFAULT_NUM_XFERS)),
             size_t(hints.cast<double>("send_frame_size", DEFAULT_XFER_SIZE))));
     }
@@ -397,42 +426,53 @@ struct libusb_zero_copy_impl : usb_zero_copy
         return _send_impl->get_buff<managed_send_buffer>(timeout);
     }
 
-    size_t get_num_recv_frames(void) const { return _recv_impl->get_num_frames(); }
-    size_t get_num_send_frames(void) const { return _send_impl->get_num_frames(); }
+    size_t get_num_recv_frames(void) const
+    {
+        return _recv_impl->get_num_frames();
+    }
+    size_t get_num_send_frames(void) const
+    {
+        return _send_impl->get_num_frames();
+    }
 
-    size_t get_recv_frame_size(void) const { return _recv_impl->get_frame_size(); }
-    size_t get_send_frame_size(void) const { return _send_impl->get_frame_size(); }
+    size_t get_recv_frame_size(void) const
+    {
+        return _recv_impl->get_frame_size();
+    }
+    size_t get_send_frame_size(void) const
+    {
+        return _send_impl->get_frame_size();
+    }
 
     boost::shared_ptr<libusb_zero_copy_single> _recv_impl, _send_impl;
     boost::mutex _recv_mutex, _send_mutex;
 };
 
-libusb_zero_copy_impl::~libusb_zero_copy_impl(void) {
+libusb_zero_copy_impl::~libusb_zero_copy_impl(void)
+{
     /* NOP */
 }
 
 /***********************************************************************
  * USB zero_copy destructor
  **********************************************************************/
-usb_zero_copy::~usb_zero_copy(void) {
+usb_zero_copy::~usb_zero_copy(void)
+{
     /* NOP */
 }
 
 /***********************************************************************
  * USB zero_copy make functions
  **********************************************************************/
-usb_zero_copy::sptr usb_zero_copy::make(
-    usb_device_handle::sptr handle,
+usb_zero_copy::sptr usb_zero_copy::make(usb_device_handle::sptr handle,
     const int recv_interface,
     const unsigned char recv_endpoint,
     const int send_interface,
     const unsigned char send_endpoint,
-    const device_addr_t &hints
-){
+    const device_addr_t& hints)
+{
     libusb::device_handle::sptr dev_handle(libusb::device_handle::get_cached_handle(
-        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()
-    ));
+        boost::static_pointer_cast<libusb::special_handle>(handle)->get_device()));
     return sptr(new libusb_zero_copy_impl(
-        dev_handle, recv_interface, recv_endpoint, send_interface, send_endpoint, hints
-    ));
+        dev_handle, recv_interface, recv_endpoint, send_interface, send_endpoint, hints));
 }
diff --git a/host/lib/transport/muxed_zero_copy_if.cpp b/host/lib/transport/muxed_zero_copy_if.cpp
index 2e7583276..b26d2097c 100644
--- a/host/lib/transport/muxed_zero_copy_if.cpp
+++ b/host/lib/transport/muxed_zero_copy_if.cpp
@@ -5,73 +5,75 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <uhd/transport/muxed_zero_copy_if.hpp>
-#include <uhd/transport/bounded_buffer.hpp>
 #include <uhd/exception.hpp>
+#include <uhd/transport/bounded_buffer.hpp>
+#include <uhd/transport/muxed_zero_copy_if.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <boost/enable_shared_from_this.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/thread.hpp>
 #include <boost/thread/locks.hpp>
-#include <map>
 #include <chrono>
+#include <map>
 #include <thread>
 
 using namespace uhd;
 using namespace uhd::transport;
 
-class muxed_zero_copy_if_impl : public muxed_zero_copy_if,
-                                public boost::enable_shared_from_this<muxed_zero_copy_if_impl>
+class muxed_zero_copy_if_impl
+    : public muxed_zero_copy_if,
+      public boost::enable_shared_from_this<muxed_zero_copy_if_impl>
 {
 public:
     typedef boost::shared_ptr<muxed_zero_copy_if_impl> sptr;
 
-    muxed_zero_copy_if_impl(
-        zero_copy_if::sptr base_xport,
+    muxed_zero_copy_if_impl(zero_copy_if::sptr base_xport,
         stream_classifier_fn classify_fn,
-        size_t max_streams
-    ):
-        _base_xport(base_xport), _classify(classify_fn),
-        _max_num_streams(max_streams), _num_dropped_frames(0)
+        size_t max_streams)
+        : _base_xport(base_xport)
+        , _classify(classify_fn)
+        , _max_num_streams(max_streams)
+        , _num_dropped_frames(0)
     {
-        //Create the receive thread to poll the underlying transport
-        //and classify packets into queues
-        _recv_thread = boost::thread(
-            boost::bind(&muxed_zero_copy_if_impl::_update_queues, this));
+        // Create the receive thread to poll the underlying transport
+        // and classify packets into queues
+        _recv_thread =
+            boost::thread(boost::bind(&muxed_zero_copy_if_impl::_update_queues, this));
     }
 
     virtual ~muxed_zero_copy_if_impl()
     {
         UHD_SAFE_CALL(
-            //Interrupt buffer updater loop
+            // Interrupt buffer updater loop
             _recv_thread.interrupt();
-            //Wait for loop to finish
-            //No timeout on join. The recv loop is guaranteed
-            //to terminate in a reasonable amount of time because
-            //there are no timed blocks on the underlying.
+            // Wait for loop to finish
+            // No timeout on join. The recv loop is guaranteed
+            // to terminate in a reasonable amount of time because
+            // there are no timed blocks on the underlying.
             _recv_thread.join();
-            //Flush base transport
+            // Flush base transport
             while (_base_xport->get_recv_buff(0.0001)) /*NOP*/;
-            //Release child streams
-            //Note that this will not delete or flush the child streams
-            //until the owners of the streams have released the respective
-            //shared pointers. This ensures that packets are not dropped.
-            _streams.clear();
-        );
+            // Release child streams
+            // Note that this will not delete or flush the child streams
+            // until the owners of the streams have released the respective
+            // shared pointers. This ensures that packets are not dropped.
+            _streams.clear(););
     }
 
     virtual zero_copy_if::sptr make_stream(const uint32_t stream_num)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         if (_streams.size() >= _max_num_streams) {
-            throw uhd::runtime_error("muxed_zero_copy_if: stream capacity exceeded. cannot create more streams.");
+            throw uhd::runtime_error("muxed_zero_copy_if: stream capacity exceeded. "
+                                     "cannot create more streams.");
         }
         // Only allocate a portion of the base transport's frames to each stream
         // to prevent all streams from attempting to use all the frames.
-        stream_impl::sptr stream = boost::make_shared<stream_impl>(
-            this->shared_from_this(), stream_num,
-            _base_xport->get_num_send_frames() / _max_num_streams,
-            _base_xport->get_num_recv_frames() / _max_num_streams);
+        stream_impl::sptr stream =
+            boost::make_shared<stream_impl>(this->shared_from_this(),
+                stream_num,
+                _base_xport->get_num_send_frames() / _max_num_streams,
+                _base_xport->get_num_recv_frames() / _max_num_streams);
         _streams[stream_num] = stream;
         return stream;
     }
@@ -97,20 +99,21 @@ private:
     public:
         stream_mrb(size_t size) : _buff(new char[size]) {}
 
-        ~stream_mrb() {
+        ~stream_mrb()
+        {
             delete[] _buff;
         }
 
         void release() {}
 
-        UHD_INLINE sptr get_new(char *buff, size_t len)
+        UHD_INLINE sptr get_new(char* buff, size_t len)
         {
             memcpy(_buff, buff, len);
             return make(this, _buff, len);
         }
 
     private:
-        char *_buff;
+        char* _buff;
     };
 
     class stream_impl : public zero_copy_if
@@ -119,20 +122,19 @@ private:
         typedef boost::shared_ptr<stream_impl> sptr;
         typedef boost::weak_ptr<stream_impl> wptr;
 
-        stream_impl(
-            muxed_zero_copy_if_impl::sptr muxed_xport,
+        stream_impl(muxed_zero_copy_if_impl::sptr muxed_xport,
             const uint32_t stream_num,
             const size_t num_send_frames,
-            const size_t num_recv_frames
-            ) :
-            _stream_num(stream_num), _muxed_xport(muxed_xport),
-            _num_send_frames(num_send_frames),
-            _send_frame_size(_muxed_xport->base_xport()->get_send_frame_size()),
-            _num_recv_frames(num_recv_frames),
-            _recv_frame_size(_muxed_xport->base_xport()->get_recv_frame_size()),
-            _buff_queue(num_recv_frames),
-            _buffers(num_recv_frames),
-            _buffer_index(0)
+            const size_t num_recv_frames)
+            : _stream_num(stream_num)
+            , _muxed_xport(muxed_xport)
+            , _num_send_frames(num_send_frames)
+            , _send_frame_size(_muxed_xport->base_xport()->get_send_frame_size())
+            , _num_recv_frames(num_recv_frames)
+            , _recv_frame_size(_muxed_xport->base_xport()->get_recv_frame_size())
+            , _buff_queue(num_recv_frames)
+            , _buffers(num_recv_frames)
+            , _buffer_index(0)
         {
             for (size_t i = 0; i < num_recv_frames; i++) {
                 _buffers[i] = boost::make_shared<stream_mrb>(_recv_frame_size);
@@ -141,25 +143,28 @@ private:
 
         ~stream_impl(void)
         {
-            //First remove the stream from muxed transport
-            //so no more frames are pushed in
+            // First remove the stream from muxed transport
+            // so no more frames are pushed in
             _muxed_xport->remove_stream(_stream_num);
-            //Flush the transport
+            // Flush the transport
             managed_recv_buffer::sptr buff;
             while (_buff_queue.pop_with_haste(buff)) {
-                //NOP
+                // NOP
             }
         }
 
-        size_t get_num_recv_frames(void) const {
+        size_t get_num_recv_frames(void) const
+        {
             return _num_recv_frames;
         }
 
-        size_t get_recv_frame_size(void) const {
+        size_t get_recv_frame_size(void) const
+        {
             return _recv_frame_size;
         }
 
-        managed_recv_buffer::sptr get_recv_buff(double timeout) {
+        managed_recv_buffer::sptr get_recv_buff(double timeout)
+        {
             managed_recv_buffer::sptr buff;
             if (_buff_queue.pop_with_timed_wait(buff, timeout)) {
                 return buff;
@@ -168,16 +173,20 @@ private:
             }
         }
 
-        void push_recv_buff(managed_recv_buffer::sptr buff) {
-            _buff_queue.push_with_wait(_buffers.at(_buffer_index++)->get_new(buff->cast<char*>(), buff->size()));
+        void push_recv_buff(managed_recv_buffer::sptr buff)
+        {
+            _buff_queue.push_with_wait(
+                _buffers.at(_buffer_index++)->get_new(buff->cast<char*>(), buff->size()));
             _buffer_index %= _buffers.size();
         }
 
-        size_t get_num_send_frames(void) const {
+        size_t get_num_send_frames(void) const
+        {
             return _num_send_frames;
         }
 
-        size_t get_send_frame_size(void) const {
+        size_t get_send_frame_size(void) const
+        {
             return _send_frame_size;
         }
 
@@ -187,51 +196,55 @@ private:
         }
 
     private:
-        const uint32_t                              _stream_num;
-        muxed_zero_copy_if_impl::sptr               _muxed_xport;
-        const size_t                                _num_send_frames;
-        const size_t                                _send_frame_size;
-        const size_t                                _num_recv_frames;
-        const size_t                                _recv_frame_size;
-        bounded_buffer<managed_recv_buffer::sptr>   _buff_queue;
-        std::vector< boost::shared_ptr<stream_mrb> >    _buffers;
-        size_t                                      _buffer_index;
+        const uint32_t _stream_num;
+        muxed_zero_copy_if_impl::sptr _muxed_xport;
+        const size_t _num_send_frames;
+        const size_t _send_frame_size;
+        const size_t _num_recv_frames;
+        const size_t _recv_frame_size;
+        bounded_buffer<managed_recv_buffer::sptr> _buff_queue;
+        std::vector<boost::shared_ptr<stream_mrb>> _buffers;
+        size_t _buffer_index;
     };
 
-    inline zero_copy_if::sptr& base_xport() { return _base_xport; }
+    inline zero_copy_if::sptr& base_xport()
+    {
+        return _base_xport;
+    }
 
     void _update_queues()
     {
-        //Run forever:
+        // Run forever:
         // - Pull packets from the base transport
         // - Classify them
         // - Push them to the appropriate receive queue
         while (true) {
-            {   //Uninterruptable block of code
+            { // Uninterruptable block of code
                 boost::this_thread::disable_interruption interrupt_disabler;
                 if (not _process_next_buffer()) {
-                    //Be a good citizen and yield if no packet is processed
+                    // Be a good citizen and yield if no packet is processed
                     static const size_t MIN_DUR = 1;
                     std::this_thread::sleep_for(std::chrono::nanoseconds(MIN_DUR));
-                    //We call sleep(MIN_DUR) above instead of yield() to ensure that we
-                    //relinquish the current scheduler time slot.
-                    //yield() is a hint to the scheduler to end the time
-                    //slice early and schedule in another thread that is ready to run.
-                    //However in most situations, there will be no other thread and
-                    //this thread will continue to run which will rail a CPU core.
-                    //We call sleep(MIN_DUR=1) instead which will sleep for a minimum time.
-                    //Ideally we would like to use boost::chrono::.*seconds::min() but that
-                    //is bound to 0, which causes the sleep_for call to be a no-op and
-                    //thus useless to actually force a sleep.
+                    // We call sleep(MIN_DUR) above instead of yield() to ensure that we
+                    // relinquish the current scheduler time slot.
+                    // yield() is a hint to the scheduler to end the time
+                    // slice early and schedule in another thread that is ready to run.
+                    // However in most situations, there will be no other thread and
+                    // this thread will continue to run which will rail a CPU core.
+                    // We call sleep(MIN_DUR=1) instead which will sleep for a minimum
+                    // time. Ideally we would like to use boost::chrono::.*seconds::min()
+                    // but that is bound to 0, which causes the sleep_for call to be a
+                    // no-op and thus useless to actually force a sleep.
 
                     //****************************************************************
-                    //NOTE: This behavior makes this transport a poor choice for
+                    // NOTE: This behavior makes this transport a poor choice for
                     //      low latency communication.
                     //****************************************************************
                 }
             }
-            //Check if the master thread has requested a shutdown
-            if (boost::this_thread::interruption_requested()) break;
+            // Check if the master thread has requested a shutdown
+            if (boost::this_thread::interruption_requested())
+                break;
         }
     }
 
@@ -241,10 +254,11 @@ private:
         if (buff) {
             stream_impl::sptr stream;
             try {
-                const uint32_t stream_num = _classify(buff->cast<void*>(), _base_xport->get_recv_frame_size());
+                const uint32_t stream_num =
+                    _classify(buff->cast<void*>(), _base_xport->get_recv_frame_size());
                 {
-                    //Hold the stream mutex long enough to pull a bounded buffer
-                    //and lock it (increment its ref count).
+                    // Hold the stream mutex long enough to pull a bounded buffer
+                    // and lock it (increment its ref count).
                     boost::lock_guard<boost::mutex> lock(_mutex);
                     stream_map_t::iterator str_iter = _streams.find(stream_num);
                     if (str_iter != _streams.end()) {
@@ -252,41 +266,41 @@ private:
                     }
                 }
             } catch (std::exception&) {
-                //If _classify throws we simply drop the frame
+                // If _classify throws we simply drop the frame
             }
-            //Once a bounded buffer is acquired, we can rely on its
-            //thread safety to serialize with the consumer.
+            // Once a bounded buffer is acquired, we can rely on its
+            // thread safety to serialize with the consumer.
             if (stream.get()) {
                 stream->push_recv_buff(buff);
             } else {
                 boost::lock_guard<boost::mutex> lock(_mutex);
                 _num_dropped_frames++;
             }
-            //We processed a packet, and there could be more coming
-            //Don't yield in the next iteration.
+            // We processed a packet, and there could be more coming
+            // Don't yield in the next iteration.
             return true;
         } else {
-            //The base transport is idle. Return false to let the
-            //thread yield.
+            // The base transport is idle. Return false to let the
+            // thread yield.
             return false;
         }
     }
 
     typedef std::map<uint32_t, stream_impl::wptr> stream_map_t;
 
-    zero_copy_if::sptr      _base_xport;
-    stream_classifier_fn    _classify;
-    stream_map_t            _streams;
-    const size_t            _max_num_streams;
-    size_t                  _num_dropped_frames;
-    boost::thread           _recv_thread;
-    boost::mutex            _mutex;
+    zero_copy_if::sptr _base_xport;
+    stream_classifier_fn _classify;
+    stream_map_t _streams;
+    const size_t _max_num_streams;
+    size_t _num_dropped_frames;
+    boost::thread _recv_thread;
+    boost::mutex _mutex;
 };
 
-muxed_zero_copy_if::sptr muxed_zero_copy_if::make(
-    zero_copy_if::sptr base_xport,
+muxed_zero_copy_if::sptr muxed_zero_copy_if::make(zero_copy_if::sptr base_xport,
     muxed_zero_copy_if::stream_classifier_fn classify_fn,
-    size_t max_streams
-) {
-    return boost::make_shared<muxed_zero_copy_if_impl>(base_xport, classify_fn, max_streams);
+    size_t max_streams)
+{
+    return boost::make_shared<muxed_zero_copy_if_impl>(
+        base_xport, classify_fn, max_streams);
 }
diff --git a/host/lib/transport/nirio_zero_copy.cpp b/host/lib/transport/nirio_zero_copy.cpp
index 993a2c593..e72064427 100644
--- a/host/lib/transport/nirio_zero_copy.cpp
+++ b/host/lib/transport/nirio_zero_copy.cpp
@@ -5,25 +5,25 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <uhd/transport/nirio_zero_copy.hpp>
 #include <uhd/transport/nirio/nirio_fifo.h>
+#include <uhd/transport/nirio_zero_copy.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhdlib/utils/atomic.hpp>
+#include <stdio.h>
+#include <boost/date_time/posix_time/posix_time.hpp>
 #include <boost/format.hpp>
+#include <boost/interprocess/mapped_region.hpp> //get_page_size()
 #include <boost/make_shared.hpp>
-#include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/interprocess/mapped_region.hpp>	//get_page_size()
-#include <vector>
-#include <algorithm>    // std::max
+#include <algorithm> // std::max
 #include <chrono>
 #include <thread>
-#include <stdio.h>
+#include <vector>
 
 //@TODO: Move the register defs required by the class to a common location
 #include "../usrp/x300/x300_regs.hpp"
 
 #if defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
-#include <windows.h>
+#    include <windows.h>
 static UHD_INLINE size_t get_page_size()
 {
     SYSTEM_INFO si;
@@ -31,7 +31,7 @@ static UHD_INLINE size_t get_page_size()
     return si.dwPageSize;
 }
 #else
-#include <unistd.h>
+#    include <unistd.h>
 static UHD_INLINE size_t get_page_size()
 {
     return size_t(sysconf(_SC_PAGESIZE));
@@ -48,153 +48,172 @@ typedef uint64_t fifo_data_t;
 class nirio_zero_copy_mrb : public managed_recv_buffer
 {
 public:
-    nirio_zero_copy_mrb(nirio_fifo<fifo_data_t>& fifo, const size_t frame_size):
-        _fifo(fifo), _frame_size(frame_size) { }
+    nirio_zero_copy_mrb(nirio_fifo<fifo_data_t>& fifo, const size_t frame_size)
+        : _fifo(fifo), _frame_size(frame_size)
+    {
+    }
 
     void release(void)
     {
         _fifo.release(_frame_size / sizeof(fifo_data_t));
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index)
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
     {
-        nirio_status status = 0;
-        size_t elems_acquired = 0;
+        nirio_status status    = 0;
+        size_t elems_acquired  = 0;
         size_t elems_remaining = 0;
-        nirio_status_chain(_fifo.acquire(
-            _typed_buffer, _frame_size / sizeof(fifo_data_t),
-            static_cast<uint32_t>(timeout*1000),
-            elems_acquired, elems_remaining), status);
+        nirio_status_chain(_fifo.acquire(_typed_buffer,
+                               _frame_size / sizeof(fifo_data_t),
+                               static_cast<uint32_t>(timeout * 1000),
+                               elems_acquired,
+                               elems_remaining),
+            status);
         _length = elems_acquired * sizeof(fifo_data_t);
         _buffer = static_cast<void*>(_typed_buffer);
 
         if (nirio_status_not_fatal(status)) {
-            index++;        //Advances the caller's buffer
+            index++; // Advances the caller's buffer
             return make(this, _buffer, _length);
         } else if (status == NiRio_Status_CommunicationTimeout) {
             nirio_status_to_exception(status, "NI-RIO PCIe data transfer failed.");
             return sptr();
         } else {
-            return sptr();  //NULL for timeout or error.
+            return sptr(); // NULL for timeout or error.
         }
     }
 
 private:
-    nirio_fifo<fifo_data_t>&    _fifo;
-    fifo_data_t*                _typed_buffer;
-    const size_t                _frame_size;
+    nirio_fifo<fifo_data_t>& _fifo;
+    fifo_data_t* _typed_buffer;
+    const size_t _frame_size;
 };
 
 class nirio_zero_copy_msb : public managed_send_buffer
 {
 public:
-    nirio_zero_copy_msb(nirio_fifo<fifo_data_t>& fifo, const size_t frame_size):
-        _fifo(fifo), _frame_size(frame_size) { }
+    nirio_zero_copy_msb(nirio_fifo<fifo_data_t>& fifo, const size_t frame_size)
+        : _fifo(fifo), _frame_size(frame_size)
+    {
+    }
 
     void release(void)
     {
         _fifo.release(_frame_size / sizeof(fifo_data_t));
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index)
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
     {
-        nirio_status status = 0;
-        size_t elems_acquired = 0;
+        nirio_status status    = 0;
+        size_t elems_acquired  = 0;
         size_t elems_remaining = 0;
-        nirio_status_chain(_fifo.acquire(
-            _typed_buffer, _frame_size / sizeof(fifo_data_t),
-            static_cast<uint32_t>(timeout*1000),
-            elems_acquired, elems_remaining), status);
+        nirio_status_chain(_fifo.acquire(_typed_buffer,
+                               _frame_size / sizeof(fifo_data_t),
+                               static_cast<uint32_t>(timeout * 1000),
+                               elems_acquired,
+                               elems_remaining),
+            status);
         _length = elems_acquired * sizeof(fifo_data_t);
         _buffer = static_cast<void*>(_typed_buffer);
 
         if (nirio_status_not_fatal(status)) {
-            index++;        //Advances the caller's buffer
+            index++; // Advances the caller's buffer
             return make(this, _buffer, _length);
         } else if (status == NiRio_Status_CommunicationTimeout) {
             nirio_status_to_exception(status, "NI-RIO PCIe data transfer failed.");
             return sptr();
         } else {
-            return sptr();  //NULL for timeout or error.
+            return sptr(); // NULL for timeout or error.
         }
     }
 
 private:
-    nirio_fifo<fifo_data_t>&    _fifo;
-    fifo_data_t*                _typed_buffer;
-    const size_t                _frame_size;
+    nirio_fifo<fifo_data_t>& _fifo;
+    fifo_data_t* _typed_buffer;
+    const size_t _frame_size;
 };
 
-class nirio_zero_copy_impl : public nirio_zero_copy {
+class nirio_zero_copy_impl : public nirio_zero_copy
+{
 public:
     typedef boost::shared_ptr<nirio_zero_copy_impl> sptr;
 
-    nirio_zero_copy_impl(
-        uhd::niusrprio::niusrprio_session::sptr fpga_session,
+    nirio_zero_copy_impl(uhd::niusrprio::niusrprio_session::sptr fpga_session,
         uint32_t instance,
-        const zero_copy_xport_params& xport_params
-    ):
-        _fpga_session(fpga_session),
-        _fifo_instance(instance),
-        _xport_params(xport_params),
-        _next_recv_buff_index(0), _next_send_buff_index(0)
+        const zero_copy_xport_params& xport_params)
+        : _fpga_session(fpga_session)
+        , _fifo_instance(instance)
+        , _xport_params(xport_params)
+        , _next_recv_buff_index(0)
+        , _next_send_buff_index(0)
     {
-        UHD_LOGGER_TRACE("NIRIO") << boost::format("Creating PCIe transport for channel %d") % instance ;
-        UHD_LOGGER_TRACE("NIRIO") << boost::format("nirio zero-copy RX transport configured with frame size = %u, #frames = %u, buffer size = %u\n")
-                    % _xport_params.recv_frame_size % _xport_params.num_recv_frames %
-                    (_xport_params.recv_frame_size * _xport_params.num_recv_frames);
-        UHD_LOGGER_TRACE("NIRIO") << boost::format("nirio zero-copy TX transport configured with frame size = %u, #frames = %u, buffer size = %u\n")
-                    % _xport_params.send_frame_size % _xport_params.num_send_frames % (_xport_params.send_frame_size * _xport_params.num_send_frames);
+        UHD_LOGGER_TRACE("NIRIO")
+            << boost::format("Creating PCIe transport for channel %d") % instance;
+        UHD_LOGGER_TRACE("NIRIO")
+            << boost::format("nirio zero-copy RX transport configured with frame size = "
+                             "%u, #frames = %u, buffer size = %u\n")
+                   % _xport_params.recv_frame_size % _xport_params.num_recv_frames
+                   % (_xport_params.recv_frame_size * _xport_params.num_recv_frames);
+        UHD_LOGGER_TRACE("NIRIO")
+            << boost::format("nirio zero-copy TX transport configured with frame size = "
+                             "%u, #frames = %u, buffer size = %u\n")
+                   % _xport_params.send_frame_size % _xport_params.num_send_frames
+                   % (_xport_params.send_frame_size * _xport_params.num_send_frames);
 
         nirio_status status = 0;
         size_t actual_depth = 0, actual_size = 0;
 
-        //Disable DMA streams in case last shutdown was unclean (cleanup, so don't status chain)
-        _proxy()->poke(PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
-        _proxy()->poke(PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
+        // Disable DMA streams in case last shutdown was unclean (cleanup, so don't status
+        // chain)
+        _proxy()->poke(
+            PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
+        _proxy()->poke(
+            PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
 
         _wait_until_stream_ready();
 
-        //Configure frame width
+        // Configure frame width
         nirio_status_chain(
             _proxy()->poke(PCIE_TX_DMA_REG(DMA_FRAME_SIZE_REG, _fifo_instance),
-                          static_cast<uint32_t>(_xport_params.send_frame_size/sizeof(fifo_data_t))),
+                static_cast<uint32_t>(
+                    _xport_params.send_frame_size / sizeof(fifo_data_t))),
             status);
         nirio_status_chain(
             _proxy()->poke(PCIE_RX_DMA_REG(DMA_FRAME_SIZE_REG, _fifo_instance),
-                          static_cast<uint32_t>(_xport_params.recv_frame_size/sizeof(fifo_data_t))),
+                static_cast<uint32_t>(
+                    _xport_params.recv_frame_size / sizeof(fifo_data_t))),
             status);
-        //Config 32-bit word flipping and enable DMA streams
+        // Config 32-bit word flipping and enable DMA streams
         nirio_status_chain(
             _proxy()->poke(PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance),
-                          DMA_CTRL_SW_BUF_U32 | DMA_CTRL_ENABLED),
+                DMA_CTRL_SW_BUF_U32 | DMA_CTRL_ENABLED),
             status);
         nirio_status_chain(
             _proxy()->poke(PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance),
-                          DMA_CTRL_SW_BUF_U32 | DMA_CTRL_ENABLED),
+                DMA_CTRL_SW_BUF_U32 | DMA_CTRL_ENABLED),
             status);
 
-        //Create FIFOs
+        // Create FIFOs
         nirio_status_chain(
-            _fpga_session->create_rx_fifo(_fifo_instance, _recv_fifo),
-            status);
+            _fpga_session->create_rx_fifo(_fifo_instance, _recv_fifo), status);
         nirio_status_chain(
-            _fpga_session->create_tx_fifo(_fifo_instance, _send_fifo),
-            status);
+            _fpga_session->create_tx_fifo(_fifo_instance, _send_fifo), status);
 
         if ((_recv_fifo.get() != NULL) && (_send_fifo.get() != NULL)) {
-            //Initialize FIFOs
-            nirio_status_chain(
-                _recv_fifo->initialize(
-                    (_xport_params.recv_frame_size*_xport_params.num_recv_frames)/sizeof(fifo_data_t),
-                    _xport_params.recv_frame_size / sizeof(fifo_data_t),
-                    actual_depth, actual_size),
+            // Initialize FIFOs
+            nirio_status_chain(_recv_fifo->initialize((_xport_params.recv_frame_size
+                                                          * _xport_params.num_recv_frames)
+                                                          / sizeof(fifo_data_t),
+                                   _xport_params.recv_frame_size / sizeof(fifo_data_t),
+                                   actual_depth,
+                                   actual_size),
                 status);
-            nirio_status_chain(
-                _send_fifo->initialize(
-                    (_xport_params.send_frame_size*_xport_params.num_send_frames)/sizeof(fifo_data_t),
-                    _xport_params.send_frame_size / sizeof(fifo_data_t),
-                    actual_depth, actual_size),
+            nirio_status_chain(_send_fifo->initialize((_xport_params.send_frame_size
+                                                          * _xport_params.num_send_frames)
+                                                          / sizeof(fifo_data_t),
+                                   _xport_params.send_frame_size / sizeof(fifo_data_t),
+                                   actual_depth,
+                                   actual_size),
                 status);
 
             _proxy()->get_rio_quirks().add_tx_fifo(_fifo_instance);
@@ -203,16 +222,16 @@ public:
             nirio_status_chain(_send_fifo->start(), status);
 
             if (nirio_status_not_fatal(status)) {
-                //allocate re-usable managed receive buffers
-                for (size_t i = 0; i < get_num_recv_frames(); i++){
-                    _mrb_pool.push_back(boost::shared_ptr<nirio_zero_copy_mrb>(new nirio_zero_copy_mrb(
-                        *_recv_fifo, get_recv_frame_size())));
+                // allocate re-usable managed receive buffers
+                for (size_t i = 0; i < get_num_recv_frames(); i++) {
+                    _mrb_pool.push_back(boost::shared_ptr<nirio_zero_copy_mrb>(
+                        new nirio_zero_copy_mrb(*_recv_fifo, get_recv_frame_size())));
                 }
 
-                //allocate re-usable managed send buffers
-                for (size_t i = 0; i < get_num_send_frames(); i++){
-                    _msb_pool.push_back(boost::shared_ptr<nirio_zero_copy_msb>(new nirio_zero_copy_msb(
-                        *_send_fifo, get_send_frame_size())));
+                // allocate re-usable managed send buffers
+                for (size_t i = 0; i < get_num_send_frames(); i++) {
+                    _msb_pool.push_back(boost::shared_ptr<nirio_zero_copy_msb>(
+                        new nirio_zero_copy_msb(*_send_fifo, get_send_frame_size())));
                 }
             }
         } else {
@@ -226,14 +245,16 @@ public:
     {
         _proxy()->get_rio_quirks().remove_tx_fifo(_fifo_instance);
 
-        //Disable DMA streams (cleanup, so don't status chain)
-        _proxy()->poke(PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
-        _proxy()->poke(PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
+        // Disable DMA streams (cleanup, so don't status chain)
+        _proxy()->poke(
+            PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
+        _proxy()->poke(
+            PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), DMA_CTRL_DISABLED);
 
         _flush_rx_buff();
 
-        //Stop DMA channels. Stop is called in the fifo dtor but
-        //it doesn't hurt to do it here.
+        // Stop DMA channels. Stop is called in the fifo dtor but
+        // it doesn't hurt to do it here.
         _send_fifo->stop();
         _recv_fifo->stop();
     }
@@ -244,12 +265,19 @@ public:
      ******************************************************************/
     managed_recv_buffer::sptr get_recv_buff(double timeout)
     {
-        if (_next_recv_buff_index == _xport_params.num_recv_frames) _next_recv_buff_index = 0;
+        if (_next_recv_buff_index == _xport_params.num_recv_frames)
+            _next_recv_buff_index = 0;
         return _mrb_pool[_next_recv_buff_index]->get_new(timeout, _next_recv_buff_index);
     }
 
-    size_t get_num_recv_frames(void) const {return _xport_params.num_recv_frames;}
-    size_t get_recv_frame_size(void) const {return _xport_params.recv_frame_size;}
+    size_t get_num_recv_frames(void) const
+    {
+        return _xport_params.num_recv_frames;
+    }
+    size_t get_recv_frame_size(void) const
+    {
+        return _xport_params.recv_frame_size;
+    }
 
     /*******************************************************************
      * Send implementation:
@@ -257,16 +285,25 @@ public:
      ******************************************************************/
     managed_send_buffer::sptr get_send_buff(double timeout)
     {
-        if (_next_send_buff_index == _xport_params.num_send_frames) _next_send_buff_index = 0;
+        if (_next_send_buff_index == _xport_params.num_send_frames)
+            _next_send_buff_index = 0;
         return _msb_pool[_next_send_buff_index]->get_new(timeout, _next_send_buff_index);
     }
 
-    size_t get_num_send_frames(void) const {return _xport_params.num_send_frames;}
-    size_t get_send_frame_size(void) const {return _xport_params.send_frame_size;}
+    size_t get_num_send_frames(void) const
+    {
+        return _xport_params.num_send_frames;
+    }
+    size_t get_send_frame_size(void) const
+    {
+        return _xport_params.send_frame_size;
+    }
 
 private:
-
-    UHD_INLINE niriok_proxy::sptr _proxy() { return _fpga_session->get_kernel_proxy(); }
+    UHD_INLINE niriok_proxy::sptr _proxy()
+    {
+        return _fpga_session->get_kernel_proxy();
+    }
 
     UHD_INLINE void _flush_rx_buff()
     {
@@ -275,21 +312,19 @@ private:
         // repeatedly with the number of remaining elements
         // until the buffer is empty
         for (size_t num_elems_requested = 0,
-            num_elems_acquired = 0,
-            num_elems_remaining = 1;
-            num_elems_remaining;
-            num_elems_requested = num_elems_remaining)
-        {
+                    num_elems_acquired  = 0,
+                    num_elems_remaining = 1;
+             num_elems_remaining;
+             num_elems_requested = num_elems_remaining) {
             fifo_data_t* elems_buffer = NULL;
-            nirio_status status = _recv_fifo->acquire(
-                elems_buffer,
+            nirio_status status       = _recv_fifo->acquire(elems_buffer,
                 num_elems_requested,
-                0,                      // timeout
+                0, // timeout
                 num_elems_acquired,
                 num_elems_remaining);
             // throw excetption if status is fatal
-            nirio_status_to_exception(status,
-                "NI-RIO PCIe data transfer failed during flush.");
+            nirio_status_to_exception(
+                status, "NI-RIO PCIe data transfer failed during flush.");
             _recv_fifo->release(num_elems_acquired);
         }
     }
@@ -304,44 +339,52 @@ private:
         boost::posix_time::time_duration elapsed;
         nirio_status status = NiRio_Status_Success;
 
-        nirio_status_chain(_proxy()->peek(
-            PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data), status);
+        nirio_status_chain(
+            _proxy()->peek(
+                PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data),
+            status);
         tx_busy = (reg_data & DMA_STATUS_BUSY) > 0;
-        nirio_status_chain(_proxy()->peek(
-            PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data), status);
+        nirio_status_chain(
+            _proxy()->peek(
+                PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data),
+            status);
         rx_busy = (reg_data & DMA_STATUS_BUSY) > 0;
 
         if (nirio_status_not_fatal(status) && (tx_busy || rx_busy)) {
             start_time = boost::posix_time::microsec_clock::local_time();
             do {
-                std::this_thread::sleep_for(std::chrono::microseconds(50)); //Avoid flooding the bus
+                std::this_thread::sleep_for(
+                    std::chrono::microseconds(50)); // Avoid flooding the bus
                 elapsed = boost::posix_time::microsec_clock::local_time() - start_time;
-                nirio_status_chain(_proxy()->peek(
-                    PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data), status);
+                nirio_status_chain(
+                    _proxy()->peek(
+                        PCIE_TX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data),
+                    status);
                 tx_busy = (reg_data & DMA_STATUS_BUSY) > 0;
-                nirio_status_chain(_proxy()->peek(
-                    PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data), status);
+                nirio_status_chain(
+                    _proxy()->peek(
+                        PCIE_RX_DMA_REG(DMA_CTRL_STATUS_REG, _fifo_instance), reg_data),
+                    status);
                 rx_busy = (reg_data & DMA_STATUS_BUSY) > 0;
-            } while (
-                nirio_status_not_fatal(status) &&
-                (tx_busy || rx_busy) &&
-                elapsed.total_milliseconds() < TIMEOUT_IN_MS);
+            } while (nirio_status_not_fatal(status) && (tx_busy || rx_busy)
+                     && elapsed.total_milliseconds() < TIMEOUT_IN_MS);
 
             if (tx_busy || rx_busy) {
                 nirio_status_chain(NiRio_Status_FpgaBusy, status);
             }
 
-            nirio_status_to_exception(status, "Could not create nirio_zero_copy transport.");
+            nirio_status_to_exception(
+                status, "Could not create nirio_zero_copy transport.");
         }
     }
 
-    //memory management -> buffers and fifos
+    // memory management -> buffers and fifos
     niusrprio::niusrprio_session::sptr _fpga_session;
     uint32_t _fifo_instance;
     nirio_fifo<fifo_data_t>::sptr _recv_fifo, _send_fifo;
     const zero_copy_xport_params _xport_params;
-    std::vector<boost::shared_ptr<nirio_zero_copy_msb> > _msb_pool;
-    std::vector<boost::shared_ptr<nirio_zero_copy_mrb> > _mrb_pool;
+    std::vector<boost::shared_ptr<nirio_zero_copy_msb>> _msb_pool;
+    std::vector<boost::shared_ptr<nirio_zero_copy_mrb>> _mrb_pool;
     size_t _next_recv_buff_index, _next_send_buff_index;
 };
 
@@ -350,102 +393,121 @@ nirio_zero_copy::sptr nirio_zero_copy::make(
     uhd::niusrprio::niusrprio_session::sptr fpga_session,
     const uint32_t instance,
     const zero_copy_xport_params& default_buff_args,
-    const device_addr_t &hints
-){
-    //Initialize xport_params
+    const device_addr_t& hints)
+{
+    // Initialize xport_params
     zero_copy_xport_params xport_params = default_buff_args;
 
-    //The kernel buffer for this transport must be (num_frames * frame_size) big. Unlike ethernet,
-    //where the kernel buffer size is independent of the circular buffer size for the transport,
-    //it is possible for users to over constrain the system when they set the num_frames and the buff_size
-    //So we give buff_size priority over num_frames and throw an error if they conflict.
+    // The kernel buffer for this transport must be (num_frames * frame_size) big. Unlike
+    // ethernet, where the kernel buffer size is independent of the circular buffer size
+    // for the transport, it is possible for users to over constrain the system when they
+    // set the num_frames and the buff_size So we give buff_size priority over num_frames
+    // and throw an error if they conflict.
 
-    //RX
-    xport_params.recv_frame_size = size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
+    // RX
+    xport_params.recv_frame_size =
+        size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
 
     size_t usr_num_recv_frames = static_cast<size_t>(
         hints.cast<double>("num_recv_frames", default_buff_args.num_recv_frames));
     size_t usr_recv_buff_size = static_cast<size_t>(
         hints.cast<double>("recv_buff_size", default_buff_args.num_recv_frames));
 
-    if (hints.has_key("recv_buff_size"))
-    {
-        if (usr_recv_buff_size % page_size != 0)
-        {
-            throw uhd::value_error((boost::format("recv_buff_size must be multiple of %d") % page_size).str());
+    if (hints.has_key("recv_buff_size")) {
+        if (usr_recv_buff_size % page_size != 0) {
+            throw uhd::value_error(
+                (boost::format("recv_buff_size must be multiple of %d") % page_size)
+                    .str());
         }
     }
 
-    if (hints.has_key("recv_frame_size") and hints.has_key("num_recv_frames"))
-    {
-        if (usr_num_recv_frames * xport_params.recv_frame_size % page_size != 0)
-        {
-            throw uhd::value_error((boost::format("num_recv_frames * recv_frame_size must be an even multiple of %d") % page_size).str());
+    if (hints.has_key("recv_frame_size") and hints.has_key("num_recv_frames")) {
+        if (usr_num_recv_frames * xport_params.recv_frame_size % page_size != 0) {
+            throw uhd::value_error(
+                (boost::format(
+                     "num_recv_frames * recv_frame_size must be an even multiple of %d")
+                    % page_size)
+                    .str());
         }
     }
 
     if (hints.has_key("num_recv_frames") and hints.has_key("recv_buff_size")) {
         if (usr_recv_buff_size < xport_params.recv_frame_size)
-            throw uhd::value_error("recv_buff_size must be equal to or greater than (num_recv_frames * recv_frame_size)");
+            throw uhd::value_error("recv_buff_size must be equal to or greater than "
+                                   "(num_recv_frames * recv_frame_size)");
 
-        if ((usr_recv_buff_size/xport_params.recv_frame_size) != usr_num_recv_frames)
-            throw uhd::value_error("Conflicting values for recv_buff_size and num_recv_frames");
+        if ((usr_recv_buff_size / xport_params.recv_frame_size) != usr_num_recv_frames)
+            throw uhd::value_error(
+                "Conflicting values for recv_buff_size and num_recv_frames");
     }
 
     if (hints.has_key("recv_buff_size")) {
-        xport_params.num_recv_frames = std::max<size_t>(1, usr_recv_buff_size/xport_params.recv_frame_size);    //Round down
+        xport_params.num_recv_frames = std::max<size_t>(
+            1, usr_recv_buff_size / xport_params.recv_frame_size); // Round down
     } else if (hints.has_key("num_recv_frames")) {
         xport_params.num_recv_frames = usr_num_recv_frames;
     }
 
-    if (xport_params.num_recv_frames * xport_params.recv_frame_size % page_size != 0)
-    {
-        throw uhd::value_error((boost::format("num_recv_frames * recv_frame_size must be an even multiple of %d") % page_size).str());
+    if (xport_params.num_recv_frames * xport_params.recv_frame_size % page_size != 0) {
+        throw uhd::value_error(
+            (boost::format(
+                 "num_recv_frames * recv_frame_size must be an even multiple of %d")
+                % page_size)
+                .str());
     }
 
-    //TX
-    xport_params.send_frame_size = size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
+    // TX
+    xport_params.send_frame_size =
+        size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
 
     size_t usr_num_send_frames = static_cast<size_t>(
         hints.cast<double>("num_send_frames", default_buff_args.num_send_frames));
     size_t usr_send_buff_size = static_cast<size_t>(
         hints.cast<double>("send_buff_size", default_buff_args.num_send_frames));
 
-    if (hints.has_key("send_buff_size")) 
-    {
-        if (usr_send_buff_size % page_size != 0)
-        {
-            throw uhd::value_error((boost::format("send_buff_size must be multiple of %d") % page_size).str());
+    if (hints.has_key("send_buff_size")) {
+        if (usr_send_buff_size % page_size != 0) {
+            throw uhd::value_error(
+                (boost::format("send_buff_size must be multiple of %d") % page_size)
+                    .str());
         }
     }
 
-    if (hints.has_key("send_frame_size") and hints.has_key("num_send_frames"))
-    {
-        if (usr_num_send_frames * xport_params.send_frame_size % page_size != 0)
-        {
-            throw uhd::value_error((boost::format("num_send_frames * send_frame_size must be an even multiple of %d") % page_size).str());
+    if (hints.has_key("send_frame_size") and hints.has_key("num_send_frames")) {
+        if (usr_num_send_frames * xport_params.send_frame_size % page_size != 0) {
+            throw uhd::value_error(
+                (boost::format(
+                     "num_send_frames * send_frame_size must be an even multiple of %d")
+                    % page_size)
+                    .str());
         }
     }
 
     if (hints.has_key("num_send_frames") and hints.has_key("send_buff_size")) {
         if (usr_send_buff_size < xport_params.send_frame_size)
-            throw uhd::value_error("send_buff_size must be equal to or greater than (num_send_frames * send_frame_size)");
+            throw uhd::value_error("send_buff_size must be equal to or greater than "
+                                   "(num_send_frames * send_frame_size)");
 
-        if ((usr_send_buff_size/xport_params.send_frame_size) != usr_num_send_frames)
-            throw uhd::value_error("Conflicting values for send_buff_size and num_send_frames");
+        if ((usr_send_buff_size / xport_params.send_frame_size) != usr_num_send_frames)
+            throw uhd::value_error(
+                "Conflicting values for send_buff_size and num_send_frames");
     }
 
     if (hints.has_key("send_buff_size")) {
-        xport_params.num_send_frames = std::max<size_t>(1, usr_send_buff_size/xport_params.send_frame_size);    //Round down
+        xport_params.num_send_frames = std::max<size_t>(
+            1, usr_send_buff_size / xport_params.send_frame_size); // Round down
     } else if (hints.has_key("num_send_frames")) {
         xport_params.num_send_frames = usr_num_send_frames;
     }
 
-    if (xport_params.num_send_frames * xport_params.send_frame_size % page_size != 0)
-    {
-        throw uhd::value_error((boost::format("num_send_frames * send_frame_size must be an even multiple of %d") % page_size).str());
+    if (xport_params.num_send_frames * xport_params.send_frame_size % page_size != 0) {
+        throw uhd::value_error(
+            (boost::format(
+                 "num_send_frames * send_frame_size must be an even multiple of %d")
+                % page_size)
+                .str());
     }
 
-    return nirio_zero_copy::sptr(new nirio_zero_copy_impl(fpga_session, instance, xport_params));
+    return nirio_zero_copy::sptr(
+        new nirio_zero_copy_impl(fpga_session, instance, xport_params));
 }
-
diff --git a/host/lib/transport/super_recv_packet_handler.hpp b/host/lib/transport/super_recv_packet_handler.hpp
index 894287d6b..342d273a6 100644
--- a/host/lib/transport/super_recv_packet_handler.hpp
+++ b/host/lib/transport/super_recv_packet_handler.hpp
@@ -9,43 +9,43 @@
 #define INCLUDED_LIBUHD_TRANSPORT_SUPER_RECV_PACKET_HANDLER_HPP
 
 #include <uhd/config.hpp>
-#include <uhd/exception.hpp>
 #include <uhd/convert.hpp>
+#include <uhd/exception.hpp>
 #include <uhd/stream.hpp>
-#include <uhd/utils/tasks.hpp>
-#include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/log.hpp>
-#include <uhd/types/metadata.hpp>
 #include <uhd/transport/vrt_if_packet.hpp>
 #include <uhd/transport/zero_copy.hpp>
+#include <uhd/types/metadata.hpp>
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/utils/log.hpp>
+#include <uhd/utils/tasks.hpp>
 #include <uhdlib/rfnoc/rx_stream_terminator.hpp>
 #include <boost/dynamic_bitset.hpp>
-#include <boost/function.hpp>
 #include <boost/format.hpp>
+#include <boost/function.hpp>
 #include <boost/make_shared.hpp>
 #include <iostream>
 #include <vector>
 
 // Included for debugging
 #ifdef UHD_TXRX_DEBUG_PRINTS
-#include <boost/format.hpp>
-#include <boost/thread/thread.hpp>
-#include "boost/date_time/posix_time/posix_time.hpp"
+#    include "boost/date_time/posix_time/posix_time.hpp"
+#    include <boost/format.hpp>
+#    include <boost/thread/thread.hpp>
 #endif
 
-namespace uhd{ namespace transport{ namespace sph{
+namespace uhd { namespace transport { namespace sph {
 
 UHD_INLINE uint32_t get_context_code(
-    const uint32_t *vrt_hdr, const vrt::if_packet_info_t &if_packet_info
-){
-    //extract the context word (we dont know the endianness so mirror the bytes)
-    uint32_t word0 = vrt_hdr[if_packet_info.num_header_words32] |
-              uhd::byteswap(vrt_hdr[if_packet_info.num_header_words32]);
+    const uint32_t* vrt_hdr, const vrt::if_packet_info_t& if_packet_info)
+{
+    // extract the context word (we dont know the endianness so mirror the bytes)
+    uint32_t word0 = vrt_hdr[if_packet_info.num_header_words32]
+                     | uhd::byteswap(vrt_hdr[if_packet_info.num_header_words32]);
     return word0 & 0xff;
 }
 
 typedef boost::function<void(void)> handle_overflow_type;
-static inline void handle_overflow_nop(void){}
+static inline void handle_overflow_nop(void) {}
 
 /***********************************************************************
  * Super receive packet handler
@@ -54,51 +54,58 @@ static inline void handle_overflow_nop(void){}
  * The channel group shares a common sample rate.
  * All channels are received in unison in recv().
  **********************************************************************/
-class recv_packet_handler{
+class recv_packet_handler
+{
 public:
     typedef boost::function<managed_recv_buffer::sptr(double)> get_buff_type;
     typedef boost::function<void(const size_t)> handle_flowctrl_type;
-    typedef std::function<void(const uint32_t *)> handle_flowctrl_ack_type;
+    typedef std::function<void(const uint32_t*)> handle_flowctrl_ack_type;
     typedef boost::function<void(const stream_cmd_t&)> issue_stream_cmd_type;
-    typedef void(*vrt_unpacker_type)(const uint32_t *, vrt::if_packet_info_t &);
-    //typedef boost::function<void(const uint32_t *, vrt::if_packet_info_t &)> vrt_unpacker_type;
+    typedef void (*vrt_unpacker_type)(const uint32_t*, vrt::if_packet_info_t&);
+    // typedef boost::function<void(const uint32_t *, vrt::if_packet_info_t &)>
+    // vrt_unpacker_type;
 
     /*!
      * Make a new packet handler for receive
      * \param size the number of transport channels
      */
-    recv_packet_handler(const size_t size = 1):
-        _queue_error_for_next_call(false),
-        _buffers_infos_index(0)
+    recv_packet_handler(const size_t size = 1)
+        : _queue_error_for_next_call(false), _buffers_infos_index(0)
     {
-        #ifdef  ERROR_INJECT_DROPPED_PACKETS
+#ifdef ERROR_INJECT_DROPPED_PACKETS
         recvd_packets = 0;
-        #endif
+#endif
 
         this->resize(size);
         set_alignment_failure_threshold(1000);
     }
 
-    ~recv_packet_handler(void){
+    ~recv_packet_handler(void)
+    {
         /* NOP */
     }
 
     //! Resize the number of transport channels
-    void resize(const size_t size){
-        if (this->size() == size) return;
+    void resize(const size_t size)
+    {
+        if (this->size() == size)
+            return;
         _props.resize(size);
-        //re-initialize all buffers infos by re-creating the vector
+        // re-initialize all buffers infos by re-creating the vector
         _buffers_infos = std::vector<buffers_info_type>(4, buffers_info_type(size));
     }
 
     //! Get the channel width of this handler
-    size_t size(void) const{
+    size_t size(void) const
+    {
         return _props.size();
     }
 
     //! Setup the vrt unpacker function and offset
-    void set_vrt_unpacker(const vrt_unpacker_type &vrt_unpacker, const size_t header_offset_words32 = 0){
-        _vrt_unpacker = vrt_unpacker;
+    void set_vrt_unpacker(
+        const vrt_unpacker_type& vrt_unpacker, const size_t header_offset_words32 = 0)
+    {
+        _vrt_unpacker          = vrt_unpacker;
         _header_offset_words32 = header_offset_words32;
     }
 
@@ -107,17 +114,20 @@ public:
      * How many packets throw out before giving up?
      * \param threshold number of packets per channel
      */
-    void set_alignment_failure_threshold(const size_t threshold){
-        _alignment_failure_threshold = threshold*this->size();
+    void set_alignment_failure_threshold(const size_t threshold)
+    {
+        _alignment_failure_threshold = threshold * this->size();
     }
 
     //! Set the rate of ticks per second
-    void set_tick_rate(const double rate){
+    void set_tick_rate(const double rate)
+    {
         _tick_rate = rate;
     }
 
     //! Set the rate of samples per second
-    void set_samp_rate(const double rate){
+    void set_samp_rate(const double rate)
+    {
         _samp_rate = rate;
     }
 
@@ -126,9 +136,12 @@ public:
      * \param xport_chan which transport channel
      * \param get_buff the getter function
      */
-    void set_xport_chan_get_buff(const size_t xport_chan, const get_buff_type &get_buff, const bool flush = false){
-        if (flush){
-            while (get_buff(0.0)) {};
+    void set_xport_chan_get_buff(
+        const size_t xport_chan, const get_buff_type& get_buff, const bool flush = false)
+    {
+        if (flush) {
+            while (get_buff(0.0)) {
+            };
         }
         _props.at(xport_chan).get_buff = get_buff;
     }
@@ -148,58 +161,67 @@ public:
      * \param xport_chan which transport channel
      * \param handle_flowctrl the callback function
      */
-    void set_xport_handle_flowctrl(const size_t xport_chan, const handle_flowctrl_type &handle_flowctrl, const size_t update_window, const bool do_init = false)
+    void set_xport_handle_flowctrl(const size_t xport_chan,
+        const handle_flowctrl_type& handle_flowctrl,
+        const size_t update_window,
+        const bool do_init = false)
     {
         _props.at(xport_chan).handle_flowctrl = handle_flowctrl;
-        //we need the window size to be within the 0xfff (max 12 bit seq)
+        // we need the window size to be within the 0xfff (max 12 bit seq)
         _props.at(xport_chan).fc_update_window = std::min<size_t>(update_window, 0xfff);
-        if (do_init) handle_flowctrl(0);
+        if (do_init)
+            handle_flowctrl(0);
     }
 
     void set_xport_handle_flowctrl_ack(
-            const size_t xport_chan,
-            const handle_flowctrl_ack_type &handle_flowctrl_ack
-    ) {
+        const size_t xport_chan, const handle_flowctrl_ack_type& handle_flowctrl_ack)
+    {
         _props.at(xport_chan).handle_flowctrl_ack = handle_flowctrl_ack;
     }
 
     //! Set the conversion routine for all channels
-    void set_converter(const uhd::convert::id_type &id){
+    void set_converter(const uhd::convert::id_type& id)
+    {
         _num_outputs = id.num_outputs;
-        _converter = uhd::convert::get_converter(id)();
-        this->set_scale_factor(1/32767.); //update after setting converter
+        _converter   = uhd::convert::get_converter(id)();
+        this->set_scale_factor(1 / 32767.); // update after setting converter
         _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.input_format);
         _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.output_format);
     }
 
     //! Set the transport channel's overflow handler
-    void set_overflow_handler(const size_t xport_chan, const handle_overflow_type &handle_overflow){
+    void set_overflow_handler(
+        const size_t xport_chan, const handle_overflow_type& handle_overflow)
+    {
         _props.at(xport_chan).handle_overflow = handle_overflow;
     }
 
     //! Set the scale factor used in float conversion
-    void set_scale_factor(const double scale_factor){
+    void set_scale_factor(const double scale_factor)
+    {
         _converter->set_scalar(scale_factor);
     }
 
     //! Set the callback to issue stream commands
-    void set_issue_stream_cmd(const size_t xport_chan, const issue_stream_cmd_type &issue_stream_cmd)
+    void set_issue_stream_cmd(
+        const size_t xport_chan, const issue_stream_cmd_type& issue_stream_cmd)
     {
         _props.at(xport_chan).issue_stream_cmd = issue_stream_cmd;
     }
 
     //! Overload call to issue stream commands
-    void issue_stream_cmd(const stream_cmd_t &stream_cmd)
+    void issue_stream_cmd(const stream_cmd_t& stream_cmd)
     {
-        if (size() > 1 and stream_cmd.stream_now and
-            stream_cmd.stream_mode != stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS)
-        {
-            throw uhd::runtime_error("Invalid recv stream command - stream now on multiple channels in a single streamer will fail to time align.");
+        if (size() > 1 and stream_cmd.stream_now
+            and stream_cmd.stream_mode != stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS) {
+            throw uhd::runtime_error(
+                "Invalid recv stream command - stream now on multiple channels in a "
+                "single streamer will fail to time align.");
         }
 
-        for (size_t i = 0; i < _props.size(); i++)
-        {
-            if (_props[i].issue_stream_cmd) _props[i].issue_stream_cmd(stream_cmd);
+        for (size_t i = 0; i < _props.size(); i++) {
+            if (_props[i].issue_stream_cmd)
+                _props[i].issue_stream_cmd(stream_cmd);
         }
     }
 
@@ -208,56 +230,57 @@ public:
      * The entry point for the fast-path receive calls.
      * Dispatch into combinations of single packet receive calls.
      ******************************************************************/
-    UHD_INLINE size_t recv(
-        const uhd::rx_streamer::buffs_type &buffs,
+    UHD_INLINE size_t recv(const uhd::rx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        uhd::rx_metadata_t &metadata,
+        uhd::rx_metadata_t& metadata,
         const double timeout,
-        const bool one_packet
-    ){
-        //handle metadata queued from a previous receive
-        if (_queue_error_for_next_call){
+        const bool one_packet)
+    {
+        // handle metadata queued from a previous receive
+        if (_queue_error_for_next_call) {
             _queue_error_for_next_call = false;
-            metadata = _queue_metadata;
-            //We want to allow a full buffer recv to be cut short by a timeout,
-            //but do not want to generate an inline timeout message packet.
-            if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_TIMEOUT) return 0;
+            metadata                   = _queue_metadata;
+            // We want to allow a full buffer recv to be cut short by a timeout,
+            // but do not want to generate an inline timeout message packet.
+            if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_TIMEOUT)
+                return 0;
         }
 
-        size_t accum_num_samps = recv_one_packet(
-            buffs, nsamps_per_buff, metadata, timeout
-        );
+        size_t accum_num_samps =
+            recv_one_packet(buffs, nsamps_per_buff, metadata, timeout);
 
-        if (one_packet or metadata.end_of_burst){
+        if (one_packet or metadata.end_of_burst) {
 #ifdef UHD_TXRX_DEBUG_PRINTS
-            dbg_gather_data(nsamps_per_buff, accum_num_samps, metadata, timeout, one_packet);
+            dbg_gather_data(
+                nsamps_per_buff, accum_num_samps, metadata, timeout, one_packet);
 #endif
             return accum_num_samps;
         }
 
-        //first recv had an error code set, return immediately
+        // first recv had an error code set, return immediately
         if (metadata.error_code != rx_metadata_t::ERROR_CODE_NONE) {
             return accum_num_samps;
         }
 
-        //loop until buffer is filled or error code
-        while(accum_num_samps < nsamps_per_buff){
-            size_t num_samps = recv_one_packet(
-                buffs, nsamps_per_buff - accum_num_samps, _queue_metadata,
-                timeout, accum_num_samps*_bytes_per_cpu_item
-            );
+        // loop until buffer is filled or error code
+        while (accum_num_samps < nsamps_per_buff) {
+            size_t num_samps = recv_one_packet(buffs,
+                nsamps_per_buff - accum_num_samps,
+                _queue_metadata,
+                timeout,
+                accum_num_samps * _bytes_per_cpu_item);
 
             metadata.end_of_burst = _queue_metadata.end_of_burst;
 
-            //metadata had an error code set, store for next call and return
-            if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_NONE){
+            // metadata had an error code set, store for next call and return
+            if (_queue_metadata.error_code != rx_metadata_t::ERROR_CODE_NONE) {
                 _queue_error_for_next_call = true;
                 break;
             }
 
             accum_num_samps += num_samps;
 
-            //return immediately if end of burst
+            // return immediately if end of burst
             if (_queue_metadata.end_of_burst) {
                 break;
             }
@@ -275,12 +298,12 @@ private:
     bool _queue_error_for_next_call;
     size_t _alignment_failure_threshold;
     rx_metadata_t _queue_metadata;
-    struct xport_chan_props_type{
-        xport_chan_props_type(void):
-            packet_count(0),
-            handle_overflow(&handle_overflow_nop),
-            fc_update_window(0)
-        {}
+    struct xport_chan_props_type
+    {
+        xport_chan_props_type(void)
+            : packet_count(0), handle_overflow(&handle_overflow_nop), fc_update_window(0)
+        {
+        }
         get_buff_type get_buff;
         issue_stream_cmd_type issue_stream_cmd;
         size_t packet_count;
@@ -291,65 +314,80 @@ private:
     };
     std::vector<xport_chan_props_type> _props;
     size_t _num_outputs;
-    size_t _bytes_per_otw_item; //used in conversion
-    size_t _bytes_per_cpu_item; //used in conversion
-    uhd::convert::converter::sptr _converter; //used in conversion
+    size_t _bytes_per_otw_item; // used in conversion
+    size_t _bytes_per_cpu_item; // used in conversion
+    uhd::convert::converter::sptr _converter; // used in conversion
 
     //! information stored for a received buffer
-    struct per_buffer_info_type{
+    struct per_buffer_info_type
+    {
         void reset()
         {
             buff.reset();
-            vrt_hdr = nullptr;
-            time = 0;
+            vrt_hdr   = nullptr;
+            time      = 0;
             copy_buff = nullptr;
         }
         managed_recv_buffer::sptr buff;
-        const uint32_t *vrt_hdr;
+        const uint32_t* vrt_hdr;
         vrt::if_packet_info_t ifpi;
         uint64_t time;
-        const char *copy_buff;
+        const char* copy_buff;
     };
 
-    //!information stored for a set of aligned buffers
-    struct buffers_info_type : std::vector<per_buffer_info_type> {
-        buffers_info_type(const size_t size):
-            std::vector<per_buffer_info_type>(size),
-            indexes_todo(size, true),
-            alignment_time(0),
-            alignment_time_valid(false),
-            data_bytes_to_copy(0),
-            fragment_offset_in_samps(0)
-        {/* NOP */}
+    //! information stored for a set of aligned buffers
+    struct buffers_info_type : std::vector<per_buffer_info_type>
+    {
+        buffers_info_type(const size_t size)
+            : std::vector<per_buffer_info_type>(size)
+            , indexes_todo(size, true)
+            , alignment_time(0)
+            , alignment_time_valid(false)
+            , data_bytes_to_copy(0)
+            , fragment_offset_in_samps(0)
+        { /* NOP */
+        }
         void reset()
         {
             indexes_todo.set();
-            alignment_time = 0;
-            alignment_time_valid = false;
-            data_bytes_to_copy = 0;
+            alignment_time           = 0;
+            alignment_time_valid     = false;
+            data_bytes_to_copy       = 0;
             fragment_offset_in_samps = 0;
             metadata.reset();
             for (size_t i = 0; i < size(); i++)
                 at(i).reset();
         }
-        boost::dynamic_bitset<> indexes_todo; //used in alignment logic
-        uint64_t alignment_time; //used in alignment logic
-        bool alignment_time_valid; //used in alignment logic
-        size_t data_bytes_to_copy; //keeps track of state
-        size_t fragment_offset_in_samps; //keeps track of state
-        rx_metadata_t metadata; //packet description
+        boost::dynamic_bitset<> indexes_todo; // used in alignment logic
+        uint64_t alignment_time; // used in alignment logic
+        bool alignment_time_valid; // used in alignment logic
+        size_t data_bytes_to_copy; // keeps track of state
+        size_t fragment_offset_in_samps; // keeps track of state
+        rx_metadata_t metadata; // packet description
     };
 
     //! a circular queue of buffer infos
     std::vector<buffers_info_type> _buffers_infos;
     size_t _buffers_infos_index;
-    buffers_info_type &get_curr_buffer_info(void){return _buffers_infos[_buffers_infos_index];}
-    buffers_info_type &get_prev_buffer_info(void){return _buffers_infos[(_buffers_infos_index + 3)%4];}
-    buffers_info_type &get_next_buffer_info(void){return _buffers_infos[(_buffers_infos_index + 1)%4];}
-    void increment_buffer_info(void){_buffers_infos_index = (_buffers_infos_index + 1)%4;}
+    buffers_info_type& get_curr_buffer_info(void)
+    {
+        return _buffers_infos[_buffers_infos_index];
+    }
+    buffers_info_type& get_prev_buffer_info(void)
+    {
+        return _buffers_infos[(_buffers_infos_index + 3) % 4];
+    }
+    buffers_info_type& get_next_buffer_info(void)
+    {
+        return _buffers_infos[(_buffers_infos_index + 1) % 4];
+    }
+    void increment_buffer_info(void)
+    {
+        _buffers_infos_index = (_buffers_infos_index + 1) % 4;
+    }
 
     //! possible return options for the packet receiver
-    enum packet_type{
+    enum packet_type {
         PACKET_IF_DATA,
         PACKET_TIMESTAMP_ERROR,
         PACKET_INLINE_MESSAGE,
@@ -357,9 +395,9 @@ private:
         PACKET_SEQUENCE_ERROR
     };
 
-    #ifdef  ERROR_INJECT_DROPPED_PACKETS
+#ifdef ERROR_INJECT_DROPPED_PACKETS
     int recvd_packets;
-    #endif
+#endif
 
     /*******************************************************************
      * Get and process a single packet from the transport:
@@ -367,57 +405,56 @@ private:
      * Extract all the relevant info and store.
      * Check the info to determine the return code.
      ******************************************************************/
-    UHD_INLINE packet_type get_and_process_single_packet(
-        const size_t index,
-        per_buffer_info_type &prev_buffer_info,
-        per_buffer_info_type &curr_buffer_info,
-        double timeout
-    ){
-        managed_recv_buffer::sptr &buff = curr_buffer_info.buff;
-        per_buffer_info_type &info = curr_buffer_info;
-        while (1)
-        {
-            //get a single packet from the transport layer
+    UHD_INLINE packet_type get_and_process_single_packet(const size_t index,
+        per_buffer_info_type& prev_buffer_info,
+        per_buffer_info_type& curr_buffer_info,
+        double timeout)
+    {
+        managed_recv_buffer::sptr& buff = curr_buffer_info.buff;
+        per_buffer_info_type& info      = curr_buffer_info;
+        while (1) {
+            // get a single packet from the transport layer
             buff = _props[index].get_buff(timeout);
-            if (buff.get() == nullptr) return PACKET_TIMEOUT_ERROR;
+            if (buff.get() == nullptr)
+                return PACKET_TIMEOUT_ERROR;
 
-            #ifdef  ERROR_INJECT_DROPPED_PACKETS
-            if (++recvd_packets > 1000)
-            {
+#ifdef ERROR_INJECT_DROPPED_PACKETS
+            if (++recvd_packets > 1000) {
                 recvd_packets = 0;
                 buff.reset();
                 buff = _props[index].get_buff(timeout);
-                if (buff.get() == nullptr) return PACKET_TIMEOUT_ERROR;
+                if (buff.get() == nullptr)
+                    return PACKET_TIMEOUT_ERROR;
             }
-            #endif
+#endif
 
-            //bounds check before extract
-            const size_t num_packet_words32 = buff->size()/sizeof(uint32_t);
-            if (num_packet_words32 <= _header_offset_words32){
+            // bounds check before extract
+            const size_t num_packet_words32 = buff->size() / sizeof(uint32_t);
+            if (num_packet_words32 <= _header_offset_words32) {
                 throw std::runtime_error("recv buffer smaller than vrt packet offset");
             }
 
-            //extract packet info
-            memset(&info.ifpi, 0, sizeof (vrt::if_packet_info_t));
+            // extract packet info
+            memset(&info.ifpi, 0, sizeof(vrt::if_packet_info_t));
             info.ifpi.num_packet_words32 = num_packet_words32 - _header_offset_words32;
-            info.vrt_hdr = buff->cast<const uint32_t *>() + _header_offset_words32;
+            info.vrt_hdr = buff->cast<const uint32_t*>() + _header_offset_words32;
             _vrt_unpacker(info.vrt_hdr, info.ifpi);
-            info.time = info.ifpi.tsf; //assumes has_tsf is true
-            info.copy_buff = reinterpret_cast<const char *>(info.vrt_hdr + info.ifpi.num_header_words32);
-
-            //handle flow control
-            if (_props[index].handle_flowctrl)
-            {
-                if ((info.ifpi.packet_count % _props[index].fc_update_window) == 0)
-                {
+            info.time      = info.ifpi.tsf; // assumes has_tsf is true
+            info.copy_buff = reinterpret_cast<const char*>(
+                info.vrt_hdr + info.ifpi.num_header_words32);
+
+            // handle flow control
+            if (_props[index].handle_flowctrl) {
+                if ((info.ifpi.packet_count % _props[index].fc_update_window) == 0) {
                     _props[index].handle_flowctrl(info.ifpi.packet_count);
                 }
             }
 
-            //handle flow control ack
-            if (info.ifpi.fc_ack){
+            // handle flow control ack
+            if (info.ifpi.fc_ack) {
                 if (_props[index].handle_flowctrl_ack) {
-                    _props[index].handle_flowctrl_ack(reinterpret_cast<const uint32_t *>(info.copy_buff));
+                    _props[index].handle_flowctrl_ack(
+                        reinterpret_cast<const uint32_t*>(info.copy_buff));
                 }
                 // Process the next packet
                 buff.reset();
@@ -433,18 +470,20 @@ private:
         //-- The order of these checks is HOLY.
         //--------------------------------------------------------------
 
-        //1) check for inline IF message packets
-        if (info.ifpi.packet_type != vrt::if_packet_info_t::PACKET_TYPE_DATA){
+        // 1) check for inline IF message packets
+        if (info.ifpi.packet_type != vrt::if_packet_info_t::PACKET_TYPE_DATA) {
             return PACKET_INLINE_MESSAGE;
         }
 
-        //2) check for sequence errors
-        #ifndef SRPH_DONT_CHECK_SEQUENCE
-        const size_t seq_mask = (info.ifpi.link_type == vrt::if_packet_info_t::LINK_TYPE_NONE)? 0xf : 0xfff;
+// 2) check for sequence errors
+#ifndef SRPH_DONT_CHECK_SEQUENCE
+        const size_t seq_mask =
+            (info.ifpi.link_type == vrt::if_packet_info_t::LINK_TYPE_NONE) ? 0xf : 0xfff;
         const size_t expected_packet_count = _props[index].packet_count;
-        _props[index].packet_count = (info.ifpi.packet_count + 1) & seq_mask;
-        if (expected_packet_count != info.ifpi.packet_count){
-            //UHD_LOGGER_INFO("STREAMER") << "expected: " << expected_packet_count << " got: " << info.ifpi.packet_count;
+        _props[index].packet_count         = (info.ifpi.packet_count + 1) & seq_mask;
+        if (expected_packet_count != info.ifpi.packet_count) {
+            // UHD_LOGGER_INFO("STREAMER") << "expected: " << expected_packet_count << "
+            // got: " << info.ifpi.packet_count;
             if (_props[index].handle_flowctrl) {
                 // Always update flow control in this case, because we don't
                 // know which packet was dropped and what state the upstream
@@ -453,14 +492,14 @@ private:
             }
             return PACKET_SEQUENCE_ERROR;
         }
-        #endif
+#endif
 
-        //3) check for out of order timestamps
-        if (info.ifpi.has_tsf and prev_buffer_info.time > info.time){
+        // 3) check for out of order timestamps
+        if (info.ifpi.has_tsf and prev_buffer_info.time > info.time) {
             return PACKET_TIMESTAMP_ERROR;
         }
 
-        //4) otherwise the packet is normal!
+        // 4) otherwise the packet is normal!
         return PACKET_IF_DATA;
     }
 
@@ -470,25 +509,22 @@ private:
         get_curr_buffer_info().reset();
         get_next_buffer_info().reset();
 
-        for (size_t i = 0; i < _props.size(); i++)
-        {
+        for (size_t i = 0; i < _props.size(); i++) {
             per_buffer_info_type prev_buffer_info, curr_buffer_info;
             prev_buffer_info.reset();
             curr_buffer_info.reset();
-            while (true)
-            {
-                //receive a single packet from the transport
-                try
-                {
+            while (true) {
+                // receive a single packet from the transport
+                try {
                     // call into get_and_process_single_packet()
                     // to make sure flow control is handled
                     if (get_and_process_single_packet(
-                            i,
-                            prev_buffer_info,
-                            curr_buffer_info,
-                            timeout) == PACKET_TIMEOUT_ERROR) break;
-                } catch(...){}
-                curr_buffer_info.buff.reset();  // Let my buffer go!
+                            i, prev_buffer_info, curr_buffer_info, timeout)
+                        == PACKET_TIMEOUT_ERROR)
+                        break;
+                } catch (...) {
+                }
+                curr_buffer_info.buff.reset(); // Let my buffer go!
                 prev_buffer_info = curr_buffer_info;
                 curr_buffer_info.reset();
             }
@@ -499,34 +535,31 @@ private:
      * Alignment check:
      * Check the received packet for alignment and mark accordingly.
      ******************************************************************/
-    UHD_INLINE void alignment_check(
-        const size_t index, buffers_info_type &info
-    ){
-        //if alignment time was not valid or if the sequence id is newer:
+    UHD_INLINE void alignment_check(const size_t index, buffers_info_type& info)
+    {
+        // if alignment time was not valid or if the sequence id is newer:
         //  use this index's time as the alignment time
         //  reset the indexes list and remove this index
-        if (not info.alignment_time_valid or info[index].time > info.alignment_time){
+        if (not info.alignment_time_valid or info[index].time > info.alignment_time) {
             info.alignment_time_valid = true;
-            info.alignment_time = info[index].time;
+            info.alignment_time       = info[index].time;
             info.indexes_todo.set();
             info.indexes_todo.reset(index);
             // release the other buffers
-            for (size_t i = 0; i < info.size(); i++)
-            {
-                if (i != index)
-                {
+            for (size_t i = 0; i < info.size(); i++) {
+                if (i != index) {
                     info[i].reset();
                 }
             }
             info.data_bytes_to_copy = info[index].ifpi.num_payload_bytes;
             // reset start_of_burst and end_of_burst states
             info.metadata.start_of_burst = info[index].ifpi.sob;
-            info.metadata.end_of_burst = info[index].ifpi.eob;
+            info.metadata.end_of_burst   = info[index].ifpi.eob;
         }
 
-        //if the sequence id matches:
+        // if the sequence id matches:
         //  remove this index from the list and continue
-        else if (info[index].time == info.alignment_time){
+        else if (info[index].time == info.alignment_time) {
             info.indexes_todo.reset(index);
             // All channels should have sob set at the same time, so only
             // set start_of burst if all channels have sob set.
@@ -539,9 +572,9 @@ private:
             info[index].reset();
         }
 
-        //if the sequence id is older:
+        // if the sequence id is older:
         //  continue with the same index to try again
-        //else if (info[index].time < info.alignment_time)...
+        // else if (info[index].time < info.alignment_time)...
     }
 
     /*******************************************************************
@@ -550,127 +583,139 @@ private:
      * Handle all of the edge cases like inline messages and errors.
      * The logic will throw out older packets until it finds a match.
      ******************************************************************/
-    UHD_INLINE void get_aligned_buffs(double timeout){
-
-        get_prev_buffer_info().reset(); // no longer need the previous info - reset it for future use
+    UHD_INLINE void get_aligned_buffs(double timeout)
+    {
+        get_prev_buffer_info()
+            .reset(); // no longer need the previous info - reset it for future use
 
-        increment_buffer_info(); //increment to next buffer
+        increment_buffer_info(); // increment to next buffer
 
-        buffers_info_type &prev_info = get_prev_buffer_info();
-        buffers_info_type &curr_info = get_curr_buffer_info();
-        buffers_info_type &next_info = get_next_buffer_info();
+        buffers_info_type& prev_info = get_prev_buffer_info();
+        buffers_info_type& curr_info = get_curr_buffer_info();
+        buffers_info_type& next_info = get_next_buffer_info();
 
         curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_NONE;
 
-        //Loop until we get a message of an aligned set of buffers:
+        // Loop until we get a message of an aligned set of buffers:
         // - Receive a single packet and extract its info.
         // - Handle the packet type yielded by the receive.
         // - Check the timestamps for alignment conditions.
         size_t iterations = 0;
-        while (curr_info.indexes_todo.any()){
-
-            //get the index to process for this iteration
+        while (curr_info.indexes_todo.any()) {
+            // get the index to process for this iteration
             const size_t index = curr_info.indexes_todo.find_first();
             packet_type packet;
 
-            //receive a single packet from the transport
-            try{
+            // receive a single packet from the transport
+            try {
                 packet = get_and_process_single_packet(
-                    index, prev_info[index], curr_info[index], timeout
-                );
+                    index, prev_info[index], curr_info[index], timeout);
             }
 
-            //handle the case where a bad header exists
-            catch(const uhd::value_error &e){
-                UHD_LOGGER_ERROR("STREAMER") << boost::format(
-                    "The receive packet handler caught a value exception.\n%s"
-                    ) % e.what();
-                std::swap(curr_info, next_info); //save progress from curr -> next
+            // handle the case where a bad header exists
+            catch (const uhd::value_error& e) {
+                UHD_LOGGER_ERROR("STREAMER")
+                    << boost::format(
+                           "The receive packet handler caught a value exception.\n%s")
+                           % e.what();
+                std::swap(curr_info, next_info); // save progress from curr -> next
                 curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_BAD_PACKET;
                 return;
             }
 
-            switch(packet){
-            case PACKET_IF_DATA:
-                alignment_check(index, curr_info);
-                break;
-
-            case PACKET_TIMESTAMP_ERROR:
-                //If the user changes the device time while streaming or without flushing,
-                //we can receive a packet that comes before the previous packet in time.
-                //This could cause the alignment logic to discard future received packets.
-                //Therefore, when this occurs, we reset the info to restart from scratch.
-                if (curr_info.alignment_time_valid and curr_info.alignment_time != curr_info[index].time){
-                    curr_info.alignment_time_valid = false;
-                }
-                alignment_check(index, curr_info);
-                break;
+            switch (packet) {
+                case PACKET_IF_DATA:
+                    alignment_check(index, curr_info);
+                    break;
+
+                case PACKET_TIMESTAMP_ERROR:
+                    // If the user changes the device time while streaming or without
+                    // flushing, we can receive a packet that comes before the previous
+                    // packet in time. This could cause the alignment logic to discard
+                    // future received packets. Therefore, when this occurs, we reset the
+                    // info to restart from scratch.
+                    if (curr_info.alignment_time_valid
+                        and curr_info.alignment_time != curr_info[index].time) {
+                        curr_info.alignment_time_valid = false;
+                    }
+                    alignment_check(index, curr_info);
+                    break;
+
+                case PACKET_INLINE_MESSAGE:
+                    curr_info[index].buff.reset(); // No data, so release the buffer
+                    curr_info[index].copy_buff = nullptr;
+                    std::swap(curr_info, next_info); // save progress from curr -> next
+                    curr_info.metadata.has_time_spec = next_info[index].ifpi.has_tsf;
+                    curr_info.metadata.time_spec =
+                        time_spec_t::from_ticks(next_info[index].time, _tick_rate);
+                    curr_info.metadata.error_code =
+                        rx_metadata_t::error_code_t(get_context_code(
+                            next_info[index].vrt_hdr, next_info[index].ifpi));
+                    if (curr_info.metadata.error_code
+                        == rx_metadata_t::ERROR_CODE_OVERFLOW) {
+                        // Not sending flow control would cause timeouts due to source
+                        // flow control locking up. Send first as the overrun handler may
+                        // flush the receive buffers which could contain packets with
+                        // sequence numbers after this packet's sequence number!
+                        if (_props[index].handle_flowctrl) {
+                            _props[index].handle_flowctrl(
+                                next_info[index].ifpi.packet_count);
+                        }
+
+                        rx_metadata_t metadata = curr_info.metadata;
+                        _props[index].handle_overflow();
+                        curr_info.metadata = metadata;
+                        UHD_LOG_FASTPATH("O");
+                    }
+                    return;
 
-            case PACKET_INLINE_MESSAGE:
-                curr_info[index].buff.reset();  // No data, so release the buffer
-                curr_info[index].copy_buff = nullptr;
-                std::swap(curr_info, next_info); //save progress from curr -> next
-                curr_info.metadata.has_time_spec = next_info[index].ifpi.has_tsf;
-                curr_info.metadata.time_spec = time_spec_t::from_ticks(next_info[index].time, _tick_rate);
-                curr_info.metadata.error_code = rx_metadata_t::error_code_t(get_context_code(next_info[index].vrt_hdr, next_info[index].ifpi));
-                if (curr_info.metadata.error_code == rx_metadata_t::ERROR_CODE_OVERFLOW){
-                    // Not sending flow control would cause timeouts due to source flow control locking up.
-                    // Send first as the overrun handler may flush the receive buffers which could contain
-                    // packets with sequence numbers after this packet's sequence number!
-                    if(_props[index].handle_flowctrl) {
+                case PACKET_TIMEOUT_ERROR:
+                    std::swap(curr_info, next_info); // save progress from curr -> next
+                    if (_props[index].handle_flowctrl) {
                         _props[index].handle_flowctrl(next_info[index].ifpi.packet_count);
                     }
-
-                    rx_metadata_t metadata = curr_info.metadata;
-                    _props[index].handle_overflow();
-                    curr_info.metadata = metadata;
-                    UHD_LOG_FASTPATH("O");
-                }
-                return;
-
-            case PACKET_TIMEOUT_ERROR:
-                std::swap(curr_info, next_info); //save progress from curr -> next
-                if(_props[index].handle_flowctrl) {
-                    _props[index].handle_flowctrl(next_info[index].ifpi.packet_count);
-                }
-                curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_TIMEOUT;
-                return;
-
-            case PACKET_SEQUENCE_ERROR:
-                alignment_check(index, curr_info);
-                std::swap(curr_info, next_info); //save progress from curr -> next
-                curr_info.metadata.has_time_spec = prev_info.metadata.has_time_spec;
-                curr_info.metadata.time_spec = prev_info.metadata.time_spec + time_spec_t::from_ticks(
-                    prev_info[index].ifpi.num_payload_words32*sizeof(uint32_t)/_bytes_per_otw_item, _samp_rate);
-                curr_info.metadata.out_of_sequence = true;
-                curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_OVERFLOW;
-                UHD_LOG_FASTPATH("D");
-                return;
-
+                    curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_TIMEOUT;
+                    return;
+
+                case PACKET_SEQUENCE_ERROR:
+                    alignment_check(index, curr_info);
+                    std::swap(curr_info, next_info); // save progress from curr -> next
+                    curr_info.metadata.has_time_spec = prev_info.metadata.has_time_spec;
+                    curr_info.metadata.time_spec =
+                        prev_info.metadata.time_spec
+                        + time_spec_t::from_ticks(
+                              prev_info[index].ifpi.num_payload_words32 * sizeof(uint32_t)
+                                  / _bytes_per_otw_item,
+                              _samp_rate);
+                    curr_info.metadata.out_of_sequence = true;
+                    curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_OVERFLOW;
+                    UHD_LOG_FASTPATH("D");
+                    return;
             }
 
-            //too many iterations: detect alignment failure
-            if (iterations++ > _alignment_failure_threshold){
-                UHD_LOGGER_ERROR("STREAMER") << boost::format(
-                    "The receive packet handler failed to time-align packets.\n"
-                    "%u received packets were processed by the handler.\n"
-                    "However, a timestamp match could not be determined.\n"
-                ) % iterations << std::endl;
-                std::swap(curr_info, next_info); //save progress from curr -> next
+            // too many iterations: detect alignment failure
+            if (iterations++ > _alignment_failure_threshold) {
+                UHD_LOGGER_ERROR("STREAMER")
+                    << boost::format(
+                           "The receive packet handler failed to time-align packets.\n"
+                           "%u received packets were processed by the handler.\n"
+                           "However, a timestamp match could not be determined.\n")
+                           % iterations
+                    << std::endl;
+                std::swap(curr_info, next_info); // save progress from curr -> next
                 curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_ALIGNMENT;
                 _props[index].handle_overflow();
                 return;
             }
-
         }
 
-        //set the metadata from the buffer information at index zero
+        // set the metadata from the buffer information at index zero
         curr_info.metadata.has_time_spec = curr_info[0].ifpi.has_tsf;
-        curr_info.metadata.time_spec = time_spec_t::from_ticks(curr_info[0].time, _tick_rate);
-        curr_info.metadata.more_fragments = false;
+        curr_info.metadata.time_spec =
+            time_spec_t::from_ticks(curr_info[0].time, _tick_rate);
+        curr_info.metadata.more_fragments  = false;
         curr_info.metadata.fragment_offset = 0;
-        curr_info.metadata.error_code = rx_metadata_t::ERROR_CODE_NONE;
-
+        curr_info.metadata.error_code      = rx_metadata_t::ERROR_CODE_NONE;
     }
 
     /*******************************************************************
@@ -679,50 +724,50 @@ private:
      * When no fragments are available, call the get aligned buffers.
      * Then copy-convert available data into the user's IO buffers.
      ******************************************************************/
-    UHD_INLINE size_t recv_one_packet(
-        const uhd::rx_streamer::buffs_type &buffs,
+    UHD_INLINE size_t recv_one_packet(const uhd::rx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        uhd::rx_metadata_t &metadata,
+        uhd::rx_metadata_t& metadata,
         const double timeout,
-        const size_t buffer_offset_bytes = 0
-    ){
-        //get the next buffer if the current one has expired
-        if (get_curr_buffer_info().data_bytes_to_copy == 0)
-        {
-            //perform receive with alignment logic
+        const size_t buffer_offset_bytes = 0)
+    {
+        // get the next buffer if the current one has expired
+        if (get_curr_buffer_info().data_bytes_to_copy == 0) {
+            // perform receive with alignment logic
             get_aligned_buffs(timeout);
         }
 
-        buffers_info_type &info = get_curr_buffer_info();
-        metadata = info.metadata;
+        buffers_info_type& info = get_curr_buffer_info();
+        metadata                = info.metadata;
 
-        //interpolate the time spec (useful when this is a fragment)
-        metadata.time_spec += time_spec_t::from_ticks(info.fragment_offset_in_samps, _samp_rate);
+        // interpolate the time spec (useful when this is a fragment)
+        metadata.time_spec +=
+            time_spec_t::from_ticks(info.fragment_offset_in_samps, _samp_rate);
 
-        //extract the number of samples available to copy
-        const size_t nsamps_available = info.data_bytes_to_copy/_bytes_per_otw_item;
-        const size_t nsamps_to_copy = std::min(nsamps_per_buff*_num_outputs, nsamps_available);
-        const size_t bytes_to_copy = nsamps_to_copy*_bytes_per_otw_item;
-        const size_t nsamps_to_copy_per_io_buff = nsamps_to_copy/_num_outputs;
+        // extract the number of samples available to copy
+        const size_t nsamps_available = info.data_bytes_to_copy / _bytes_per_otw_item;
+        const size_t nsamps_to_copy =
+            std::min(nsamps_per_buff * _num_outputs, nsamps_available);
+        const size_t bytes_to_copy              = nsamps_to_copy * _bytes_per_otw_item;
+        const size_t nsamps_to_copy_per_io_buff = nsamps_to_copy / _num_outputs;
 
-        //setup the data to share with converter threads
-        _convert_nsamps = nsamps_to_copy_per_io_buff;
-        _convert_buffs = &buffs;
+        // setup the data to share with converter threads
+        _convert_nsamps              = nsamps_to_copy_per_io_buff;
+        _convert_buffs               = &buffs;
         _convert_buffer_offset_bytes = buffer_offset_bytes;
-        _convert_bytes_to_copy = bytes_to_copy;
+        _convert_bytes_to_copy       = bytes_to_copy;
 
-        //perform N channels of conversion
+        // perform N channels of conversion
         for (size_t i = 0; i < this->size(); i++) {
             convert_to_out_buff(i);
         }
 
-        //update the copy buffer's availability
+        // update the copy buffer's availability
         info.data_bytes_to_copy -= bytes_to_copy;
 
-        //setup the fragment flags and offset
-        metadata.more_fragments = info.data_bytes_to_copy != 0;
+        // setup the fragment flags and offset
+        metadata.more_fragments  = info.data_bytes_to_copy != 0;
         metadata.fragment_offset = info.fragment_offset_in_samps;
-        info.fragment_offset_in_samps += nsamps_to_copy; //set for next call
+        info.fragment_offset_in_samps += nsamps_to_copy; // set for next call
 
         return nsamps_to_copy_per_io_buff;
     }
@@ -736,34 +781,34 @@ private:
      */
     inline void convert_to_out_buff(const size_t index)
     {
-        //shortcut references to local data structures
-        buffers_info_type &buff_info = get_curr_buffer_info();
-        per_buffer_info_type &info = buff_info[index];
-        const rx_streamer::buffs_type &buffs = *_convert_buffs;
-
-        //fill IO buffs with pointers into the output buffer
-        void *io_buffs[4/*max interleave*/];
-        for (size_t i = 0; i < _num_outputs; i++){
-            char *b = reinterpret_cast<char *>(buffs[index*_num_outputs + i]);
+        // shortcut references to local data structures
+        buffers_info_type& buff_info         = get_curr_buffer_info();
+        per_buffer_info_type& info           = buff_info[index];
+        const rx_streamer::buffs_type& buffs = *_convert_buffs;
+
+        // fill IO buffs with pointers into the output buffer
+        void* io_buffs[4 /*max interleave*/];
+        for (size_t i = 0; i < _num_outputs; i++) {
+            char* b     = reinterpret_cast<char*>(buffs[index * _num_outputs + i]);
             io_buffs[i] = b + _convert_buffer_offset_bytes;
         }
-        const ref_vector<void *> out_buffs(io_buffs, _num_outputs);
+        const ref_vector<void*> out_buffs(io_buffs, _num_outputs);
 
-        //perform the conversion operation
+        // perform the conversion operation
         _converter->conv(info.copy_buff, out_buffs, _convert_nsamps);
 
-        //advance the pointer for the source buffer
+        // advance the pointer for the source buffer
         info.copy_buff += _convert_bytes_to_copy;
 
-        //release the buffer if fully consumed
-        if (buff_info.data_bytes_to_copy == _convert_bytes_to_copy){
-            info.buff.reset(); //effectively a release
+        // release the buffer if fully consumed
+        if (buff_info.data_bytes_to_copy == _convert_bytes_to_copy) {
+            info.buff.reset(); // effectively a release
         }
     }
 
     //! Shared variables for the worker threads
     size_t _convert_nsamps;
-    const rx_streamer::buffs_type *_convert_buffs;
+    const rx_streamer::buffs_type* _convert_buffs;
     size_t _convert_buffer_offset_bytes;
     size_t _convert_bytes_to_copy;
 
@@ -773,10 +818,24 @@ private:
      * Gathered data can be used to post process it with external tools.
      */
 #ifdef UHD_TXRX_DEBUG_PRINTS
-    struct dbg_recv_stat_t {
-        dbg_recv_stat_t(long wc, size_t nspb, size_t nsr, uhd::rx_metadata_t md, double to, bool op, double rate):
-        wallclock(wc), nsamps_per_buff(nspb), nsamps_recv(nsr), metadata(md), timeout(to), one_packet(op), samp_rate(rate)
-        {}
+    struct dbg_recv_stat_t
+    {
+        dbg_recv_stat_t(long wc,
+            size_t nspb,
+            size_t nsr,
+            uhd::rx_metadata_t md,
+            double to,
+            bool op,
+            double rate)
+            : wallclock(wc)
+            , nsamps_per_buff(nspb)
+            , nsamps_recv(nsr)
+            , metadata(md)
+            , timeout(to)
+            , one_packet(op)
+            , samp_rate(rate)
+        {
+        }
         long wallclock;
         size_t nsamps_per_buff;
         size_t nsamps_recv;
@@ -785,42 +844,47 @@ private:
         bool one_packet;
         double samp_rate;
         // Create a formatted print line for all the info gathered in this struct.
-        std::string print_line() {
+        std::string print_line()
+        {
             boost::format fmt("recv,%ld,%f,%i,%i,%s,%i,%s,%s,%s,%i,%s,%ld");
             fmt % wallclock;
-            fmt % timeout % (int)nsamps_per_buff % (int) nsamps_recv;
-            fmt % (one_packet ? "true":"false");
+            fmt % timeout % (int)nsamps_per_buff % (int)nsamps_recv;
+            fmt % (one_packet ? "true" : "false");
             fmt % metadata.error_code;
-            fmt % (metadata.start_of_burst ? "true":"false") % (metadata.end_of_burst ? "true":"false");
-            fmt % (metadata.more_fragments ? "true":"false") % (int)metadata.fragment_offset;
-            fmt % (metadata.has_time_spec ? "true":"false") % metadata.time_spec.to_ticks(samp_rate);
+            fmt % (metadata.start_of_burst ? "true" : "false")
+                % (metadata.end_of_burst ? "true" : "false");
+            fmt % (metadata.more_fragments ? "true" : "false")
+                % (int)metadata.fragment_offset;
+            fmt % (metadata.has_time_spec ? "true" : "false")
+                % metadata.time_spec.to_ticks(samp_rate);
             return fmt.str();
         }
     };
 
-    void dbg_gather_data(const size_t nsamps_per_buff, const size_t nsamps_recv,
-            uhd::rx_metadata_t &metadata, const double timeout,
-            const bool one_packet,
-            bool dbg_print_directly = true
-        )
+    void dbg_gather_data(const size_t nsamps_per_buff,
+        const size_t nsamps_recv,
+        uhd::rx_metadata_t& metadata,
+        const double timeout,
+        const bool one_packet,
+        bool dbg_print_directly = true)
     {
-        // Initialize a struct with all available data. It can return a formatted string with all infos if wanted.
+        // Initialize a struct with all available data. It can return a formatted string
+        // with all infos if wanted.
         dbg_recv_stat_t data(boost::get_system_time().time_of_day().total_microseconds(),
-                nsamps_per_buff,
-                nsamps_recv,
-                metadata,
-                timeout,
-                one_packet,
-                _samp_rate
-            );
-        if(dbg_print_directly) {
+            nsamps_per_buff,
+            nsamps_recv,
+            metadata,
+            timeout,
+            one_packet,
+            _samp_rate);
+        if (dbg_print_directly) {
             dbg_print_err(data.print_line());
         }
     }
 
 
-
-    void dbg_print_err(std::string msg) {
+    void dbg_print_err(std::string msg)
+    {
         std::string dbg_prefix("super_recv_packet_handler,");
         msg = dbg_prefix + msg;
         fprintf(stderr, "%s\n", msg.c_str());
@@ -828,31 +892,35 @@ private:
 #endif
 };
 
-class recv_packet_streamer : public recv_packet_handler, public rx_streamer{
+class recv_packet_streamer : public recv_packet_handler, public rx_streamer
+{
 public:
-    recv_packet_streamer(const size_t max_num_samps){
+    recv_packet_streamer(const size_t max_num_samps)
+    {
         _max_num_samps = max_num_samps;
     }
 
-    size_t get_num_channels(void) const{
+    size_t get_num_channels(void) const
+    {
         return this->size();
     }
 
-    size_t get_max_num_samps(void) const{
+    size_t get_max_num_samps(void) const
+    {
         return _max_num_samps;
     }
 
-    size_t recv(
-        const rx_streamer::buffs_type &buffs,
+    size_t recv(const rx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        uhd::rx_metadata_t &metadata,
+        uhd::rx_metadata_t& metadata,
         const double timeout,
-        const bool one_packet
-    ){
-        return recv_packet_handler::recv(buffs, nsamps_per_buff, metadata, timeout, one_packet);
+        const bool one_packet)
+    {
+        return recv_packet_handler::recv(
+            buffs, nsamps_per_buff, metadata, timeout, one_packet);
     }
 
-    void issue_stream_cmd(const stream_cmd_t &stream_cmd)
+    void issue_stream_cmd(const stream_cmd_t& stream_cmd)
     {
         return recv_packet_handler::issue_stream_cmd(stream_cmd);
     }
@@ -861,6 +929,6 @@ private:
     size_t _max_num_samps;
 };
 
-}}} //namespace
+}}} // namespace uhd::transport::sph
 
 #endif /* INCLUDED_LIBUHD_TRANSPORT_SUPER_RECV_PACKET_HANDLER_HPP */
diff --git a/host/lib/transport/super_send_packet_handler.hpp b/host/lib/transport/super_send_packet_handler.hpp
index b90ea8afd..af6ecaa5e 100644
--- a/host/lib/transport/super_send_packet_handler.hpp
+++ b/host/lib/transport/super_send_packet_handler.hpp
@@ -9,34 +9,32 @@
 #define INCLUDED_LIBUHD_TRANSPORT_SUPER_SEND_PACKET_HANDLER_HPP
 
 #include <uhd/config.hpp>
-#include <uhd/exception.hpp>
 #include <uhd/convert.hpp>
+#include <uhd/exception.hpp>
 #include <uhd/stream.hpp>
-#include <uhd/utils/tasks.hpp>
-#include <uhd/utils/byteswap.hpp>
-#include <uhd/utils/thread.hpp>
-#include <uhd/types/metadata.hpp>
 #include <uhd/transport/vrt_if_packet.hpp>
 #include <uhd/transport/zero_copy.hpp>
+#include <uhd/types/metadata.hpp>
+#include <uhd/utils/byteswap.hpp>
+#include <uhd/utils/tasks.hpp>
+#include <uhd/utils/thread.hpp>
 #include <uhdlib/rfnoc/tx_stream_terminator.hpp>
 #include <boost/function.hpp>
-#include <iostream>
-#include <vector>
 #include <chrono>
+#include <iostream>
 #include <thread>
+#include <vector>
 
 #ifdef UHD_TXRX_DEBUG_PRINTS
 // Included for debugging
-#include <boost/format.hpp>
-#include <boost/thread/thread.hpp>
-#include "boost/date_time/posix_time/posix_time.hpp"
-#include <map>
-#include <fstream>
+#    include "boost/date_time/posix_time/posix_time.hpp"
+#    include <boost/format.hpp>
+#    include <boost/thread/thread.hpp>
+#    include <fstream>
+#    include <map>
 #endif
 
-namespace uhd {
-namespace transport {
-namespace sph {
+namespace uhd { namespace transport { namespace sph {
 
 /***********************************************************************
  * Super send packet handler
@@ -45,52 +43,61 @@ namespace sph {
  * The channel group shares a common sample rate.
  * All channels are sent in unison in send().
  **********************************************************************/
-class send_packet_handler{
+class send_packet_handler
+{
 public:
     typedef std::function<managed_send_buffer::sptr(double)> get_buff_type;
     typedef std::function<void(void)> post_send_cb_type;
-    typedef std::function<bool(uhd::async_metadata_t &, const double)> async_receiver_type;
-    typedef void(*vrt_packer_type)(uint32_t *, vrt::if_packet_info_t &);
-    //typedef std::function<void(uint32_t *, vrt::if_packet_info_t &)> vrt_packer_type;
+    typedef std::function<bool(uhd::async_metadata_t&, const double)> async_receiver_type;
+    typedef void (*vrt_packer_type)(uint32_t*, vrt::if_packet_info_t&);
+    // typedef std::function<void(uint32_t *, vrt::if_packet_info_t &)> vrt_packer_type;
 
     /*!
      * Make a new packet handler for send
      * \param size the number of transport channels
      */
-    send_packet_handler(const size_t size = 1):
-        _next_packet_seq(0), _cached_metadata(false)
+    send_packet_handler(const size_t size = 1)
+        : _next_packet_seq(0), _cached_metadata(false)
     {
         this->set_enable_trailer(true);
         this->resize(size);
     }
 
-    ~send_packet_handler(void){
+    ~send_packet_handler(void)
+    {
         /* NOP */
     }
 
     //! Resize the number of transport channels
-    void resize(const size_t size){
-        if (this->size() == size) return;
+    void resize(const size_t size)
+    {
+        if (this->size() == size)
+            return;
         _props.resize(size);
         static const uint64_t zero = 0;
         _zero_buffs.resize(size, &zero);
     }
 
     //! Get the channel width of this handler
-    size_t size(void) const{
+    size_t size(void) const
+    {
         return _props.size();
     }
 
     //! Setup the vrt packer function and offset
-    void set_vrt_packer(const vrt_packer_type &vrt_packer, const size_t header_offset_words32 = 0){
-        _vrt_packer = vrt_packer;
+    void set_vrt_packer(
+        const vrt_packer_type& vrt_packer, const size_t header_offset_words32 = 0)
+    {
+        _vrt_packer            = vrt_packer;
         _header_offset_words32 = header_offset_words32;
     }
 
     //! Set the stream ID for a specific channel (or no SID)
-    void set_xport_chan_sid(const size_t xport_chan, const bool has_sid, const uint32_t sid = 0){
+    void set_xport_chan_sid(
+        const size_t xport_chan, const bool has_sid, const uint32_t sid = 0)
+    {
         _props.at(xport_chan).has_sid = has_sid;
-        _props.at(xport_chan).sid = sid;
+        _props.at(xport_chan).sid     = sid;
     }
 
     void set_enable_trailer(const bool enable)
@@ -99,12 +106,14 @@ public:
     }
 
     //! Set the rate of ticks per second
-    void set_tick_rate(const double rate){
+    void set_tick_rate(const double rate)
+    {
         _tick_rate = rate;
     }
 
     //! Set the rate of samples per second
-    void set_samp_rate(const double rate){
+    void set_samp_rate(const double rate)
+    {
         _samp_rate = rate;
     }
 
@@ -113,7 +122,8 @@ public:
      * \param xport_chan which transport channel
      * \param get_buff the getter function
      */
-    void set_xport_chan_get_buff(const size_t xport_chan, const get_buff_type &get_buff){
+    void set_xport_chan_get_buff(const size_t xport_chan, const get_buff_type& get_buff)
+    {
         _props.at(xport_chan).get_buff = get_buff;
     }
 
@@ -122,15 +132,17 @@ public:
      * \param xport_chan which transport channel
      * \param cb post-send callback
      */
-    void set_xport_chan_post_send_cb(const size_t xport_chan, const post_send_cb_type &cb){
+    void set_xport_chan_post_send_cb(const size_t xport_chan, const post_send_cb_type& cb)
+    {
         _props.at(xport_chan).go_postal = cb;
     }
 
     //! Set the conversion routine for all channels
-    void set_converter(const uhd::convert::id_type &id){
+    void set_converter(const uhd::convert::id_type& id)
+    {
         _num_inputs = id.num_inputs;
-        _converter = uhd::convert::get_converter(id)();
-        this->set_scale_factor(32767.); //update after setting converter
+        _converter  = uhd::convert::get_converter(id)();
+        this->set_scale_factor(32767.); // update after setting converter
         _bytes_per_otw_item = uhd::convert::get_bytes_per_item(id.output_format);
         _bytes_per_cpu_item = uhd::convert::get_bytes_per_item(id.input_format);
     }
@@ -140,27 +152,29 @@ public:
      * Ex: A USRP1 in dual channel mode would be half.
      * \param num_samps the maximum samples in a packet
      */
-    void set_max_samples_per_packet(const size_t num_samps){
+    void set_max_samples_per_packet(const size_t num_samps)
+    {
         _max_samples_per_packet = num_samps;
     }
 
     //! Set the scale factor used in float conversion
-    void set_scale_factor(const double scale_factor){
+    void set_scale_factor(const double scale_factor)
+    {
         _converter->set_scalar(scale_factor);
     }
 
     //! Set the callback to get async messages
-    void set_async_receiver(const async_receiver_type &async_receiver)
+    void set_async_receiver(const async_receiver_type& async_receiver)
     {
         _async_receiver = async_receiver;
     }
 
     //! Overload call to get async metadata
-    bool recv_async_msg(
-        uhd::async_metadata_t &async_metadata, double timeout = 0.1
-    ){
-        if (_async_receiver) return _async_receiver(async_metadata, timeout);
-        std::this_thread::sleep_for(std::chrono::microseconds(long(timeout*1e6)));
+    bool recv_async_msg(uhd::async_metadata_t& async_metadata, double timeout = 0.1)
+    {
+        if (_async_receiver)
+            return _async_receiver(async_metadata, timeout);
+        std::this_thread::sleep_for(std::chrono::microseconds(long(timeout * 1e6)));
         return false;
     }
 
@@ -169,16 +183,15 @@ public:
      * The entry point for the fast-path send calls.
      * Dispatch into combinations of single packet send calls.
      ******************************************************************/
-    UHD_INLINE size_t send(
-        const uhd::tx_streamer::buffs_type &buffs,
+    UHD_INLINE size_t send(const uhd::tx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        const uhd::tx_metadata_t &metadata,
-        const double timeout
-    ){
-        //translate the metadata to vrt if packet info
+        const uhd::tx_metadata_t& metadata,
+        const double timeout)
+    {
+        // translate the metadata to vrt if packet info
         vrt::if_packet_info_t if_packet_info;
         if_packet_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA;
-        //if_packet_info.has_sid = false; //set per channel
+        // if_packet_info.has_sid = false; //set per channel
         if_packet_info.has_cid = false;
         if_packet_info.has_tlr = _has_tlr;
         if_packet_info.has_tsi = false;
@@ -186,99 +199,102 @@ public:
         if_packet_info.tsf     = metadata.time_spec.to_ticks(_tick_rate);
         if_packet_info.sob     = metadata.start_of_burst;
         if_packet_info.eob     = metadata.end_of_burst;
-        if_packet_info.fc_ack  = false; //This is a data packet
+        if_packet_info.fc_ack  = false; // This is a data packet
 
         /*
-         * Metadata is cached when we get a send requesting a start of burst with no samples.
-         * It is applied here on the next call to send() that actually has samples to send.
+         * Metadata is cached when we get a send requesting a start of burst with no
+         * samples. It is applied here on the next call to send() that actually has
+         * samples to send.
          */
-        if (_cached_metadata && nsamps_per_buff != 0)
-        {
+        if (_cached_metadata && nsamps_per_buff != 0) {
             // If the new metada has a time_spec, do not use the cached time_spec.
-            if (!metadata.has_time_spec)
-            {
+            if (!metadata.has_time_spec) {
                 if_packet_info.has_tsf = _metadata_cache.has_time_spec;
                 if_packet_info.tsf     = _metadata_cache.time_spec.to_ticks(_tick_rate);
             }
-            if_packet_info.sob     = _metadata_cache.start_of_burst;
-            if_packet_info.eob     = _metadata_cache.end_of_burst;
-            _cached_metadata = false;
+            if_packet_info.sob = _metadata_cache.start_of_burst;
+            if_packet_info.eob = _metadata_cache.end_of_burst;
+            _cached_metadata   = false;
         }
 
-        if (nsamps_per_buff <= _max_samples_per_packet){
-
-            //TODO remove this code when sample counts of zero are supported by hardware
-            #ifndef SSPH_DONT_PAD_TO_ONE
-                static const uint64_t zero = 0;
-                _zero_buffs.resize(buffs.size(), &zero);
-
-                if (nsamps_per_buff == 0)
-                {
-                    // if this is a start of a burst and there are no samples
-                    if (metadata.start_of_burst)
-                    {
-                        // cache metadata and apply on the next send()
-                        _metadata_cache = metadata;
-                        _cached_metadata = true;
-                        return 0;
-                    } else {
-                        // send requests with no samples are handled here (such as end of burst)
-                        return send_one_packet(_zero_buffs, 1, if_packet_info, timeout) & 0x0;
-                    }
+        if (nsamps_per_buff <= _max_samples_per_packet) {
+// TODO remove this code when sample counts of zero are supported by hardware
+#ifndef SSPH_DONT_PAD_TO_ONE
+            static const uint64_t zero = 0;
+            _zero_buffs.resize(buffs.size(), &zero);
+
+            if (nsamps_per_buff == 0) {
+                // if this is a start of a burst and there are no samples
+                if (metadata.start_of_burst) {
+                    // cache metadata and apply on the next send()
+                    _metadata_cache  = metadata;
+                    _cached_metadata = true;
+                    return 0;
+                } else {
+                    // send requests with no samples are handled here (such as end of
+                    // burst)
+                    return send_one_packet(_zero_buffs, 1, if_packet_info, timeout) & 0x0;
                 }
-            #endif
+            }
+#endif
 
-			size_t nsamps_sent = send_one_packet(buffs, nsamps_per_buff, if_packet_info, timeout);
+            size_t nsamps_sent =
+                send_one_packet(buffs, nsamps_per_buff, if_packet_info, timeout);
 #ifdef UHD_TXRX_DEBUG_PRINTS
-			dbg_print_send(nsamps_per_buff, nsamps_sent, metadata, timeout);
+            dbg_print_send(nsamps_per_buff, nsamps_sent, metadata, timeout);
 #endif
-			return nsamps_sent;        }
+            return nsamps_sent;
+        }
         size_t total_num_samps_sent = 0;
 
-        //false until final fragment
+        // false until final fragment
         if_packet_info.eob = false;
 
-        const size_t num_fragments = (nsamps_per_buff-1)/_max_samples_per_packet;
-        const size_t final_length = ((nsamps_per_buff-1)%_max_samples_per_packet)+1;
-
-        //loop through the following fragment indexes
-        for (size_t i = 0; i < num_fragments; i++){
-
-            //send a fragment with the helper function
-            const size_t num_samps_sent = send_one_packet(
-                buffs, _max_samples_per_packet,
-                if_packet_info, timeout,
-                total_num_samps_sent*_bytes_per_cpu_item
-            );
+        const size_t num_fragments = (nsamps_per_buff - 1) / _max_samples_per_packet;
+        const size_t final_length = ((nsamps_per_buff - 1) % _max_samples_per_packet) + 1;
+
+        // loop through the following fragment indexes
+        for (size_t i = 0; i < num_fragments; i++) {
+            // send a fragment with the helper function
+            const size_t num_samps_sent = send_one_packet(buffs,
+                _max_samples_per_packet,
+                if_packet_info,
+                timeout,
+                total_num_samps_sent * _bytes_per_cpu_item);
             total_num_samps_sent += num_samps_sent;
-            if (num_samps_sent == 0) return total_num_samps_sent;
+            if (num_samps_sent == 0)
+                return total_num_samps_sent;
 
-            //setup metadata for the next fragment
-            const time_spec_t time_spec = metadata.time_spec + time_spec_t::from_ticks(total_num_samps_sent, _samp_rate);
+            // setup metadata for the next fragment
+            const time_spec_t time_spec =
+                metadata.time_spec
+                + time_spec_t::from_ticks(total_num_samps_sent, _samp_rate);
             if_packet_info.tsf = time_spec.to_ticks(_tick_rate);
             if_packet_info.sob = false;
-
         }
 
-        //send the final fragment with the helper function
+        // send the final fragment with the helper function
         if_packet_info.eob = metadata.end_of_burst;
-		size_t nsamps_sent = total_num_samps_sent
-				+ send_one_packet(buffs, final_length, if_packet_info, timeout,
-					total_num_samps_sent * _bytes_per_cpu_item);
+        size_t nsamps_sent = total_num_samps_sent
+                             + send_one_packet(buffs,
+                                   final_length,
+                                   if_packet_info,
+                                   timeout,
+                                   total_num_samps_sent * _bytes_per_cpu_item);
 #ifdef UHD_TXRX_DEBUG_PRINTS
-		dbg_print_send(nsamps_per_buff, nsamps_sent, metadata, timeout);
+        dbg_print_send(nsamps_per_buff, nsamps_sent, metadata, timeout);
 
 #endif
-		return nsamps_sent;
+        return nsamps_sent;
     }
 
 private:
-
     vrt_packer_type _vrt_packer;
     size_t _header_offset_words32;
     double _tick_rate, _samp_rate;
-    struct xport_chan_props_type{
-        xport_chan_props_type(void):has_sid(false),sid(0){}
+    struct xport_chan_props_type
+    {
+        xport_chan_props_type(void) : has_sid(false), sid(0) {}
         get_buff_type get_buff;
         post_send_cb_type go_postal;
         bool has_sid;
@@ -287,11 +303,11 @@ private:
     };
     std::vector<xport_chan_props_type> _props;
     size_t _num_inputs;
-    size_t _bytes_per_otw_item; //used in conversion
-    size_t _bytes_per_cpu_item; //used in conversion
-    uhd::convert::converter::sptr _converter; //used in conversion
+    size_t _bytes_per_otw_item; // used in conversion
+    size_t _bytes_per_cpu_item; // used in conversion
+    uhd::convert::converter::sptr _converter; // used in conversion
     size_t _max_samples_per_packet;
-    std::vector<const void *> _zero_buffs;
+    std::vector<const void*> _zero_buffs;
     size_t _next_packet_seq;
     bool _has_tlr;
     async_receiver_type _async_receiver;
@@ -299,10 +315,22 @@ private:
     uhd::tx_metadata_t _metadata_cache;
 
 #ifdef UHD_TXRX_DEBUG_PRINTS
-    struct dbg_send_stat_t {
-        dbg_send_stat_t(long wc, size_t nspb, size_t nss, uhd::tx_metadata_t md, double to, double rate):
-            wallclock(wc), nsamps_per_buff(nspb), nsamps_sent(nss), metadata(md), timeout(to), samp_rate(rate)
-        {}
+    struct dbg_send_stat_t
+    {
+        dbg_send_stat_t(long wc,
+            size_t nspb,
+            size_t nss,
+            uhd::tx_metadata_t md,
+            double to,
+            double rate)
+            : wallclock(wc)
+            , nsamps_per_buff(nspb)
+            , nsamps_sent(nss)
+            , metadata(md)
+            , timeout(to)
+            , samp_rate(rate)
+        {
+        }
         long wallclock;
         size_t nsamps_per_buff;
         size_t nsamps_sent;
@@ -310,32 +338,37 @@ private:
         double timeout;
         double samp_rate;
         // Create a formatted print line for all the info gathered in this struct.
-        std::string print_line() {
+        std::string print_line()
+        {
             boost::format fmt("send,%ld,%f,%i,%i,%s,%s,%s,%ld");
             fmt % wallclock;
-            fmt % timeout % (int)nsamps_per_buff % (int) nsamps_sent;
-            fmt % (metadata.start_of_burst ? "true":"false") % (metadata.end_of_burst ? "true":"false");
-            fmt % (metadata.has_time_spec ? "true":"false") % metadata.time_spec.to_ticks(samp_rate);
+            fmt % timeout % (int)nsamps_per_buff % (int)nsamps_sent;
+            fmt % (metadata.start_of_burst ? "true" : "false")
+                % (metadata.end_of_burst ? "true" : "false");
+            fmt % (metadata.has_time_spec ? "true" : "false")
+                % metadata.time_spec.to_ticks(samp_rate);
             return fmt.str();
         }
     };
 
-    void dbg_print_send(size_t nsamps_per_buff, size_t nsamps_sent,
-            const uhd::tx_metadata_t &metadata, const double timeout,
-            bool dbg_print_directly = true)
+    void dbg_print_send(size_t nsamps_per_buff,
+        size_t nsamps_sent,
+        const uhd::tx_metadata_t& metadata,
+        const double timeout,
+        bool dbg_print_directly = true)
     {
         dbg_send_stat_t data(boost::get_system_time().time_of_day().total_microseconds(),
             nsamps_per_buff,
             nsamps_sent,
             metadata,
             timeout,
-            _samp_rate
-        );
-        if(dbg_print_directly){
+            _samp_rate);
+        if (dbg_print_directly) {
             dbg_print_err(data.print_line());
         }
     }
-    void dbg_print_err(std::string msg) {
+    void dbg_print_err(std::string msg)
+    {
         msg = "super_send_packet_handler," + msg;
         fprintf(stderr, "%s\n", msg.c_str());
     }
@@ -346,37 +379,39 @@ private:
     /*******************************************************************
      * Send a single packet:
      ******************************************************************/
-    UHD_INLINE size_t send_one_packet(
-        const uhd::tx_streamer::buffs_type &buffs,
+    UHD_INLINE size_t send_one_packet(const uhd::tx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        vrt::if_packet_info_t &if_packet_info,
+        vrt::if_packet_info_t& if_packet_info,
         const double timeout,
-        const size_t buffer_offset_bytes = 0
-    ){
-
-        //load the rest of the if_packet_info in here
-        if_packet_info.num_payload_bytes = nsamps_per_buff*_num_inputs*_bytes_per_otw_item;
-        if_packet_info.num_payload_words32 = (if_packet_info.num_payload_bytes + 3/*round up*/)/sizeof(uint32_t);
+        const size_t buffer_offset_bytes = 0)
+    {
+        // load the rest of the if_packet_info in here
+        if_packet_info.num_payload_bytes =
+            nsamps_per_buff * _num_inputs * _bytes_per_otw_item;
+        if_packet_info.num_payload_words32 =
+            (if_packet_info.num_payload_bytes + 3 /*round up*/) / sizeof(uint32_t);
         if_packet_info.packet_count = _next_packet_seq;
 
-        //get a buffer for each channel or timeout
-        BOOST_FOREACH(xport_chan_props_type &props, _props){
-            if (not props.buff) props.buff = props.get_buff(timeout);
-            if (not props.buff) return 0; //timeout
+        // get a buffer for each channel or timeout
+        BOOST_FOREACH (xport_chan_props_type& props, _props) {
+            if (not props.buff)
+                props.buff = props.get_buff(timeout);
+            if (not props.buff)
+                return 0; // timeout
         }
 
-        //setup the data to share with converter threads
-        _convert_nsamps = nsamps_per_buff;
-        _convert_buffs = &buffs;
+        // setup the data to share with converter threads
+        _convert_nsamps              = nsamps_per_buff;
+        _convert_buffs               = &buffs;
         _convert_buffer_offset_bytes = buffer_offset_bytes;
-        _convert_if_packet_info = &if_packet_info;
+        _convert_if_packet_info      = &if_packet_info;
 
-        //perform N channels of conversion
+        // perform N channels of conversion
         for (size_t i = 0; i < this->size(); i++) {
             convert_to_in_buff(i);
         }
 
-        _next_packet_seq++; //increment sequence after commits
+        _next_packet_seq++; // increment sequence after commits
         return nsamps_per_buff;
     }
 
@@ -389,75 +424,76 @@ private:
      */
     UHD_INLINE void convert_to_in_buff(const size_t index)
     {
-        //shortcut references to local data structures
-        managed_send_buffer::sptr &buff = _props[index].buff;
+        // shortcut references to local data structures
+        managed_send_buffer::sptr& buff      = _props[index].buff;
         vrt::if_packet_info_t if_packet_info = *_convert_if_packet_info;
-        const tx_streamer::buffs_type &buffs = *_convert_buffs;
+        const tx_streamer::buffs_type& buffs = *_convert_buffs;
 
-        //fill IO buffs with pointers into the output buffer
-        const void *io_buffs[4/*max interleave*/];
-        for (size_t i = 0; i < _num_inputs; i++){
-            const char *b = reinterpret_cast<const char *>(buffs[index*_num_inputs + i]);
-            io_buffs[i] = b + _convert_buffer_offset_bytes;
+        // fill IO buffs with pointers into the output buffer
+        const void* io_buffs[4 /*max interleave*/];
+        for (size_t i = 0; i < _num_inputs; i++) {
+            const char* b = reinterpret_cast<const char*>(buffs[index * _num_inputs + i]);
+            io_buffs[i]   = b + _convert_buffer_offset_bytes;
         }
-        const ref_vector<const void *> in_buffs(io_buffs, _num_inputs);
+        const ref_vector<const void*> in_buffs(io_buffs, _num_inputs);
 
-        //pack metadata into a vrt header
-        uint32_t *otw_mem = buff->cast<uint32_t *>() + _header_offset_words32;
+        // pack metadata into a vrt header
+        uint32_t* otw_mem      = buff->cast<uint32_t*>() + _header_offset_words32;
         if_packet_info.has_sid = _props[index].has_sid;
-        if_packet_info.sid = _props[index].sid;
+        if_packet_info.sid     = _props[index].sid;
         _vrt_packer(otw_mem, if_packet_info);
         otw_mem += if_packet_info.num_header_words32;
 
-        //perform the conversion operation
+        // perform the conversion operation
         _converter->conv(in_buffs, otw_mem, _convert_nsamps);
 
-        //commit the samples to the zero-copy interface
-        const size_t num_vita_words32 = _header_offset_words32+if_packet_info.num_packet_words32;
-        buff->commit(num_vita_words32*sizeof(uint32_t));
-        buff.reset(); //effectively a release
+        // commit the samples to the zero-copy interface
+        const size_t num_vita_words32 =
+            _header_offset_words32 + if_packet_info.num_packet_words32;
+        buff->commit(num_vita_words32 * sizeof(uint32_t));
+        buff.reset(); // effectively a release
 
-        if (_props[index].go_postal)
-        {
+        if (_props[index].go_postal) {
             _props[index].go_postal();
         }
     }
 
     //! Shared variables for the worker threads
     size_t _convert_nsamps;
-    const tx_streamer::buffs_type *_convert_buffs;
+    const tx_streamer::buffs_type* _convert_buffs;
     size_t _convert_buffer_offset_bytes;
-    vrt::if_packet_info_t *_convert_if_packet_info;
-
+    vrt::if_packet_info_t* _convert_if_packet_info;
 };
 
-class send_packet_streamer : public send_packet_handler, public tx_streamer{
+class send_packet_streamer : public send_packet_handler, public tx_streamer
+{
 public:
-    send_packet_streamer(const size_t max_num_samps){
+    send_packet_streamer(const size_t max_num_samps)
+    {
         _max_num_samps = max_num_samps;
         this->set_max_samples_per_packet(_max_num_samps);
     }
 
-    size_t get_num_channels(void) const{
+    size_t get_num_channels(void) const
+    {
         return this->size();
     }
 
-    size_t get_max_num_samps(void) const{
+    size_t get_max_num_samps(void) const
+    {
         return _max_num_samps;
     }
 
-    size_t send(
-        const tx_streamer::buffs_type &buffs,
+    size_t send(const tx_streamer::buffs_type& buffs,
         const size_t nsamps_per_buff,
-        const uhd::tx_metadata_t &metadata,
-        const double timeout
-    ){
+        const uhd::tx_metadata_t& metadata,
+        const double timeout)
+    {
         return send_packet_handler::send(buffs, nsamps_per_buff, metadata, timeout);
     }
 
-    bool recv_async_msg(
-        uhd::async_metadata_t &async_metadata, double timeout = 0.1
-    ){
+    bool recv_async_msg(uhd::async_metadata_t& async_metadata, double timeout = 0.1)
+    {
         return send_packet_handler::recv_async_msg(async_metadata, timeout);
     }
 
@@ -465,8 +501,6 @@ private:
     size_t _max_num_samps;
 };
 
-} // namespace sph
-} // namespace transport
-} // namespace uhd
+}}} // namespace uhd::transport::sph
 
 #endif /* INCLUDED_LIBUHD_TRANSPORT_SUPER_SEND_PACKET_HANDLER_HPP */
diff --git a/host/lib/transport/tcp_zero_copy.cpp b/host/lib/transport/tcp_zero_copy.cpp
index a52d089a8..5cb713427 100644
--- a/host/lib/transport/tcp_zero_copy.cpp
+++ b/host/lib/transport/tcp_zero_copy.cpp
@@ -6,15 +6,15 @@
 //
 
 #include "udp_common.hpp"
-#include <uhd/transport/tcp_zero_copy.hpp>
 #include <uhd/transport/buffer_pool.hpp>
+#include <uhd/transport/tcp_zero_copy.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhdlib/utils/atomic.hpp>
 #include <boost/format.hpp>
 #include <boost/make_shared.hpp>
-#include <vector>
 #include <chrono>
 #include <thread>
+#include <vector>
 
 using namespace uhd;
 using namespace uhd::transport;
@@ -27,38 +27,44 @@ static const size_t DEFAULT_FRAME_SIZE = 2048;
  * Reusable managed receiver buffer:
  *  - get_new performs the recv operation
  **********************************************************************/
-class tcp_zero_copy_asio_mrb : public managed_recv_buffer{
+class tcp_zero_copy_asio_mrb : public managed_recv_buffer
+{
 public:
-    tcp_zero_copy_asio_mrb(void *mem, int sock_fd, const size_t frame_size):
-        _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size) { /*NOP*/ }
+    tcp_zero_copy_asio_mrb(void* mem, int sock_fd, const size_t frame_size)
+        : _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size)
+    { /*NOP*/
+    }
 
-    void release(void){
+    void release(void)
+    {
         _claimer.release();
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
-        if (not _claimer.claim_with_wait(timeout)) return sptr();
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
+        if (not _claimer.claim_with_wait(timeout))
+            return sptr();
 
-        #ifdef MSG_DONTWAIT //try a non-blocking recv() if supported
-        _len = ::recv(_sock_fd, (char *)_mem, _frame_size, MSG_DONTWAIT);
-        if (_len > 0){
-            index++; //advances the caller's buffer
+#ifdef MSG_DONTWAIT // try a non-blocking recv() if supported
+        _len = ::recv(_sock_fd, (char*)_mem, _frame_size, MSG_DONTWAIT);
+        if (_len > 0) {
+            index++; // advances the caller's buffer
             return make(this, _mem, size_t(_len));
         }
-        #endif
+#endif
 
-        if (wait_for_recv_ready(_sock_fd, timeout)){
-            _len = ::recv(_sock_fd, (char *)_mem, _frame_size, 0);
-            index++; //advances the caller's buffer
+        if (wait_for_recv_ready(_sock_fd, timeout)) {
+            _len = ::recv(_sock_fd, (char*)_mem, _frame_size, 0);
+            index++; // advances the caller's buffer
             return make(this, _mem, size_t(_len));
         }
 
-        _claimer.release(); //undo claim
-        return sptr(); //null for timeout
+        _claimer.release(); // undo claim
+        return sptr(); // null for timeout
     }
 
 private:
-    void *_mem;
+    void* _mem;
     int _sock_fd;
     size_t _frame_size;
     ssize_t _len;
@@ -69,44 +75,50 @@ private:
  * Reusable managed send buffer:
  *  - commit performs the send operation
  **********************************************************************/
-class tcp_zero_copy_asio_msb : public managed_send_buffer{
+class tcp_zero_copy_asio_msb : public managed_send_buffer
+{
 public:
-    tcp_zero_copy_asio_msb(void *mem, int sock_fd, const size_t frame_size):
-        _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size) { /*NOP*/ }
-
-    void release(void){
-        //Retry logic because send may fail with ENOBUFS.
-        //This is known to occur at least on some OSX systems.
-        //But it should be safe to always check for the error.
-        while (true)
-        {
-            this->commit(_frame_size); //always full size frames to avoid pkt coalescing
-            const ssize_t ret = ::send(_sock_fd, (const char *)_mem, size(), 0);
-            if (ret == ssize_t(size())) break;
-            if (ret == -1 and errno == ENOBUFS)
-            {
+    tcp_zero_copy_asio_msb(void* mem, int sock_fd, const size_t frame_size)
+        : _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size)
+    { /*NOP*/
+    }
+
+    void release(void)
+    {
+        // Retry logic because send may fail with ENOBUFS.
+        // This is known to occur at least on some OSX systems.
+        // But it should be safe to always check for the error.
+        while (true) {
+            this->commit(_frame_size); // always full size frames to avoid pkt coalescing
+            const ssize_t ret = ::send(_sock_fd, (const char*)_mem, size(), 0);
+            if (ret == ssize_t(size()))
+                break;
+            if (ret == -1 and errno == ENOBUFS) {
                 std::this_thread::sleep_for(std::chrono::microseconds(1));
-                continue; //try to send again
+                continue; // try to send again
             }
             UHD_ASSERT_THROW(ret == ssize_t(size()));
         }
         _claimer.release();
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
-        if (not _claimer.claim_with_wait(timeout)) return sptr();
-        index++; //advances the caller's buffer
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
+        if (not _claimer.claim_with_wait(timeout))
+            return sptr();
+        index++; // advances the caller's buffer
         return make(this, _mem, _frame_size);
     }
 
 private:
-    void *_mem;
+    void* _mem;
     int _sock_fd;
     size_t _frame_size;
     simple_claimer _claimer;
 };
 
-tcp_zero_copy::~tcp_zero_copy(void){
+tcp_zero_copy::~tcp_zero_copy(void)
+{
     /* NOP */
 }
 
@@ -117,51 +129,53 @@ tcp_zero_copy::~tcp_zero_copy(void){
  *   However, it is not a true zero copy implementation as each
  *   send and recv requires a copy operation to/from userspace.
  **********************************************************************/
-class tcp_zero_copy_asio_impl : public tcp_zero_copy{
+class tcp_zero_copy_asio_impl : public tcp_zero_copy
+{
 public:
     typedef boost::shared_ptr<tcp_zero_copy_asio_impl> sptr;
 
     tcp_zero_copy_asio_impl(
-        const std::string &addr,
-        const std::string &port,
-        const device_addr_t &hints
-    ):
-        _recv_frame_size(size_t(hints.cast<double>("recv_frame_size", DEFAULT_FRAME_SIZE))),
-        _num_recv_frames(size_t(hints.cast<double>("num_recv_frames", DEFAULT_NUM_FRAMES))),
-        _send_frame_size(size_t(hints.cast<double>("send_frame_size", DEFAULT_FRAME_SIZE))),
-        _num_send_frames(size_t(hints.cast<double>("num_send_frames", DEFAULT_NUM_FRAMES))),
-        _recv_buffer_pool(buffer_pool::make(_num_recv_frames, _recv_frame_size)),
-        _send_buffer_pool(buffer_pool::make(_num_send_frames, _send_frame_size)),
-        _next_recv_buff_index(0), _next_send_buff_index(0)
+        const std::string& addr, const std::string& port, const device_addr_t& hints)
+        : _recv_frame_size(
+              size_t(hints.cast<double>("recv_frame_size", DEFAULT_FRAME_SIZE)))
+        , _num_recv_frames(
+              size_t(hints.cast<double>("num_recv_frames", DEFAULT_NUM_FRAMES)))
+        , _send_frame_size(
+              size_t(hints.cast<double>("send_frame_size", DEFAULT_FRAME_SIZE)))
+        , _num_send_frames(
+              size_t(hints.cast<double>("num_send_frames", DEFAULT_NUM_FRAMES)))
+        , _recv_buffer_pool(buffer_pool::make(_num_recv_frames, _recv_frame_size))
+        , _send_buffer_pool(buffer_pool::make(_num_send_frames, _send_frame_size))
+        , _next_recv_buff_index(0)
+        , _next_send_buff_index(0)
     {
-        UHD_LOGGER_TRACE("TCP") << boost::format("Creating tcp transport for %s %s") % addr % port ;
+        UHD_LOGGER_TRACE("TCP")
+            << boost::format("Creating tcp transport for %s %s") % addr % port;
 
-        //resolve the address
+        // resolve the address
         asio::ip::tcp::resolver resolver(_io_service);
         asio::ip::tcp::resolver::query query(asio::ip::tcp::v4(), addr, port);
         asio::ip::tcp::endpoint receiver_endpoint = *resolver.resolve(query);
 
-        //create, open, and connect the socket
+        // create, open, and connect the socket
         _socket.reset(new asio::ip::tcp::socket(_io_service));
         _socket->connect(receiver_endpoint);
         _sock_fd = _socket->native_handle();
 
-        //packets go out ASAP
+        // packets go out ASAP
         asio::ip::tcp::no_delay option(true);
         _socket->set_option(option);
 
-        //allocate re-usable managed receive buffers
-        for (size_t i = 0; i < get_num_recv_frames(); i++){
+        // allocate re-usable managed receive buffers
+        for (size_t i = 0; i < get_num_recv_frames(); i++) {
             _mrb_pool.push_back(boost::make_shared<tcp_zero_copy_asio_mrb>(
-                _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size()
-            ));
+                _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size()));
         }
 
-        //allocate re-usable managed send buffers
-        for (size_t i = 0; i < get_num_send_frames(); i++){
+        // allocate re-usable managed send buffers
+        for (size_t i = 0; i < get_num_send_frames(); i++) {
             _msb_pool.push_back(boost::make_shared<tcp_zero_copy_asio_msb>(
-                _send_buffer_pool->at(i), _sock_fd, get_send_frame_size()
-            ));
+                _send_buffer_pool->at(i), _sock_fd, get_send_frame_size()));
         }
     }
 
@@ -169,51 +183,66 @@ public:
      * Receive implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_recv_buffer::sptr get_recv_buff(double timeout){
-        if (_next_recv_buff_index == _num_recv_frames) _next_recv_buff_index = 0;
+    managed_recv_buffer::sptr get_recv_buff(double timeout)
+    {
+        if (_next_recv_buff_index == _num_recv_frames)
+            _next_recv_buff_index = 0;
         return _mrb_pool[_next_recv_buff_index]->get_new(timeout, _next_recv_buff_index);
     }
 
-    size_t get_num_recv_frames(void) const {return _num_recv_frames;}
-    size_t get_recv_frame_size(void) const {return _recv_frame_size;}
+    size_t get_num_recv_frames(void) const
+    {
+        return _num_recv_frames;
+    }
+    size_t get_recv_frame_size(void) const
+    {
+        return _recv_frame_size;
+    }
 
     /*******************************************************************
      * Send implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_send_buffer::sptr get_send_buff(double timeout){
-        if (_next_send_buff_index == _num_send_frames) _next_send_buff_index = 0;
+    managed_send_buffer::sptr get_send_buff(double timeout)
+    {
+        if (_next_send_buff_index == _num_send_frames)
+            _next_send_buff_index = 0;
         return _msb_pool[_next_send_buff_index]->get_new(timeout, _next_send_buff_index);
     }
 
-    size_t get_num_send_frames(void) const {return _num_send_frames;}
-    size_t get_send_frame_size(void) const {return _send_frame_size;}
+    size_t get_num_send_frames(void) const
+    {
+        return _num_send_frames;
+    }
+    size_t get_send_frame_size(void) const
+    {
+        return _send_frame_size;
+    }
 
 private:
-    //memory management -> buffers and fifos
+    // memory management -> buffers and fifos
     const size_t _recv_frame_size, _num_recv_frames;
     const size_t _send_frame_size, _num_send_frames;
     buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool;
-    std::vector<boost::shared_ptr<tcp_zero_copy_asio_msb> > _msb_pool;
-    std::vector<boost::shared_ptr<tcp_zero_copy_asio_mrb> > _mrb_pool;
+    std::vector<boost::shared_ptr<tcp_zero_copy_asio_msb>> _msb_pool;
+    std::vector<boost::shared_ptr<tcp_zero_copy_asio_mrb>> _mrb_pool;
     size_t _next_recv_buff_index, _next_send_buff_index;
 
-    //asio guts -> socket and service
-    asio::io_service        _io_service;
+    // asio guts -> socket and service
+    asio::io_service _io_service;
     boost::shared_ptr<asio::ip::tcp::socket> _socket;
-    int                     _sock_fd;
+    int _sock_fd;
 };
 
 /***********************************************************************
  * TCP zero copy make function
  **********************************************************************/
 zero_copy_if::sptr tcp_zero_copy::make(
-    const std::string &addr,
-    const std::string &port,
-    const device_addr_t &hints
-){
+    const std::string& addr, const std::string& port, const device_addr_t& hints)
+{
     zero_copy_if::sptr xport;
     xport.reset(new tcp_zero_copy_asio_impl(addr, port, hints));
-    while (xport->get_recv_buff(0.0)){} //flush
+    while (xport->get_recv_buff(0.0)) {
+    } // flush
     return xport;
 }
diff --git a/host/lib/transport/udp_common.hpp b/host/lib/transport/udp_common.hpp
index 19457903b..f320e3d85 100644
--- a/host/lib/transport/udp_common.hpp
+++ b/host/lib/transport/udp_common.hpp
@@ -11,60 +11,61 @@
 #include <uhd/config.hpp>
 #include <boost/asio.hpp>
 
-namespace uhd{ namespace transport{
+namespace uhd { namespace transport {
 
-    // Jumbo frames can be up to 9600 bytes;
-    static const size_t MAX_ETHERNET_MTU = 9600;
+// Jumbo frames can be up to 9600 bytes;
+static const size_t MAX_ETHERNET_MTU = 9600;
 
 #if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
-    // MacOS limits socket buffer size to 1 Mib
-    static const size_t MAX_BUFF_SIZE_ETH_MACOS = 0x100000; //1Mib
+// MacOS limits socket buffer size to 1 Mib
+static const size_t MAX_BUFF_SIZE_ETH_MACOS = 0x100000; // 1Mib
 #endif
 
-    typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_sptr;
+typedef boost::shared_ptr<boost::asio::ip::udp::socket> socket_sptr;
 
-    /*!
-     * Wait for the socket to become ready for a receive operation.
-     * \param sock_fd the open socket file descriptor
-     * \param timeout the timeout duration in seconds
-     * \return true when the socket is ready for receive
-     */
-    UHD_INLINE bool wait_for_recv_ready(int sock_fd, double timeout){
+/*!
+ * Wait for the socket to become ready for a receive operation.
+ * \param sock_fd the open socket file descriptor
+ * \param timeout the timeout duration in seconds
+ * \return true when the socket is ready for receive
+ */
+UHD_INLINE bool wait_for_recv_ready(int sock_fd, double timeout)
+{
 #ifdef UHD_PLATFORM_WIN32 // select is more portable than poll unfortunately
-        //setup timeval for timeout
-        timeval tv;
-        //If the tv_usec > 1 second on some platforms, select will
-        //error EINVAL: An invalid timeout interval was specified.
-        tv.tv_sec = int(timeout);
-        tv.tv_usec = int(timeout*1000000)%1000000;
+    // setup timeval for timeout
+    timeval tv;
+    // If the tv_usec > 1 second on some platforms, select will
+    // error EINVAL: An invalid timeout interval was specified.
+    tv.tv_sec  = int(timeout);
+    tv.tv_usec = int(timeout * 1000000) % 1000000;
 
-        //setup rset for timeout
-        fd_set rset;
-        FD_ZERO(&rset);
-        FD_SET(sock_fd, &rset);
+    // setup rset for timeout
+    fd_set rset;
+    FD_ZERO(&rset);
+    FD_SET(sock_fd, &rset);
 
-        //http://www.gnu.org/s/hello/manual/libc/Interrupted-Primitives.html
-        //This macro is provided with gcc to properly deal with EINTR.
-        //If not provided, define an empty macro, assume that is OK
-        #ifndef TEMP_FAILURE_RETRY
-            #define TEMP_FAILURE_RETRY(x) (x)
-        #endif
+// http://www.gnu.org/s/hello/manual/libc/Interrupted-Primitives.html
+// This macro is provided with gcc to properly deal with EINTR.
+// If not provided, define an empty macro, assume that is OK
+#    ifndef TEMP_FAILURE_RETRY
+#        define TEMP_FAILURE_RETRY(x) (x)
+#    endif
 
-        //call select with timeout on receive socket
-        return TEMP_FAILURE_RETRY(::select(sock_fd+1, &rset, NULL, NULL, &tv)) > 0;
+    // call select with timeout on receive socket
+    return TEMP_FAILURE_RETRY(::select(sock_fd + 1, &rset, NULL, NULL, &tv)) > 0;
 #else
-        //calculate the total timeout in milliseconds (from seconds)
-        int total_timeout = int(timeout*1000);
+    // calculate the total timeout in milliseconds (from seconds)
+    int total_timeout = int(timeout * 1000);
 
-        pollfd pfd_read;
-        pfd_read.fd = sock_fd;
-        pfd_read.events = POLLIN;
+    pollfd pfd_read;
+    pfd_read.fd     = sock_fd;
+    pfd_read.events = POLLIN;
 
-        //call poll with timeout on receive socket
-        return ::poll(&pfd_read, 1, total_timeout) > 0;
+    // call poll with timeout on receive socket
+    return ::poll(&pfd_read, 1, total_timeout) > 0;
 #endif
-    }
+}
 
-}} //namespace uhd::transport
+}} // namespace uhd::transport
 
 #endif /* INCLUDED_LIBUHD_TRANSPORT_VRT_PACKET_HANDLER_HPP */
diff --git a/host/lib/transport/udp_simple.cpp b/host/lib/transport/udp_simple.cpp
index e3936afc2..48d7b500e 100644
--- a/host/lib/transport/udp_simple.cpp
+++ b/host/lib/transport/udp_simple.cpp
@@ -16,58 +16,68 @@ namespace asio = boost::asio;
 /***********************************************************************
  * UDP simple implementation: connected and broadcast
  **********************************************************************/
-class udp_simple_impl : public udp_simple{
+class udp_simple_impl : public udp_simple
+{
 public:
     udp_simple_impl(
-        const std::string &addr, const std::string &port, bool bcast, bool connect
-    ):_connected(connect){
-        UHD_LOGGER_TRACE("UDP") << boost::format("Creating udp transport for %s %s") % addr % port ;
+        const std::string& addr, const std::string& port, bool bcast, bool connect)
+        : _connected(connect)
+    {
+        UHD_LOGGER_TRACE("UDP")
+            << boost::format("Creating udp transport for %s %s") % addr % port;
 
-        //resolve the address
+        // resolve the address
         asio::ip::udp::resolver resolver(_io_service);
-        asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port,
-            asio::ip::resolver_query_base::all_matching);
+        asio::ip::udp::resolver::query query(
+            asio::ip::udp::v4(), addr, port, asio::ip::resolver_query_base::all_matching);
         _send_endpoint = *resolver.resolve(query);
 
-        //create and open the socket
+        // create and open the socket
         _socket = socket_sptr(new asio::ip::udp::socket(_io_service));
         _socket->open(asio::ip::udp::v4());
 
-        //allow broadcasting
+        // allow broadcasting
         _socket->set_option(asio::socket_base::broadcast(bcast));
 
-        //connect the socket
-        if (connect) _socket->connect(_send_endpoint);
-
+        // connect the socket
+        if (connect)
+            _socket->connect(_send_endpoint);
     }
 
-    size_t send(const asio::const_buffer &buff){
-        if (_connected) return _socket->send(asio::buffer(buff));
+    size_t send(const asio::const_buffer& buff)
+    {
+        if (_connected)
+            return _socket->send(asio::buffer(buff));
         return _socket->send_to(asio::buffer(buff), _send_endpoint);
     }
 
-    size_t recv(const asio::mutable_buffer &buff, double timeout){
-        if (not wait_for_recv_ready(_socket->native_handle(), timeout)) return 0;
+    size_t recv(const asio::mutable_buffer& buff, double timeout)
+    {
+        if (not wait_for_recv_ready(_socket->native_handle(), timeout))
+            return 0;
         return _socket->receive_from(asio::buffer(buff), _recv_endpoint);
     }
 
-    std::string get_recv_addr(void){
+    std::string get_recv_addr(void)
+    {
         return _recv_endpoint.address().to_string();
     }
 
-    std::string get_send_addr(void){
+    std::string get_send_addr(void)
+    {
         return _send_endpoint.address().to_string();
     }
 
 private:
-    bool                    _connected;
-    asio::io_service        _io_service;
-    socket_sptr             _socket;
+    bool _connected;
+    asio::io_service _io_service;
+    socket_sptr _socket;
     asio::ip::udp::endpoint _send_endpoint;
     asio::ip::udp::endpoint _recv_endpoint;
 };
 
-udp_simple::~udp_simple(void){
+udp_simple::~udp_simple(void)
+{
     /* NOP */
 }
 
@@ -75,14 +85,14 @@ udp_simple::~udp_simple(void){
  * UDP public make functions
  **********************************************************************/
 udp_simple::sptr udp_simple::make_connected(
-    const std::string &addr, const std::string &port
-){
+    const std::string& addr, const std::string& port)
+{
     return sptr(new udp_simple_impl(addr, port, false, true /* no bcast, connect */));
 }
 
 udp_simple::sptr udp_simple::make_broadcast(
-    const std::string &addr, const std::string &port
-){
+    const std::string& addr, const std::string& port)
+{
     return sptr(new udp_simple_impl(addr, port, true, false /* bcast, no connect */));
 }
 
@@ -90,36 +100,44 @@ udp_simple::sptr udp_simple::make_broadcast(
  * Simple UART over UDP
  **********************************************************************/
 #include <boost/thread/thread.hpp>
-class udp_simple_uart_impl : public uhd::uart_iface{
+class udp_simple_uart_impl : public uhd::uart_iface
+{
 public:
-    udp_simple_uart_impl(udp_simple::sptr udp){
+    udp_simple_uart_impl(udp_simple::sptr udp)
+    {
         _udp = udp;
         _len = 0;
         _off = 0;
-        this->write_uart(""); //send an empty packet to init
+        this->write_uart(""); // send an empty packet to init
     }
 
-    void write_uart(const std::string &buf){
+    void write_uart(const std::string& buf)
+    {
         _udp->send(asio::buffer(buf));
     }
 
-    std::string read_uart(double timeout){
+    std::string read_uart(double timeout)
+    {
         std::string line;
-        const boost::system_time exit_time = boost::get_system_time() + boost::posix_time::milliseconds(long(timeout*1000));
-        do{
-            //drain anything in current buffer
-            while (_off < _len){
+        const boost::system_time exit_time =
+            boost::get_system_time()
+            + boost::posix_time::milliseconds(long(timeout * 1000));
+        do {
+            // drain anything in current buffer
+            while (_off < _len) {
                 const char ch = _buf[_off++];
                 _line += ch;
-                if (ch == '\n')
-                {
+                if (ch == '\n') {
                     line.swap(_line);
                     return line;
                 }
             }
 
-            //recv a new packet into the buffer
-            _len = _udp->recv(asio::buffer(_buf), std::max((exit_time - boost::get_system_time()).total_milliseconds()/1000., 0.0));
+            // recv a new packet into the buffer
+            _len = _udp->recv(asio::buffer(_buf),
+                std::max(
+                    (exit_time - boost::get_system_time()).total_milliseconds() / 1000.,
+                    0.0));
             _off = 0;
 
         } while (_len != 0);
@@ -133,6 +151,7 @@ private:
     std::string _line;
 };
 
-uhd::uart_iface::sptr udp_simple::make_uart(sptr udp){
+uhd::uart_iface::sptr udp_simple::make_uart(sptr udp)
+{
     return uart_iface::sptr(new udp_simple_uart_impl(udp));
 }
diff --git a/host/lib/transport/udp_wsa_zero_copy.cpp b/host/lib/transport/udp_wsa_zero_copy.cpp
index 1bdf18095..c1eeb7cb1 100644
--- a/host/lib/transport/udp_wsa_zero_copy.cpp
+++ b/host/lib/transport/udp_wsa_zero_copy.cpp
@@ -6,10 +6,9 @@
 //
 
 #include "udp_common.hpp"
-#include <uhd/transport/udp_zero_copy.hpp>
-#include <uhd/transport/udp_simple.hpp> //mtu
 #include <uhd/transport/buffer_pool.hpp>
-
+#include <uhd/transport/udp_simple.hpp> //mtu
+#include <uhd/transport/udp_zero_copy.hpp>
 #include <uhd/utils/log.hpp>
 #include <boost/format.hpp>
 #include <vector>
@@ -18,31 +17,38 @@ using namespace uhd;
 using namespace uhd::transport;
 namespace asio = boost::asio;
 
-//A reasonable number of frames for send/recv and async/sync
+// A reasonable number of frames for send/recv and async/sync
 constexpr size_t UDP_ZERO_COPY_DEFAULT_NUM_FRAMES = 1;
-constexpr size_t UDP_ZERO_COPY_DEFAULT_FRAME_SIZE = 1472; // Based on common 1500 byte MTU for 1GbE.
+constexpr size_t UDP_ZERO_COPY_DEFAULT_FRAME_SIZE =
+    1472; // Based on common 1500 byte MTU for 1GbE.
 
 /***********************************************************************
  * Check registry for correct fast-path setting (windows only)
  **********************************************************************/
 #ifdef HAVE_ATLBASE_H
-#define CHECK_REG_SEND_THRESH
-#include <atlbase.h> //CRegKey
-static void check_registry_for_fast_send_threshold(const size_t mtu){
+#    define CHECK_REG_SEND_THRESH
+#    include <atlbase.h> //CRegKey
+static void check_registry_for_fast_send_threshold(const size_t mtu)
+{
     static bool warned = false;
-    if (warned) return; //only allow one printed warning per process
+    if (warned)
+        return; // only allow one printed warning per process
 
     CRegKey reg_key;
-    DWORD threshold = 1024; //system default when threshold is not specified
-    if (
-        reg_key.Open(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\AFD\\Parameters", KEY_READ) != ERROR_SUCCESS or
-        reg_key.QueryDWORDValue("FastSendDatagramThreshold", threshold) != ERROR_SUCCESS or threshold < mtu
-    ){
-        UHD_LOGGER_WARNING("UDP") << boost::format(
-            "The MTU (%d) is larger than the FastSendDatagramThreshold (%d)!\n"
-            "This will negatively affect the transmit performance.\n"
-            "See the transport application notes for more detail.\n"
-        ) % mtu % threshold ;
+    DWORD threshold = 1024; // system default when threshold is not specified
+    if (reg_key.Open(HKEY_LOCAL_MACHINE,
+            "System\\CurrentControlSet\\Services\\AFD\\Parameters",
+            KEY_READ)
+            != ERROR_SUCCESS
+        or reg_key.QueryDWORDValue("FastSendDatagramThreshold", threshold)
+               != ERROR_SUCCESS
+        or threshold < mtu) {
+        UHD_LOGGER_WARNING("UDP")
+            << boost::format(
+                   "The MTU (%d) is larger than the FastSendDatagramThreshold (%d)!\n"
+                   "This will negatively affect the transmit performance.\n"
+                   "See the transport application notes for more detail.\n")
+                   % mtu % threshold;
         warned = true;
     }
     reg_key.Close();
@@ -52,13 +58,16 @@ static void check_registry_for_fast_send_threshold(const size_t mtu){
 /***********************************************************************
  * Static initialization to take care of WSA init and cleanup
  **********************************************************************/
-struct uhd_wsa_control{
-    uhd_wsa_control(void){
+struct uhd_wsa_control
+{
+    uhd_wsa_control(void)
+    {
         WSADATA wsaData;
         WSAStartup(MAKEWORD(2, 2), &wsaData); /*windows socket startup */
     }
 
-    ~uhd_wsa_control(void){
+    ~uhd_wsa_control(void)
+    {
         WSACleanup();
     }
 };
@@ -68,34 +77,38 @@ struct uhd_wsa_control{
  *  - Initialize with memory and a release callback.
  *  - Call get new with a length in bytes to re-use.
  **********************************************************************/
-class udp_zero_copy_asio_mrb : public managed_recv_buffer{
+class udp_zero_copy_asio_mrb : public managed_recv_buffer
+{
 public:
-    udp_zero_copy_asio_mrb(void *mem, int sock_fd, const size_t frame_size):
-        _sock_fd(sock_fd), _frame_size(frame_size)
+    udp_zero_copy_asio_mrb(void* mem, int sock_fd, const size_t frame_size)
+        : _sock_fd(sock_fd), _frame_size(frame_size)
     {
-        _wsa_buff.buf = reinterpret_cast<char *>(mem);
+        _wsa_buff.buf = reinterpret_cast<char*>(mem);
         ZeroMemory(&_overlapped, sizeof(_overlapped));
         _overlapped.hEvent = WSACreateEvent();
         UHD_ASSERT_THROW(_overlapped.hEvent != WSA_INVALID_EVENT);
-        this->release(); //makes buffer available via get_new
+        this->release(); // makes buffer available via get_new
     }
 
-    ~udp_zero_copy_asio_mrb(void){
+    ~udp_zero_copy_asio_mrb(void)
+    {
         WSACloseEvent(_overlapped.hEvent);
     }
 
-    void release(void){
+    void release(void)
+    {
         _wsa_buff.len = _frame_size;
-        _flags = 0;
+        _flags        = 0;
         WSARecv(_sock_fd, &_wsa_buff, 1, &_wsa_buff.len, &_flags, &_overlapped, NULL);
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
         const DWORD result = WSAWaitForMultipleEvents(
-            1, &_overlapped.hEvent, true, DWORD(timeout*1000), true
-        );
-        if (result == WSA_WAIT_TIMEOUT) return managed_recv_buffer::sptr();
-        index++; //advances the caller's buffer
+            1, &_overlapped.hEvent, true, DWORD(timeout * 1000), true);
+        if (result == WSA_WAIT_TIMEOUT)
+            return managed_recv_buffer::sptr();
+        index++; // advances the caller's buffer
 
         WSAGetOverlappedResult(_sock_fd, &_overlapped, &_wsa_buff.len, true, &_flags);
 
@@ -116,33 +129,37 @@ private:
  *  - committing the buffer calls the asynchronous socket send
  *  - getting a new buffer performs the blocking wait for completion
  **********************************************************************/
-class udp_zero_copy_asio_msb : public managed_send_buffer{
+class udp_zero_copy_asio_msb : public managed_send_buffer
+{
 public:
-    udp_zero_copy_asio_msb(void *mem, int sock_fd, const size_t frame_size):
-        _sock_fd(sock_fd), _frame_size(frame_size)
+    udp_zero_copy_asio_msb(void* mem, int sock_fd, const size_t frame_size)
+        : _sock_fd(sock_fd), _frame_size(frame_size)
     {
-        _wsa_buff.buf = reinterpret_cast<char *>(mem);
+        _wsa_buff.buf = reinterpret_cast<char*>(mem);
         ZeroMemory(&_overlapped, sizeof(_overlapped));
         _overlapped.hEvent = WSACreateEvent();
         UHD_ASSERT_THROW(_overlapped.hEvent != WSA_INVALID_EVENT);
-        WSASetEvent(_overlapped.hEvent); //makes buffer available via get_new
+        WSASetEvent(_overlapped.hEvent); // makes buffer available via get_new
     }
 
-    ~udp_zero_copy_asio_msb(void){
+    ~udp_zero_copy_asio_msb(void)
+    {
         WSACloseEvent(_overlapped.hEvent);
     }
 
-    void release(void){
+    void release(void)
+    {
         _wsa_buff.len = size();
         WSASend(_sock_fd, &_wsa_buff, 1, NULL, 0, &_overlapped, NULL);
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
         const DWORD result = WSAWaitForMultipleEvents(
-            1, &_overlapped.hEvent, true, DWORD(timeout*1000), true
-        );
-        if (result == WSA_WAIT_TIMEOUT) return managed_send_buffer::sptr();
-        index++; //advances the caller's buffer
+            1, &_overlapped.hEvent, true, DWORD(timeout * 1000), true);
+        if (result == WSA_WAIT_TIMEOUT)
+            return managed_send_buffer::sptr();
+        index++; // advances the caller's buffer
 
         WSAResetEvent(_overlapped.hEvent);
         _wsa_buff.len = _frame_size;
@@ -166,87 +183,108 @@ private:
  *   This has better performance than the overlapped IO.
  *   For send, use overlapped IO to submit async sends.
  **********************************************************************/
-class udp_zero_copy_wsa_impl : public udp_zero_copy{
+class udp_zero_copy_wsa_impl : public udp_zero_copy
+{
 public:
     typedef boost::shared_ptr<udp_zero_copy_wsa_impl> sptr;
 
-    udp_zero_copy_wsa_impl(
-        const std::string &addr,
-        const std::string &port,
+    udp_zero_copy_wsa_impl(const std::string& addr,
+        const std::string& port,
         zero_copy_xport_params& xport_params,
-        const device_addr_t &hints
-    ):
-        _recv_frame_size(xport_params.recv_frame_size),
-        _num_recv_frames(xport_params.num_recv_frames),
-        _send_frame_size(xport_params.send_frame_size),
-        _num_send_frames(xport_params.num_send_frames),
-        _recv_buffer_pool(buffer_pool::make(xport_params.num_recv_frames, xport_params.recv_frame_size)),
-        _send_buffer_pool(buffer_pool::make(xport_params.num_send_frames, xport_params.send_frame_size)),
-        _next_recv_buff_index(0), _next_send_buff_index(0)
+        const device_addr_t& hints)
+        : _recv_frame_size(xport_params.recv_frame_size)
+        , _num_recv_frames(xport_params.num_recv_frames)
+        , _send_frame_size(xport_params.send_frame_size)
+        , _num_send_frames(xport_params.num_send_frames)
+        , _recv_buffer_pool(buffer_pool::make(
+              xport_params.num_recv_frames, xport_params.recv_frame_size))
+        , _send_buffer_pool(buffer_pool::make(
+              xport_params.num_send_frames, xport_params.send_frame_size))
+        , _next_recv_buff_index(0)
+        , _next_send_buff_index(0)
     {
-        #ifdef CHECK_REG_SEND_THRESH
+#ifdef CHECK_REG_SEND_THRESH
         check_registry_for_fast_send_threshold(this->get_send_frame_size());
-        #endif /*CHECK_REG_SEND_THRESH*/
+#endif /*CHECK_REG_SEND_THRESH*/
 
         UHD_LOGGER_TRACE("UDP")
-            << boost::format("Creating WSA UDP transport to %s:%s")
-               % addr % port;
+            << boost::format("Creating WSA UDP transport to %s:%s") % addr % port;
 
-        static uhd_wsa_control uhd_wsa; //makes wsa start happen via lazy initialization
+        static uhd_wsa_control uhd_wsa; // makes wsa start happen via lazy initialization
 
         UHD_ASSERT_THROW(_num_send_frames <= WSA_MAXIMUM_WAIT_EVENTS);
 
-        //resolve the address
+        // resolve the address
         asio::io_service io_service;
         asio::ip::udp::resolver resolver(io_service);
         asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port);
         asio::ip::udp::endpoint receiver_endpoint = *resolver.resolve(query);
 
-        //create the socket
-        _sock_fd = WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, WSA_FLAG_OVERLAPPED);
-        if (_sock_fd == INVALID_SOCKET){
+        // create the socket
+        _sock_fd =
+            WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, WSA_FLAG_OVERLAPPED);
+        if (_sock_fd == INVALID_SOCKET) {
             const DWORD error = WSAGetLastError();
-            throw uhd::os_error(str(boost::format("WSASocket() failed with error %d") % error));
+            throw uhd::os_error(
+                str(boost::format("WSASocket() failed with error %d") % error));
         }
 
-        //set the socket non-blocking for recv
-        //u_long mode = 1;
-        //ioctlsocket(_sock_fd, FIONBIO, &mode);
+        // set the socket non-blocking for recv
+        // u_long mode = 1;
+        // ioctlsocket(_sock_fd, FIONBIO, &mode);
 
-        //resize the socket buffers
+        // resize the socket buffers
         const int recv_buff_size = int(hints.cast<double>("recv_buff_size", 0.0));
         const int send_buff_size = int(hints.cast<double>("send_buff_size", 0.0));
-        if (recv_buff_size > 0) setsockopt(_sock_fd, SOL_SOCKET, SO_RCVBUF, (const char *)&recv_buff_size, sizeof(recv_buff_size));
-        if (send_buff_size > 0) setsockopt(_sock_fd, SOL_SOCKET, SO_SNDBUF, (const char *)&send_buff_size, sizeof(send_buff_size));
-
-        //connect the socket so we can send/recv
-        const asio::ip::udp::endpoint::data_type &servaddr = *receiver_endpoint.data();
-        if (WSAConnect(_sock_fd, (const struct sockaddr *)&servaddr, sizeof(servaddr), NULL, NULL, NULL, NULL) != 0){
+        if (recv_buff_size > 0)
+            setsockopt(_sock_fd,
+                SOL_SOCKET,
+                SO_RCVBUF,
+                (const char*)&recv_buff_size,
+                sizeof(recv_buff_size));
+        if (send_buff_size > 0)
+            setsockopt(_sock_fd,
+                SOL_SOCKET,
+                SO_SNDBUF,
+                (const char*)&send_buff_size,
+                sizeof(send_buff_size));
+
+        // connect the socket so we can send/recv
+        const asio::ip::udp::endpoint::data_type& servaddr = *receiver_endpoint.data();
+        if (WSAConnect(_sock_fd,
+                (const struct sockaddr*)&servaddr,
+                sizeof(servaddr),
+                NULL,
+                NULL,
+                NULL,
+                NULL)
+            != 0) {
             const DWORD error = WSAGetLastError();
             closesocket(_sock_fd);
-            throw uhd::os_error(str(boost::format("WSAConnect() failed with error %d") % error));
+            throw uhd::os_error(
+                str(boost::format("WSAConnect() failed with error %d") % error));
         }
 
-        UHD_LOGGER_TRACE("UDP")
-            << boost::format("Local WSA UDP socket endpoint: %s:%s")
-            % get_local_addr() % get_local_port();
-
-        //allocate re-usable managed receive buffers
-        for (size_t i = 0; i < get_num_recv_frames(); i++){
-            _mrb_pool.push_back(boost::shared_ptr<udp_zero_copy_asio_mrb>(
-                new udp_zero_copy_asio_mrb(_recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size())
-            ));
+        UHD_LOGGER_TRACE("UDP") << boost::format("Local WSA UDP socket endpoint: %s:%s")
+                                       % get_local_addr() % get_local_port();
+
+        // allocate re-usable managed receive buffers
+        for (size_t i = 0; i < get_num_recv_frames(); i++) {
+            _mrb_pool.push_back(
+                boost::shared_ptr<udp_zero_copy_asio_mrb>(new udp_zero_copy_asio_mrb(
+                    _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size())));
         }
 
-        //allocate re-usable managed send buffers
-        for (size_t i = 0; i < get_num_send_frames(); i++){
-            _msb_pool.push_back(boost::shared_ptr<udp_zero_copy_asio_msb>(
-                new udp_zero_copy_asio_msb(_send_buffer_pool->at(i), _sock_fd, get_send_frame_size())
-            ));
+        // allocate re-usable managed send buffers
+        for (size_t i = 0; i < get_num_send_frames(); i++) {
+            _msb_pool.push_back(
+                boost::shared_ptr<udp_zero_copy_asio_msb>(new udp_zero_copy_asio_msb(
+                    _send_buffer_pool->at(i), _sock_fd, get_send_frame_size())));
         }
     }
 
-    ~udp_zero_copy_wsa_impl(void){
+    ~udp_zero_copy_wsa_impl(void)
+    {
         closesocket(_sock_fd);
     }
 
@@ -254,45 +292,62 @@ public:
      * Receive implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_recv_buffer::sptr get_recv_buff(double timeout){
-        if (_next_recv_buff_index == _num_recv_frames) _next_recv_buff_index = 0;
+    managed_recv_buffer::sptr get_recv_buff(double timeout)
+    {
+        if (_next_recv_buff_index == _num_recv_frames)
+            _next_recv_buff_index = 0;
         return _mrb_pool[_next_recv_buff_index]->get_new(timeout, _next_recv_buff_index);
     }
 
-    size_t get_num_recv_frames(void) const {return _num_recv_frames;}
-    size_t get_recv_frame_size(void) const {return _recv_frame_size;}
+    size_t get_num_recv_frames(void) const
+    {
+        return _num_recv_frames;
+    }
+    size_t get_recv_frame_size(void) const
+    {
+        return _recv_frame_size;
+    }
 
     /*******************************************************************
      * Send implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_send_buffer::sptr get_send_buff(double timeout){
-        if (_next_send_buff_index == _num_send_frames) _next_send_buff_index = 0;
+    managed_send_buffer::sptr get_send_buff(double timeout)
+    {
+        if (_next_send_buff_index == _num_send_frames)
+            _next_send_buff_index = 0;
         return _msb_pool[_next_send_buff_index]->get_new(timeout, _next_send_buff_index);
     }
 
-    size_t get_num_send_frames(void) const {return _num_send_frames;}
-    size_t get_send_frame_size(void) const {return _send_frame_size;}
+    size_t get_num_send_frames(void) const
+    {
+        return _num_send_frames;
+    }
+    size_t get_send_frame_size(void) const
+    {
+        return _send_frame_size;
+    }
 
-    uint16_t get_local_port(void) const {
+    uint16_t get_local_port(void) const
+    {
         struct sockaddr_in addr_info;
-        int addr_len = sizeof(addr_info);
+        int addr_len        = sizeof(addr_info);
         uint16_t local_port = 0;
-        if (getsockname( _sock_fd, (SOCKADDR*) &addr_info,
-                         &addr_len) == 0){
+        if (getsockname(_sock_fd, (SOCKADDR*)&addr_info, &addr_len) == 0) {
             local_port = ntohs(addr_info.sin_port);
         }
         return local_port;
     }
 
-    std::string get_local_addr(void) const {
+    std::string get_local_addr(void) const
+    {
         // Behold the beauty of winsock
         struct sockaddr_in addr_info;
         int addr_len = sizeof(addr_info);
         std::string local_addr;
-        if (getsockname(_sock_fd, (SOCKADDR*) &addr_info, &addr_len) == 0) {
+        if (getsockname(_sock_fd, (SOCKADDR*)&addr_info, &addr_len) == 0) {
             // inet_ntoa() guarantees either NULL or null-terminated array
-            char *local_ip = inet_ntoa(addr_info.sin_addr);
+            char* local_ip = inet_ntoa(addr_info.sin_addr);
             if (local_ip) {
                 local_addr = std::string(local_ip);
             }
@@ -301,86 +356,77 @@ public:
     }
 
     //! Read back the socket's buffer space reserved for receives
-    size_t get_recv_buff_size(void) {
+    size_t get_recv_buff_size(void)
+    {
         int recv_buff_size = 0;
-        int opt_len = sizeof(recv_buff_size);
+        int opt_len        = sizeof(recv_buff_size);
         getsockopt(
-                _sock_fd,
-                SOL_SOCKET,
-                SO_RCVBUF,
-                (char *)&recv_buff_size,
-                (int *)&opt_len
-        );
+            _sock_fd, SOL_SOCKET, SO_RCVBUF, (char*)&recv_buff_size, (int*)&opt_len);
 
-        return (size_t) recv_buff_size;
+        return (size_t)recv_buff_size;
     }
 
     //! Read back the socket's buffer space reserved for sends
-    size_t get_send_buff_size(void) {
+    size_t get_send_buff_size(void)
+    {
         int send_buff_size = 0;
-        int opt_len = sizeof(send_buff_size);
+        int opt_len        = sizeof(send_buff_size);
         getsockopt(
-                _sock_fd,
-                SOL_SOCKET,
-                SO_SNDBUF,
-                (char *)&send_buff_size,
-                (int *)&opt_len
-        );
+            _sock_fd, SOL_SOCKET, SO_SNDBUF, (char*)&send_buff_size, (int*)&opt_len);
 
-        return (size_t) send_buff_size;
+        return (size_t)send_buff_size;
     }
 
 private:
-    //memory management -> buffers and fifos
+    // memory management -> buffers and fifos
     const size_t _recv_frame_size, _num_recv_frames;
     const size_t _send_frame_size, _num_send_frames;
     buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool;
-    std::vector<boost::shared_ptr<udp_zero_copy_asio_msb> > _msb_pool;
-    std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb> > _mrb_pool;
+    std::vector<boost::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool;
+    std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool;
     size_t _next_recv_buff_index, _next_send_buff_index;
 
-    //socket guts
-    SOCKET                  _sock_fd;
+    // socket guts
+    SOCKET _sock_fd;
 };
 
 /***********************************************************************
  * UDP zero copy make function
  **********************************************************************/
-void check_usr_buff_size(
-    size_t actual_buff_size,
+void check_usr_buff_size(size_t actual_buff_size,
     size_t user_buff_size, // Set this to zero for no user-defined preference
-    const std::string tx_rx
-){
-    UHD_LOGGER_DEBUG("UDP")
-        << boost::format("Target/actual %s sock buff size: %d/%d bytes")
-           % tx_rx
-           % user_buff_size
-           % actual_buff_size
-    ;
-    if ((user_buff_size != 0.0) and (actual_buff_size < user_buff_size)) UHD_LOGGER_WARNING("UDP") << boost::format(
-        "The %s buffer could not be resized sufficiently.\n"
-        "Target sock buff size: %d bytes.\n"
-        "Actual sock buff size: %d bytes.\n"
-        "See the transport application notes on buffer resizing.\n"
-    ) % tx_rx % user_buff_size % actual_buff_size;
+    const std::string tx_rx)
+{
+    UHD_LOGGER_DEBUG("UDP") << boost::format(
+                                   "Target/actual %s sock buff size: %d/%d bytes")
+                                   % tx_rx % user_buff_size % actual_buff_size;
+    if ((user_buff_size != 0.0) and (actual_buff_size < user_buff_size))
+        UHD_LOGGER_WARNING("UDP")
+            << boost::format("The %s buffer could not be resized sufficiently.\n"
+                             "Target sock buff size: %d bytes.\n"
+                             "Actual sock buff size: %d bytes.\n"
+                             "See the transport application notes on buffer resizing.\n")
+                   % tx_rx % user_buff_size % actual_buff_size;
 }
 
 
-
-udp_zero_copy::sptr udp_zero_copy::make(
-    const std::string &addr,
-    const std::string &port,
-    const zero_copy_xport_params &default_buff_args,
+udp_zero_copy::sptr udp_zero_copy::make(const std::string& addr,
+    const std::string& port,
+    const zero_copy_xport_params& default_buff_args,
     udp_zero_copy::buff_params& buff_params_out,
-    const device_addr_t &hints
-){
-    //Initialize xport_params
+    const device_addr_t& hints)
+{
+    // Initialize xport_params
     zero_copy_xport_params xport_params = default_buff_args;
 
-    xport_params.recv_frame_size = size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
-    xport_params.num_recv_frames = size_t(hints.cast<double>("num_recv_frames", default_buff_args.num_recv_frames));
-    xport_params.send_frame_size = size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
-    xport_params.num_send_frames = size_t(hints.cast<double>("num_send_frames", default_buff_args.num_send_frames));
+    xport_params.recv_frame_size =
+        size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
+    xport_params.num_recv_frames =
+        size_t(hints.cast<double>("num_recv_frames", default_buff_args.num_recv_frames));
+    xport_params.send_frame_size =
+        size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
+    xport_params.num_send_frames =
+        size_t(hints.cast<double>("num_send_frames", default_buff_args.num_send_frames));
 
     if (xport_params.num_recv_frames == 0) {
         UHD_LOG_TRACE("UDP",
@@ -405,27 +451,34 @@ udp_zero_copy::sptr udp_zero_copy::make(
         xport_params.send_frame_size = UDP_ZERO_COPY_DEFAULT_FRAME_SIZE;
     }
 
-    //extract buffer size hints from the device addr and check if they match up
+    // extract buffer size hints from the device addr and check if they match up
     size_t usr_recv_buff_size = size_t(hints.cast<double>("recv_buff_size", 0.0));
     size_t usr_send_buff_size = size_t(hints.cast<double>("send_buff_size", 0.0));
     if (hints.has_key("recv_buff_size")) {
-        if (usr_recv_buff_size < xport_params.recv_frame_size * xport_params.num_recv_frames) {
-            throw uhd::value_error((boost::format(
-                "recv_buff_size must be equal to or greater than (num_recv_frames * recv_frame_size) where num_recv_frames=%d, recv_frame_size=%d")
-                % xport_params.num_recv_frames % xport_params.recv_frame_size).str());
+        if (usr_recv_buff_size
+            < xport_params.recv_frame_size * xport_params.num_recv_frames) {
+            throw uhd::value_error(
+                (boost::format(
+                     "recv_buff_size must be equal to or greater than (num_recv_frames * "
+                     "recv_frame_size) where num_recv_frames=%d, recv_frame_size=%d")
+                    % xport_params.num_recv_frames % xport_params.recv_frame_size)
+                    .str());
         }
     }
     if (hints.has_key("send_buff_size")) {
-        if (usr_send_buff_size < xport_params.send_frame_size * xport_params.num_send_frames) {
-            throw uhd::value_error((boost::format(
-                "send_buff_size must be equal to or greater than (num_send_frames * send_frame_size) where num_send_frames=%d, send_frame_size=%d")
-                % xport_params.num_send_frames % xport_params.send_frame_size).str());
+        if (usr_send_buff_size
+            < xport_params.send_frame_size * xport_params.num_send_frames) {
+            throw uhd::value_error(
+                (boost::format(
+                     "send_buff_size must be equal to or greater than (num_send_frames * "
+                     "send_frame_size) where num_send_frames=%d, send_frame_size=%d")
+                    % xport_params.num_send_frames % xport_params.send_frame_size)
+                    .str());
         }
     }
 
     udp_zero_copy_wsa_impl::sptr udp_trans(
-        new udp_zero_copy_wsa_impl(addr, port, xport_params, hints)
-    );
+        new udp_zero_copy_wsa_impl(addr, port, xport_params, hints));
 
     // Read back the actual socket buffer sizes
     buff_params_out.recv_buff_size = udp_trans->get_recv_buff_size();
diff --git a/host/lib/transport/udp_zero_copy.cpp b/host/lib/transport/udp_zero_copy.cpp
index 2b637639b..1ccee72a2 100644
--- a/host/lib/transport/udp_zero_copy.cpp
+++ b/host/lib/transport/udp_zero_copy.cpp
@@ -6,45 +6,52 @@
 //
 
 #include "udp_common.hpp"
-#include <uhd/transport/udp_zero_copy.hpp>
-#include <uhd/transport/udp_simple.hpp> //mtu
 #include <uhd/transport/buffer_pool.hpp>
-
+#include <uhd/transport/udp_simple.hpp> //mtu
+#include <uhd/transport/udp_zero_copy.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhdlib/utils/atomic.hpp>
 #include <boost/format.hpp>
 #include <boost/make_shared.hpp>
-#include <vector>
 #include <chrono>
 #include <thread>
+#include <vector>
 
 using namespace uhd;
 using namespace uhd::transport;
-namespace asio = boost::asio;
+namespace asio                                    = boost::asio;
 constexpr size_t UDP_ZERO_COPY_DEFAULT_NUM_FRAMES = 1;
-constexpr size_t UDP_ZERO_COPY_DEFAULT_FRAME_SIZE = 1472; // Based on common 1500 byte MTU for 1GbE.
-constexpr size_t UDP_ZERO_COPY_DEFAULT_BUFF_SIZE = 2500000; // 20ms of data for 1GbE link (in bytes)
+constexpr size_t UDP_ZERO_COPY_DEFAULT_FRAME_SIZE =
+    1472; // Based on common 1500 byte MTU for 1GbE.
+constexpr size_t UDP_ZERO_COPY_DEFAULT_BUFF_SIZE =
+    2500000; // 20ms of data for 1GbE link (in bytes)
 /***********************************************************************
  * Check registry for correct fast-path setting (windows only)
  **********************************************************************/
 #ifdef HAVE_ATLBASE_H
-#define CHECK_REG_SEND_THRESH
-#include <atlbase.h> //CRegKey
-static void check_registry_for_fast_send_threshold(const size_t mtu){
+#    define CHECK_REG_SEND_THRESH
+#    include <atlbase.h> //CRegKey
+static void check_registry_for_fast_send_threshold(const size_t mtu)
+{
     static bool warned = false;
-    if (warned) return; //only allow one printed warning per process
+    if (warned)
+        return; // only allow one printed warning per process
 
     CRegKey reg_key;
-    DWORD threshold = 1024; //system default when threshold is not specified
-    if (
-        reg_key.Open(HKEY_LOCAL_MACHINE, "System\\CurrentControlSet\\Services\\AFD\\Parameters", KEY_READ) != ERROR_SUCCESS or
-        reg_key.QueryDWORDValue("FastSendDatagramThreshold", threshold) != ERROR_SUCCESS or threshold < mtu
-    ){
-        UHD_LOGGER_WARNING("UDP") << boost::format(
-            "The MTU (%d) is larger than the FastSendDatagramThreshold (%d)!\n"
-            "This will negatively affect the transmit performance.\n"
-            "See the transport application notes for more detail.\n"
-        ) % mtu % threshold ;
+    DWORD threshold = 1024; // system default when threshold is not specified
+    if (reg_key.Open(HKEY_LOCAL_MACHINE,
+            "System\\CurrentControlSet\\Services\\AFD\\Parameters",
+            KEY_READ)
+            != ERROR_SUCCESS
+        or reg_key.QueryDWORDValue("FastSendDatagramThreshold", threshold)
+               != ERROR_SUCCESS
+        or threshold < mtu) {
+        UHD_LOGGER_WARNING("UDP")
+            << boost::format(
+                   "The MTU (%d) is larger than the FastSendDatagramThreshold (%d)!\n"
+                   "This will negatively affect the transmit performance.\n"
+                   "See the transport application notes for more detail.\n")
+                   % mtu % threshold;
         warned = true;
     }
     reg_key.Close();
@@ -55,42 +62,49 @@ static void check_registry_for_fast_send_threshold(const size_t mtu){
  * Reusable managed receiver buffer:
  *  - get_new performs the recv operation
  **********************************************************************/
-class udp_zero_copy_asio_mrb : public managed_recv_buffer{
+class udp_zero_copy_asio_mrb : public managed_recv_buffer
+{
 public:
-    udp_zero_copy_asio_mrb(void *mem, int sock_fd, const size_t frame_size):
-        _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size), _len(0) { /*NOP*/ }
+    udp_zero_copy_asio_mrb(void* mem, int sock_fd, const size_t frame_size)
+        : _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size), _len(0)
+    { /*NOP*/
+    }
 
-    void release(void){
+    void release(void)
+    {
         _claimer.release();
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
-        if (not _claimer.claim_with_wait(timeout)) return sptr();
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
+        if (not _claimer.claim_with_wait(timeout))
+            return sptr();
 
-        #ifdef MSG_DONTWAIT //try a non-blocking recv() if supported
-        _len = ::recv(_sock_fd, (char *)_mem, _frame_size, MSG_DONTWAIT);
-        if (_len > 0){
-            index++; //advances the caller's buffer
+#ifdef MSG_DONTWAIT // try a non-blocking recv() if supported
+        _len = ::recv(_sock_fd, (char*)_mem, _frame_size, MSG_DONTWAIT);
+        if (_len > 0) {
+            index++; // advances the caller's buffer
             return make(this, _mem, size_t(_len));
         }
-        #endif
+#endif
 
-        if (wait_for_recv_ready(_sock_fd, timeout)){
-            _len = ::recv(_sock_fd, (char *)_mem, _frame_size, 0);
+        if (wait_for_recv_ready(_sock_fd, timeout)) {
+            _len = ::recv(_sock_fd, (char*)_mem, _frame_size, 0);
             if (_len == 0)
                 throw uhd::io_error("socket closed");
             if (_len < 0)
-                throw uhd::io_error(str(boost::format("recv error on socket: %s") % strerror(errno)));
-            index++; //advances the caller's buffer
+                throw uhd::io_error(
+                    str(boost::format("recv error on socket: %s") % strerror(errno)));
+            index++; // advances the caller's buffer
             return make(this, _mem, size_t(_len));
         }
 
-        _claimer.release(); //undo claim
-        return sptr(); //null for timeout
+        _claimer.release(); // undo claim
+        return sptr(); // null for timeout
     }
 
 private:
-    void *_mem;
+    void* _mem;
     int _sock_fd;
     size_t _frame_size;
     ssize_t _len;
@@ -101,41 +115,46 @@ private:
  * Reusable managed send buffer:
  *  - commit performs the send operation
  **********************************************************************/
-class udp_zero_copy_asio_msb : public managed_send_buffer{
+class udp_zero_copy_asio_msb : public managed_send_buffer
+{
 public:
-    udp_zero_copy_asio_msb(void *mem, int sock_fd, const size_t frame_size):
-        _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size) { /*NOP*/ }
-
-    void release(void){
-        //Retry logic because send may fail with ENOBUFS.
-        //This is known to occur at least on some OSX systems.
-        //But it should be safe to always check for the error.
-        while (true)
-        {
-            const ssize_t ret = ::send(_sock_fd, (const char *)_mem, size(), 0);
-            if (ret == ssize_t(size())) break;
-            if (ret == -1 and errno == ENOBUFS)
-            {
+    udp_zero_copy_asio_msb(void* mem, int sock_fd, const size_t frame_size)
+        : _mem(mem), _sock_fd(sock_fd), _frame_size(frame_size)
+    { /*NOP*/
+    }
+
+    void release(void)
+    {
+        // Retry logic because send may fail with ENOBUFS.
+        // This is known to occur at least on some OSX systems.
+        // But it should be safe to always check for the error.
+        while (true) {
+            const ssize_t ret = ::send(_sock_fd, (const char*)_mem, size(), 0);
+            if (ret == ssize_t(size()))
+                break;
+            if (ret == -1 and errno == ENOBUFS) {
                 std::this_thread::sleep_for(std::chrono::microseconds(1));
-                continue; //try to send again
+                continue; // try to send again
             }
-            if (ret == -1)
-            {
-                throw uhd::io_error(str(boost::format("send error on socket: %s") % strerror(errno)));
+            if (ret == -1) {
+                throw uhd::io_error(
+                    str(boost::format("send error on socket: %s") % strerror(errno)));
             }
             UHD_ASSERT_THROW(ret == ssize_t(size()));
         }
         _claimer.release();
     }
 
-    UHD_INLINE sptr get_new(const double timeout, size_t &index){
-        if (not _claimer.claim_with_wait(timeout)) return sptr();
-        index++; //advances the caller's buffer
+    UHD_INLINE sptr get_new(const double timeout, size_t& index)
+    {
+        if (not _claimer.claim_with_wait(timeout))
+            return sptr();
+        index++; // advances the caller's buffer
         return make(this, _mem, _frame_size);
     }
 
 private:
-    void *_mem;
+    void* _mem;
     int _sock_fd;
     size_t _frame_size;
     simple_claimer _claimer;
@@ -148,74 +167,74 @@ private:
  *   However, it is not a true zero copy implementation as each
  *   send and recv requires a copy operation to/from userspace.
  **********************************************************************/
-class udp_zero_copy_asio_impl : public udp_zero_copy{
+class udp_zero_copy_asio_impl : public udp_zero_copy
+{
 public:
     typedef boost::shared_ptr<udp_zero_copy_asio_impl> sptr;
 
-    udp_zero_copy_asio_impl(
-        const std::string &addr,
-        const std::string &port,
-        const zero_copy_xport_params& xport_params
-    ):
-        _recv_frame_size(xport_params.recv_frame_size),
-        _num_recv_frames(xport_params.num_recv_frames),
-        _send_frame_size(xport_params.send_frame_size),
-        _num_send_frames(xport_params.num_send_frames),
-        _recv_buffer_pool(buffer_pool::make(xport_params.num_recv_frames, xport_params.recv_frame_size)),
-        _send_buffer_pool(buffer_pool::make(xport_params.num_send_frames, xport_params.send_frame_size)),
-        _next_recv_buff_index(0), _next_send_buff_index(0)
+    udp_zero_copy_asio_impl(const std::string& addr,
+        const std::string& port,
+        const zero_copy_xport_params& xport_params)
+        : _recv_frame_size(xport_params.recv_frame_size)
+        , _num_recv_frames(xport_params.num_recv_frames)
+        , _send_frame_size(xport_params.send_frame_size)
+        , _num_send_frames(xport_params.num_send_frames)
+        , _recv_buffer_pool(buffer_pool::make(
+              xport_params.num_recv_frames, xport_params.recv_frame_size))
+        , _send_buffer_pool(buffer_pool::make(
+              xport_params.num_send_frames, xport_params.send_frame_size))
+        , _next_recv_buff_index(0)
+        , _next_send_buff_index(0)
     {
         UHD_LOGGER_TRACE("UDP")
             << boost::format("Creating UDP transport to %s:%s") % addr % port;
 
-        #ifdef CHECK_REG_SEND_THRESH
+#ifdef CHECK_REG_SEND_THRESH
         check_registry_for_fast_send_threshold(this->get_send_frame_size());
-        #endif /*CHECK_REG_SEND_THRESH*/
+#endif /*CHECK_REG_SEND_THRESH*/
 
-        //resolve the address
+        // resolve the address
         asio::ip::udp::resolver resolver(_io_service);
         asio::ip::udp::resolver::query query(asio::ip::udp::v4(), addr, port);
         asio::ip::udp::endpoint receiver_endpoint = *resolver.resolve(query);
 
-        //create, open, and connect the socket
+        // create, open, and connect the socket
         _socket = socket_sptr(new asio::ip::udp::socket(_io_service));
         _socket->open(asio::ip::udp::v4());
         _socket->connect(receiver_endpoint);
         _sock_fd = _socket->native_handle();
 
-        UHD_LOGGER_TRACE("UDP")
-            << boost::format("Local UDP socket endpoint: %s:%s")
-            % get_local_addr() % get_local_port();
+        UHD_LOGGER_TRACE("UDP") << boost::format("Local UDP socket endpoint: %s:%s")
+                                       % get_local_addr() % get_local_port();
 
-        //allocate re-usable managed receive buffers
-        for (size_t i = 0; i < get_num_recv_frames(); i++){
+        // allocate re-usable managed receive buffers
+        for (size_t i = 0; i < get_num_recv_frames(); i++) {
             _mrb_pool.push_back(boost::make_shared<udp_zero_copy_asio_mrb>(
-                _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size()
-            ));
+                _recv_buffer_pool->at(i), _sock_fd, get_recv_frame_size()));
         }
 
-        //allocate re-usable managed send buffers
-        for (size_t i = 0; i < get_num_send_frames(); i++){
+        // allocate re-usable managed send buffers
+        for (size_t i = 0; i < get_num_send_frames(); i++) {
             _msb_pool.push_back(boost::make_shared<udp_zero_copy_asio_msb>(
-                _send_buffer_pool->at(i), _sock_fd, get_send_frame_size()
-            ));
+                _send_buffer_pool->at(i), _sock_fd, get_send_frame_size()));
         }
     }
 
-    //get size for internal socket buffer
-    template <typename Opt> size_t get_buff_size(void) const{
+    // get size for internal socket buffer
+    template <typename Opt> size_t get_buff_size(void) const
+    {
         Opt option;
         _socket->get_option(option);
         return option.value();
     }
 
-    //set size for internal socket buffer
+    // set size for internal socket buffer
     template <typename Opt> size_t resize_buff(size_t num_bytes)
     {
-        #if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
-            //limit buffer resize on macos or it will error
-            num_bytes = std::min(num_bytes, MAX_BUFF_SIZE_ETH_MACOS);
-        #endif
+#if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
+        // limit buffer resize on macos or it will error
+        num_bytes = std::min(num_bytes, MAX_BUFF_SIZE_ETH_MACOS);
+#endif
         Opt option(num_bytes);
         _socket->set_option(option);
         return get_buff_size<Opt>();
@@ -225,25 +244,41 @@ public:
      * Receive implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_recv_buffer::sptr get_recv_buff(double timeout){
-        if (_next_recv_buff_index == _num_recv_frames) _next_recv_buff_index = 0;
+    managed_recv_buffer::sptr get_recv_buff(double timeout)
+    {
+        if (_next_recv_buff_index == _num_recv_frames)
+            _next_recv_buff_index = 0;
         return _mrb_pool[_next_recv_buff_index]->get_new(timeout, _next_recv_buff_index);
     }
 
-    size_t get_num_recv_frames(void) const {return _num_recv_frames;}
-    size_t get_recv_frame_size(void) const {return _recv_frame_size;}
+    size_t get_num_recv_frames(void) const
+    {
+        return _num_recv_frames;
+    }
+    size_t get_recv_frame_size(void) const
+    {
+        return _recv_frame_size;
+    }
 
     /*******************************************************************
      * Send implementation:
      * Block on the managed buffer's get call and advance the index.
      ******************************************************************/
-    managed_send_buffer::sptr get_send_buff(double timeout){
-        if (_next_send_buff_index == _num_send_frames) _next_send_buff_index = 0;
+    managed_send_buffer::sptr get_send_buff(double timeout)
+    {
+        if (_next_send_buff_index == _num_send_frames)
+            _next_send_buff_index = 0;
         return _msb_pool[_next_send_buff_index]->get_new(timeout, _next_send_buff_index);
     }
 
-    size_t get_num_send_frames(void) const {return _num_send_frames;}
-    size_t get_send_frame_size(void) const {return _send_frame_size;}
+    size_t get_num_send_frames(void) const
+    {
+        return _num_send_frames;
+    }
+    size_t get_send_frame_size(void) const
+    {
+        return _send_frame_size;
+    }
 
     uint16_t get_local_port(void) const
     {
@@ -256,149 +291,153 @@ public:
     }
 
 private:
-    //memory management -> buffers and fifos
+    // memory management -> buffers and fifos
     const size_t _recv_frame_size, _num_recv_frames;
     const size_t _send_frame_size, _num_send_frames;
     buffer_pool::sptr _recv_buffer_pool, _send_buffer_pool;
-    std::vector<boost::shared_ptr<udp_zero_copy_asio_msb> > _msb_pool;
-    std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb> > _mrb_pool;
+    std::vector<boost::shared_ptr<udp_zero_copy_asio_msb>> _msb_pool;
+    std::vector<boost::shared_ptr<udp_zero_copy_asio_mrb>> _mrb_pool;
     size_t _next_recv_buff_index, _next_send_buff_index;
 
-    //asio guts -> socket and service
-    asio::io_service        _io_service;
-    socket_sptr             _socket;
-    int                     _sock_fd;
+    // asio guts -> socket and service
+    asio::io_service _io_service;
+    socket_sptr _socket;
+    int _sock_fd;
 };
 
 /***********************************************************************
  * UDP zero copy make function
  **********************************************************************/
-template<typename Opt> static size_t resize_buff_helper(
-    udp_zero_copy_asio_impl::sptr udp_trans,
+template <typename Opt>
+static size_t resize_buff_helper(udp_zero_copy_asio_impl::sptr udp_trans,
     const size_t target_size,
-    const std::string &name
-){
+    const std::string& name)
+{
     size_t actual_size = 0;
     std::string help_message;
-    #if defined(UHD_PLATFORM_LINUX)
-        help_message = str(boost::format(
-            "Please run: sudo sysctl -w net.core.%smem_max=%d"
-        ) % ((name == "recv")?"r":"w") % target_size);
-    #endif /*defined(UHD_PLATFORM_LINUX)*/
-
-    //resize the buffer if size was provided
-    if (target_size > 0){
+#if defined(UHD_PLATFORM_LINUX)
+    help_message = str(boost::format("Please run: sudo sysctl -w net.core.%smem_max=%d")
+                       % ((name == "recv") ? "r" : "w") % target_size);
+#endif /*defined(UHD_PLATFORM_LINUX)*/
+
+    // resize the buffer if size was provided
+    if (target_size > 0) {
         actual_size = udp_trans->resize_buff<Opt>(target_size);
         UHD_LOGGER_TRACE("UDP")
-            << boost::format("Target/actual %s sock buff size: %d/%d bytes")
-               % name
-               % target_size
-               % actual_size
-        ;
-        if (actual_size < target_size) UHD_LOGGER_WARNING("UDP") << boost::format(
-            "The %s buffer could not be resized sufficiently.\n"
-            "Target sock buff size: %d bytes.\n"
-            "Actual sock buff size: %d bytes.\n"
-            "See the transport application notes on buffer resizing.\n%s"
-        ) % name % target_size % actual_size % help_message;
+            << boost::format("Target/actual %s sock buff size: %d/%d bytes") % name
+                   % target_size % actual_size;
+        if (actual_size < target_size)
+            UHD_LOGGER_WARNING("UDP")
+                << boost::format(
+                       "The %s buffer could not be resized sufficiently.\n"
+                       "Target sock buff size: %d bytes.\n"
+                       "Actual sock buff size: %d bytes.\n"
+                       "See the transport application notes on buffer resizing.\n%s")
+                       % name % target_size % actual_size % help_message;
     }
 
     return actual_size;
 }
 
-udp_zero_copy::sptr udp_zero_copy::make(
-    const std::string &addr,
-    const std::string &port,
-    const zero_copy_xport_params &default_buff_args,
+udp_zero_copy::sptr udp_zero_copy::make(const std::string& addr,
+    const std::string& port,
+    const zero_copy_xport_params& default_buff_args,
     udp_zero_copy::buff_params& buff_params_out,
-    const device_addr_t &hints
-){
-    //Initialize xport_params
+    const device_addr_t& hints)
+{
+    // Initialize xport_params
     zero_copy_xport_params xport_params = default_buff_args;
 
-    xport_params.recv_frame_size = size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
-    xport_params.num_recv_frames = size_t(hints.cast<double>("num_recv_frames", default_buff_args.num_recv_frames));
-    xport_params.send_frame_size = size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
-    xport_params.num_send_frames = size_t(hints.cast<double>("num_send_frames", default_buff_args.num_send_frames));
-    xport_params.recv_buff_size = size_t(hints.cast<double>("recv_buff_size", default_buff_args.recv_buff_size));
-    xport_params.send_buff_size = size_t(hints.cast<double>("send_buff_size", default_buff_args.send_buff_size));
+    xport_params.recv_frame_size =
+        size_t(hints.cast<double>("recv_frame_size", default_buff_args.recv_frame_size));
+    xport_params.num_recv_frames =
+        size_t(hints.cast<double>("num_recv_frames", default_buff_args.num_recv_frames));
+    xport_params.send_frame_size =
+        size_t(hints.cast<double>("send_frame_size", default_buff_args.send_frame_size));
+    xport_params.num_send_frames =
+        size_t(hints.cast<double>("num_send_frames", default_buff_args.num_send_frames));
+    xport_params.recv_buff_size =
+        size_t(hints.cast<double>("recv_buff_size", default_buff_args.recv_buff_size));
+    xport_params.send_buff_size =
+        size_t(hints.cast<double>("send_buff_size", default_buff_args.send_buff_size));
 
     if (xport_params.num_recv_frames == 0) {
-        UHD_LOG_TRACE("UDP", "Default value for num_recv_frames: "
-            << UDP_ZERO_COPY_DEFAULT_NUM_FRAMES
-        );
+        UHD_LOG_TRACE("UDP",
+            "Default value for num_recv_frames: " << UDP_ZERO_COPY_DEFAULT_NUM_FRAMES);
         xport_params.num_recv_frames = UDP_ZERO_COPY_DEFAULT_NUM_FRAMES;
     }
     if (xport_params.num_send_frames == 0) {
-        UHD_LOG_TRACE("UDP", "Default value for no num_send_frames: "
-            << UDP_ZERO_COPY_DEFAULT_NUM_FRAMES
-        );
+        UHD_LOG_TRACE("UDP",
+            "Default value for no num_send_frames: " << UDP_ZERO_COPY_DEFAULT_NUM_FRAMES);
         xport_params.num_send_frames = UDP_ZERO_COPY_DEFAULT_NUM_FRAMES;
     }
     if (xport_params.recv_frame_size == 0) {
-        UHD_LOG_TRACE("UDP", "Using default value for  recv_frame_size: "
-            << UDP_ZERO_COPY_DEFAULT_FRAME_SIZE
-        );
+        UHD_LOG_TRACE("UDP",
+            "Using default value for  recv_frame_size: "
+                << UDP_ZERO_COPY_DEFAULT_FRAME_SIZE);
         xport_params.recv_frame_size = UDP_ZERO_COPY_DEFAULT_FRAME_SIZE;
     }
     if (xport_params.send_frame_size == 0) {
-        UHD_LOG_TRACE("UDP", "Using default value for send_frame_size, "
-            << UDP_ZERO_COPY_DEFAULT_FRAME_SIZE
-        );
+        UHD_LOG_TRACE("UDP",
+            "Using default value for send_frame_size, "
+                << UDP_ZERO_COPY_DEFAULT_FRAME_SIZE);
         xport_params.send_frame_size = UDP_ZERO_COPY_DEFAULT_FRAME_SIZE;
     }
 
     if (xport_params.recv_buff_size == 0) {
         UHD_LOG_TRACE("UDP", "Using default value for recv_buff_size");
-        xport_params.recv_buff_size = std::max(
-                UDP_ZERO_COPY_DEFAULT_BUFF_SIZE,
-                xport_params.num_recv_frames*MAX_ETHERNET_MTU
-            );
-        UHD_LOG_TRACE("UDP", "Using default value for recv_buff_size"
-            << xport_params.recv_buff_size
-        );
+        xport_params.recv_buff_size = std::max(UDP_ZERO_COPY_DEFAULT_BUFF_SIZE,
+            xport_params.num_recv_frames * MAX_ETHERNET_MTU);
+        UHD_LOG_TRACE("UDP",
+            "Using default value for recv_buff_size" << xport_params.recv_buff_size);
     }
     if (xport_params.send_buff_size == 0) {
         UHD_LOG_TRACE("UDP", "default_buff_args has no send_buff_size");
-        xport_params.send_buff_size = std::max(
-                UDP_ZERO_COPY_DEFAULT_BUFF_SIZE,
-                xport_params.num_send_frames*MAX_ETHERNET_MTU
-        );
+        xport_params.send_buff_size = std::max(UDP_ZERO_COPY_DEFAULT_BUFF_SIZE,
+            xport_params.num_send_frames * MAX_ETHERNET_MTU);
     }
 
-    #if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
-        //limit default buffer size on macos to avoid the warning issued by resize_buff_helper
-        if (not hints.has_key("recv_buff_size") and xport_params.recv_buff_size > MAX_BUFF_SIZE_ETH_MACOS)
-        {
-            xport_params.recv_buff_size = MAX_BUFF_SIZE_ETH_MACOS;
-        }
-        if (not hints.has_key("send_buff_size") and xport_params.send_buff_size > MAX_BUFF_SIZE_ETH_MACOS)
-        {
-            xport_params.send_buff_size = MAX_BUFF_SIZE_ETH_MACOS;
-        }
-    #endif
+#if defined(UHD_PLATFORM_MACOS) || defined(UHD_PLATFORM_BSD)
+    // limit default buffer size on macos to avoid the warning issued by
+    // resize_buff_helper
+    if (not hints.has_key("recv_buff_size")
+        and xport_params.recv_buff_size > MAX_BUFF_SIZE_ETH_MACOS) {
+        xport_params.recv_buff_size = MAX_BUFF_SIZE_ETH_MACOS;
+    }
+    if (not hints.has_key("send_buff_size")
+        and xport_params.send_buff_size > MAX_BUFF_SIZE_ETH_MACOS) {
+        xport_params.send_buff_size = MAX_BUFF_SIZE_ETH_MACOS;
+    }
+#endif
 
     udp_zero_copy_asio_impl::sptr udp_trans(
-        new udp_zero_copy_asio_impl(addr, port, xport_params)
-    );
-
-    //call the helper to resize send and recv buffers
-    buff_params_out.recv_buff_size = resize_buff_helper<asio::socket_base::receive_buffer_size>(
-        udp_trans, xport_params.recv_buff_size, "recv");
-    buff_params_out.send_buff_size = resize_buff_helper<asio::socket_base::send_buffer_size> (
-        udp_trans, xport_params.send_buff_size, "send");
-
-    if (buff_params_out.recv_buff_size < xport_params.num_recv_frames * MAX_ETHERNET_MTU){
-        UHD_LOG_WARNING("UDP", "The current recv_buff_size of " << xport_params.recv_buff_size
-                        << " is less than the minimum recommended size of "
-                        << xport_params.num_recv_frames * MAX_ETHERNET_MTU
-                        << " and may result in dropped packets on some NICs");
+        new udp_zero_copy_asio_impl(addr, port, xport_params));
+
+    // call the helper to resize send and recv buffers
+    buff_params_out.recv_buff_size =
+        resize_buff_helper<asio::socket_base::receive_buffer_size>(
+            udp_trans, xport_params.recv_buff_size, "recv");
+    buff_params_out.send_buff_size =
+        resize_buff_helper<asio::socket_base::send_buffer_size>(
+            udp_trans, xport_params.send_buff_size, "send");
+
+    if (buff_params_out.recv_buff_size
+        < xport_params.num_recv_frames * MAX_ETHERNET_MTU) {
+        UHD_LOG_WARNING("UDP",
+            "The current recv_buff_size of "
+                << xport_params.recv_buff_size
+                << " is less than the minimum recommended size of "
+                << xport_params.num_recv_frames * MAX_ETHERNET_MTU
+                << " and may result in dropped packets on some NICs");
     }
-    if (buff_params_out.send_buff_size < xport_params.num_send_frames * MAX_ETHERNET_MTU){
-        UHD_LOG_WARNING("UDP", "The current send_buff_size of " << xport_params.send_buff_size
-                        << " is less than the minimum recommended size of "
-                        << xport_params.num_send_frames * MAX_ETHERNET_MTU
-                        << " and may result in dropped packets on some NICs");
+    if (buff_params_out.send_buff_size
+        < xport_params.num_send_frames * MAX_ETHERNET_MTU) {
+        UHD_LOG_WARNING("UDP",
+            "The current send_buff_size of "
+                << xport_params.send_buff_size
+                << " is less than the minimum recommended size of "
+                << xport_params.num_send_frames * MAX_ETHERNET_MTU
+                << " and may result in dropped packets on some NICs");
     }
 
     return udp_trans;
diff --git a/host/lib/transport/usb_dummy_impl.cpp b/host/lib/transport/usb_dummy_impl.cpp
index 81aad97c6..8e5084a9b 100644
--- a/host/lib/transport/usb_dummy_impl.cpp
+++ b/host/lib/transport/usb_dummy_impl.cpp
@@ -5,44 +5,48 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <uhd/transport/usb_device_handle.hpp>
+#include <uhd/exception.hpp>
 #include <uhd/transport/usb_control.hpp>
+#include <uhd/transport/usb_device_handle.hpp>
 #include <uhd/transport/usb_zero_copy.hpp>
-#include <uhd/exception.hpp>
 
 using namespace uhd;
 using namespace uhd::transport;
 
-usb_control::~usb_control(void){
+usb_control::~usb_control(void)
+{
     /* NOP */
 }
 
-usb_device_handle::~usb_device_handle(void) {
+usb_device_handle::~usb_device_handle(void)
+{
     /* NOP */
 }
 
-usb_zero_copy::~usb_zero_copy(void) {
+usb_zero_copy::~usb_zero_copy(void)
+{
     /* NOP */
 }
 
-std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(uint16_t, uint16_t){
-    return std::vector<usb_device_handle::sptr>(); //empty list
+std::vector<usb_device_handle::sptr> usb_device_handle::get_device_list(
+    uint16_t, uint16_t)
+{
+    return std::vector<usb_device_handle::sptr>(); // empty list
 }
 
-usb_control::sptr usb_control::make(
-        usb_device_handle::sptr,
-        const int
-) {
-    throw uhd::not_implemented_error("no usb support -> usb_control::make not implemented");
+usb_control::sptr usb_control::make(usb_device_handle::sptr, const int)
+{
+    throw uhd::not_implemented_error(
+        "no usb support -> usb_control::make not implemented");
 }
 
-usb_zero_copy::sptr usb_zero_copy::make(
-    usb_device_handle::sptr,
+usb_zero_copy::sptr usb_zero_copy::make(usb_device_handle::sptr,
     const int,
     const unsigned char,
     const int,
     const unsigned char,
-    const device_addr_t &
-){
-    throw uhd::not_implemented_error("no usb support -> usb_zero_copy::make not implemented");
+    const device_addr_t&)
+{
+    throw uhd::not_implemented_error(
+        "no usb support -> usb_zero_copy::make not implemented");
 }
diff --git a/host/lib/transport/xport_benchmarker.cpp b/host/lib/transport/xport_benchmarker.cpp
index 0351d5106..67582ff2c 100644
--- a/host/lib/transport/xport_benchmarker.cpp
+++ b/host/lib/transport/xport_benchmarker.cpp
@@ -11,8 +11,7 @@
 
 namespace uhd { namespace transport {
 
-const device_addr_t& xport_benchmarker::benchmark_throughput_chdr
-(
+const device_addr_t& xport_benchmarker::benchmark_throughput_chdr(
     zero_copy_if::sptr tx_transport,
     zero_copy_if::sptr rx_transport,
     uint32_t sid,
@@ -24,8 +23,16 @@ const device_addr_t& xport_benchmarker::benchmark_throughput_chdr
     _reset_counters();
     boost::posix_time::ptime start_time(boost::posix_time::microsec_clock::local_time());
 
-    _tx_thread.reset(new boost::thread(boost::bind(&xport_benchmarker::_stream_tx, this, tx_transport.get(), &pkt_info, big_endian)));
-    _rx_thread.reset(new boost::thread(boost::bind(&xport_benchmarker::_stream_rx, this, rx_transport.get(), &pkt_info, big_endian)));
+    _tx_thread.reset(new boost::thread(boost::bind(&xport_benchmarker::_stream_tx,
+        this,
+        tx_transport.get(),
+        &pkt_info,
+        big_endian)));
+    _rx_thread.reset(new boost::thread(boost::bind(&xport_benchmarker::_stream_rx,
+        this,
+        rx_transport.get(),
+        &pkt_info,
+        big_endian)));
 
     std::this_thread::sleep_for(std::chrono::milliseconds(duration_ms));
 
@@ -35,17 +42,19 @@ const device_addr_t& xport_benchmarker::benchmark_throughput_chdr
     _rx_thread->join();
 
     boost::posix_time::ptime stop_time(boost::posix_time::microsec_clock::local_time());
-    double duration_s = ((double)(stop_time-start_time).total_microseconds())/1e6;
-
-    uint64_t tx_bytes = pkt_info.num_payload_words32*sizeof(uint32_t)*_num_tx_packets;
-    uint64_t rx_bytes = pkt_info.num_payload_words32*sizeof(uint32_t)*_num_rx_packets;
-    double tx_rate = (((double)tx_bytes)/duration_s);
-    double rx_rate = (((double)rx_bytes)/duration_s);
-
-    _results["TX-Bytes"] = (boost::format("%.2fMB") % (tx_bytes/(1024*1024))).str();
-    _results["RX-Bytes"] = (boost::format("%.2fMB") % (rx_bytes/(1024*1024))).str();
-    _results["TX-Throughput"] = (boost::format("%.2fMB/s") % (tx_rate/(1024*1024))).str();
-    _results["RX-Throughput"] = (boost::format("%.2fMB/s") % (rx_rate/(1024*1024))).str();
+    double duration_s = ((double)(stop_time - start_time).total_microseconds()) / 1e6;
+
+    uint64_t tx_bytes = pkt_info.num_payload_words32 * sizeof(uint32_t) * _num_tx_packets;
+    uint64_t rx_bytes = pkt_info.num_payload_words32 * sizeof(uint32_t) * _num_rx_packets;
+    double tx_rate    = (((double)tx_bytes) / duration_s);
+    double rx_rate    = (((double)rx_bytes) / duration_s);
+
+    _results["TX-Bytes"] = (boost::format("%.2fMB") % (tx_bytes / (1024 * 1024))).str();
+    _results["RX-Bytes"] = (boost::format("%.2fMB") % (rx_bytes / (1024 * 1024))).str();
+    _results["TX-Throughput"] =
+        (boost::format("%.2fMB/s") % (tx_rate / (1024 * 1024))).str();
+    _results["RX-Throughput"] =
+        (boost::format("%.2fMB/s") % (rx_rate / (1024 * 1024))).str();
     _results["TX-Timeouts"] = std::to_string(_num_tx_timeouts);
     _results["RX-Timeouts"] = std::to_string(_num_rx_timeouts);
     _results["Data-Errors"] = std::to_string(_num_data_errors);
@@ -53,20 +62,21 @@ const device_addr_t& xport_benchmarker::benchmark_throughput_chdr
     return _results;
 }
 
-void xport_benchmarker::_stream_tx(zero_copy_if* transport, vrt::if_packet_info_t* pkt_info, bool big_endian)
+void xport_benchmarker::_stream_tx(
+    zero_copy_if* transport, vrt::if_packet_info_t* pkt_info, bool big_endian)
 {
     while (not boost::this_thread::interruption_requested()) {
         managed_send_buffer::sptr buff = transport->get_send_buff(_tx_timeout);
         if (buff) {
-            uint32_t *packet_buff = buff->cast<uint32_t *>();
-            //Populate packet
+            uint32_t* packet_buff = buff->cast<uint32_t*>();
+            // Populate packet
             if (big_endian) {
                 vrt::if_hdr_pack_be(packet_buff, *pkt_info);
             } else {
                 vrt::if_hdr_pack_le(packet_buff, *pkt_info);
             }
-            //send the buffer over the interface
-            buff->commit(sizeof(uint32_t)*(pkt_info->num_packet_words32));
+            // send the buffer over the interface
+            buff->commit(sizeof(uint32_t) * (pkt_info->num_packet_words32));
             _num_tx_packets++;
         } else {
             _num_tx_timeouts++;
@@ -74,20 +84,21 @@ void xport_benchmarker::_stream_tx(zero_copy_if* transport, vrt::if_packet_info_
     }
 }
 
-void xport_benchmarker::_stream_rx(zero_copy_if* transport, const vrt::if_packet_info_t* exp_pkt_info, bool big_endian)
+void xport_benchmarker::_stream_rx(
+    zero_copy_if* transport, const vrt::if_packet_info_t* exp_pkt_info, bool big_endian)
 {
     while (not boost::this_thread::interruption_requested()) {
         managed_recv_buffer::sptr buff = transport->get_recv_buff(_rx_timeout);
         if (buff) {
-            //Extract packet info
+            // Extract packet info
             vrt::if_packet_info_t pkt_info;
-            pkt_info.link_type = exp_pkt_info->link_type;
-            pkt_info.num_packet_words32 = buff->size()/sizeof(uint32_t);
-            const uint32_t *packet_buff = buff->cast<const uint32_t *>();
+            pkt_info.link_type          = exp_pkt_info->link_type;
+            pkt_info.num_packet_words32 = buff->size() / sizeof(uint32_t);
+            const uint32_t* packet_buff = buff->cast<const uint32_t*>();
 
             _num_rx_packets++;
 
-            //unpacking can fail
+            // unpacking can fail
             try {
                 if (big_endian) {
                     vrt::if_hdr_unpack_be(packet_buff, pkt_info);
@@ -95,11 +106,11 @@ void xport_benchmarker::_stream_rx(zero_copy_if* transport, const vrt::if_packet
                     vrt::if_hdr_unpack_le(packet_buff, pkt_info);
                 }
 
-                if (exp_pkt_info->packet_type != pkt_info.packet_type ||
-                    exp_pkt_info->num_payload_bytes != pkt_info.num_payload_bytes) {
+                if (exp_pkt_info->packet_type != pkt_info.packet_type
+                    || exp_pkt_info->num_payload_bytes != pkt_info.num_payload_bytes) {
                     _num_data_errors++;
                 }
-            } catch(const std::exception &ex) {
+            } catch (const std::exception& ex) {
                 _num_data_errors++;
             }
         } else {
@@ -110,15 +121,14 @@ void xport_benchmarker::_stream_rx(zero_copy_if* transport, const vrt::if_packet
 
 void xport_benchmarker::_reset_counters(void)
 {
-    _num_tx_packets = 0;
-    _num_rx_packets = 0;
+    _num_tx_packets  = 0;
+    _num_rx_packets  = 0;
     _num_tx_timeouts = 0;
     _num_rx_timeouts = 0;
     _num_data_errors = 0;
 }
 
-void xport_benchmarker::_initialize_chdr(
-    zero_copy_if::sptr tx_transport,
+void xport_benchmarker::_initialize_chdr(zero_copy_if::sptr tx_transport,
     zero_copy_if::sptr rx_transport,
     uint32_t sid,
     vrt::if_packet_info_t& pkt_info)
@@ -126,22 +136,23 @@ void xport_benchmarker::_initialize_chdr(
     _tx_timeout = 0.5;
     _rx_timeout = 0.5;
 
-    size_t frame_size = std::min(tx_transport->get_send_frame_size(), rx_transport->get_recv_frame_size());
+    size_t frame_size = std::min(
+        tx_transport->get_send_frame_size(), rx_transport->get_recv_frame_size());
 
-    pkt_info.link_type = vrt::if_packet_info_t::LINK_TYPE_CHDR;
-    pkt_info.packet_type = vrt::if_packet_info_t::PACKET_TYPE_DATA;
-    pkt_info.num_packet_words32 = (frame_size/sizeof(uint32_t));
+    pkt_info.link_type           = vrt::if_packet_info_t::LINK_TYPE_CHDR;
+    pkt_info.packet_type         = vrt::if_packet_info_t::PACKET_TYPE_DATA;
+    pkt_info.num_packet_words32  = (frame_size / sizeof(uint32_t));
     pkt_info.num_payload_words32 = pkt_info.num_packet_words32 - 2;
-    pkt_info.num_payload_bytes = pkt_info.num_payload_words32*sizeof(uint32_t);
-    pkt_info.packet_count = 0;
-    pkt_info.sob = false;
-    pkt_info.eob = false;
-    pkt_info.sid = sid;
-    pkt_info.has_sid = true;
-    pkt_info.has_cid = false;
-    pkt_info.has_tsi = false;
-    pkt_info.has_tsf = false;
-    pkt_info.has_tlr = false;
+    pkt_info.num_payload_bytes   = pkt_info.num_payload_words32 * sizeof(uint32_t);
+    pkt_info.packet_count        = 0;
+    pkt_info.sob                 = false;
+    pkt_info.eob                 = false;
+    pkt_info.sid                 = sid;
+    pkt_info.has_sid             = true;
+    pkt_info.has_cid             = false;
+    pkt_info.has_tsi             = false;
+    pkt_info.has_tsf             = false;
+    pkt_info.has_tlr             = false;
 }
 
-}}
+}} // namespace uhd::transport
diff --git a/host/lib/transport/xport_benchmarker.hpp b/host/lib/transport/xport_benchmarker.hpp
index c9ddee0e3..bd12c0ad8 100644
--- a/host/lib/transport/xport_benchmarker.hpp
+++ b/host/lib/transport/xport_benchmarker.hpp
@@ -8,20 +8,20 @@
 #ifndef INCLUDED_LIBUHD_XPORT_BENCHMARKER_HPP
 #define INCLUDED_LIBUHD_XPORT_BENCHMARKER_HPP
 
+#include <uhd/transport/vrt_if_packet.hpp>
 #include <uhd/transport/zero_copy.hpp>
 #include <uhd/types/device_addr.hpp>
 #include <uhd/utils/log.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/thread/thread.hpp>
-#include <uhd/transport/vrt_if_packet.hpp>
 
 namespace uhd { namespace transport {
 
-//Test class to benchmark a low-level transport object with a VITA/C-VITA data stream
-class xport_benchmarker : boost::noncopyable {
+// Test class to benchmark a low-level transport object with a VITA/C-VITA data stream
+class xport_benchmarker : boost::noncopyable
+{
 public:
-    const device_addr_t& benchmark_throughput_chdr(
-        zero_copy_if::sptr tx_transport,
+    const device_addr_t& benchmark_throughput_chdr(zero_copy_if::sptr tx_transport,
         zero_copy_if::sptr rx_transport,
         uint32_t sid,
         bool big_endian,
@@ -29,39 +29,35 @@ public:
 
 private:
     void _stream_tx(
-        zero_copy_if* transport,
-        vrt::if_packet_info_t* pkt_info,
-        bool big_endian);
+        zero_copy_if* transport, vrt::if_packet_info_t* pkt_info, bool big_endian);
 
-    void _stream_rx(
-        zero_copy_if* transport,
+    void _stream_rx(zero_copy_if* transport,
         const vrt::if_packet_info_t* exp_pkt_info,
         bool big_endian);
 
-    void _initialize_chdr(
-        zero_copy_if::sptr tx_transport,
+    void _initialize_chdr(zero_copy_if::sptr tx_transport,
         zero_copy_if::sptr rx_transport,
         uint32_t sid,
         vrt::if_packet_info_t& pkt_info);
 
     void _reset_counters(void);
 
-    boost::shared_ptr<boost::thread>    _tx_thread;
-    boost::shared_ptr<boost::thread>    _rx_thread;
+    boost::shared_ptr<boost::thread> _tx_thread;
+    boost::shared_ptr<boost::thread> _rx_thread;
 
-    uint64_t     _num_tx_packets;
-    uint64_t     _num_rx_packets;
-    uint64_t     _num_tx_timeouts;
-    uint64_t     _num_rx_timeouts;
-    uint64_t     _num_data_errors;
+    uint64_t _num_tx_packets;
+    uint64_t _num_rx_packets;
+    uint64_t _num_tx_timeouts;
+    uint64_t _num_rx_timeouts;
+    uint64_t _num_data_errors;
 
-    double              _tx_timeout;
-    double              _rx_timeout;
+    double _tx_timeout;
+    double _rx_timeout;
 
-    device_addr_t       _results;
+    device_addr_t _results;
 };
 
 
-}} //namespace
+}} // namespace uhd::transport
 
 #endif /* INCLUDED_LIBUHD_XPORT_BENCHMARKER_HPP */
diff --git a/host/lib/transport/zero_copy_flow_ctrl.cpp b/host/lib/transport/zero_copy_flow_ctrl.cpp
index 25be35569..7d1ddd7e0 100644
--- a/host/lib/transport/zero_copy_flow_ctrl.cpp
+++ b/host/lib/transport/zero_copy_flow_ctrl.cpp
@@ -5,16 +5,16 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <uhd/transport/zero_copy_flow_ctrl.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
 #include <uhd/transport/buffer_pool.hpp>
+#include <uhd/transport/zero_copy_flow_ctrl.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/safe_call.hpp>
+#include <boost/bind.hpp>
 #include <boost/format.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/bind.hpp>
 
 using namespace uhd;
 using namespace uhd::transport;
@@ -24,11 +24,8 @@ typedef bounded_buffer<managed_send_buffer::sptr> bounded_buffer_t;
 class zero_copy_flow_ctrl_msb : public managed_send_buffer
 {
 public:
-    zero_copy_flow_ctrl_msb(
-        flow_ctrl_func flow_ctrl
-    ) :
-        _mb(nullptr),
-        _flow_ctrl(flow_ctrl)
+    zero_copy_flow_ctrl_msb(flow_ctrl_func flow_ctrl)
+        : _mb(nullptr), _flow_ctrl(flow_ctrl)
     {
         /* NOP */
     }
@@ -40,18 +37,18 @@ public:
 
     void release()
     {
-        if (_mb)
-        {
+        if (_mb) {
             _mb->commit(size());
-            while (_flow_ctrl and not _flow_ctrl(_mb)) {}
+            while (_flow_ctrl and not _flow_ctrl(_mb)) {
+            }
             _mb.reset();
         }
     }
 
-    UHD_INLINE sptr get(sptr &mb)
+    UHD_INLINE sptr get(sptr& mb)
     {
         _mb = mb;
-        return make(this, _mb->cast<void *>(), _mb->size());
+        return make(this, _mb->cast<void*>(), _mb->size());
     }
 
 private:
@@ -62,11 +59,7 @@ private:
 class zero_copy_flow_ctrl_mrb : public managed_recv_buffer
 {
 public:
-    zero_copy_flow_ctrl_mrb(
-        flow_ctrl_func flow_ctrl
-    ) :
-        _mb(NULL),
-        _flow_ctrl(flow_ctrl)
+    zero_copy_flow_ctrl_mrb(flow_ctrl_func flow_ctrl) : _mb(NULL), _flow_ctrl(flow_ctrl)
     {
         /* NOP */
     }
@@ -78,17 +71,17 @@ public:
 
     void release()
     {
-        if (_mb)
-        {
+        if (_mb) {
             _mb.reset();
         }
     }
 
-    UHD_INLINE sptr get(sptr &mb)
+    UHD_INLINE sptr get(sptr& mb)
     {
         _mb = mb;
-        while (_flow_ctrl and not _flow_ctrl(_mb)) {}
-        return make(this, _mb->cast<void *>(), _mb->size());
+        while (_flow_ctrl and not _flow_ctrl(_mb)) {
+        }
+        return make(this, _mb->cast<void*>(), _mb->size());
     }
 
 private:
@@ -101,36 +94,35 @@ private:
  * An intermediate transport that utilizes threading to free
  * the main thread from any receive work.
  **********************************************************************/
-class zero_copy_flow_ctrl_impl : public zero_copy_flow_ctrl {
+class zero_copy_flow_ctrl_impl : public zero_copy_flow_ctrl
+{
 public:
     typedef boost::shared_ptr<zero_copy_flow_ctrl_impl> sptr;
 
     zero_copy_flow_ctrl_impl(zero_copy_if::sptr transport,
         flow_ctrl_func send_flow_ctrl,
-        flow_ctrl_func recv_flow_ctrl) :
-        _transport(transport),
-        _send_buffers(transport->get_num_send_frames()),
-        _recv_buffers(transport->get_num_recv_frames()),
-        _send_buff_index(0),
-        _recv_buff_index(0),
-        _send_flow_ctrl(send_flow_ctrl),
-        _recv_flow_ctrl(recv_flow_ctrl)
+        flow_ctrl_func recv_flow_ctrl)
+        : _transport(transport)
+        , _send_buffers(transport->get_num_send_frames())
+        , _recv_buffers(transport->get_num_recv_frames())
+        , _send_buff_index(0)
+        , _recv_buff_index(0)
+        , _send_flow_ctrl(send_flow_ctrl)
+        , _recv_flow_ctrl(recv_flow_ctrl)
     {
         UHD_LOG_TRACE("TRANSPORT", "Created zero_copy_flow_ctrl");
 
-        for (size_t i = 0; i < transport->get_num_send_frames(); i++)
-        {
-            _send_buffers[i] = boost::make_shared<zero_copy_flow_ctrl_msb>(_send_flow_ctrl);
+        for (size_t i = 0; i < transport->get_num_send_frames(); i++) {
+            _send_buffers[i] =
+                boost::make_shared<zero_copy_flow_ctrl_msb>(_send_flow_ctrl);
         }
-        for (size_t i = 0; i < transport->get_num_recv_frames(); i++)
-        {
-            _recv_buffers[i] = boost::make_shared<zero_copy_flow_ctrl_mrb>(_recv_flow_ctrl);
+        for (size_t i = 0; i < transport->get_num_recv_frames(); i++) {
+            _recv_buffers[i] =
+                boost::make_shared<zero_copy_flow_ctrl_mrb>(_recv_flow_ctrl);
         }
     }
 
-    ~zero_copy_flow_ctrl_impl()
-    {
-    }
+    ~zero_copy_flow_ctrl_impl() {}
 
     /*******************************************************************
      * Receive implementation:
@@ -140,9 +132,9 @@ public:
     {
         managed_recv_buffer::sptr ptr;
         managed_recv_buffer::sptr buff = _transport->get_recv_buff(timeout);
-        if (buff)
-        {
-            boost::shared_ptr<zero_copy_flow_ctrl_mrb> mb = _recv_buffers[_recv_buff_index++];
+        if (buff) {
+            boost::shared_ptr<zero_copy_flow_ctrl_mrb> mb =
+                _recv_buffers[_recv_buff_index++];
             _recv_buff_index %= _recv_buffers.size();
             ptr = mb->get(buff);
         }
@@ -167,9 +159,9 @@ public:
     {
         managed_send_buffer::sptr ptr;
         managed_send_buffer::sptr buff = _transport->get_send_buff(timeout);
-        if (buff)
-        {
-            boost::shared_ptr<zero_copy_flow_ctrl_msb> mb = _send_buffers[_send_buff_index++];
+        if (buff) {
+            boost::shared_ptr<zero_copy_flow_ctrl_msb> mb =
+                _send_buffers[_send_buff_index++];
             _send_buff_index %= _send_buffers.size();
             ptr = mb->get(buff);
         }
@@ -191,8 +183,8 @@ private:
     zero_copy_if::sptr _transport;
 
     // buffers
-    std::vector< boost::shared_ptr<zero_copy_flow_ctrl_msb> > _send_buffers;
-    std::vector< boost::shared_ptr<zero_copy_flow_ctrl_mrb> > _recv_buffers;
+    std::vector<boost::shared_ptr<zero_copy_flow_ctrl_msb>> _send_buffers;
+    std::vector<boost::shared_ptr<zero_copy_flow_ctrl_mrb>> _recv_buffers;
     size_t _send_buff_index;
     size_t _recv_buff_index;
 
@@ -201,15 +193,12 @@ private:
     flow_ctrl_func _recv_flow_ctrl;
 };
 
-zero_copy_flow_ctrl::sptr zero_copy_flow_ctrl::make(
-        zero_copy_if::sptr transport,
-        flow_ctrl_func send_flow_ctrl,
-        flow_ctrl_func recv_flow_ctrl
-)
+zero_copy_flow_ctrl::sptr zero_copy_flow_ctrl::make(zero_copy_if::sptr transport,
+    flow_ctrl_func send_flow_ctrl,
+    flow_ctrl_func recv_flow_ctrl)
 {
     zero_copy_flow_ctrl_impl::sptr zero_copy_flow_ctrl(
-        new zero_copy_flow_ctrl_impl(transport, send_flow_ctrl, recv_flow_ctrl)
-    );
+        new zero_copy_flow_ctrl_impl(transport, send_flow_ctrl, recv_flow_ctrl));
 
     return zero_copy_flow_ctrl;
 }
diff --git a/host/lib/transport/zero_copy_recv_offload.cpp b/host/lib/transport/zero_copy_recv_offload.cpp
index 4a8a07a0c..7329dbdf3 100644
--- a/host/lib/transport/zero_copy_recv_offload.cpp
+++ b/host/lib/transport/zero_copy_recv_offload.cpp
@@ -5,18 +5,17 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 //
 
-#include <uhd/transport/zero_copy_recv_offload.hpp>
 #include <uhd/transport/bounded_buffer.hpp>
 #include <uhd/transport/buffer_pool.hpp>
-
+#include <uhd/transport/zero_copy_recv_offload.hpp>
 #include <uhd/utils/log.hpp>
 #include <uhd/utils/safe_call.hpp>
 #include <uhd/utils/thread.hpp>
+#include <boost/bind.hpp>
 #include <boost/format.hpp>
 #include <boost/make_shared.hpp>
 #include <boost/thread/mutex.hpp>
 #include <boost/thread/thread.hpp>
-#include <boost/bind.hpp>
 
 using namespace uhd;
 using namespace uhd::transport;
@@ -28,23 +27,23 @@ typedef bounded_buffer<managed_recv_buffer::sptr> bounded_buffer_t;
  * An intermediate transport that utilizes threading to free
  * the main thread from any receive work.
  **********************************************************************/
-class zero_copy_recv_offload_impl : public zero_copy_recv_offload {
+class zero_copy_recv_offload_impl : public zero_copy_recv_offload
+{
 public:
     typedef boost::shared_ptr<zero_copy_recv_offload_impl> sptr;
 
-    zero_copy_recv_offload_impl(zero_copy_if::sptr transport,
-                          const double timeout) :
-        _transport(transport), _timeout(timeout),
-        _inbox(transport->get_num_recv_frames()),
-        _recv_done(false)
+    zero_copy_recv_offload_impl(zero_copy_if::sptr transport, const double timeout)
+        : _transport(transport)
+        , _timeout(timeout)
+        , _inbox(transport->get_num_recv_frames())
+        , _recv_done(false)
     {
-        UHD_LOGGER_TRACE("XPORT") << "Created threaded transport" ;
+        UHD_LOGGER_TRACE("XPORT") << "Created threaded transport";
 
         // Create the receive and send threads to offload
         // the system calls onto other threads
-        _recv_thread = boost::thread(
-            boost::bind(&zero_copy_recv_offload_impl::enqueue_recv, this)
-        );
+        _recv_thread =
+            boost::thread(boost::bind(&zero_copy_recv_offload_impl::enqueue_recv, this));
         set_thread_name(&_recv_thread, "zero_copy_recv");
     }
 
@@ -67,9 +66,7 @@ public:
         set_recv_done();
 
         // Wait for them to join
-        UHD_SAFE_CALL(
-            _recv_thread.join();
-        )
+        UHD_SAFE_CALL(_recv_thread.join();)
     }
 
     // The receive thread function is responsible for
@@ -78,7 +75,8 @@ public:
     {
         while (not is_recv_done()) {
             managed_recv_buffer::sptr buff = _transport->get_recv_buff(_timeout);
-            if (not buff) continue;
+            if (not buff)
+                continue;
             _inbox.push_with_timed_wait(buff, _timeout);
         }
     }
@@ -135,16 +133,14 @@ private:
     // Threading
     bool _recv_done;
     boost::thread _recv_thread;
-    boost::mutex  _recv_mutex;
+    boost::mutex _recv_mutex;
 };
 
 zero_copy_recv_offload::sptr zero_copy_recv_offload::make(
-        zero_copy_if::sptr transport,
-        const double timeout)
+    zero_copy_if::sptr transport, const double timeout)
 {
     zero_copy_recv_offload_impl::sptr zero_copy_recv_offload(
-        new zero_copy_recv_offload_impl(transport, timeout)
-    );
+        new zero_copy_recv_offload_impl(transport, timeout));
 
     return zero_copy_recv_offload;
 }