1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
//
// Copyright 2020 Ettus Research, a National Instruments Brand
//
// SPDX-License-Identifier: GPL-3.0-or-later
//
#include "../rfnoc_graph_mock_nodes.hpp"
#include <uhd/rfnoc/defaults.hpp>
#include <uhd/rfnoc/fft_block_control.hpp>
#include <uhd/rfnoc/mock_block.hpp>
#include <uhdlib/rfnoc/graph.hpp>
#include <uhdlib/rfnoc/node_accessor.hpp>
#include <boost/test/unit_test.hpp>
#include <iostream>
using namespace uhd::rfnoc;
// Redeclare this here, since it's only defined outside of UHD_API
noc_block_base::make_args_t::~make_args_t() = default;
/*
* This class extends mock_reg_iface_t, adding a register poke override
* that monitors the reset strobe address and sets a flag when written.
*/
class fft_mock_reg_iface_t : public mock_reg_iface_t
{
public:
void _poke_cb(uint32_t addr,
uint32_t /*data*/,
uhd::time_spec_t /*time*/,
bool /*ack*/) override
{
if (addr == fft_block_control::REG_RESET_ADDR) {
fft_was_reset = true;
}
}
void reset_strobe()
{
fft_was_reset = false;
}
bool fft_was_reset = false;
};
/* fft_block_fixture is a class which is instantiated before each test case
* is run. It sets up the block container, mock register interface, and
* fft_block_control object, all of which are accessible to the test case.
* The instance of the object is destroyed at the end of each test case.
*/
namespace {
constexpr size_t DEFAULT_MTU = 8000;
};
struct fft_block_fixture
{
//! Create an FFT block and all related infrastructure for unit testsing.
fft_block_fixture()
: reg_iface(std::make_shared<fft_mock_reg_iface_t>())
, block_container(get_mock_block(
FFT_BLOCK, 1, 1, uhd::device_addr_t(), DEFAULT_MTU, ANY_DEVICE, reg_iface))
, test_fft(block_container.get_block<fft_block_control>())
{
node_accessor.init_props(test_fft.get());
}
std::shared_ptr<fft_mock_reg_iface_t> reg_iface;
mock_block_container block_container;
std::shared_ptr<fft_block_control> test_fft;
node_accessor_t node_accessor{};
};
/*
* This test case ensures that the hardware is programmed correctly with
* defaults when the FFT block is constructed.
*/
BOOST_FIXTURE_TEST_CASE(fft_test_construction, fft_block_fixture)
{
// These are the defaults from the FFT block controller. They are not
// exported, so duplicate them here. Obviously, if these defaults are
// changed in fft_block_control, those changes must be reflected here.
constexpr int fft_default_size_log2 = 8; // log2(256)
constexpr fft_shift fft_default_shift = fft_shift::NORMAL;
constexpr fft_direction fft_default_direction = fft_direction::FORWARD;
constexpr fft_magnitude fft_default_magnitude = fft_magnitude::COMPLEX;
constexpr int fft_default_scaling = 1706;
BOOST_CHECK(reg_iface->fft_was_reset);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_LENGTH_LOG2_ADDR],
fft_default_size_log2);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_MAGNITUDE_OUT_ADDR],
static_cast<uint32_t>(fft_default_magnitude));
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_DIRECTION_ADDR],
static_cast<uint32_t>(fft_default_direction));
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_SCALING_ADDR],
fft_default_scaling);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_SHIFT_CONFIG_ADDR],
static_cast<uint32_t>(fft_default_shift));
}
/*
* This test case exercises the remainder of the FFT block API with valid,
* in-range values and ensures that the appropriate register is programmed
* appropriately.
*/
BOOST_FIXTURE_TEST_CASE(fft_test_api, fft_block_fixture)
{
constexpr fft_direction direction = fft_direction::REVERSE;
test_fft->set_direction(direction);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_DIRECTION_ADDR],
static_cast<uint32_t>(direction));
BOOST_CHECK(test_fft->get_direction() == direction);
constexpr fft_magnitude magnitude = fft_magnitude::MAGNITUDE_SQUARED;
test_fft->set_magnitude(magnitude);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_MAGNITUDE_OUT_ADDR],
static_cast<uint32_t>(magnitude));
BOOST_CHECK(test_fft->get_magnitude() == magnitude);
constexpr fft_shift shift = fft_shift::NATURAL;
test_fft->set_shift_config(shift);
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_SHIFT_CONFIG_ADDR],
static_cast<uint32_t>(shift));
BOOST_CHECK(test_fft->get_shift_config() == shift);
constexpr uint16_t scaling = 256;
test_fft->set_scaling(scaling);
BOOST_CHECK_EQUAL(
reg_iface->write_memory[fft_block_control::REG_SCALING_ADDR], scaling);
BOOST_CHECK(test_fft->get_scaling() == scaling);
constexpr size_t length_log2 = 10;
test_fft->set_length(1 << length_log2);
BOOST_CHECK_EQUAL(
reg_iface->write_memory[fft_block_control::REG_LENGTH_LOG2_ADDR], length_log2);
BOOST_CHECK_EQUAL(test_fft->get_length(), (1 << length_log2));
// Make sure that the FFT length parameter is coerced to the closest
// power of two smaller than the desired value.
constexpr size_t coerced_length_log2 = 9;
test_fft->set_length((1 << coerced_length_log2) + (1 << (coerced_length_log2 - 1)));
BOOST_CHECK_EQUAL(reg_iface->write_memory[fft_block_control::REG_LENGTH_LOG2_ADDR],
coerced_length_log2);
BOOST_CHECK_EQUAL(test_fft->get_length(), (1 << coerced_length_log2));
}
/*
* This test case exercises the range checking performed on several of the
* FFT block properties, ensuring that the appropriate exception is thrown.
*/
BOOST_FIXTURE_TEST_CASE(fft_test_range_errors, fft_block_fixture)
{
BOOST_CHECK_THROW(test_fft->set_property<int>("direction", 12345), uhd::value_error);
BOOST_CHECK_THROW(test_fft->set_property<int>("magnitude", 54321), uhd::value_error);
BOOST_CHECK_THROW(
test_fft->set_property<int>("shift_config", 31337), uhd::value_error);
BOOST_CHECK_THROW(test_fft->set_scaling(32767), uhd::value_error);
BOOST_CHECK_THROW(test_fft->set_length(65535), uhd::value_error);
}
/*
* This test case ensures that the FFT block controller can be added
* to a graph.
*/
BOOST_FIXTURE_TEST_CASE(fft_test_graph, fft_block_fixture)
{
detail::graph_t graph{};
detail::graph_t::graph_edge_t edge_info{
0, 0, detail::graph_t::graph_edge_t::DYNAMIC, true};
mock_radio_node_t mock_radio_block{0};
mock_ddc_node_t mock_ddc_block{};
mock_terminator_t mock_sink_term(2, {}, "MOCK_SINK");
UHD_LOG_INFO("TEST", "Priming mock block properties");
node_accessor.init_props(&mock_radio_block);
node_accessor.init_props(&mock_ddc_block);
mock_sink_term.set_edge_property<std::string>(
"type", "sc16", {res_source_info::INPUT_EDGE, 0});
UHD_LOG_INFO("TEST", "Creating graph...");
graph.connect(&mock_radio_block, &mock_ddc_block, edge_info);
graph.connect(&mock_ddc_block, test_fft.get(), edge_info);
graph.connect(test_fft.get(), &mock_sink_term, edge_info);
UHD_LOG_INFO("TEST", "Committing graph...");
graph.commit();
UHD_LOG_INFO("TEST", "Commit complete.");
}
|
