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
//

#ifndef INCLUDED_UHD_TRANSPORT_ZERO_COPY_HPP
#define INCLUDED_UHD_TRANSPORT_ZERO_COPY_HPP

#include <uhd/config.hpp>
#include <uhd/utils/noncopyable.hpp>
#include <boost/detail/atomic_count.hpp>
#include <boost/intrusive_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>

namespace uhd { namespace transport {

class UHD_API managed_buffer
{
public:
    managed_buffer(void) : _ref_count(0), _buffer(NULL), _length(0)
    {
#ifdef UHD_TXRX_DEBUG_PRINTS
        _mb_num = s_buffer_count;
        // From Boost website: atomic_count seems only to have precrement operator.
        ++s_buffer_count;
#endif
    }

    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;
    }

#ifdef UHD_TXRX_DEBUG_PRINTS
    int num() const
    {
        return _mb_num;
    }
#endif

protected:
    void* _buffer;
    size_t _length;
#ifdef UHD_TXRX_DEBUG_PRINTS
    int _mb_num;
#endif

private:
#ifdef UHD_TXRX_DEBUG_PRINTS
    static boost::detail::atomic_count s_buffer_count;
#endif
};

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 boost::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

#endif /* INCLUDED_UHD_TRANSPORT_ZERO_COPY_HPP */