GenericFarm.h

Go to the documentation of this file.

/*
 This file is part of cpp-ethereum.

 cpp-ethereum 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.

 cpp-ethereum 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 cpp-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
#pragma once

#include <thread>
#include <list>
#include <atomic>
#include <libdevcore/Common.h>
#include <libdevcore/Worker.h>
#include <libethcore/Common.h>
#include <libethereum/GenericMiner.h>
#include <libethcore/BlockHeader.h>

namespace dev
{

namespace eth
{

template <class PoW>
class GenericFarm: public GenericFarmFace<PoW>
{
public:
    using WorkPackage = typename PoW::WorkPackage;
    using Solution = typename PoW::Solution;
    using Miner = GenericMiner<PoW>;

    struct SealerDescriptor
    {
        std::function<unsigned()> instances;
        std::function<Miner*(typename Miner::ConstructionInfo ci)> create;
    };

    ~GenericFarm()
    {
        stop();
    }

    void setWork(WorkPackage const& _wp)
    {
        WriteGuard l(x_minerWork);
        if (_wp.headerHash() == m_work.headerHash())
            return;
        m_work = _wp;
        for (auto const& m: m_miners)
            m->setWork(m_work);
        resetTimer();
    }

    void setSealers(std::map<std::string, SealerDescriptor> const& _sealers) { m_sealers = _sealers; }

    bool start(std::string const& _sealer)
    {
        WriteGuard l(x_minerWork);
        if (!m_miners.empty() && m_lastSealer == _sealer)
            return true;
        if (!m_sealers.count(_sealer))
            return false;

        m_miners.clear();
        auto ins = m_sealers[_sealer].instances();
        m_miners.reserve(ins);
        for (unsigned i = 0; i < ins; ++i)
        {
            m_miners.push_back(std::shared_ptr<Miner>(m_sealers[_sealer].create(std::make_pair(this, i))));
            m_miners.back()->setWork(m_work);
        }
        m_isMining = true;
        m_lastSealer = _sealer;
        resetTimer();
        return true;
    }
    void stop()
    {
        WriteGuard l(x_minerWork);
        m_miners.clear();
        m_work.reset();
        m_isMining = false;
    }

    bool isMining() const
    {
        return m_isMining;
    }

    WorkingProgress const& miningProgress() const
    {
        WorkingProgress p;
        p.ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_lastStart).count();
        {
            ReadGuard l2(x_minerWork);
            for (auto const& i: m_miners)
                p.hashes += i->hashCount();
        }
        WriteGuard l(x_progress);
        m_progress = p;
        return m_progress;
    }

    void resetMiningProgress()
    {
        DEV_READ_GUARDED(x_minerWork)
            for (auto const& i: m_miners)
                i->resetHashCount();
        resetTimer();
    }

    using SolutionFound = std::function<bool(Solution const&)>;

    void onSolutionFound(SolutionFound const& _handler) { m_onSolutionFound = _handler; }

    WorkPackage work() const { ReadGuard l(x_minerWork); return m_work; }

    bool submitProof(Solution const& _s, Miner* _m) override
    {
        if (m_onSolutionFound && m_onSolutionFound(_s))
            if (x_minerWork.try_lock())
            {
                for (std::shared_ptr<Miner> const& m: m_miners)
                    if (m.get() != _m)
                        m->setWork();
                m_work.reset();
                x_minerWork.unlock();
                return true;
            }
        return false;
    }

private:
    void resetTimer()
    {
        m_lastStart = std::chrono::steady_clock::now();
    }

    mutable SharedMutex x_minerWork;
    std::vector<std::shared_ptr<Miner>> m_miners;
    WorkPackage m_work;

    std::atomic<bool> m_isMining = {false};

    mutable SharedMutex x_progress;
    mutable WorkingProgress m_progress;
    std::chrono::steady_clock::time_point m_lastStart;

    SolutionFound m_onSolutionFound;

    std::map<std::string, SealerDescriptor> m_sealers;
    std::string m_lastSealer;
};

}
}