v3.12.4.6

RELEASE_NOTES

@@ -65,7 +65,31 @@ If not what makes it happen or not happen?
 Change Log
 ----------
 
-v3.12.5
+v3.12.4.6
+
+Issue #246: fixed getwork repeated new block logs with same height. New work
+for the same block is now reported as "New work" instead of New block".
+Also added a check that work is new before generating "New work" log.
+
+Added target diff to getwork new block log.
+
+Changed share ratio in share result log to simple fraction, no longer %.
+
+Added debug log to display mininginfo, use -D.
+
+v3.12.4.5
+
+Issue #246: better stale share detection for getwork, and enhanced logging
+of stale shares for stratum & getwork.
+
+Issue #251: fixed incorrect share difficulty and share ratio in share
+result log.
+
+Changed submit log to include share diff and block height.
+
+Small cosmetic changes to logs. 
+
+v3.12.4.4
 
 Issue #246: Fixed net hashrate in getwork block log,
             removed duplicate getwork block log, 

algo/scrypt/scrypt.c

@@ -440,7 +440,8 @@ static bool scrypt_1024_1_1_256_4way(const uint32_t *input,
 	for (i = 0; i < 20; i++)
 		for (k = 0; k < 4; k++)
 			W[4 * i + k] = input[k * 20 + i];
-	for (i = 0; i < 8; i++)
+
+   for (i = 0; i < 8; i++)
 		for (k = 0; k < 4; k++)
 			tstate[4 * i + k] = midstate[i];
 
@@ -466,6 +467,7 @@ static bool scrypt_1024_1_1_256_4way(const uint32_t *input,
    for (i = 0; i < 8; i++)
 		for (k = 0; k < 4; k++)
 			output[k * 8 + i] = W[4 * i + k];
+
    return true;
 }
 #endif /* HAVE_SHA256_4WAY */
@@ -505,6 +507,7 @@ static bool scrypt_1024_1_1_256_3way(const uint32_t *input,
    PBKDF2_SHA256_128_32(tstate +  0, ostate +  0, X +  0, output +  0);
 	PBKDF2_SHA256_128_32(tstate +  8, ostate +  8, X + 32, output +  8);
 	PBKDF2_SHA256_128_32(tstate + 16, ostate + 16, X + 64, output + 16);
+
    return true;
 }
 
@@ -526,7 +529,8 @@ static bool scrypt_1024_1_1_256_12way(const uint32_t *input,
 		for (i = 0; i < 20; i++)
 			for (k = 0; k < 4; k++)
 				W[128 * j + 4 * i + k] = input[80 * j + k * 20 + i];
-	for (j = 0; j < 3; j++)
+
+   for (j = 0; j < 3; j++)
 		for (i = 0; i < 8; i++)
 			for (k = 0; k < 4; k++)
 				tstate[32 * j + 4 * i + k] = midstate[i];
@@ -568,6 +572,7 @@ static bool scrypt_1024_1_1_256_12way(const uint32_t *input,
 		for (i = 0; i < 8; i++)
 			for (k = 0; k < 4; k++)
 				output[32 * j + k * 8 + i] = W[128 * j + 4 * i + k];
+
    return true;
 }
 #endif /* HAVE_SHA256_4WAY */
@@ -575,9 +580,9 @@ static bool scrypt_1024_1_1_256_12way(const uint32_t *input,
 #endif /* HAVE_SCRYPT_3WAY */
 
 #ifdef HAVE_SCRYPT_6WAY
-static bool scrypt_1024_1_1_256_24way(const uint32_t *input,
+static bool scrypt_1024_1_1_256_24way( const uint32_t *input,
-	uint32_t *output, uint32_t *midstate, unsigned char *scratchpad, int N, 
+                               uint32_t *output, uint32_t *midstate,
-   int thrid )
+                               unsigned char *scratchpad, int N, int thrid )
 {
 	uint32_t _ALIGN(128) tstate[24 * 8];
 	uint32_t _ALIGN(128) ostate[24 * 8];
@@ -586,54 +591,56 @@ static bool scrypt_1024_1_1_256_24way(const uint32_t *input,
 	uint32_t *V;
 	int i, j, k;
 	
-	V = (uint32_t *)(((uintptr_t)(scratchpad) + 63) & ~ (uintptr_t)(63));
+	V = (uint32_t *)( ( (uintptr_t)(scratchpad) + 63 ) & ~ (uintptr_t)(63) );
 	
-	for (j = 0; j < 3; j++) 
+	for ( j = 0; j < 3; j++ ) 
-		for (i = 0; i < 20; i++)
+		for ( i = 0; i < 20; i++ )
-			for (k = 0; k < 8; k++)
+			for ( k = 0; k < 8; k++ )
 				W[8 * 32 * j + 8 * i + k] = input[8 * 20 * j + k * 20 + i];
-	for (j = 0; j < 3; j++)
+
-		for (i = 0; i < 8; i++)
+   for ( j = 0; j < 3; j++ )
-			for (k = 0; k < 8; k++)
+		for ( i = 0; i < 8; i++ )
+			for ( k = 0; k < 8; k++ )
 				tstate[8 * 8 * j + 8 * i + k] = midstate[i];
 
-   HMAC_SHA256_80_init_8way(W +   0, tstate +   0, ostate +   0);
+   HMAC_SHA256_80_init_8way( W +   0, tstate +   0, ostate +   0 );
-	HMAC_SHA256_80_init_8way(W + 256, tstate +  64, ostate +  64);
+	HMAC_SHA256_80_init_8way( W + 256, tstate +  64, ostate +  64 );
-	HMAC_SHA256_80_init_8way(W + 512, tstate + 128, ostate + 128);
+	HMAC_SHA256_80_init_8way( W + 512, tstate + 128, ostate + 128 );
 
    if ( work_restart[thrid].restart ) return false;
    
-   PBKDF2_SHA256_80_128_8way(tstate +   0, ostate +   0, W +   0, W +   0);
+   PBKDF2_SHA256_80_128_8way( tstate +   0, ostate +   0, W +   0, W +   0 );
-	PBKDF2_SHA256_80_128_8way(tstate +  64, ostate +  64, W + 256, W + 256);
+	PBKDF2_SHA256_80_128_8way( tstate +  64, ostate +  64, W + 256, W + 256 );
-	PBKDF2_SHA256_80_128_8way(tstate + 128, ostate + 128, W + 512, W + 512);
+	PBKDF2_SHA256_80_128_8way( tstate + 128, ostate + 128, W + 512, W + 512 );
 
    if ( work_restart[thrid].restart ) return false;
 
-   for (j = 0; j < 3; j++)
+   for ( j = 0; j < 3; j++ )
-		for (i = 0; i < 32; i++)
+		for ( i = 0; i < 32; i++ )
-			for (k = 0; k < 8; k++)
+			for ( k = 0; k < 8; k++ )
 				X[8 * 32 * j + k * 32 + i] = W[8 * 32 * j + 8 * i + k];
 
-   scrypt_core_6way(X + 0 * 32, V, N);
+   scrypt_core_6way( X +  0 * 32, V, N );
-	scrypt_core_6way(X + 6 * 32, V, N);
+	scrypt_core_6way( X +  6 * 32, V, N );
-	scrypt_core_6way(X + 12 * 32, V, N);
+	scrypt_core_6way( X + 12 * 32, V, N );
-	scrypt_core_6way(X + 18 * 32, V, N);
+	scrypt_core_6way( X + 18 * 32, V, N );
 
    if ( work_restart[thrid].restart ) return false;
    
-   for (j = 0; j < 3; j++)
+   for ( j = 0; j < 3; j++ )
-		for (i = 0; i < 32; i++)
+		for ( i = 0; i < 32; i++ )
-			for (k = 0; k < 8; k++)
+			for ( k = 0; k < 8; k++ )
 				W[8 * 32 * j + 8 * i + k] = X[8 * 32 * j + k * 32 + i];
 
-   PBKDF2_SHA256_128_32_8way(tstate +   0, ostate +   0, W +   0, W +   0);
+   PBKDF2_SHA256_128_32_8way( tstate +   0, ostate +   0, W +   0, W +   0 );
-	PBKDF2_SHA256_128_32_8way(tstate +  64, ostate +  64, W + 256, W + 256);
+	PBKDF2_SHA256_128_32_8way( tstate +  64, ostate +  64, W + 256, W + 256 );
-	PBKDF2_SHA256_128_32_8way(tstate + 128, ostate + 128, W + 512, W + 512);
+	PBKDF2_SHA256_128_32_8way( tstate + 128, ostate + 128, W + 512, W + 512 );
 
-   for (j = 0; j < 3; j++)
+   for ( j = 0; j < 3; j++ )
-		for (i = 0; i < 8; i++)
+		for ( i = 0; i < 8; i++ )
-			for (k = 0; k < 8; k++)
+			for ( k = 0; k < 8; k++ )
 				output[8 * 8 * j + k * 8 + i] = W[8 * 32 * j + 8 * i + k];
+
    return true;
 }
 #endif /* HAVE_SCRYPT_6WAY */

configure

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.12.4.4.
+# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.12.4.6.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -577,8 +577,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='cpuminer-opt'
 PACKAGE_TARNAME='cpuminer-opt'
-PACKAGE_VERSION='3.12.4.4'
+PACKAGE_VERSION='3.12.4.6'
-PACKAGE_STRING='cpuminer-opt 3.12.4.4'
+PACKAGE_STRING='cpuminer-opt 3.12.4.6'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''
 
@@ -1332,7 +1332,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures cpuminer-opt 3.12.4.4 to adapt to many kinds of systems.
+\`configure' configures cpuminer-opt 3.12.4.6 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1404,7 +1404,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of cpuminer-opt 3.12.4.4:";;
+     short | recursive ) echo "Configuration of cpuminer-opt 3.12.4.6:";;
    esac
   cat <<\_ACEOF
 
@@ -1509,7 +1509,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-cpuminer-opt configure 3.12.4.4
+cpuminer-opt configure 3.12.4.6
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2012,7 +2012,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by cpuminer-opt $as_me 3.12.4.4, which was
+It was created by cpuminer-opt $as_me 3.12.4.6, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2993,7 +2993,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='cpuminer-opt'
- VERSION='3.12.4.4'
+ VERSION='3.12.4.6'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -6690,7 +6690,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by cpuminer-opt $as_me 3.12.4.4, which was
+This file was extended by cpuminer-opt $as_me 3.12.4.6, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -6756,7 +6756,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-cpuminer-opt config.status 3.12.4.4
+cpuminer-opt config.status 3.12.4.6
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([cpuminer-opt], [3.12.4.4])
+AC_INIT([cpuminer-opt], [3.12.4.6])
 
 AC_PREREQ([2.59c])
 AC_CANONICAL_SYSTEM

cpu-miner.c

@@ -489,6 +489,10 @@ static bool get_mininginfo( CURL *curl, struct work *work )
 	   if ( key && json_is_integer( key ) )
 		  	net_blocks = json_integer_value( key );
 
+      if ( opt_debug )
+         applog(LOG_INFO," Mining info: diff %.5g, net_hashrate %f, height %d",
+                              net_diff, net_hashrate, net_blocks );
+      
       if ( !work->height )
       {
 	      // complete missing data from getwork
@@ -890,16 +894,8 @@ static inline void sprintf_et( char *str, int seconds )
       sprintf( str, "%um%02us", min, sec );
 }
    
-// Bitcoin formula for converting difficulty to an equivalent
+const double exp32 = 4294967296.;                // 2**32
-// number of hashes.
+const double exp64 = 4294967296. * 4294967296.;  // 2**64
-//
-//     https://en.bitcoin.it/wiki/Difficulty
-//
-//     hash = diff * 2**32
-//
-// diff_to_hash = 2**32 = 0x100000000 = 4294967296;
-
-const double diff_to_hash = 4294967296.;
 
 struct share_stats_t
 {
@@ -954,9 +950,9 @@ void report_summary_log( bool force )
    double share_time = (double)et.tv_sec + (double)et.tv_usec / 1e6;
    double ghrate = global_hashrate;
 
-   double shrate = share_time == 0. ? 0. : diff_to_hash * last_targetdiff
+   double shrate = share_time == 0. ? 0. : exp32 * last_targetdiff
                                            * (double)(accepts) / share_time;
-   double sess_hrate = uptime.tv_sec == 0. ? 0. : diff_to_hash * norm_diff_sum
+   double sess_hrate = uptime.tv_sec == 0. ? 0. : exp32 * norm_diff_sum
                                                    / (double)uptime.tv_sec;
 
    double submit_rate = share_time == 0. ? 0. : (double)submits*60. / share_time;
@@ -973,8 +969,8 @@ void report_summary_log( bool force )
    sprintf_et( et_str, et.tv_sec );
    sprintf_et( upt_str, uptime.tv_sec );
 
-   applog( LOG_NOTICE, "Periodic Report     %s        %s", et_str, upt_str );
+   applog( LOG_BLUE, "%s: %s", algo_names[ opt_algo ], short_url );
-   applog2( LOG_INFO, "%s: %s", algo_names[ opt_algo ], short_url );
+   applog2( LOG_NOTICE, "Periodic Report     %s        %s", et_str, upt_str );
    applog2( LOG_INFO, "Share rate        %.2f/min     %.2f/min",
                       submit_rate, (double)submitted_share_count*60. /
                     ( (double)uptime.tv_sec + (double)uptime.tv_usec / 1e6 ) );
@@ -985,11 +981,11 @@ void report_summary_log( bool force )
    if ( accepted_share_count < submitted_share_count )
    {
       double lost_ghrate = uptime.tv_sec == 0. ? 0.
-                  : diff_to_hash * last_targetdiff
+                  : exp32 * last_targetdiff
                       * (double)(submitted_share_count - accepted_share_count )
                     / (double)uptime.tv_sec;
       double lost_shrate = share_time == 0. ? 0.
-               : diff_to_hash * last_targetdiff  * (double)(submits - accepts )
+               : exp32 * last_targetdiff  * (double)(submits - accepts )
                 / share_time;
       char lshr_units[4] = {0};
       char lghr_units[4] = {0};
@@ -1016,7 +1012,7 @@ void report_summary_log( bool force )
 
 bool lowdiff_debug = false;
 
-static int share_result( int result, struct work *null_work,
+static int share_result( int result, struct work *work,
                          const char *reason )
 {
    double share_time = 0., share_ratio = 0.;
@@ -1061,8 +1057,7 @@ static int share_result( int result, struct work *null_work,
    }
 
    share_ratio = my_stats.net_diff == 0. ? 0. : my_stats.share_diff /
-                                                my_stats.net_diff * 100.;
+                                                my_stats.net_diff;
-
    // check result
    if ( likely( result ) )
    {
@@ -1087,9 +1082,10 @@ static int share_result( int result, struct work *null_work,
    {
      sprintf( ares, "A%d", accepted_share_count );
      sprintf( bres, "B%d", solved_block_count );
-     if ( reason && strstr( reason, "Invalid job id" ) )
+     if ( work ) stale = work->stale;
+     if ( reason ) stale = stale || strstr( reason, "Invalid job id" );
+     if ( stale )
      {
-        stale = true;
         stale_share_count++;
         sprintf( sres, "Stale %d", stale_share_count );
         sprintf( rres, "R%d", rejected_share_count );
@@ -1125,65 +1121,32 @@ static int share_result( int result, struct work *null_work,
 
    pthread_mutex_unlock( &stats_lock );
 
-/*
-   if ( likely( result ) )
-   {
-     if ( unlikely( solved ) )
-     {
-       sprintf( bres, "BLOCK SOLVED %d", solved_block_count );
-       sprintf( ares, "A%d", accepted_share_count );
-     }
-     else
-     {
-       sprintf( bres, "B%d", solved_block_count );
-       sprintf( ares, "Accepted %d", accepted_share_count );
-     }
-     sprintf( sres, "S%d", stale_share_count );
-     sprintf( rres, "R%d", rejected_share_count );
-   }
-   else  
-   {
-     sprintf( ares, "A%d", accepted_share_count );
-     sprintf( bres, "B%d", solved_block_count );
-     if ( stale )
-     {
-        sprintf( sres, "Stale %d", stale_share_count );
-        sprintf( rres, "R%d", rejected_share_count );
-     }
-     else
-     {
-        sprintf( sres, "S%d", stale_share_count ); 
-        sprintf( rres, "Rejected %d" , rejected_share_count );
-     }
-   } 
-*/
-
    if ( use_colors )
    {
-     bcol = acol = scol = rcol = CL_WHT;
+     bcol = acol = scol = rcol = CL_N;
      if ( likely( result ) )
      {
-       acol = CL_GRN;  
+       acol = CL_WHT CL_GRN;  
-       if ( unlikely( solved ) ) bcol = CL_MAG;
+       if ( unlikely( solved ) ) bcol = CL_WHT CL_MAG;
      }        
-     else if ( stale ) scol = CL_YL2;
+     else if ( stale ) scol = CL_WHT CL_YL2;
-     else              rcol = CL_RED;
+     else              rcol = CL_WHT CL_RED;
    }
    else
       bcol = acol = scol = rcol = "\0";
 
-   applog( LOG_NOTICE, "%d %s%s %s%s %s%s %s%s" CL_WHT ", %.3f sec (%dms)",
+   applog( LOG_NOTICE, "%d %s%s %s%s %s%s %s%s" CL_N ", %.3f sec (%dms)",
            my_stats.share_count, acol, ares, scol, sres, rcol, rres, bcol,
            bres, share_time, latency );
 
    if ( !opt_quiet )
    {
       if ( have_stratum )
-         applog2( LOG_NOTICE, "Diff %.5g (%.3g%), %sBlock %d, %sJob %s" CL_WHT,
+         applog2( LOG_INFO, "Diff %.5g (%.3g), %sBlock %d" CL_N ", %sJob %s",
                my_stats.share_diff, share_ratio, bcol, stratum.block_height,
                scol, my_stats.job_id );
       else
-         applog2( LOG_NOTICE, "Diff %.5g (%.3g%), %sBlock %d" CL_WHT,
+         applog2( LOG_INFO, "Diff %.5g (%.3g), %sBlock %d",
                my_stats.share_diff, share_ratio, bcol, stratum.block_height );
    }
 
@@ -1359,27 +1322,29 @@ char* std_malloc_txs_request( struct work *work )
 
 static bool submit_upstream_work( CURL *curl, struct work *work )
 {
-
+   work->stale = false;
-   /* pass if the previous hash is not the current previous hash */
+   // Submit anyway, discardring here messes up the stats
-/* Submit anyway, discardring here messes up the stats
-   if ( !submit_old && memcmp( &work->data[1], &g_work.data[1], 32 ) )
-   {
-      applog( LOG_WARNING, "Stale work detected, discarding" );
-      return true;
-   }
-
    if ( !have_stratum && allow_mininginfo )
    {
       struct work mining_info;
       get_mininginfo( curl, &mining_info );
       if ( work->height < mining_info.height )
       {
- 	      applog( LOG_WARNING, "Block %u was already solved, current block %d",
+ 	      if ( !opt_quiet )
-                               work->height, mining_info.height );
+            applog( LOG_WARNING, "Block %u already solved, current block %d",
-	      return true;
+                                 work->height, mining_info.height );
+         work->stale = true;
       }
    }
-*/
+
+   /* pass if the previous hash is not the current previous hash */
+   if ( !( work->stale || submit_old )
+        && memcmp( &work->data[1], &g_work.data[1], 32 ) )
+   {
+      if ( !opt_quiet )
+         applog( LOG_WARNING, "Stale work detected, submitting anyway" );
+      work->stale = true;
+   }
 
    if ( have_stratum )
    {
@@ -1501,47 +1466,78 @@ start:
    else
       rc = work_decode( json_object_get( val, "result" ), work );
 
-   if ( opt_protocol && rc )
+   if ( rc ) 
    {
-      timeval_subtract( &diff, &tv_end, &tv_start );
+      if ( opt_protocol )
-      applog( LOG_DEBUG, "got new work in %.2f ms",
-              ( 1000.0 * diff.tv_sec ) + ( 0.001 * diff.tv_usec ) );
-   }
-
-   json_decref( val );
-   // store work height in solo
-   get_mininginfo(curl, work);
-
-   applog( LOG_BLUE, "New block %d, diff %.5g", work->height, net_diff );
-
-   if ( !opt_quiet && net_diff && net_hashrate )
-   {
-      double miner_hr = 0.;
-      pthread_mutex_lock( &stats_lock );
-
-      for ( int i = 0; i < opt_n_threads; i++ )
-         miner_hr += thr_hashrates[i];
-      global_hashrate = miner_hr;
-
-      pthread_mutex_unlock( &stats_lock );
-
-      if ( miner_hr )
       {
-         double net_hr = net_hashrate;
+         timeval_subtract( &diff, &tv_end, &tv_start );
-         char net_hr_units[4] = {0};
+         applog( LOG_DEBUG, "got new work in %.2f ms",
-         char miner_hr_units[4] = {0};
+              ( 1000.0 * diff.tv_sec ) + ( 0.001 * diff.tv_usec ) );
-         char net_ttf[32];
-         char miner_ttf[32];
-
-         sprintf_et( net_ttf, net_diff * diff_to_hash / net_hr );
-         sprintf_et( miner_ttf, net_diff * diff_to_hash / miner_hr );
-         scale_hash_for_display ( &miner_hr, miner_hr_units );
-         scale_hash_for_display ( &net_hr, net_hr_units );
-         applog2(LOG_INFO, "Miner TTF @ %.2f %sh/s %s, net TTF @ %.2f %sh/s %s",
-                             miner_hr, miner_hr_units, miner_ttf,
-                             net_hr, net_hr_units, net_ttf );
       }
-   }
+
+      json_decref( val );
+      // store work height in solo
+      get_mininginfo(curl, work);
+
+      if ( work->height > last_block_height )
+      {
+         last_block_height = work->height;
+         applog( LOG_BLUE, "New block %d, net diff %.5g, target diff %.5g",
+                 work->height, net_diff, work->targetdiff );
+
+         if ( !opt_quiet && net_diff && net_hashrate )
+         {
+            double miner_hr = 0.;
+            pthread_mutex_lock( &stats_lock );
+
+            for ( int i = 0; i < opt_n_threads; i++ )
+               miner_hr += thr_hashrates[i];
+            global_hashrate = miner_hr;
+
+            pthread_mutex_unlock( &stats_lock );
+
+            if ( miner_hr )
+            {
+               double net_hr = net_hashrate;
+               char net_hr_units[4] = {0};
+               char miner_hr_units[4] = {0};
+               char net_ttf[32];
+               char miner_ttf[32];
+
+               sprintf_et( net_ttf, ( work->targetdiff * exp32 ) / net_hr );
+               sprintf_et( miner_ttf, ( work->targetdiff * exp32 ) / miner_hr );
+               scale_hash_for_display ( &miner_hr, miner_hr_units );
+               scale_hash_for_display ( &net_hr, net_hr_units );
+               applog2( LOG_INFO,
+                         "Miner TTF @ %.2f %sh/s %s, net TTF @ %.2f %sh/s %s",
+                                miner_hr, miner_hr_units, miner_ttf,
+                                net_hr, net_hr_units, net_ttf );
+            }
+         }
+      }  // work->height > last_block_height
+      else if ( memcmp( &work->data[1], &g_work.data[1], 32 ) )
+      {
+         applog( LOG_BLUE, "New work" );
+         if ( opt_debug )
+         {
+            uint32_t *old = g_work.data;
+            uint32_t *new = work->data;
+            printf("old: %08x %08x %08x %08x %08x %08x %08x %08x/n",
+              old[0],old[1],old[2],old[3],old[4],old[5],old[6],old[7]); 
+            printf("     %08x %08x %08x %08x %08x %08x %08x %08x/n",
+              old[8],old[9],old[10],old[11],old[12],old[13],old[14],old[15]); 
+            printf("     %08x %08x %08x %08x/n",
+                    old[16],old[17],old[18],old[19]); 
+            printf("new: %08x %08x %08x %08x %08x %08x %08x %08x/n",
+              new[0],new[1],new[2],new[3],new[4],new[5],new[6],new[7]);       
+            printf("     %08x %08x %08x %08x %08x %08x %08x %08x/n",
+              new[8],new[9],new[10],new[11],new[12],new[13],new[14],new[15]);  
+            printf("     %08x %08x %08x %08x/n",
+                    new[16],new[17],new[18],new[19]);                        
+         }
+      }
+   }  // rc
+
    return rc;
 }
 
@@ -1706,8 +1702,7 @@ static bool get_work(struct thr_info *thr, struct work *work)
 	return true;
 }
 
-bool submit_work( struct thr_info *thr,
+bool submit_work( struct thr_info *thr, const struct work *work_in )
-                         const struct work *work_in )
 {
 	struct workio_cmd *wc;
 
@@ -1731,27 +1726,47 @@ err_out:
 	return false;
 }
 
+/*
 // __float128?
 // Convert little endian 256 bit (38 decimal digits) unsigned integer to
 // double precision floating point with 15 decimal digits precision.
-// returns u * ( 2**256 ) 
 static inline double u256_to_double( const uint64_t *u )
 {
    const double exp64 = 4294967296.0 * 4294967296.0;  // 2**64
    return ( ( u[3] * exp64 + u[2] ) * exp64 + u[1] ) * exp64 + u[0];
 }
+*/
 
+static void update_submit_stats( struct work *work, const void *hash )
+{
+  // Workaround until problems with target_to_diff are resolved.
+  work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
+                                / (double)( ((uint64_t*)work->target)[3] );
+//     work->sharediff = likely( hash ) ? target_to_diff( (uint32_t*)hash ) : 0.;
+
+   pthread_mutex_lock( &stats_lock );
+
+   submitted_share_count++;
+   share_stats[ s_put_ptr ].share_count = submitted_share_count;
+   gettimeofday( &share_stats[ s_put_ptr ].submit_time, NULL );
+   share_stats[ s_put_ptr ].share_diff = work->sharediff;
+   share_stats[ s_put_ptr ].net_diff = net_diff;
+   share_stats[ s_put_ptr ].stratum_diff = stratum_diff;
+   share_stats[ s_put_ptr ].target_diff = work->targetdiff;
+   if ( have_stratum )
+      strncpy( share_stats[ s_put_ptr ].job_id, work->job_id, 30 );
+   s_put_ptr = stats_ptr_incr( s_put_ptr );
+
+   pthread_mutex_unlock( &stats_lock );
+}
+
+//deprecated
 void work_set_target_ratio( struct work* work, const void *hash )
 {
-   if ( likely( hash ) )
+   submitted_share_count++;
-   {
+   work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
-      double dhash = u256_to_double( (const uint64_t*)hash );
+                                / (double)( ((uint64_t*)work->target)[3] );
-      if ( likely( dhash > 0. ) )
+//   work->sharediff = likely( hash ) ? target_to_diff( (uint32_t*)hash ) : 0.;
-         work->sharediff = work->targetdiff *
-             u256_to_double( (const uint64_t*)( work->target ) ) / dhash;
-   }
-   else
-      work->sharediff = 0.;
 
    // collect some share stats
    // Frequent share submission combined with high latency can caused
@@ -1777,20 +1792,20 @@ bool submit_solution( struct work *work, const void *hash,
 {
   if ( likely( submit_work( thr, work ) ) )
   {
-     submitted_share_count++;
+     update_submit_stats( work, hash );
-     work_set_target_ratio( work, hash );
 
      if ( !opt_quiet )
      {
-        if ( have_stratum )
+            if ( have_stratum )
-           applog( LOG_NOTICE, "%d submitted by thread %d, job %s",
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
-               submitted_share_count, thr->id, work->job_id );
+                      submitted_share_count, work->sharediff, work->height,
-        else
+                      work->job_id );
-           applog( LOG_NOTICE, "%d submitted by thread %d",
+            else
-               submitted_share_count, thr->id );
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
+                      submitted_share_count, work->sharediff, work->height );
      }
 
-     if ( lowdiff_debug )
+     if ( unlikely( lowdiff_debug ) )
      {
         uint32_t* h = (uint32_t*)hash;
         uint32_t* t = (uint32_t*)work->target;
@@ -1802,27 +1817,27 @@ bool submit_solution( struct work *work, const void *hash,
      return true;
   }
   else
-     applog( LOG_WARNING, "%d failed to submit share thread %d.",
+     applog( LOG_WARNING, "%d failed to submit share", submitted_share_count );
-             submitted_share_count, thr->id );
   return false;
 }
 
+// deprecated, use submit_solution
 bool submit_lane_solution( struct work *work, const void *hash,
                            struct thr_info *thr, const int lane )
 {
   if ( likely( submit_work( thr, work ) ) )
   {
-     submitted_share_count++;
+     update_submit_stats( work, hash );
-     work_set_target_ratio( work, hash );
 
      if ( !opt_quiet )
      {
-        if ( have_stratum )
+            if ( have_stratum )
-           applog( LOG_NOTICE, "%d submitted by thread %d, lane %d, job %s",
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
-               submitted_share_count, thr->id, lane, work->job_id );
+                      submitted_share_count, work->sharediff, work->height,
-        else
+                      work->job_id );
-           applog( LOG_NOTICE, "%d submitted by thread %d, lane %d",
+            else
-               submitted_share_count, thr->id, lane );
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
+                      submitted_share_count, work->sharediff, work->height );
      }
 
      if ( lowdiff_debug )
@@ -1837,11 +1852,54 @@ bool submit_lane_solution( struct work *work, const void *hash,
     return true;
   }
   else
-     applog( LOG_WARNING, "%d failed to submit share, thread %d, lane %d.",
+     applog( LOG_WARNING, "%d failed to submit share", submitted_share_count );
-          submitted_share_count, thr->id, lane );
+
   return false;
 }
 
+
+// The new way, replaces fulltest and submit_solution
+bool test_hash_and_submit( struct work *work, const void *hash,
+                           struct thr_info *thr )
+{
+   work->sharediff = work->targetdiff * (double)( ((uint64_t*)hash)[3] )
+                                / (double)( ((uint64_t*)work->target)[3] );
+
+   if ( work->sharediff >= work->targetdiff )
+   {
+      if ( likely( submit_work( thr, work ) ) )
+      {
+         update_submit_stats( work, hash );
+
+         if ( !opt_quiet )
+         {
+            if ( have_stratum )
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d, job %s",
+                      submitted_share_count, work->sharediff, work->height,
+                      work->job_id );
+            else
+              applog( LOG_NOTICE, "%d Submit diff %.5g, block %d",
+                      submitted_share_count, work->sharediff, work->height );
+         }
+
+         if ( lowdiff_debug )
+         {
+           uint32_t* h = (uint32_t*)hash;
+           uint32_t* t = (uint32_t*)work->target;
+           applog(LOG_INFO,"Hash[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
+                                      h[7],h[6],h[5],h[4],h[3],h[2],h[1],h[0]);
+           applog(LOG_INFO,"Targ[7:0]: %08x %08x %08x %08x %08x %08x %08x %08x",
+                                      t[7],t[6],t[5],t[4],t[3],t[2],t[1],t[0]);
+         }
+         return true;
+       }
+       else
+          applog( LOG_WARNING, "%d failed to submit share, thread %d",
+                               submitted_share_count, thr->id );
+   }
+   return false;
+}
+
 static bool wanna_mine(int thr_id)
 {
 	bool state = true;
@@ -2249,7 +2307,7 @@ static void *miner_thread( void *userdata )
              }
              else
                 sprintf( tempstr, "%d C", temp );
-             applog( LOG_INFO,"CPU temp: curr %s (max %d), Freq: %.3f/%.3f GHz",
+             applog( LOG_NOTICE,"CPU temp: curr %s (max %d), Freq: %.3f/%.3f GHz",
                      tempstr, hi_temp, (float)lo_freq / 1e6, (float)hi_freq/ 1e6 );
              if ( temp > hi_temp ) hi_temp = temp;
           }
@@ -2567,8 +2625,12 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
    algo_gate.build_extraheader( g_work, sctx );
    net_diff = algo_gate.calc_network_diff( g_work );
    algo_gate.set_work_data_endian( g_work );
-   work_set_target( g_work, sctx->job.diff
+   g_work->height = sctx->block_height;
-                                  / ( opt_target_factor * opt_diff_factor ) );
+   g_work->targetdiff = sctx->job.diff
+                      / ( opt_target_factor * opt_diff_factor );
+   diff_to_target( g_work->target, g_work->targetdiff );
+//   work_set_target( g_work, sctx->job.diff
+//                                  / ( opt_target_factor * opt_diff_factor ) );
 
    pthread_mutex_unlock( &sctx->work_lock );
 
@@ -2623,8 +2685,8 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
             char block_ttf[32];
             char share_ttf[32];
 
-            sprintf_et( block_ttf, net_diff * diff_to_hash / hr );
+            sprintf_et( block_ttf, ( net_diff * exp32 ) /  hr );
-            sprintf_et( share_ttf, last_targetdiff * diff_to_hash / hr );
+            sprintf_et( share_ttf, last_targetdiff * exp32 / hr );
             scale_hash_for_display ( &hr, hr_units );
             applog2( LOG_INFO, "TTF @ %.2f %sh/s: block %s, share %s",
                                hr, hr_units, block_ttf, share_ttf );
@@ -2639,7 +2701,7 @@ void std_stratum_gen_work( struct stratum_ctx *sctx, struct work *g_work )
                     : et.tv_sec / ( last_block_height - session_first_block );
                if ( net_diff && net_ttf )
                {
-                  double net_hr = net_diff * diff_to_hash / net_ttf;
+                  double net_hr = net_diff * exp32 / net_ttf;
                   char net_ttf_str[32];
                   char net_hr_units[4] = {0};
 
@@ -3701,9 +3763,6 @@ int main(int argc, char *argv[])
 */
    }
 
-   applog( LOG_INFO, "Extranonce subscribe: %s",
-                           opt_extranonce ? "YES" : "NO" );
-
 #ifdef HAVE_SYSLOG_H
 	if (use_syslog)
 		openlog("cpuminer", LOG_PID, LOG_USER);

miner.h

@@ -312,6 +312,19 @@ int    varint_encode( unsigned char *p, uint64_t n );
 size_t address_to_script( unsigned char *out, size_t outsz, const char *addr );
 int    timeval_subtract( struct timeval *result, struct timeval *x,
                            struct timeval *y);
+
+// Bitcoin formula for converting difficulty to an equivalent
+// number of hashes.
+//
+//     https://en.bitcoin.it/wiki/Difficulty
+//
+//     hash = diff * 2**32
+//
+// diff_to_hash = 2**32 = 0x100000000 = 4294967296 = exp32;
+
+const double exp32;  // 2**32
+const double exp64;  // 2**64
+
 bool   fulltest( const uint32_t *hash, const uint32_t *target );
 bool   valid_hash( const void*, const void* );
 
@@ -332,11 +345,12 @@ struct thr_info {
 
 //struct thr_info *thr_info;
 
-bool   submit_solution( struct work *work, const void *hash,
+bool submit_solution( struct work *work, const void *hash,
-                        struct thr_info *thr );
+                      struct thr_info *thr );
-bool   submit_lane_solution( struct work *work, const void *hash,
+bool submit_lane_solution( struct work *work, const void *hash,
-                             struct thr_info *thr, const int lane );
+                           struct thr_info *thr, const int lane );
 
+bool test_hash_and_submit( struct work*, const void*, struct thr_info* );
 
 bool submit_work( struct thr_info *thr, const struct work *work_in );
 
@@ -378,6 +392,7 @@ struct work {
 	size_t xnonce2_len;
 	unsigned char *xnonce2;
    bool sapling;
+   bool stale;
 
    // x16rt
    uint32_t merkleroothash[8];

util.c

@@ -983,6 +983,7 @@ int timeval_subtract(struct timeval *result, struct timeval *x,
 	return x->tv_sec < y->tv_sec;
 }
 
+// deprecated, use test_hash_and_submit
 // Use this when deinterleaved
 // do 64 bit test 4 iterations
 inline bool valid_hash( const void *hash, const void *target )
@@ -999,6 +1000,7 @@ inline bool valid_hash( const void *hash, const void *target )
    return true;
 }
 
+// deprecated, use test_hash_and_submit
 bool fulltest( const uint32_t *hash, const uint32_t *target )
 {
 	int i;
@@ -1039,37 +1041,55 @@ bool fulltest( const uint32_t *hash, const uint32_t *target )
 	return rc;
 }
 
+/*
 void diff_to_target(uint32_t *target, double diff)
 {
-	uint64_t m;
+   uint64_t m;
+   int k;
+
+   for (k = 6; k > 0 && diff > 1.0; k--)
+      diff /= 4294967296.0;
+
+   m = (uint64_t)(4294901760.0 / diff);
+
+   if (m == 0 && k == 6)
+      memset(target, 0xff, 32);
+   else {
+      memset(target, 0, 32);
+      target[k] = (uint32_t)m;
+      target[k + 1] = (uint32_t)(m >> 32);
+   }
+}
+*/
+
+
+void diff_to_target(uint32_t *target, double diff)
+{
+   uint64_t *t = (uint64_t*)target;
+   uint64_t m;
 	int k;
 	
-   const double exp64 = (double)0xffffffffffffffff + 1.;   
    for ( k = 3; k > 0 && diff > 1.0; k-- )
       diff /= exp64;
 
-//   for (k = 6; k > 0 && diff > 1.0; k--)
+   m = (uint64_t)( 0xffff0000 / diff );
-//		diff /= 4294967296.0;
+
-	m = (uint64_t)( 0xffff0000 / diff );
+   if unlikely( m == 0 && k == 3 )
-	if unlikely( m == 0 && k == 3 )
+		memset( t, 0xff, 32 );
-		memset( target, 0xff, 32 );
 	else
    {
-		memset( target, 0, 32 );
+		memset( t, 0, 32 );
-      ((uint64_t*)target)[k] = m;
+      t[k] = m;
-//		target[k] = (uint32_t)m;
-//		target[k + 1] = (uint32_t)(m >> 32);
 	}
 }
 
-// Only used by stratum pools
+// deprecated
 void work_set_target(struct work* work, double diff)
 {
 	diff_to_target( work->target, diff );
 	work->targetdiff = diff;
 }
 
-// Only used by longpoll pools
 double target_to_diff(uint32_t* target)
 {
 	uchar* tgt = (uchar*) target;
@@ -1546,35 +1566,44 @@ bool stratum_authorize(struct stratum_ctx *sctx, const char *user, const char *p
 
 	ret = true;
 
-	if (!opt_extranonce)
+	if ( !opt_extranonce )
 		goto out;
 
 	// subscribe to extranonce (optional)
 	sprintf(s, "{\"id\": 3, \"method\": \"mining.extranonce.subscribe\", \"params\": []}");
 
-	if (!stratum_send_line(sctx, s))
+	if ( !stratum_send_line( sctx, s ) )
 		goto out;
 
-	if (!socket_full(sctx->sock, 3)) {
+	if ( !socket_full( sctx->sock, 3 ) )
-         applog(LOG_WARNING, "stratum extranonce subscribe timed out");
+   {
-		goto out;
+      applog( LOG_WARNING, "Extranonce disabled, subscribe timed out" );
+		opt_extranonce = false;
+      goto out;
 	}
+   if ( !opt_quiet )
+      applog( LOG_INFO, "Extranonce subscription enabled" );
 
-	sret = stratum_recv_line(sctx);
+	sret = stratum_recv_line( sctx );
-	if (sret) {
+	if ( sret )
-		json_t *extra = JSON_LOADS(sret, &err);
+   {
-		if (!extra) {
+		json_t *extra = JSON_LOADS( sret, &err );
+		if ( !extra )
+      {
 			applog(LOG_WARNING, "JSON decode failed(%d): %s", err.line, err.text);
-		} else {
+		}
-			if (json_integer_value(json_object_get(extra, "id")) != 3) {
+      else
+      {
+			if ( json_integer_value(json_object_get( extra, "id" ) ) != 3 )
+         {
 				// we receive a standard method if extranonce is ignored
-				if (!stratum_handle_method(sctx, sret))
+				if ( !stratum_handle_method( sctx, sret ) )
-					applog(LOG_WARNING, "Stratum answer id is not correct!");
+					applog( LOG_WARNING, "Stratum answer id is not correct!" );
 			}
-			res_val = json_object_get(extra, "result");
+			res_val = json_object_get( extra, "result" );
 //			if (opt_debug && (!res_val || json_is_false(res_val)))
 //				applog(LOG_DEBUG, "extranonce subscribe not supported");
-			json_decref(extra);
+			json_decref( extra );
 		}
 		free(sret);
 	}