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
|
//
// Copyright 2017 Ettus Research (National Instruments)
//
// 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 <http://www.gnu.org/licenses/>.
//
#include "mpmd_impl.hpp"
#include <chrono>
#include <thread>
namespace {
const size_t MPMD_RECLAIM_INTERVAL_MS = 1000;
const std::string MPMD_DEFAULT_SESSION_ID = "UHD";
}
using namespace uhd;
/*****************************************************************************
* Structors
****************************************************************************/
mpmd_mboard_impl::mpmd_mboard_impl(
const device_addr_t &mb_args,
const std::string& ip_addr
) : rpc(uhd::rpc_client::make(ip_addr, MPM_RPC_PORT))
{
UHD_LOGGER_TRACE("MPMD")
<< "Initializing mboard, connecting to IP address: " << ip_addr
<< " mboard args: " << mb_args.to_string()
;
auto device_info_dict = rpc->call<dev_info>("get_device_info");
for (const auto &info_pair: device_info_dict) {
device_info[info_pair.first] = info_pair.second;
}
UHD_LOGGER_TRACE("MPMD")
<< "MPM reports device info: " << device_info.to_string();
// Claim logic
auto rpc_token = rpc->call<std::string>("claim",
mb_args.get("session_id", MPMD_DEFAULT_SESSION_ID)
);
if (rpc_token.empty()) {
throw uhd::value_error("mpmd device claiming failed!");
}
rpc->set_token(rpc_token);
_claimer_task = task::make([this] {
if (not this->claim()) {
throw uhd::value_error("mpmd device reclaiming loop failed!");
};
std::this_thread::sleep_for(
std::chrono::milliseconds(MPMD_RECLAIM_INTERVAL_MS)
);
});
// Initialize properties
this->num_xbars = rpc->call<size_t>("get_num_xbars");
// Local addresses are not yet valid after this!
this->xbar_local_addrs.resize(this->num_xbars, 0xFF);
// std::vector<std::string> data_ifaces =
// rpc.call<std::vector<std::string>>("get_interfaces", rpc_token);
// discover path to device and tell MPM our MAC address seen at the data
// interfaces
// move this into make_transport
//for (const auto& iface : data_ifaces) {
//std::vector<std::string> addrs = rpc.call<std::vector<std::string>>(
//"get_interface_addrs", _rpc_token, iface);
//for (const auto& iface_addr : addrs) {
//if (rpc_client(iface_addr, MPM_RPC_PORT)
//.call<bool>("probe_interface", _rpc_token)) {
//data_interfaces.emplace(iface, iface_addr);
//break;
//}
//}
//}
}
mpmd_mboard_impl::~mpmd_mboard_impl()
{
/* nop */
}
/*****************************************************************************
* API
****************************************************************************/
uhd::sid_t mpmd_mboard_impl::allocate_sid(const uint16_t port,
const uhd::sid_t address,
const uint32_t xbar_src_addr,
const uint32_t xbar_src_port)
{
const auto sid = rpc->call_with_token<uint32_t>(
"allocate_sid",
port, address.get(), xbar_src_addr, xbar_src_port
);
return uhd::sid_t(sid);
}
void mpmd_mboard_impl::set_xbar_local_addr(
const size_t xbar_index,
const size_t local_addr
) {
rpc->call_with_token<void>("set_xbar_local_addr", xbar_index, local_addr);
UHD_ASSERT_THROW(xbar_index < xbar_local_addrs.size());
xbar_local_addrs.at(xbar_index) = local_addr;
}
/*****************************************************************************
* Private methods
****************************************************************************/
bool mpmd_mboard_impl::claim()
{
return rpc->call_with_token<bool>("reclaim");
}
/*****************************************************************************
* Factory
****************************************************************************/
mpmd_mboard_impl::uptr mpmd_mboard_impl::make(
const uhd::device_addr_t &mb_args,
const std::string& addr
) {
mpmd_mboard_impl::uptr mb =
mpmd_mboard_impl::uptr(new mpmd_mboard_impl(mb_args, addr));
// implicit move
return mb;
}
|
