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 +- host/test/CMakeLists.txt | 1 + host/test/convert_types_test.cpp | 123 +++++++++++++++++++++ 6 files changed, 322 insertions(+), 159 deletions(-) delete mode 100644 host/lib/transport/convert_types.cpp create mode 100755 host/lib/transport/gen_convert_types.py create mode 100644 host/test/convert_types_test.cpp 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); } /*! diff --git a/host/test/CMakeLists.txt b/host/test/CMakeLists.txt index 7fd3dd401..74f3376e6 100644 --- a/host/test/CMakeLists.txt +++ b/host/test/CMakeLists.txt @@ -23,6 +23,7 @@ ADD_EXECUTABLE(main_test addr_test.cpp buffer_test.cpp byteswap_test.cpp + convert_types_test.cpp dict_test.cpp error_test.cpp gain_handler_test.cpp diff --git a/host/test/convert_types_test.cpp b/host/test/convert_types_test.cpp new file mode 100644 index 000000000..096da441b --- /dev/null +++ b/host/test/convert_types_test.cpp @@ -0,0 +1,123 @@ +// +// 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 + +using namespace uhd; + +template +void loopback( + const io_type_t &io_type, + const otw_type_t &otw_type, + const host_type *input, + host_type *output +){ + dev_type dev[nsamps]; + + //convert to dev type + transport::convert_io_type_to_otw_type( + input, io_type, + dev, otw_type, + nsamps + ); + + //convert back to host type + transport::convert_otw_type_to_io_type( + dev, otw_type, + output, io_type, + nsamps + ); +} + +typedef std::complex sc16_t; + +BOOST_AUTO_TEST_CASE(test_convert_types_be_sc16){ + sc16_t in_sc16[] = { + sc16_t(0, -1234), sc16_t(4321, 1234), + sc16_t(9876, -4567), sc16_t(8912, 0) + }, out_sc16[4]; + + io_type_t io_type(io_type_t::COMPLEX_INT16); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN; + otw_type.width = 16; + + loopback(io_type, otw_type, in_sc16, out_sc16); + BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4); +} + +BOOST_AUTO_TEST_CASE(test_convert_types_le_sc16){ + sc16_t in_sc16[] = { + sc16_t(0, -1234), sc16_t(4321, 1234), + sc16_t(9876, -4567), sc16_t(8912, 0) + }, out_sc16[4]; + + io_type_t io_type(io_type_t::COMPLEX_INT16); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN; + otw_type.width = 16; + + loopback(io_type, otw_type, in_sc16, out_sc16); + BOOST_CHECK_EQUAL_COLLECTIONS(in_sc16, in_sc16+4, out_sc16, out_sc16+4); +} + +typedef std::complex fc32_t; + +#define BOOST_CHECK_CLOSE_COMPLEX(a1, a2, p) \ + BOOST_CHECK_CLOSE(a1.real(), a2.real(), p); \ + BOOST_CHECK_CLOSE(a1.imag(), a2.imag(), p); + +BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){ + fc32_t in_fc32[] = { + fc32_t(0, -0.2), fc32_t(0.03, -0.16), + fc32_t(1.0, .45), fc32_t(0.09, 0) + }, out_fc32[4]; + + io_type_t io_type(io_type_t::COMPLEX_FLOAT32); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_BIG_ENDIAN; + otw_type.width = 16; + + loopback(io_type, otw_type, in_fc32, out_fc32); + + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); +} + +BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){ + fc32_t in_fc32[] = { + fc32_t(0, -0.2), fc32_t(0.03, -0.16), + fc32_t(1.0, .45), fc32_t(0.09, 0) + }, out_fc32[4]; + + io_type_t io_type(io_type_t::COMPLEX_FLOAT32); + otw_type_t otw_type; + otw_type.byteorder = otw_type_t::BO_LITTLE_ENDIAN; + otw_type.width = 16; + + loopback(io_type, otw_type, in_fc32, out_fc32); + + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); +} -- cgit v1.2.3 From c0ed726125550a1d7dfdad4fb2cc61cd17ca2d89 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Tue, 8 Jun 2010 10:49:40 -0700 Subject: fix to ensure 32 bit swap is called on a 64 bit machine --- host/lib/transport/gen_vrt.py | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/host/lib/transport/gen_vrt.py b/host/lib/transport/gen_vrt.py index 1417240ab..6cac2ae08 100755 --- a/host/lib/transport/gen_vrt.py +++ b/host/lib/transport/gen_vrt.py @@ -44,8 +44,6 @@ TMPL_TEXT = """ \#define LE_MACRO(x) (x) \#endif -#set $XE_MACRO = "BE_MACRO" - using namespace uhd; using namespace uhd::transport; @@ -130,10 +128,11 @@ void vrt::pack_$(suffix)( if (metadata.end_of_burst) vrt_hdr_flags |= $hex(0x1 << 24); //fill in complete header word - header_buff[0] = $(XE_MACRO)(vrt_hdr_flags | - ((packet_count & 0xf) << 16) | - (num_packet_words32 & 0xffff) - ); + header_buff[0] = $(XE_MACRO)(boost::uint32_t(0 + | vrt_hdr_flags + | ((packet_count & 0xf) << 16) + | (num_packet_words32 & 0xffff) + )); } void vrt::unpack_$(suffix)( -- cgit v1.2.3 From 37cf8a77e86de2d9247738ed6ce7b2534e66e2f8 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Tue, 8 Jun 2010 14:55:57 -0700 Subject: float casts to remove msvc warnings --- host/test/convert_types_test.cpp | 26 ++++++++++++++------------ 1 file changed, 14 insertions(+), 12 deletions(-) diff --git a/host/test/convert_types_test.cpp b/host/test/convert_types_test.cpp index 096da441b..1587be57f 100644 --- a/host/test/convert_types_test.cpp +++ b/host/test/convert_types_test.cpp @@ -84,10 +84,12 @@ typedef std::complex fc32_t; BOOST_CHECK_CLOSE(a1.real(), a2.real(), p); \ BOOST_CHECK_CLOSE(a1.imag(), a2.imag(), p); +static const float tolerance = float(0.1); + BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){ fc32_t in_fc32[] = { - fc32_t(0, -0.2), fc32_t(0.03, -0.16), - fc32_t(1.0, .45), fc32_t(0.09, 0) + fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)), + fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(0)) }, out_fc32[4]; io_type_t io_type(io_type_t::COMPLEX_FLOAT32); @@ -97,16 +99,16 @@ BOOST_AUTO_TEST_CASE(test_convert_types_be_fc32){ loopback(io_type, otw_type, in_fc32, out_fc32); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance); } BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){ fc32_t in_fc32[] = { - fc32_t(0, -0.2), fc32_t(0.03, -0.16), - fc32_t(1.0, .45), fc32_t(0.09, 0) + fc32_t(float(0), float(-0.2)), fc32_t(float(0.03), float(-0.16)), + fc32_t(float(1.0), float(.45)), fc32_t(float(0.09), float(0)) }, out_fc32[4]; io_type_t io_type(io_type_t::COMPLEX_FLOAT32); @@ -116,8 +118,8 @@ BOOST_AUTO_TEST_CASE(test_convert_types_le_fc32){ loopback(io_type, otw_type, in_fc32, out_fc32); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], 0.1); - BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], 0.1); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[0], out_fc32[0], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[1], out_fc32[1], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[2], out_fc32[2], tolerance); + BOOST_CHECK_CLOSE_COMPLEX(in_fc32[3], out_fc32[3], tolerance); } -- cgit v1.2.3 From 185971dd625034366b2d1420b74c3de072a90330 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Tue, 8 Jun 2010 14:59:51 -0700 Subject: extend byteswap routines for macosx, and added case for unknown --- host/include/uhd/utils/byteswap.hpp | 36 ++++++++++++++++++++++++++++++++---- 1 file changed, 32 insertions(+), 4 deletions(-) diff --git a/host/include/uhd/utils/byteswap.hpp b/host/include/uhd/utils/byteswap.hpp index 779b48ec9..dd5dcbc09 100644 --- a/host/include/uhd/utils/byteswap.hpp +++ b/host/include/uhd/utils/byteswap.hpp @@ -57,11 +57,10 @@ namespace uhd{ return _byteswap_uint64(x); } -#elif defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 3 - #include +#elif defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 2 UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){ - return bswap_16(x); //no __builtin_bswap16 + return (x>>8) | (x<<8); //DNE return __builtin_bswap16(x); } UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){ @@ -72,7 +71,22 @@ namespace uhd{ return __builtin_bswap64(x); } -#else +#elif defined(__FreeBSD__) || defined(__MACOSX__) || defined(__APPLE__) + #include + + UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){ + return OSSwapInt16(x); + } + + UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){ + return OSSwapInt32(x); + } + + UHD_INLINE boost::uint64_t uhd::byteswap(boost::uint64_t x){ + return OSSwapInt64(x); + } + +#elif defined(linux) || defined(__linux) #include UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){ @@ -87,6 +101,20 @@ namespace uhd{ return bswap_64(x); } +#else //http://www.koders.com/c/fidB93B34CD44F0ECF724F1A4EAE3854BA2FE692F59.aspx + + UHD_INLINE boost::uint16_t uhd::byteswap(boost::uint16_t x){ + return (x>>8) | (x<<8); + } + + UHD_INLINE boost::uint32_t uhd::byteswap(boost::uint32_t x){ + return (boost::uint32_t(uhd::byteswap(boost::uint16_t(x&0xfffful)))<<16) | (uhd::byteswap(boost::uint16_t(x>>16))); + } + + UHD_INLINE boost::uint64_t uhd::byteswap(boost::uint64_t x){ + return (boost::uint64_t(uhd::byteswap(boost::uint32_t(x&0xffffffffull)))<<32) | (uhd::byteswap(boost::uint32_t(x>>32))); + } + #endif #endif /* INCLUDED_UHD_UTILS_BYTESWAP_HPP */ -- cgit v1.2.3 From 8c7b73ee536357d2f7efc4558b531575fa28ca31 Mon Sep 17 00:00:00 2001 From: Josh Blum Date: Tue, 8 Jun 2010 17:07:41 -0700 Subject: fixed converter logic in convert types --- host/lib/transport/gen_convert_types.py | 31 ++++++++++++++++--------------- 1 file changed, 16 insertions(+), 15 deletions(-) diff --git a/host/lib/transport/gen_convert_types.py b/host/lib/transport/gen_convert_types.py index 1b6b71e00..af2bcc7cb 100755 --- a/host/lib/transport/gen_convert_types.py +++ b/host/lib/transport/gen_convert_types.py @@ -56,30 +56,29 @@ 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); + boost::uint16_t real = boost::int16_t(num.real()); + boost::uint16_t imag = boost::int16_t(num.imag()); + return (item32_t(real) << 16) | (item32_t(imag) << 0); } static UHD_INLINE sc16_t item32_to_sc16(item32_t item){ - return *conv_ptr(&item); + return sc16_t( + boost::uint16_t(item >> 16), + boost::uint16_t(item >> 0) + ); } 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) - )); + boost::uint16_t real = boost::int16_t(num.real()*shorts_per_float); + boost::uint16_t imag = boost::int16_t(num.imag()*shorts_per_float); + return (item32_t(real) << 16) | (item32_t(imag) << 0); } 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) + return fc32_t( + float(boost::int16_t(item >> 16)*floats_per_short), + float(boost::int16_t(item >> 0)*floats_per_short) ); } @@ -120,7 +119,7 @@ void transport::convert_io_type_to_otw_type( size_t num_samps ){ switch(get_pred(io_type, otw_type)){ - #for $pred in range(4) + #for $pred in range(2**$ph.nbits) case $pred: #set $out_type = $ph.get_dev_type($pred) #set $in_type = $ph.get_host_type($pred) @@ -167,6 +166,8 @@ class ph: sc16_p = 0b00010 fc32_p = 0b00000 + nbits = 2 #see above + @staticmethod def get_xe_macro(pred): if (pred & ph.be_p) == ph.be_p: return 'BE_MACRO' -- cgit v1.2.3