void read_loop()
{
const int BUFFER_SIZE = 16;
const int LEFTOVER = BUFFER_SIZE - sizeof(message_header);
try {
message m;
while( !read_loop_complete.canceled() )
{
char tmp[BUFFER_SIZE];
ilog( "read.." );
sock->read( tmp, BUFFER_SIZE );
ilog( "." );
memcpy( (char*)&m, tmp, sizeof(message_header) );
m.data.resize( m.size + 16 ); //give extra 16 bytes to allow for padding added in send call
memcpy( (char*)m.data.data(), tmp + sizeof(message_header), LEFTOVER );
sock->read( m.data.data() + LEFTOVER, 16*((m.size -LEFTOVER + 15)/16) );
try { // message handling errors are warnings...
con_del->on_connection_message( self, m );
}
catch ( fc::canceled_exception& e ) { wlog(".");throw; }
catch ( fc::eof_exception& e ) { wlog(".");throw; }
catch ( fc::exception& e )
{
wlog( "disconnected ${er}", ("er", e.to_detail_string() ) );
return;
// TODO: log and potentiall disconnect... for now just warn.
}
catch( ... )
{
wlog("...????" );
return;
}
}
}
catch ( const fc::canceled_exception& e )
{
if( con_del )
{
con_del->on_connection_disconnected( self );
}
else
{
wlog( "disconnected ${e}", ("e", e.to_detail_string() ) );
}
wlog( "exit read loop" );
return;
}
catch ( const fc::eof_exception& e )
{
if( con_del )
{
ilog( ".");
fc::async( [=](){con_del->on_connection_disconnected( self );} );
ilog( ".");
}
else
{
wlog( "disconnected ${e}", ("e", e.to_detail_string() ) );
}
}
catch ( fc::exception& er )
{
wlog( ".." );
if( con_del )
{
elog( "disconnected ${er}", ("er", er.to_detail_string() ) );
//con_del->on_connection_disconnected( self );
fc::async( [=](){con_del->on_connection_disconnected( self );} );
}
else
{
elog( "disconnected ${e}", ("e", er.to_detail_string() ) );
}
FC_RETHROW_EXCEPTION( er, warn, "disconnected ${e}", ("e", er.to_detail_string() ) );
}
catch ( ... )
{
wlog( "unhandled??" );
// TODO: call con_del->????
FC_THROW_EXCEPTION( unhandled_exception, "disconnected: {e}", ("e", fc::except_str() ) );
}
}
void mining_loop()
{
while( !_mining_loop_complete.canceled() )
{
try {
if( _current_block.prev == block_id_type() || !_callback || _effort < 0.01 || _prev_header.next_difficulty == 0 )
{
ilog( "${current.prev} _effort ${effort} prev_header: ${prev_header}",
("current.prev",_current_block.prev)("effort",_effort)("prev_header",_prev_header) );
fc::usleep( fc::microseconds( 1000*1000 ) );
continue;
}
auto start = fc::time_point::now();
block_header tmp = _current_block;
tmp.timestamp = fc::time_point::now();
auto next_diff = _prev_header.next_difficulty * 300*1000000ll / (tmp.timestamp - _prev_header.timestamp).count();
tmp.next_difficulty = (_prev_header.next_difficulty * 24 + next_diff ) / 25;
tmp.noncea = 0;
tmp.nonceb = 0;
auto tmp_id = tmp.id();
auto seed = fc::sha256::hash( (char*)&tmp_id, sizeof(tmp_id) );
auto pairs = momentum_search( seed );
for( auto collision : pairs )
{
tmp.noncea = collision.first;
tmp.nonceb = collision.second;
FC_ASSERT( _min_votes > 0 );
FC_ASSERT( _prev_header.next_difficulty > 0 );
ilog( "difficlty ${d} target ${t} tmp.get_difficulty ${dd} mv ${mv} min: ${min} block:\n${block}", ("min",_min_votes)("mv",_miner_votes)("dd",tmp.get_difficulty())
("d",(tmp.get_difficulty() * _miner_votes)/_min_votes)("t",_prev_header.next_difficulty)("block",_current_block) );
if( (tmp.get_difficulty() * _miner_votes)/_min_votes >= _prev_header.next_difficulty )
{
if( _callback )
{
auto cb = _callback;
_main_thread->async( [cb,tmp](){cb( tmp );} );
}
_effort = 0;
break;
}
}
// search space...
auto end = fc::time_point::now();
// wait while checking for cancel...
if( _effort < 1.0 )
{
auto calc_time = (end-start).count();
auto wait_time = ((1-_effort)/_effort) * calc_time;
auto wait_until = end + fc::microseconds(wait_time);
if( wait_until > fc::time_point::now() && !_mining_loop_complete.canceled() )
{
ilog( "." );
fc::usleep( fc::microseconds( 1000*100 ) );
}
}
else
{
ilog( "." );
fc::usleep( fc::microseconds(1000*10) );
}
}
catch ( const fc::exception& e )
{
wlog( "${e}", ("e",e.to_detail_string() ));
}
} // while
} /// mining_loop