104 lines
3.1 KiB
C++
104 lines
3.1 KiB
C++
#include <libdevcore/Log.h>
|
|
#include <chrono>
|
|
|
|
#include "SimulateClient.h"
|
|
|
|
using namespace std;
|
|
using namespace std::chrono;
|
|
using namespace dev;
|
|
using namespace eth;
|
|
|
|
SimulateClient::SimulateClient(unsigned const& block, float const& difficulty)
|
|
: PoolClient(), Worker("sim"), m_block(block), m_difficulty(difficulty)
|
|
{
|
|
}
|
|
|
|
SimulateClient::~SimulateClient() = default;
|
|
|
|
void SimulateClient::connect()
|
|
{
|
|
// Initialize new session
|
|
m_connected.store(true, memory_order_relaxed);
|
|
m_session = unique_ptr<Session>(new Session);
|
|
m_session->subscribed.store(true, memory_order_relaxed);
|
|
m_session->authorized.store(true, memory_order_relaxed);
|
|
|
|
if (m_onConnected)
|
|
m_onConnected();
|
|
|
|
// No need to worry about starting again.
|
|
// Worker class prevents that
|
|
startWorking();
|
|
}
|
|
|
|
void SimulateClient::disconnect()
|
|
{
|
|
cnote << "Simulation results : " << EthWhiteBold << "Max "
|
|
<< dev::getFormattedHashes((double)hr_max, ScaleSuffix::Add, 6) << " Mean "
|
|
<< dev::getFormattedHashes((double)hr_mean, ScaleSuffix::Add, 6) << EthReset;
|
|
|
|
m_conn->addDuration(m_session->duration());
|
|
m_session = nullptr;
|
|
m_connected.store(false, memory_order_relaxed);
|
|
|
|
if (m_onDisconnected)
|
|
m_onDisconnected();
|
|
}
|
|
|
|
void SimulateClient::submitHashrate(uint64_t const& rate, string const& id)
|
|
{
|
|
(void)rate;
|
|
(void)id;
|
|
}
|
|
|
|
void SimulateClient::submitSolution(const Solution& solution)
|
|
{
|
|
// This is a fake submission only evaluated locally
|
|
std::chrono::steady_clock::time_point submit_start = std::chrono::steady_clock::now();
|
|
bool accepted =
|
|
EthashAux::eval(solution.work.epoch, solution.work.block, solution.work.header, solution.nonce).value <=
|
|
solution.work.boundary;
|
|
std::chrono::milliseconds response_delay_ms =
|
|
std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
std::chrono::steady_clock::now() - submit_start);
|
|
|
|
if (accepted)
|
|
{
|
|
if (m_onSolutionAccepted)
|
|
m_onSolutionAccepted(response_delay_ms, solution.midx, false);
|
|
}
|
|
else
|
|
{
|
|
if (m_onSolutionRejected)
|
|
m_onSolutionRejected(response_delay_ms, solution.midx);
|
|
}
|
|
}
|
|
|
|
// Handles all logic here
|
|
void SimulateClient::workLoop()
|
|
{
|
|
m_start_time = std::chrono::steady_clock::now();
|
|
|
|
// apply exponential sliding average
|
|
// ref: https://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average
|
|
|
|
WorkPackage current;
|
|
current.seed = h256::random(); // We don't actually need a real seed as the epoch
|
|
// is calculated upon block number (see poolmanager)
|
|
current.header = h256::random();
|
|
current.block = m_block;
|
|
current.boundary = h256(dev::getTargetFromDiff(m_difficulty));
|
|
m_onWorkReceived(current); // submit new fake job
|
|
|
|
cnote << "Using block " << m_block << ", difficulty " << m_difficulty;
|
|
|
|
while (m_session)
|
|
{
|
|
float hr = Farm::f().HashRate();
|
|
hr_max = std::max(hr_max, hr);
|
|
hr_mean = hr_alpha * hr_mean + (1.0f - hr_alpha) * hr;
|
|
|
|
this_thread::sleep_for(chrono::milliseconds(200));
|
|
}
|
|
}
|