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

}
}