3ba971e4-2004-46a3-b2d0-8a6d687db0d1

Build # 3ba971e4-2004-46a3-b2d0-8a6d687db0d1

Build Type

circleci

Committed by fairlight1337

Commit Message

Repaired context menu popping up

Pull Request Pull Request #9: Adding pipeline applications

Run Details

1225 of 1225 new or added lines in 24 files covered. (100.0%)

2850 of 3071 relevant lines covered (92.8%)

12345.72 hits per line

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

97.62

/src/evaluators/random_serial_data_passthrough_evaluator.cpp

#include <beast/evaluators/random_serial_data_passthrough_evaluator.hpp>

// Standard
#include <limits>
#include <random>

// BEAST
#include <beast/cpu_virtual_machine.hpp>

namespace beast {

RandomSerialDataPassthroughEvaluator::RandomSerialDataPassthroughEvaluator(uint32_t data_count,
                                                                           uint32_t repeats,
                                                                           uint32_t max_steps)
    : data_count_{data_count}, repeats_{repeats}, max_steps_{max_steps} {}

double RandomSerialDataPassthroughEvaluator::evaluate(const VmSession& session) {
  std::random_device random_device;
  std::mt19937 mersenne_twister(random_device());
  std::uniform_int_distribution<> distribution(std::numeric_limits<int32_t>::min(),
                                               std::numeric_limits<int32_t>::max());

  double worst_result = 1.0;
  for (uint32_t repeat = 0; repeat < repeats_; ++repeat) {
    std::vector<int32_t> values;
    for (uint32_t idx = 0; idx < data_count_; ++idx) {
      values.push_back(distribution(mersenne_twister));
    }

    // Make a copy because we're changing the state of the session.
    VmSession work_session = session;
    uint32_t correct_forwards = 0;

    work_session.setVariableBehavior(0, beast::VmSession::VariableIoBehavior::Input);
    work_session.setVariableBehavior(1, beast::VmSession::VariableIoBehavior::Output);

    work_session.setVariableValue(0, true, values[0]);

    try {
      correct_forwards = runProgram(work_session, values);
    } catch (...) {
      return 0.0;
    }

    const double result =
        std::min(1.0,
                 (static_cast<double>(correct_forwards) / static_cast<double>(values.size())) +
                     (correct_forwards == 0 ? static_cast<double>(values.size()) * 0.1 : 0.0));
    worst_result = std::min(worst_result, result);
  }

  return worst_result;
}

uint32_t
RandomSerialDataPassthroughEvaluator::runProgram(VmSession& work_session,
                                                 const std::vector<int32_t>& values) const {
  beast::CpuVirtualMachine virtual_machine;
  virtual_machine.setSilent(true);

  uint32_t value_index = 0;
  uint32_t step_count = 0;
  uint32_t correct_forwards = 0;

  do {
    if (work_session.hasOutputDataAvailable(1, true)) {
      if (work_session.getVariableValue(1, true) == values[value_index]) {
        correct_forwards++;
      }
      value_index++;
      if (value_index < values.size()) {
        work_session.setVariableValue(0, true, values[value_index]);
      }
    }
    step_count++;
  } while (value_index < values.size() && step_count < max_steps_ &&
           virtual_machine.step(work_session, false));

  return correct_forwards;
}

} // namespace beast

1	#include <beast/evaluators/random_serial_data_passthrough_evaluator.hpp>
2
3	// Standard
4	#include <limits>
5	#include <random>
6
7	// BEAST
8	#include <beast/cpu_virtual_machine.hpp>
9
10	namespace beast {
11
12	RandomSerialDataPassthroughEvaluator::RandomSerialDataPassthroughEvaluator(uint32_t data_count,	4✔
13	uint32_t repeats,
14	uint32_t max_steps)	4✔
15	: data_count_{data_count}, repeats_{repeats}, max_steps_{max_steps} {}	4✔
16
17	double RandomSerialDataPassthroughEvaluator::evaluate(const VmSession& session) {	1,369✔
18	std::random_device random_device;	2,738✔
19	std::mt19937 mersenne_twister(random_device());	1,369✔
20	std::uniform_int_distribution<> distribution(std::numeric_limits<int32_t>::min(),
21	std::numeric_limits<int32_t>::max());	1,369✔
22
23	double worst_result = 1.0;	1,369✔
24	for (uint32_t repeat = 0; repeat < repeats_; ++repeat) {	4,466✔
25	std::vector<int32_t> values;	3,851✔
26	for (uint32_t idx = 0; idx < data_count_; ++idx) {	7,702✔
27	values.push_back(distribution(mersenne_twister));	3,851✔
28	}
29
30	// Make a copy because we're changing the state of the session.
31	VmSession work_session = session;	3,851✔
32	uint32_t correct_forwards = 0;	3,851✔
33
34	work_session.setVariableBehavior(0, beast::VmSession::VariableIoBehavior::Input);	3,851✔
35	work_session.setVariableBehavior(1, beast::VmSession::VariableIoBehavior::Output);	3,851✔
36
37	work_session.setVariableValue(0, true, values[0]);	3,851✔
38
39	try {
40	correct_forwards = runProgram(work_session, values);	3,851✔
41	} catch (...) {	754✔
42	return 0.0;	754✔
43	}
44
45	const double result =
46	std::min(1.0,	6,194✔
47	(static_cast<double>(correct_forwards) / static_cast<double>(values.size())) +	3,097✔
48	(correct_forwards == 0 ? static_cast<double>(values.size()) * 0.1 : 0.0));	3,097✔
49	worst_result = std::min(worst_result, result);	3,097✔
50	}
51
52	return worst_result;	615✔
53	}
54
55	uint32_t
56	RandomSerialDataPassthroughEvaluator::runProgram(VmSession& work_session,	3,851✔
57	const std::vector<int32_t>& values) const {
58	beast::CpuVirtualMachine virtual_machine;	3,851✔
59	virtual_machine.setSilent(true);	3,851✔
60
61	uint32_t value_index = 0;	3,851✔
62	uint32_t step_count = 0;	3,851✔
63	uint32_t correct_forwards = 0;	3,851✔
64
65	do {	11,154✔
66	if (work_session.hasOutputDataAvailable(1, true)) {	15,005✔
67	if (work_session.getVariableValue(1, true) == values[value_index]) {	2,676✔
68	correct_forwards++;	820✔
69	}
70	value_index++;	2,676✔
71	if (value_index < values.size()) {	2,676✔
72	work_session.setVariableValue(0, true, values[value_index]);	×
73	}
74	}
75	step_count++;	15,004✔
76	} while (value_index < values.size() && step_count < max_steps_ &&	26,509✔
77	virtual_machine.step(work_session, false));	12,258✔
78
79	return correct_forwards;	3,097✔
80	}
81
82	} // namespace beast

dedicate-project / beast / 3ba971e4-2004-46a3-b2d0-8a6d687db0d1

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