GenericMiner.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 <libdevcore/Common.h>
#include <libdevcore/Log.h>
#include <libdevcore/Worker.h>
#include <libethcore/Common.h>
 
namespace dev
{
 
namespace eth
{
 
inline std::ostream& operator<<(std::ostream& _out, WorkingProgress _p)
{
    _out << _p.rate() << " H/s = " <<  _p.hashes << " hashes / " << (double(_p.ms) / 1000) << " s";
    return _out;
}
 
template <class PoW> class GenericMiner;
 
template <class PoW> class GenericFarmFace
{
public:
    using WorkPackage = typename PoW::WorkPackage;
    using Solution = typename PoW::Solution;
    using Miner = GenericMiner<PoW>;
 
    virtual ~GenericFarmFace() {}
 
    virtual bool submitProof(Solution const& _p, Miner* _finder) = 0;
};
 
template <class PoW> class GenericMiner
{
public:
    using WorkPackage = typename PoW::WorkPackage;
    using Solution = typename PoW::Solution;
    using FarmFace = GenericFarmFace<PoW>;
    using ConstructionInfo = std::pair<FarmFace*, unsigned>;
 
    GenericMiner(ConstructionInfo const& _ci):
        m_farm(_ci.first),
        m_index(_ci.second)
    {}
    virtual ~GenericMiner() {}
 
    // API FOR THE FARM TO CALL IN WITH
 
    void setWork(WorkPackage const& _work = WorkPackage())
    {
        bool const old_exists = !!m_work;
        {
            Guard l(x_work);
            m_work = _work;
        }
        if (!!_work)
        {
            DEV_TIMED_ABOVE("pause", 250)
                pause();
            DEV_TIMED_ABOVE("kickOff", 250)
                kickOff();
        }
        else if (!_work && old_exists)
            pause();
        Guard l(x_hashCount);
        m_hashCount = 0;
    }
 
    uint64_t hashCount() const { Guard l(x_hashCount); return m_hashCount; }
 
    void resetHashCount() { Guard l(x_hashCount); m_hashCount = 0; }
 
    unsigned index() const { return m_index; }
 
protected:
 
    // REQUIRED TO BE REIMPLEMENTED BY A SUBCLASS:
 
    virtual void kickOff() = 0;
 
    virtual void pause() = 0;
 
    // AVAILABLE FOR A SUBCLASS TO CALL:
 
    bool submitProof(Solution const& _s)
    {
        if (!m_farm)
            return true;
        if (m_farm->submitProof(_s, this))
        {
            Guard l(x_work);
            m_work.reset();
            return true;
        }
        return false;
    }
 
    WorkPackage const& work() const { Guard l(x_work); return m_work; }
 
    void accumulateHashes(unsigned _n) { Guard l(x_hashCount); m_hashCount += _n; }
 
private:
    FarmFace* m_farm = nullptr;
    unsigned m_index;
 
    uint64_t m_hashCount = 0;
    mutable Mutex x_hashCount;
 
    WorkPackage m_work;
    mutable Mutex x_work;
};
 
}
}