zero_copy.hpp

Go to the documentation of this file.

//
// Copyright 2010-2012,2015 Ettus Research LLC
// Copyright 2018 Ettus Research, a National Instruments Company
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#pragma once
 
#include <uhd/config.hpp>
#include <uhd/utils/noncopyable.hpp>
#include <boost/detail/atomic_count.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/utility.hpp>
#include <memory>
 
namespace uhd { namespace transport {
 
class UHD_API managed_buffer
{
public:
    managed_buffer(void) : _ref_count(0), _buffer(NULL), _length(0) {}
 
    virtual ~managed_buffer(void) {}
 
    virtual void release(void) = 0;
 
    UHD_INLINE void commit(size_t num_bytes)
    {
        _length = num_bytes;
    }
 
    template <class T>
    UHD_INLINE T cast(void) const
    {
        return static_cast<T>(_buffer);
    }
 
    UHD_INLINE size_t size(void) const
    {
        return _length;
    }
 
    template <typename T>
    UHD_INLINE boost::intrusive_ptr<T> make(T* p, void* buffer, size_t length)
    {
        _buffer = buffer;
        _length = length;
        return boost::intrusive_ptr<T>(p);
    }
 
    boost::detail::atomic_count _ref_count;
    typedef boost::intrusive_ptr<managed_buffer> sptr;
 
    int ref_count()
    {
        return (int)_ref_count;
    }
 
protected:
    void* _buffer;
    size_t _length;
 
private:
};
 
UHD_INLINE void intrusive_ptr_add_ref(managed_buffer* p)
{
    ++(p->_ref_count);
}
 
UHD_INLINE void intrusive_ptr_release(managed_buffer* p)
{
    if (--(p->_ref_count) == 0)
        p->release();
}
 
class UHD_API managed_recv_buffer : public managed_buffer
{
public:
    typedef boost::intrusive_ptr<managed_recv_buffer> sptr;
};
 
class UHD_API managed_send_buffer : public managed_buffer
{
public:
    typedef boost::intrusive_ptr<managed_send_buffer> sptr;
};
 
struct zero_copy_xport_params
{
    zero_copy_xport_params()
        : recv_frame_size(0)
        , send_frame_size(0)
        , num_recv_frames(0)
        , num_send_frames(0)
        , recv_buff_size(0)
        , send_buff_size(0)
    { /* NOP */
    }
    size_t recv_frame_size;
    size_t send_frame_size;
    size_t num_recv_frames;
    size_t num_send_frames;
    size_t recv_buff_size;
    size_t send_buff_size;
};
 
class UHD_API zero_copy_if : uhd::noncopyable
{
public:
    typedef std::shared_ptr<zero_copy_if> sptr;
 
    virtual ~zero_copy_if(){};
 
    virtual managed_recv_buffer::sptr get_recv_buff(double timeout = 0.1) = 0;
 
    virtual size_t get_num_recv_frames(void) const = 0;
 
    virtual size_t get_recv_frame_size(void) const = 0;
 
    virtual managed_send_buffer::sptr get_send_buff(double timeout = 0.1) = 0;
 
    virtual size_t get_num_send_frames(void) const = 0;
 
    virtual size_t get_send_frame_size(void) const = 0;
};
 
}} // namespace uhd::transport