cryptonote::miner Class Reference

#include <miner.h>

Public Member Functions
	miner (i_miner_handler *phandler)
	~miner ()
bool	init (const boost::program_options::variables_map &vm, network_type nettype, bool fallback_to_pow=false)
bool	set_block_template (const block &bl, const difficulty_type &diffic, uint64_t height, uint64_t block_reward)
bool	on_block_chain_update ()
bool	start (const account_public_address &adr, size_t threads_count, bool do_background=false, bool ignore_battery=false)
uint64_t	get_speed () const
uint32_t	get_threads_count () const
void	send_stop_signal ()
bool	stop ()
bool	is_mining () const
const account_public_address &	get_mining_address () const
bool	on_idle ()
void	on_synchronized ()
void	pause ()
void	resume ()
void	do_print_hashrate (bool do_hr)
bool	get_is_background_mining_enabled () const
bool	get_ignore_battery () const
uint64_t	get_min_idle_seconds () const
bool	set_min_idle_seconds (uint64_t min_idle_seconds)
uint8_t	get_idle_threshold () const
bool	set_idle_threshold (uint8_t idle_threshold)
uint8_t	get_mining_target () const
bool	set_mining_target (uint8_t mining_target)
uint64_t	get_block_reward () const

Static Public Member Functions
static void	init_options (boost::program_options::options_description &desc)
static bool	find_nonce_for_given_block (block &bl, const difficulty_type &diffic, uint64_t height)

Static Public Attributes
static constexpr uint8_t	BACKGROUND_MINING_DEFAULT_IDLE_THRESHOLD_PERCENTAGE = 90
static constexpr uint8_t	BACKGROUND_MINING_MIN_IDLE_THRESHOLD_PERCENTAGE = 50
static constexpr uint8_t	BACKGROUND_MINING_MAX_IDLE_THRESHOLD_PERCENTAGE = 99
static constexpr uint16_t	BACKGROUND_MINING_DEFAULT_MIN_IDLE_INTERVAL_IN_SECONDS = 10
static constexpr uint16_t	BACKGROUND_MINING_MIN_MIN_IDLE_INTERVAL_IN_SECONDS = 10
static constexpr uint16_t	BACKGROUND_MINING_MAX_MIN_IDLE_INTERVAL_IN_SECONDS = 3600
static constexpr uint8_t	BACKGROUND_MINING_DEFAULT_MINING_TARGET_PERCENTAGE = 40
static constexpr uint8_t	BACKGROUND_MINING_MIN_MINING_TARGET_PERCENTAGE = 5
static constexpr uint8_t	BACKGROUND_MINING_MAX_MINING_TARGET_PERCENTAGE = 50
static constexpr uint8_t	BACKGROUND_MINING_MINER_MONITOR_INVERVAL_IN_SECONDS = 10
static constexpr uint64_t	BACKGROUND_MINING_DEFAULT_MINER_EXTRA_SLEEP_MILLIS = 400
static constexpr uint64_t	BACKGROUND_MINING_MIN_MINER_EXTRA_SLEEP_MILLIS = 5

Detailed Description

Definition at line 59 of file miner.h.

Constructor & Destructor Documentation

miner()

cryptonote::miner::miner

(

i_miner_handler *

phandler

)

Definition at line 104 of file miner.cpp.

                                       :m_stop(1),
    m_template(boost::value_initialized<block>()),
    m_template_no(0),
    m_diffic(0),
    m_thread_index(0),
    m_phandler(phandler),
    m_height(0),
    m_threads_active(0),
    m_pausers_count(0),
    m_threads_total(0),
    m_starter_nonce(0),
    m_last_hr_merge_time(0),
    m_hashes(0),
    m_total_hashes(0),
    m_do_print_hashrate(false),
    m_do_mining(false),
    m_current_hash_rate(0),
    m_is_background_mining_enabled(false),
    m_min_idle_seconds(BACKGROUND_MINING_DEFAULT_MIN_IDLE_INTERVAL_IN_SECONDS),
    m_idle_threshold(BACKGROUND_MINING_DEFAULT_IDLE_THRESHOLD_PERCENTAGE),
    m_mining_target(BACKGROUND_MINING_DEFAULT_MINING_TARGET_PERCENTAGE),
    m_miner_extra_sleep(BACKGROUND_MINING_DEFAULT_MINER_EXTRA_SLEEP_MILLIS),
    m_block_reward(0)
  {
    m_attrs.set_stack_size(THREAD_STACK_SIZE);
  }

~miner()

cryptonote::miner::~miner

(

)

Definition at line 131 of file miner.cpp.

  {
    try { stop(); }
    catch (...) { /* ignore */ }
  }

Here is the call graph for this function:

Member Function Documentation

do_print_hashrate()

void cryptonote::miner::do_print_hashrate

(

bool

do_hr

)

Definition at line 199 of file miner.cpp.

  {
    m_do_print_hashrate = do_hr;
  }

find_nonce_for_given_block()

bool cryptonote::miner::find_nonce_for_given_block ( block & bl, const difficulty_type & diffic, uint64_t height )

static

Definition at line 478 of file miner.cpp.

  {
    for(; bl.nonce != std::numeric_limits<uint32_t>::max(); bl.nonce++)
    {
      crypto::hash h;
      get_block_longhash(bl, h, height);
 
      if(check_hash(h, diffic))
      {
        bl.invalidate_hashes();
        return true;
      }
    }
    bl.invalidate_hashes();
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_block_reward()

uint64_t cryptonote::miner::get_block_reward ( ) const

inline

Definition at line 90 of file miner.h.

{ return m_block_reward; }

Here is the caller graph for this function:

get_idle_threshold()

uint8_t cryptonote::miner::get_idle_threshold

(

)

const

Definition at line 652 of file miner.cpp.

  {
    return m_idle_threshold;
  }

Here is the caller graph for this function:

get_ignore_battery()

bool cryptonote::miner::get_ignore_battery

(

)

const

Definition at line 616 of file miner.cpp.

  {
    return m_ignore_battery;
  }  

Here is the caller graph for this function:

get_is_background_mining_enabled()

bool cryptonote::miner::get_is_background_mining_enabled

(

)

const

Definition at line 611 of file miner.cpp.

  {
    return m_is_background_mining_enabled;
  }

Here is the caller graph for this function:

get_min_idle_seconds()

uint64_t cryptonote::miner::get_min_idle_seconds

(

)

const

Definition at line 639 of file miner.cpp.

  {
    return m_min_idle_seconds;
  }

Here is the caller graph for this function:

get_mining_address()

const account_public_address & cryptonote::miner::get_mining_address

(

)

const

Definition at line 364 of file miner.cpp.

  {
    return m_mine_address;
  }

Here is the caller graph for this function:

get_mining_target()

uint8_t cryptonote::miner::get_mining_target

(

)

const

Definition at line 665 of file miner.cpp.

  {
    return m_mining_target;
  }

Here is the caller graph for this function:

get_speed()

uint64_t cryptonote::miner::get_speed

(

)

const

Definition at line 429 of file miner.cpp.

  {
    if(is_mining()) {
      return m_current_hash_rate;
    }
    else {
      return 0;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

get_threads_count()

uint32_t cryptonote::miner::get_threads_count

(

)

const

Definition at line 369 of file miner.cpp.

                                          {
    return m_threads_total;
  }

Here is the caller graph for this function:

init()

bool cryptonote::miner::init	(	const boost::program_options::variables_map &	vm,
		network_type	nettype,
		bool	fallback_to_pow = false )

Definition at line 292 of file miner.cpp.

  {
    if(command_line::has_arg(vm, arg_extra_messages))
    {
      std::string buff;
      bool r = file_io_utils::load_file_to_string(command_line::get_arg(vm, arg_extra_messages), buff);
      CHECK_AND_ASSERT_MES(r, false, "Failed to load file with extra messages: " << command_line::get_arg(vm, arg_extra_messages));
      std::vector<std::string> extra_vec;
      boost::split(extra_vec, buff, boost::is_any_of("\n"), boost::token_compress_on );
      m_extra_messages.resize(extra_vec.size());
      for(size_t i = 0; i != extra_vec.size(); i++)
      {
        string_tools::trim(extra_vec[i]);
        if(!extra_vec[i].size())
          continue;
        std::string buff = string_encoding::base64_decode(extra_vec[i]);
        if(buff != "0")
          m_extra_messages[i] = buff;
      }
      m_config_folder_path = boost::filesystem::path(command_line::get_arg(vm, arg_extra_messages)).parent_path().string();
      m_config = AUTO_VAL_INIT(m_config);
      const std::string filename = m_config_folder_path + "/" + MINER_CONFIG_FILE_NAME;
      CHECK_AND_ASSERT_MES(epee::serialization::load_t_from_json_file(m_config, filename), false, "Failed to load data from " << filename);
      MINFO("Loaded " << m_extra_messages.size() << " extra messages, current index " << m_config.current_extra_message_index);
    }
 
    if(command_line::has_arg(vm, arg_start_mining))
    {
      address_parse_info info;
      if(!cryptonote::get_account_address_from_str(info, nettype, command_line::get_arg(vm, arg_start_mining)) || info.is_subaddress)
      {
        LOG_ERROR("Target account address " << command_line::get_arg(vm, arg_start_mining) << " has wrong format, starting daemon canceled");
        return false;
      }
      // just a safeguard for the legacy infrastructure
        if(!(command_line::get_arg(vm, arg_start_mining) == "etnkCys4uGhSi9h48ajL9vBDJTcn2s2ttXtXq3SXWPAbiMHNhHitu5fJ8QgRfFWTzmJ8QgRfFWTzmJ8QgRfFWTzm4t51HTfCtK"))
        {
            LOG_ERROR("Target account address " << command_line::get_arg(vm, arg_start_mining) << " isn't equal to the Aurelius legacy mining burn address etnkCys4uGhSi9h48ajL9vBDJTcn2s2ttXtXq3SXWPAbiMHNhHitu5fJ8QgRfFWTzmJ8QgRfFWTzmJ8QgRfFWTzm4t51HTfCtK");
            return false;
        }
      m_mine_address = info.address;
      m_threads_total = 1;
      m_do_mining = true;
      if(command_line::has_arg(vm, arg_mining_threads))
      {
        m_threads_total = command_line::get_arg(vm, arg_mining_threads);
      }
    }
 
    // Background mining parameters
    // Let init set all parameters even if background mining is not enabled, they can start later with params set
    if(command_line::has_arg(vm, arg_bg_mining_enable))
      set_is_background_mining_enabled( command_line::get_arg(vm, arg_bg_mining_enable) );
    if(command_line::has_arg(vm, arg_bg_mining_ignore_battery))
      set_ignore_battery( command_line::get_arg(vm, arg_bg_mining_ignore_battery) );      
    if(command_line::has_arg(vm, arg_bg_mining_min_idle_interval_seconds))
      set_min_idle_seconds( command_line::get_arg(vm, arg_bg_mining_min_idle_interval_seconds) );
    if(command_line::has_arg(vm, arg_bg_mining_idle_threshold_percentage))
      set_idle_threshold( command_line::get_arg(vm, arg_bg_mining_idle_threshold_percentage) );
    if(command_line::has_arg(vm, arg_bg_mining_miner_target_percentage))
      set_mining_target( command_line::get_arg(vm, arg_bg_mining_miner_target_percentage) );
 
    m_fallback_to_pow = fallback_to_pow;
 
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

init_options()

void cryptonote::miner::init_options ( boost::program_options::options_description & desc )

static

Definition at line 280 of file miner.cpp.

  {
    command_line::add_arg(desc, arg_extra_messages);
    command_line::add_arg(desc, arg_start_mining);
    command_line::add_arg(desc, arg_mining_threads);
    command_line::add_arg(desc, arg_bg_mining_enable);
    command_line::add_arg(desc, arg_bg_mining_ignore_battery);    
    command_line::add_arg(desc, arg_bg_mining_min_idle_interval_seconds);
    command_line::add_arg(desc, arg_bg_mining_idle_threshold_percentage);
    command_line::add_arg(desc, arg_bg_mining_miner_target_percentage);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

is_mining()

bool cryptonote::miner::is_mining

(

)

const

Definition at line 359 of file miner.cpp.

  {
    return !m_stop;
  }

Here is the caller graph for this function:

on_block_chain_update()

bool cryptonote::miner::on_block_chain_update

(

)

Definition at line 149 of file miner.cpp.

  {
    if(!is_mining())
      return true;
 
    return request_block_template();
  }

Here is the call graph for this function:

on_idle()

bool cryptonote::miner::on_idle

(

)

Definition at line 179 of file miner.cpp.

  {
    m_update_block_template_interval.do_call([&](){
      if(is_mining())request_block_template();
      return true;
    });
 
    m_update_merge_hr_interval.do_call([&](){
      merge_hr();
      return true;
    });
 
    m_autodetect_interval.do_call([&](){
      update_autodetection();
      return true;
    });
 
    return true;
  }

Here is the call graph for this function:

on_synchronized()

void cryptonote::miner::on_synchronized

(

)

Definition at line 495 of file miner.cpp.

  {
    if(m_do_mining)
    {
      start(m_mine_address, m_threads_total, get_is_background_mining_enabled(), get_ignore_battery());
    }
  }

Here is the call graph for this function:

pause()

void cryptonote::miner::pause

(

)

Definition at line 503 of file miner.cpp.

  {
    CRITICAL_REGION_LOCAL(m_miners_count_lock);
    MDEBUG("miner::pause: " << m_pausers_count << " -> " << (m_pausers_count + 1));
    ++m_pausers_count;
    if(m_pausers_count == 1 && is_mining())
      MDEBUG("MINING PAUSED");
  }

Here is the call graph for this function:

resume()

void cryptonote::miner::resume

(

)

Definition at line 512 of file miner.cpp.

  {
    CRITICAL_REGION_LOCAL(m_miners_count_lock);
    MDEBUG("miner::resume: " << m_pausers_count << " -> " << (m_pausers_count - 1));
    --m_pausers_count;
    if(m_pausers_count < 0)
    {
      m_pausers_count = 0;
    }
    if(!m_pausers_count && is_mining())
      MDEBUG("MINING RESUMED");
  }

Here is the call graph for this function:

send_stop_signal()

void cryptonote::miner::send_stop_signal

(

)

Definition at line 439 of file miner.cpp.

  {
    boost::interprocess::ipcdetail::atomic_write32(&m_stop, 1);
  }

Here is the caller graph for this function:

set_block_template()

bool cryptonote::miner::set_block_template	(	const block &	bl,
		const difficulty_type &	diffic,
		uint64_t	height,
		uint64_t	block_reward )

Definition at line 137 of file miner.cpp.

  {
    CRITICAL_REGION_LOCAL(m_template_lock);
    m_template = bl;
    m_diffic = di;
    m_height = height;
    m_block_reward = block_reward;
    ++m_template_no;
    m_starter_nonce = crypto::rand<uint32_t>();
    return true;
  }

Here is the call graph for this function:

set_idle_threshold()

bool cryptonote::miner::set_idle_threshold

(

uint8_t

idle_threshold

)

Definition at line 657 of file miner.cpp.

  {
    if(idle_threshold > BACKGROUND_MINING_MAX_IDLE_THRESHOLD_PERCENTAGE) return false;
    if(idle_threshold < BACKGROUND_MINING_MIN_IDLE_THRESHOLD_PERCENTAGE) return false;
    m_idle_threshold = idle_threshold;
    return true;
  }

Here is the caller graph for this function:

set_min_idle_seconds()

bool cryptonote::miner::set_min_idle_seconds

(

uint64_t

min_idle_seconds

)

Definition at line 644 of file miner.cpp.

  {
    if(min_idle_seconds > BACKGROUND_MINING_MAX_MIN_IDLE_INTERVAL_IN_SECONDS) return false;
    if(min_idle_seconds < BACKGROUND_MINING_MIN_MIN_IDLE_INTERVAL_IN_SECONDS) return false;
    m_min_idle_seconds = min_idle_seconds;
    return true;
  }

Here is the caller graph for this function:

set_mining_target()

bool cryptonote::miner::set_mining_target

(

uint8_t

mining_target

)

Definition at line 670 of file miner.cpp.

  {
    if(mining_target > BACKGROUND_MINING_MAX_MINING_TARGET_PERCENTAGE) return false;
    if(mining_target < BACKGROUND_MINING_MIN_MINING_TARGET_PERCENTAGE) return false;
    m_mining_target = mining_target;
    return true;
  }

Here is the caller graph for this function:

start()

bool cryptonote::miner::start	(	const account_public_address &	adr,
		size_t	threads_count,
		bool	do_background = false,
		bool	ignore_battery = false )

Definition at line 373 of file miner.cpp.

  {
    m_block_reward = 0;
    m_mine_address = adr;
    m_threads_total = static_cast<uint32_t>(threads_count);
    if (threads_count == 0)
    {
      m_threads_autodetect.clear();
      m_threads_autodetect.push_back({epee::misc_utils::get_ns_count(), m_total_hashes});
      m_threads_total = 1;
    }
    m_starter_nonce = crypto::rand<uint32_t>();
    CRITICAL_REGION_LOCAL(m_threads_lock);
    if(is_mining())
    {
      LOG_ERROR("Starting miner but it's already started");
      return false;
    }
 
    if(!m_threads.empty())
    {
      LOG_ERROR("Unable to start miner because there are active mining threads");
      return false;
    }
 
    request_block_template();//lets update block template
 
    boost::interprocess::ipcdetail::atomic_write32(&m_stop, 0);
    boost::interprocess::ipcdetail::atomic_write32(&m_thread_index, 0);
    set_is_background_mining_enabled(do_background);
    set_ignore_battery(ignore_battery);
    
    for(size_t i = 0; i != m_threads_total; i++)
    {
      m_threads.push_back(boost::thread(m_attrs, boost::bind(&miner::worker_thread, this)));
    }
 
    if (threads_count == 0)
      MINFO("Mining has started, autodetecting optimal number of threads, good luck!" );
    else
      MINFO("Mining has started with " << threads_count << " threads, good luck!" );
 
    if( get_is_background_mining_enabled() )
    {
      m_background_mining_thread = boost::thread(m_attrs, boost::bind(&miner::background_worker_thread, this));
      LOG_PRINT_L0("Background mining controller thread started" );
    }
 
    if(get_ignore_battery())
    {
      MINFO("Ignoring battery");
    }
 
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

stop()

bool cryptonote::miner::stop

(

)

Definition at line 444 of file miner.cpp.

  {
    MTRACE("Miner has received stop signal");
 
    CRITICAL_REGION_LOCAL(m_threads_lock);
    bool mining = !m_threads.empty();
    if (!mining)
    {
      MTRACE("Not mining - nothing to stop" );
      return true;
    }
 
    send_stop_signal();
 
    // In case background mining was active and the miner threads are waiting
    // on the background miner to signal start. 
    while (m_threads_active > 0)
    {
      m_is_background_mining_started_cond.notify_all();
      misc_utils::sleep_no_w(100);
    }
 
    // The background mining thread could be sleeping for a long time, so we
    // interrupt it just in case
    m_background_mining_thread.interrupt();
    m_background_mining_thread.join();
    m_is_background_mining_enabled = false;
 
    MINFO("Mining has been stopped, " << m_threads.size() << " finished" );
    m_threads.clear();
    m_threads_autodetect.clear();
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BACKGROUND_MINING_DEFAULT_IDLE_THRESHOLD_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_DEFAULT_IDLE_THRESHOLD_PERCENTAGE = 90

staticconstexpr

Definition at line 92 of file miner.h.

BACKGROUND_MINING_DEFAULT_MIN_IDLE_INTERVAL_IN_SECONDS

uint16_t cryptonote::miner::BACKGROUND_MINING_DEFAULT_MIN_IDLE_INTERVAL_IN_SECONDS = 10

staticconstexpr

Definition at line 95 of file miner.h.

BACKGROUND_MINING_DEFAULT_MINER_EXTRA_SLEEP_MILLIS

uint64_t cryptonote::miner::BACKGROUND_MINING_DEFAULT_MINER_EXTRA_SLEEP_MILLIS = 400

staticconstexpr

Definition at line 102 of file miner.h.

BACKGROUND_MINING_DEFAULT_MINING_TARGET_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_DEFAULT_MINING_TARGET_PERCENTAGE = 40

staticconstexpr

Definition at line 98 of file miner.h.

BACKGROUND_MINING_MAX_IDLE_THRESHOLD_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_MAX_IDLE_THRESHOLD_PERCENTAGE = 99

staticconstexpr

Definition at line 94 of file miner.h.

BACKGROUND_MINING_MAX_MIN_IDLE_INTERVAL_IN_SECONDS

uint16_t cryptonote::miner::BACKGROUND_MINING_MAX_MIN_IDLE_INTERVAL_IN_SECONDS = 3600

staticconstexpr

Definition at line 97 of file miner.h.

BACKGROUND_MINING_MAX_MINING_TARGET_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_MAX_MINING_TARGET_PERCENTAGE = 50

staticconstexpr

Definition at line 100 of file miner.h.

BACKGROUND_MINING_MIN_IDLE_THRESHOLD_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_MIN_IDLE_THRESHOLD_PERCENTAGE = 50

staticconstexpr

Definition at line 93 of file miner.h.

BACKGROUND_MINING_MIN_MIN_IDLE_INTERVAL_IN_SECONDS

uint16_t cryptonote::miner::BACKGROUND_MINING_MIN_MIN_IDLE_INTERVAL_IN_SECONDS = 10

staticconstexpr

Definition at line 96 of file miner.h.

BACKGROUND_MINING_MIN_MINER_EXTRA_SLEEP_MILLIS

uint64_t cryptonote::miner::BACKGROUND_MINING_MIN_MINER_EXTRA_SLEEP_MILLIS = 5

staticconstexpr

Definition at line 103 of file miner.h.

BACKGROUND_MINING_MIN_MINING_TARGET_PERCENTAGE

uint8_t cryptonote::miner::BACKGROUND_MINING_MIN_MINING_TARGET_PERCENTAGE = 5

staticconstexpr

Definition at line 99 of file miner.h.

BACKGROUND_MINING_MINER_MONITOR_INVERVAL_IN_SECONDS

uint8_t cryptonote::miner::BACKGROUND_MINING_MINER_MONITOR_INVERVAL_IN_SECONDS = 10

staticconstexpr

Definition at line 101 of file miner.h.

---

The documentation for this class was generated from the following files:

• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/miner.h
• /home/abuild/rpmbuild/BUILD/electroneum-5.1.3.1-build/electroneum-5.1.3.1/src/cryptonote_basic/miner.cpp