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;
};

}
}