From d0039bd4128eed56acccce7b20c913afa8cb7381 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Tue, 8 Jun 2010 00:00:54 -0700 Subject: Replaced convert types with generated convert types that handles more cases. Added unit test for generated converter. --- host/lib/transport/CMakeLists.txt | 6 +- host/lib/transport/convert_types.cpp | 153 -------------------------- host/lib/transport/gen_convert_types.py | 189 ++++++++++++++++++++++++++++++++ host/lib/usrp/dsp_utils.hpp | 9 +- 4 files changed, 198 insertions(+), 159 deletions(-) delete mode 100644 host/lib/transport/convert_types.cpp create mode 100755 host/lib/transport/gen_convert_types.py (limited to 'host/lib') diff --git a/host/lib/transport/CMakeLists.txt b/host/lib/transport/CMakeLists.txt index a74f7d527..872865d6c 100644 --- a/host/lib/transport/CMakeLists.txt +++ b/host/lib/transport/CMakeLists.txt @@ -44,8 +44,12 @@ LIBUHD_PYTHON_GEN_SOURCE( ${CMAKE_BINARY_DIR}/lib/transport/vrt.cpp ) +LIBUHD_PYTHON_GEN_SOURCE( + ${CMAKE_SOURCE_DIR}/lib/transport/gen_convert_types.py + ${CMAKE_BINARY_DIR}/lib/transport/convert_types.cpp +) + LIBUHD_APPEND_SOURCES( - ${CMAKE_SOURCE_DIR}/lib/transport/convert_types.cpp ${CMAKE_SOURCE_DIR}/lib/transport/if_addrs.cpp ${CMAKE_SOURCE_DIR}/lib/transport/udp_simple.cpp ${CMAKE_SOURCE_DIR}/lib/transport/udp_zero_copy_asio.cpp diff --git a/host/lib/transport/convert_types.cpp b/host/lib/transport/convert_types.cpp deleted file mode 100644 index 374479eee..000000000 --- a/host/lib/transport/convert_types.cpp +++ /dev/null @@ -1,153 +0,0 @@ -// -// Copyright 2010 Ettus Research LLC -// -// This program is free software: you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program. If not, see . -// - -#include -#include -#include -#include //endianness conversion -#include -#include -#include - -using namespace uhd; - -/*********************************************************************** - * Constants - **********************************************************************/ -typedef std::complex fc32_t; - -static const float shorts_per_float = float(1 << 15); -static const float floats_per_short = float(1.0/shorts_per_float); - -#define unrolled_loop(__inst, __len){ \ - size_t __i = 0; \ - for(; __i < (__len & ~0x3); __i+= 4){ \ - __inst(__i+0); __inst(__i+1); \ - __inst(__i+2); __inst(__i+3); \ - } \ - for(; __i < __len; __i++){ \ - __inst(__i); \ - } \ -} - -// set a boolean flag that indicates the endianess -#ifdef BOOST_BIG_ENDIAN -static const bool is_big_endian = true; -#else -static const bool is_big_endian = false; -#endif - -static UHD_INLINE void host_floats_to_usrp2_items( - boost::uint32_t *usrp2_items, - const fc32_t *host_floats, - size_t num_samps -){ - #define host_floats_to_usrp2_items_i(i){ \ - boost::uint16_t real = boost::int16_t(host_floats[i].real()*shorts_per_float); \ - boost::uint16_t imag = boost::int16_t(host_floats[i].imag()*shorts_per_float); \ - usrp2_items[i] = htonl((real << 16) | (imag << 0)); \ - } - unrolled_loop(host_floats_to_usrp2_items_i, num_samps); -} - -static UHD_INLINE void usrp2_items_to_host_floats( - fc32_t *host_floats, - const boost::uint32_t *usrp2_items, - size_t num_samps -){ - #define usrp2_items_to_host_floats_i(i){ \ - boost::uint32_t item = ntohl(usrp2_items[i]); \ - boost::int16_t real = boost::uint16_t(item >> 16); \ - boost::int16_t imag = boost::uint16_t(item >> 0); \ - host_floats[i] = fc32_t(float(real*floats_per_short), float(imag*floats_per_short)); \ - } - unrolled_loop(usrp2_items_to_host_floats_i, num_samps); -} - -static UHD_INLINE void host_items_to_usrp2_items( - boost::uint32_t *usrp2_items, - const boost::uint32_t *host_items, - size_t num_samps -){ - #define host_items_to_usrp2_items_i(i) usrp2_items[i] = htonl(host_items[i]) - if (is_big_endian){ - std::memcpy(usrp2_items, host_items, num_samps*sizeof(boost::uint32_t)); - } - else{ - unrolled_loop(host_items_to_usrp2_items_i, num_samps); - } -} - -static UHD_INLINE void usrp2_items_to_host_items( - boost::uint32_t *host_items, - const boost::uint32_t *usrp2_items, - size_t num_samps -){ - #define usrp2_items_to_host_items_i(i) host_items[i] = ntohl(usrp2_items[i]) - if (is_big_endian){ - std::memcpy(host_items, usrp2_items, num_samps*sizeof(boost::uint32_t)); - } - else{ - unrolled_loop(usrp2_items_to_host_items_i, num_samps); - } -} - -void transport::convert_io_type_to_otw_type( - const void *io_buff, const io_type_t &io_type, - void *otw_buff, const otw_type_t &otw_type, - size_t num_samps -){ - //all we handle for now: - UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN); - - switch(io_type.tid){ - case io_type_t::COMPLEX_FLOAT32: - host_floats_to_usrp2_items((boost::uint32_t *)otw_buff, (const fc32_t*)io_buff, num_samps); - return; - case io_type_t::COMPLEX_INT16: - host_items_to_usrp2_items((boost::uint32_t *)otw_buff, (const boost::uint32_t*)io_buff, num_samps); - return; - case io_type_t::CUSTOM_TYPE: - std::memcpy(otw_buff, io_buff, num_samps*io_type.size); - return; - default: - throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid)); - } -} - -void transport::convert_otw_type_to_io_type( - const void *otw_buff, const otw_type_t &otw_type, - void *io_buff, const io_type_t &io_type, - size_t num_samps -){ - //all we handle for now: - UHD_ASSERT_THROW(otw_type.width == 16 and otw_type.byteorder == otw_type_t::BO_BIG_ENDIAN); - - switch(io_type.tid){ - case io_type_t::COMPLEX_FLOAT32: - usrp2_items_to_host_floats((fc32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps); - return; - case io_type_t::COMPLEX_INT16: - usrp2_items_to_host_items((boost::uint32_t*)io_buff, (const boost::uint32_t *)otw_buff, num_samps); - return; - case io_type_t::CUSTOM_TYPE: - std::memcpy(io_buff, otw_buff, num_samps*io_type.size); - return; - default: - throw std::runtime_error(str(boost::format("convert_types: cannot handle type \"%c\"") % io_type.tid)); - } -} diff --git a/host/lib/transport/gen_convert_types.py b/host/lib/transport/gen_convert_types.py new file mode 100755 index 000000000..1b6b71e00 --- /dev/null +++ b/host/lib/transport/gen_convert_types.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python +# +# Copyright 2010 Ettus Research LLC +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . +# + +TMPL_TEXT = """ +#import time +/*********************************************************************** + * This file was generated by $file on $time.strftime("%c") + **********************************************************************/ + +\#include +\#include +\#include +\#include +\#include +\#include +\#include + +//define the endian macros to convert integers +\#ifdef BOOST_BIG_ENDIAN + \#define BE_MACRO(x) x + \#define LE_MACRO(x) uhd::byteswap(x) + static const bool is_big_endian = true; +\#else + \#define BE_MACRO(x) uhd::byteswap(x) + \#define LE_MACRO(x) x + static const bool is_big_endian = false; +\#endif + +using namespace uhd; + +/*********************************************************************** + * Constants + **********************************************************************/ +typedef std::complex fc32_t; +typedef std::complex sc16_t; +typedef boost::uint32_t item32_t; + +static const float shorts_per_float = float(32767); +static const float floats_per_short = float(1.0/shorts_per_float); + +/*********************************************************************** + * Single-sample converters + **********************************************************************/ +template +static UHD_INLINE outptr_type conv_ptr(inptr_type inptr){ + return reinterpret_cast(inptr); +} + +static UHD_INLINE item32_t sc16_to_item32(sc16_t num){ + return *conv_ptr(&num); +} + +static UHD_INLINE sc16_t item32_to_sc16(item32_t item){ + return *conv_ptr(&item); +} + +static UHD_INLINE item32_t fc32_to_item32(fc32_t num){ + return sc16_to_item32(sc16_t( + boost::int16_t(num.real()*shorts_per_float), + boost::int16_t(num.imag()*shorts_per_float) + )); +} + +static UHD_INLINE fc32_t item32_to_fc32(item32_t item){ + sc16_t num = item32_to_sc16(item); return fc32_t( + float(num.real()*floats_per_short), + float(num.imag()*floats_per_short) + ); +} + +/*********************************************************************** + * Sample-buffer converters + **********************************************************************/ +UHD_INLINE boost::uint8_t get_pred( + const io_type_t &io_type, + const otw_type_t &otw_type +){ + boost::uint8_t pred = 0; + + switch(otw_type.byteorder){ + case otw_type_t::BO_BIG_ENDIAN: pred |= $ph.be_p; break; + case otw_type_t::BO_LITTLE_ENDIAN: pred |= $ph.le_p; break; + ##let the compiler determine the native byte order (we could use python sys.byteorder) + case otw_type_t::BO_NATIVE: pred |= (is_big_endian)? $ph.be_p : $ph.le_p; break; + default: throw std::runtime_error("unhandled byteorder type"); + } + + switch(otw_type.width){ + case 16: pred |= $ph.w16_p; break; + default: throw std::runtime_error("unhandled bit width"); + } + + switch(io_type.tid){ + case io_type_t::COMPLEX_INT16: pred |= $ph.sc16_p; break; + case io_type_t::COMPLEX_FLOAT32: pred |= $ph.fc32_p; break; + default: throw std::runtime_error("unhandled io type id"); + } + + return pred; +} + +void transport::convert_io_type_to_otw_type( + const void *io_buff, const io_type_t &io_type, + void *otw_buff, const otw_type_t &otw_type, + size_t num_samps +){ + switch(get_pred(io_type, otw_type)){ + #for $pred in range(4) + case $pred: + #set $out_type = $ph.get_dev_type($pred) + #set $in_type = $ph.get_host_type($pred) + #set $converter = $in_type+"_to_"+$out_type + #set $xe_macro = $ph.get_xe_macro($pred) + for (size_t i = 0; i < num_samps; i++){ + (($(out_type)_t *)otw_buff)[i] = $(xe_macro)($(converter)(((const $(in_type)_t *)io_buff)[i])); + } + break; + #end for + } +} + +void transport::convert_otw_type_to_io_type( + const void *otw_buff, const otw_type_t &otw_type, + void *io_buff, const io_type_t &io_type, + size_t num_samps +){ + switch(get_pred(io_type, otw_type)){ + #for $pred in range(4) + case $pred: + #set $out_type = $ph.get_host_type($pred) + #set $in_type = $ph.get_dev_type($pred) + #set $converter = $in_type+"_to_"+$out_type + #set $xe_macro = $ph.get_xe_macro($pred) + for (size_t i = 0; i < num_samps; i++){ + (($(out_type)_t *)io_buff)[i] = $(converter)($(xe_macro)(((const $(in_type)_t *)otw_buff)[i])); + } + break; + #end for + } +} + +""" + +def parse_tmpl(_tmpl_text, **kwargs): + from Cheetah.Template import Template + return str(Template(_tmpl_text, kwargs)) + +class ph: + be_p = 0b00001 + le_p = 0b00000 + w16_p = 0b00000 + sc16_p = 0b00010 + fc32_p = 0b00000 + + @staticmethod + def get_xe_macro(pred): + if (pred & ph.be_p) == ph.be_p: return 'BE_MACRO' + if (pred & ph.le_p) == ph.le_p: return 'LE_MACRO' + raise NotImplementedError + + @staticmethod + def get_dev_type(pred): + if (pred & ph.w16_p) == ph.w16_p: return 'item32' + raise NotImplementedError + + @staticmethod + def get_host_type(pred): + if (pred & ph.sc16_p) == ph.sc16_p: return 'sc16' + if (pred & ph.fc32_p) == ph.fc32_p: return 'fc32' + raise NotImplementedError + +if __name__ == '__main__': + import sys + open(sys.argv[1], 'w').write(parse_tmpl(TMPL_TEXT, file=__file__, ph=ph)) diff --git a/host/lib/usrp/dsp_utils.hpp b/host/lib/usrp/dsp_utils.hpp index 8a6afb292..cfe5375f8 100644 --- a/host/lib/usrp/dsp_utils.hpp +++ b/host/lib/usrp/dsp_utils.hpp @@ -81,15 +81,14 @@ namespace dsp_type1{ /*! * Calculate the IQ scale factor word from I and Q components. - * \param i the I component - * \param q the Q component + * \param i the I component of the scalar + * \param q the Q component of the scalar * \return the 32-bit scale factor control word */ static inline boost::uint32_t calc_iq_scale_word( - boost::int16_t i, - boost::int16_t q + boost::int16_t i, boost::int16_t q ){ - return (boost::uint16_t(i) << 16) | (boost::uint16_t(q) << 0); + return (boost::uint32_t(i) << 16) | (boost::uint32_t(q) << 0); } /*! -- cgit v1.2.3