1594536712

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/OPAE/opae-sdk/commit/<a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/<a class="double-link" href="https://git"><a class=hub.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227">e779ee234">&lt;a href=&quot;https://github.com/OPAE/opae-sdk/commit/</a><a class="double-link" href="https://github.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227">e779ee234</a><a href="https://github.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/OPAE/opae-sdk/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227&quot;&gt;e779ee234&lt;/a&gt;&lt;a href=&quot;https://github.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/OPAE/opae-sdk/commit/e779ee23403b3e39aaff55588c4e1bea0d208227&amp;quot;&amp;gt;&amp;amp;quot;&amp;amp;gt;&amp;amp;amp;lt;a href=&amp;amp;amp;quot;https://github.com/OPAE/opae-sdk/commit/&amp;amp;lt;/a&amp;amp;gt;&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;am... (continued)

Pull Request Pull Request #2424: hssi: support hssi performance

Run Details

50 of 50 new or added lines in 3 files covered. (100.0%)

11100 of 18261 relevant lines covered (60.79%)

12815.59 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.29

/afu-test/afu_test.h

// Copyright(c) 2020, Intel Corporation
//
// Redistribution  and  use  in source  and  binary  forms,  with  or  without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of  source code  must retain the  above copyright notice,
//   this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
// * Neither the name  of Intel Corporation  nor the names of its contributors
//   may be used to  endorse or promote  products derived  from this  software
//   without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING,  BUT NOT LIMITED TO,  THE
// IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED.  IN NO EVENT  SHALL THE COPYRIGHT OWNER  OR CONTRIBUTORS BE
// LIABLE  FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL,  SPECIAL,  EXEMPLARY,  OR
// CONSEQUENTIAL  DAMAGES  (INCLUDING,  BUT  NOT LIMITED  TO,  PROCUREMENT  OF
// SUBSTITUTE GOODS OR SERVICES;  LOSS OF USE,  DATA, OR PROFITS;  OR BUSINESS
// INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY  OF LIABILITY,  WHETHER IN
// CONTRACT,  STRICT LIABILITY,  OR TORT  (INCLUDING NEGLIGENCE  OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,  EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
#pragma once
#include <poll.h>
#include <regex.h>
#include <unistd.h>
#include <chrono>
#include <future>
#include <memory>
#include <random>
#include <thread>

#include <CLI/CLI.hpp>
#include <spdlog/spdlog.h>
#include <spdlog/sinks/stdout_color_sinks.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <opae/cxx/core.h>

const char *sbdf_pattern =
  "(([0-9a-fA-F]{4}):)?([0-9a-fA-F]{2}):([0-9a-fA-F]{2})\\.([0-9])";

enum {
  MATCHES_SIZE = 6
};


namespace opae {
namespace afu_test {

namespace fpga = fpga::types;


template<typename T>
inline bool parse_match_int(const char *s,
                            regmatch_t m, T &v, int radix=10)
{
  if (m.rm_so == -1 || m.rm_eo == -1) return false;
  errno = 0;
  v = std::strtoul(s + m.rm_so, NULL, radix);
  return errno == 0;
}

union pcie_address {
  struct {
    uint32_t function: 3;
    uint32_t device: 5;
    uint32_t bus : 8;
    uint32_t domain : 16;
  } fields;
  uint32_t value;

  static pcie_address parse(const char *s)
  {
    auto deleter = [&](regex_t *r){
      regfree(r);
      delete r;
    };
    std::unique_ptr<regex_t, decltype(deleter)> re(new regex_t, deleter);
    regmatch_t matches[MATCHES_SIZE];

    int reg_res = regcomp(re.get(), sbdf_pattern, REG_EXTENDED | REG_ICASE);
    if (reg_res)
      throw std::runtime_error("could not compile regex");

    reg_res = regexec(re.get(), s, MATCHES_SIZE, matches, 0);
    if (reg_res)
      throw std::runtime_error("pcie address not valid format");

    uint16_t domain, bus, device, function;
    if (!parse_match_int(s, matches[2], domain, 16))
      domain = 0;
    if (!parse_match_int(s, matches[3], bus, 16))
      throw std::runtime_error("error parsing pcie address");
    if (!parse_match_int(s, matches[4], device, 16))
      throw std::runtime_error("error parsing pcie address");
    if (!parse_match_int(s, matches[5], function))
      throw std::runtime_error("error parsing; pcie address");
    pcie_address a;
    a.fields.domain=domain;
    a.fields.bus=bus;
    a.fields.device=device;
    a.fields.function=function;
    return a;
  }

};

class afu; // forward declaration

class command {
public:
  typedef std::shared_ptr<command> ptr_t;
  command(){}
  virtual ~command(){}
  virtual const char *name() const = 0;
  virtual const char *description() const = 0;
  virtual int run(afu *afu, CLI::App *app) = 0;
  virtual void add_options(CLI::App *app)
  {
    (void)app;
  }
  virtual const char *afu_id() const
  {
    return nullptr;
  }

private:

};

class afu {
public:
  typedef int (*command_fn)(afu *afu, CLI::App *app);
  enum exit_codes {
    success = 0,
    not_run,
    not_found,
    no_access,
    exception,
    error
  };

  afu(const char *name, const char *afu_id = nullptr, const char *log_level = nullptr)
  : name_(name)
  , afu_id_(afu_id ? afu_id : "")
  , app_(name_)
  , pci_addr_("")
  , log_level_(log_level ? log_level : "info")
  , shared_(false)
  , timeout_msec_(60000)
  , handle_(nullptr)
  , current_command_(nullptr)
  {
    if (!afu_id_.empty())
      app_.add_option("-g,--guid", afu_id_, "GUID")->default_str(afu_id_);
    app_.add_option("-p,--pci-address", pci_addr_,
                    "[<domain>:]<bus>:<device>.<function>");
    app_.add_option("-l,--log-level", log_level_, "stdout logging level")->
      default_str(log_level_)->
      check(CLI::IsMember(SPDLOG_LEVEL_NAMES));
    app_.add_flag("-s,--shared", shared_, "open in shared mode, default is off");
    app_.add_option("-t,--timeout", timeout_msec_, "test timeout (msec)")->default_str(std::to_string(timeout_msec_));
  }
  virtual ~afu() {
    if (logger_)
      spdlog::drop(logger_->name());
  }

  CLI::App & cli() { return app_; }

  fpga::properties::ptr_t afu_properties() const
  {
    return fpga::properties::get(handle_);
  }

  int open_handle(const char *afu_id) {
    auto filter = fpga::properties::get();
    auto app_afu_id = afu_id ? afu_id : afu_id_.c_str();
    filter->type = FPGA_ACCELERATOR;
    try {
      filter->guid.parse(app_afu_id);
    } catch(opae::fpga::types::except & err) {
      return error;
    }
    if (!pci_addr_.empty()) {
      auto p = pcie_address::parse(pci_addr_.c_str());
      filter->segment = p.fields.domain;
      filter->bus = p.fields.bus;
      filter->device = p.fields.device;
      filter->function = p.fields.function;
    }

    auto tokens = fpga::token::enumerate({filter});
    if (tokens.size() < 1) {
      if (pci_addr_.empty()) {
        logger_->error("no accelerator found with id: {0}", app_afu_id);
      } else {
        logger_->error("no accelerator found with id: {0} at PCIe address {1}",
            app_afu_id, pci_addr_);
      }
      return exit_codes::not_found;
    }

    if (tokens.size() > 1) {
      std::cerr << "more than one accelerator found matching filter\n";
    }
    int flags = shared_ ? FPGA_OPEN_SHARED : 0;
    try {
      handle_ = fpga::handle::open(tokens[0], flags);
    } catch (fpga::no_access &err) {
      std::cerr << err.what() << "\n";
      return exit_codes::no_access;
    }
    return exit_codes::not_run;
  }

  int main(int argc, char *argv[])
  {
    if (!commands_.empty())
      app_.require_subcommand();
    CLI11_PARSE(app_, argc, argv);

    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();

    command::ptr_t test(nullptr);
    CLI::App *app = nullptr;
    for (auto kv : commands_) {
      if (*kv.first) {
        app = kv.first;
        test = kv.second;
        break;
      }
    }
    if (!test) {
      std::cerr << "no command specified\n";
      return exit_codes::not_run;
    }

    std::stringstream ss;
    ss << name_ << "_" << test->name() << ".log";
    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(ss.str(), true);
    file_sink->set_level(spdlog::level::trace);
    logger_ = std::make_shared<spdlog::logger>(test->name(), spdlog::sinks_init_list ({console_sink, file_sink}));
    spdlog::register_logger(logger_);
    logger_->set_level(spdlog::level::from_str(log_level_));

    int res = open_handle(test->afu_id());
    if (res != exit_codes::not_run) {
      return res;
    }

    return run(app, test);
  }

  virtual int run(CLI::App *app, command::ptr_t test)
  {
    int res = exit_codes::not_run;

    current_command_ = test;

    try {
      std::future<int> f = std::async(std::launch::async,
        [this, test, app](){
          return test->run(this, app);
        });
      auto status = f.wait_for(std::chrono::milliseconds(timeout_msec_));
      if (status == std::future_status::timeout)
        throw std::runtime_error("timeout");
      res = f.get();
    } catch(std::exception &ex) {
      res = exit_codes::exception;
    }

    current_command_.reset();
    return res;
  }

  template<class T>
  CLI::App *register_command()
  {
    command::ptr_t cmd(new T());
    auto sub = app_.add_subcommand(cmd->name(),
                                   cmd->description());
    cmd->add_options(sub);
    commands_[sub] = cmd;
    return sub;
  }

  fpga::handle::ptr_t handle() const {
    return handle_;
  }

  uint64_t read64(uint32_t offset) const {
    return handle_->read_csr64(offset);
  }

  void write64(uint32_t offset, uint64_t value) const {
    return handle_->write_csr64(offset, value);
  }

  uint32_t read32(uint32_t offset) const {
    return handle_->read_csr32(offset);
  }

  void write32(uint32_t offset, uint32_t value) const {
    return handle_->write_csr32(offset, value);
  }

  command::ptr_t current_command() const {
    return current_command_;
  }

protected:
  std::string name_;
  std::string afu_id_;
  CLI::App app_;
  std::string pci_addr_;
  std::string log_level_;
  bool shared_;
  uint32_t timeout_msec_;
  fpga::handle::ptr_t handle_;
  command::ptr_t current_command_;
  std::map<CLI::App*, command::ptr_t> commands_;
public:
  std::shared_ptr<spdlog::logger> logger_;
};


} // end of namespace afu_test
} // end of namespace opae


1	// Copyright(c) 2020, Intel Corporation
2	//
3	// Redistribution and use in source and binary forms, with or without
4	// modification, are permitted provided that the following conditions are met:
5	//
6	// * Redistributions of source code must retain the above copyright notice,
7	// this list of conditions and the following disclaimer.
8	// * Redistributions in binary form must reproduce the above copyright notice,
9	// this list of conditions and the following disclaimer in the documentation
10	// and/or other materials provided with the distribution.
11	// * Neither the name of Intel Corporation nor the names of its contributors
12	// may be used to endorse or promote products derived from this software
13	// without specific prior written permission.
14	//
15	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16	// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17	// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18	// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19	// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20	// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21	// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22	// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23	// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24	// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25	// POSSIBILITY OF SUCH DAMAGE.
26	#pragma once
27	#include <poll.h>
28	#include <regex.h>
29	#include <unistd.h>
30	#include <chrono>
31	#include <future>
32	#include <memory>
33	#include <random>
34	#include <thread>
35
36	#include <CLI/CLI.hpp>
37	#include <spdlog/spdlog.h>
38	#include <spdlog/sinks/stdout_color_sinks.h>
39	#include <spdlog/sinks/basic_file_sink.h>
40	#include <opae/cxx/core.h>
41
42	const char *sbdf_pattern =
43	"(([0-9a-fA-F]{4}):)?([0-9a-fA-F]{2}):([0-9a-fA-F]{2})\\.([0-9])";
44
45	enum {
46	MATCHES_SIZE = 6
47	};
48
49
50	namespace opae {
51	namespace afu_test {
52
53	namespace fpga = fpga::types;
54
55
56	template<typename T>
57	inline bool parse_match_int(const char *s,	12✔
58	regmatch_t m, T &v, int radix=10)
59	{
60	if (m.rm_so == -1 \|\| m.rm_eo == -1) return false;	12✔
61	errno = 0;	10✔
62	v = std::strtoul(s + m.rm_so, NULL, radix);	10✔
63	return errno == 0;	10✔
64	}
65
66	union pcie_address {
67	struct {
68	uint32_t function: 3;
69	uint32_t device: 5;
70	uint32_t bus : 8;
71	uint32_t domain : 16;
72	} fields;
73	uint32_t value;
74
75	static pcie_address parse(const char *s)	4✔
76	{
77	auto deleter = [&](regex_t *r){	4✔
78	regfree(r);	4✔
79	delete r;	4✔
80	};	4✔
81	std::unique_ptr<regex_t, decltype(deleter)> re(new regex_t, deleter);	5✔
82	regmatch_t matches[MATCHES_SIZE];
83
84	int reg_res = regcomp(re.get(), sbdf_pattern, REG_EXTENDED \| REG_ICASE);	4✔
85	if (reg_res)	4✔
86	throw std::runtime_error("could not compile regex");	×
87
88	reg_res = regexec(re.get(), s, MATCHES_SIZE, matches, 0);	4✔
89	if (reg_res)	4✔
90	throw std::runtime_error("pcie address not valid format");	1✔
91
92	uint16_t domain, bus, device, function;
93	if (!parse_match_int(s, matches[2], domain, 16))	3✔
94	domain = 0;	2✔
95	if (!parse_match_int(s, matches[3], bus, 16))	3✔
96	throw std::runtime_error("error parsing pcie address");	×
97	if (!parse_match_int(s, matches[4], device, 16))	3✔
98	throw std::runtime_error("error parsing pcie address");	×
99	if (!parse_match_int(s, matches[5], function))	3✔
100	throw std::runtime_error("error parsing; pcie address");	×
101	pcie_address a;
102	a.fields.domain=domain;	3✔
103	a.fields.bus=bus;	3✔
104	a.fields.device=device;	3✔
105	a.fields.function=function;	3✔
106	return a;	6✔
107	}
108
109	};
110
111	class afu; // forward declaration
112
113	class command {
114	public:
115	typedef std::shared_ptr<command> ptr_t;
116	command(){}	36✔
117	virtual ~command(){}	36✔
118	virtual const char *name() const = 0;
119	virtual const char *description() const = 0;
120	virtual int run(afu afu, CLI::App app) = 0;
121	virtual void add_options(CLI::App *app)	18✔
122	{
123	(void)app;
124	}	18✔
125	virtual const char *afu_id() const	8✔
126	{
127	return nullptr;	8✔
128	}
129
130	private:
131
132	};
133
134	class afu {
135	public:
136	typedef int (command_fn)(afu afu, CLI::App *app);
137	enum exit_codes {
138	success = 0,
139	not_run,
140	not_found,
141	no_access,
142	exception,
143	error
144	};
145
146	afu(const char name, const char afu_id = nullptr, const char *log_level = nullptr)	9✔
147	: name_(name)	9✔
148	, afu_id_(afu_id ? afu_id : "")
149	, app_(name_)	9✔
150	, pci_addr_("")
151	, log_level_(log_level ? log_level : "info")
152	, shared_(false)
153	, timeout_msec_(60000)
154	, handle_(nullptr)
155	, current_command_(nullptr)	9✔
156	{
157	if (!afu_id_.empty())	9✔
158	app_.add_option("-g,--guid", afu_id_, "GUID")->default_str(afu_id_);	9✔
159	app_.add_option("-p,--pci-address", pci_addr_,	9✔
160	"[<domain>:]<bus>:<device>.<function>");
161	app_.add_option("-l,--log-level", log_level_, "stdout logging level")->	9✔
162	default_str(log_level_)->	9✔
163	check(CLI::IsMember(SPDLOG_LEVEL_NAMES));	9✔
164	app_.add_flag("-s,--shared", shared_, "open in shared mode, default is off");	9✔
165	app_.add_option("-t,--timeout", timeout_msec_, "test timeout (msec)")->default_str(std::to_string(timeout_msec_));	9✔
166	}	9✔
167	virtual ~afu() {	9✔
168	if (logger_)	9✔
169	spdlog::drop(logger_->name());	8✔
170	}	9✔
171
172	CLI::App & cli() { return app_; }
173
174	fpga::properties::ptr_t afu_properties() const	×
175	{
176	return fpga::properties::get(handle_);	×
177	}
178
179	int open_handle(const char *afu_id) {	8✔
180	auto filter = fpga::properties::get();	16✔
181	auto app_afu_id = afu_id ? afu_id : afu_id_.c_str();	8✔
182	filter->type = FPGA_ACCELERATOR;	8✔
183	try {
184	filter->guid.parse(app_afu_id);	8✔
185	} catch(opae::fpga::types::except & err) {	×
186	return error;	×
187	}
188	if (!pci_addr_.empty()) {	8✔
189	auto p = pcie_address::parse(pci_addr_.c_str());	1✔
190	filter->segment = p.fields.domain;	1✔
191	filter->bus = p.fields.bus;	1✔
192	filter->device = p.fields.device;	1✔
193	filter->function = p.fields.function;	1✔
194	}
195
196	auto tokens = fpga::token::enumerate({filter});	32✔
197	if (tokens.size() < 1) {	8✔
198	if (pci_addr_.empty()) {	2✔
199	logger_->error("no accelerator found with id: {0}", app_afu_id);	1✔
200	} else {
201	logger_->error("no accelerator found with id: {0} at PCIe address {1}",	1✔
202	app_afu_id, pci_addr_);	1✔
203	}
204	return exit_codes::not_found;	2✔
205	}
206
207	if (tokens.size() > 1) {	6✔
208	std::cerr << "more than one accelerator found matching filter\n";	×
209	}
210	int flags = shared_ ? FPGA_OPEN_SHARED : 0;	6✔
211	try {
212	handle_ = fpga::handle::open(tokens[0], flags);	6✔
213	} catch (fpga::no_access &err) {	×
214	std::cerr << err.what() << "\n";	×
215	return exit_codes::no_access;	×
216	}
217	return exit_codes::not_run;	6✔
218	}
219
220	int main(int argc, char *argv[])	9✔
221	{
222	if (!commands_.empty())	9✔
223	app_.require_subcommand();	9✔
224	CLI11_PARSE(app_, argc, argv);	10✔
225
226	auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();	16✔
227
228	command::ptr_t test(nullptr);	8✔
229	CLI::App *app = nullptr;	8✔
230	for (auto kv : commands_) {	21✔
231	if (*kv.first) {	21✔
232	app = kv.first;	8✔
233	test = kv.second;	8✔
234	break;	8✔
235	}
236	}
237	if (!test) {	8✔
238	std::cerr << "no command specified\n";	×
239	return exit_codes::not_run;	×
240	}
241
242	std::stringstream ss;	16✔
243	ss << name_ << "_" << test->name() << ".log";	8✔
244	auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>(ss.str(), true);	16✔
245	file_sink->set_level(spdlog::level::trace);	8✔
246	logger_ = std::make_shared<spdlog::logger>(test->name(), spdlog::sinks_init_list ({console_sink, file_sink}));	24✔
247	spdlog::register_logger(logger_);	8✔
248	logger_->set_level(spdlog::level::from_str(log_level_));	8✔
249
250	int res = open_handle(test->afu_id());	8✔
251	if (res != exit_codes::not_run) {	8✔
252	return res;	2✔
253	}
254
255	return run(app, test);	6✔
256	}
257
258	virtual int run(CLI::App *app, command::ptr_t test)	105✔
259	{
260	int res = exit_codes::not_run;	105✔
261
262	current_command_ = test;	105✔
263
264	try {
265	std::future<int> f = std::async(std::launch::async,
266	[this, test, app](){	210✔
267	return test->run(this, app);	105✔
268	});	108✔
269	auto status = f.wait_for(std::chrono::milliseconds(timeout_msec_));	105✔
270	if (status == std::future_status::timeout)	105✔
271	throw std::runtime_error("timeout");	1✔
272	res = f.get();	104✔
273	} catch(std::exception &ex) {	3✔
274	res = exit_codes::exception;	3✔
275	}
276
277	current_command_.reset();	105✔
278	return res;	105✔
279	}
280
281	template<class T>
282	CLI::App *register_command()	36✔
283	{
284	command::ptr_t cmd(new T());	36✔
285	auto sub = app_.add_subcommand(cmd->name(),	72✔
286	cmd->description());	36✔
287	cmd->add_options(sub);	36✔
288	commands_[sub] = cmd;	36✔
289	return sub;	72✔
290	}
291
292	fpga::handle::ptr_t handle() const {	×
293	return handle_;	×
294	}
295
296	uint64_t read64(uint32_t offset) const {	×
297	return handle_->read_csr64(offset);	×
298	}
299
300	void write64(uint32_t offset, uint64_t value) const {	6✔
301	return handle_->write_csr64(offset, value);	6✔
302	}
303
304	uint32_t read32(uint32_t offset) const {
305	return handle_->read_csr32(offset);
306	}
307
308	void write32(uint32_t offset, uint32_t value) const {	×
309	return handle_->write_csr32(offset, value);	×
310	}
311
312	command::ptr_t current_command() const {	×
313	return current_command_;	×
314	}
315
316	protected:
317	std::string name_;
318	std::string afu_id_;
319	CLI::App app_;
320	std::string pci_addr_;
321	std::string log_level_;
322	bool shared_;
323	uint32_t timeout_msec_;
324	fpga::handle::ptr_t handle_;
325	command::ptr_t current_command_;
326	std::map<CLI::App*, command::ptr_t> commands_;
327	public:
328	std::shared_ptr<spdlog::logger> logger_;
329	};
330
331
332	} // end of namespace afu_test
333	} // end of namespace opae
334

OPAE / opae-sdk / 1594536712

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous