Overclock.net banner

1 - 20 of 52 Posts

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #1 (Edited)
First, many thanks go to the 'Pi - Unleashed' authors - Jörg Arndt; Christoph Haenel.

It's time for something simplistic, yet quite useful, in sense of telling your actual single-threaded REAL INTEGER CPU performance - the awesome SPIGOT PI algorithm.
The thing that stands out is the brutal disregard of your CPU caches, RAM size and speed, in essence, the benchmark highlights the frequency of your CPU without bothering to measure steppings and time-intervals - it simply reports a STABLE number, like 32 DPS (on my Core 2 laptop), meaning 32 digits-per-second, that is all.



Funny, my "faster" laptop with i5-7200U @ 2.5GHz, which is advertised to have boost of 3.1GHz, while actually works at 2.7GHz reports less than 32... as it should!

I believe, all nifty benchmarks have to come with their source, thus allowing people to see what actually is executed, so, here the .C source comes:

Please share your ?? DPS with your CPU-Z screenshot, my wish is fellow members to enrich the experience, maybe I will come up with some add-ons in the .C source, given below:

Code:
#ifdef _N_HIGH_PRIORITY
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms686219.aspx
#include <stdio.h>
#include <windows.h>
#include <tchar.h>
#endif

// Rabinowitz and Wagon call their algorithm a spigot algorithm, 
// because it yields digits incrementally and does not reuse digits 
// after they have been computed. The digits drip out one by one,
// as if from a leaky tap.

/*

     inf     2  (i+1)
     __  (i!)  2            1       2       3              i
PI = \  _____________ = 2 + - ( 2 + - ( 2 + - ( ... ( 2 + ---- (...) ) ) ) )
     /   (2i+1)!            3       5       7             2i+1
     ~~
     i=0

i=0: 2 = 2 + 0x(2)
Because:
2= 2
2+0*(2)= 2

i=1: 2 + 1x4/(1x2x3) = 2 + 1/3x(2)
Because:
2+1*4/(1*2*3)= 2.6666666666666666666666666666667
2+1/3*(2)= 2.6666666666666666666666666666667

i=2: 2 + 1x4/(1x2x3) + 4x8/(1x2x3x4x5) = 2 + 1/3x(2 + 2/5x(2))
Because:
2+1*4/(1*2*3)+4*8/(1*2*3*4*5)= 2+1*4/(1*2*3)+4*8/(1*2*3*4*5)= 2.9333333333333333333333333333333
2+1/3*(2+2/5*(2))= 2.9333333333333333333333333333333

*/

// https://www.jjj.de/hfloat/spigot.haenel.txt

/*
To the spigot programs, I have several comments .

At spigotpi.c

The program is a 1:1 port of the PASCAL program of the original paper of
Rabinowitz and Wagon.
The ported program has herited several bugs from the
original program and this in turn suffers from the erreanous algorithm:

1. The program fails when used to calculate N=1 or N=32 decimals
of pi. In these cases is the chain length LEN = [10N/3] by 1 too small.
Ironically enough, Rabinowitz and Wagon "proof" in their paper
the expression [10N/3] to be "correct" (Lemma 5).

2. The program fails when used to calculate N=85,167,245 and
many more values of N.
The reason is that the number of iterations of the outer loop is too
small. This loop must be iterated "as long as the number of true
decimals is not greater N".

3. The program computes in many cases less decimals than it should.
Such cases are e.g. N= 6,13,15,31 and many more. An extreme is N=768 where
only 761 digits will be computed. 
This occurs for the same reason as point 2.

4. Here is a version of the program which seems to be correct in these
respects and hopefully without new bugs. (It is also faster.)
*/

/* A spigot algorithm for the digits of pi, Stanley Rabinowitz
   and Stan Wagon, Amer.Math.Monthly, March 1995, 195-203
   Bug fixes by C. Haenel.
   The program can be compiled with an 16- or 32-Bit compiler.
   The upper limit for N is 9826 on 16 Bit and (at least) 50000
   on 32 Bit compilers.
*/

#define N     1000000             // Decimals to compute.
#define LEN   (10L * N) / 3 + 1   // Chain length

unsigned j, predigit, nines, a[LEN];
long x, q, k, len, i;

long DigitsSoFar=0;
#include <time.h>
time_t time1,time2;
int Melnitchka=0;
char *Auberge[4] = {"|\0","/\0","-\0","\\\0"};

void x64toaKAZE (      /* stdcall is faster and smaller... Might as well use it for the helper. */
        unsigned long long val,
        char *buf,
        unsigned radix,
        int is_neg
        )
{
        char *p;                /* pointer to traverse string */
        char *firstdig;         /* pointer to first digit */
        char temp;              /* temp char */
        unsigned digval;        /* value of digit */

        p = buf;

        if ( is_neg )
        {
            *p++ = '-';         /* negative, so output '-' and negate */
            val = (unsigned long long)(-(long long)val);
        }

        firstdig = p;           /* save pointer to first digit */

        do {
            digval = (unsigned) (val % radix);
            val /= radix;       /* get next digit */

            /* convert to ascii and store */
            if (digval > 9)
                *p++ = (char) (digval - 10 + 'a');  /* a letter */
            else
                *p++ = (char) (digval + '0');       /* a digit */
        } while (val > 0);

        /* We now have the digit of the number in the buffer, but in reverse
           order.  Thus we reverse them now. */

        *p-- = '\0';            /* terminate string; p points to last digit */

        do {
            temp = *p;
            *p = *firstdig;
            *firstdig = temp;   /* swap *p and *firstdig */
            --p;
            ++firstdig;         /* advance to next two digits */
        } while (firstdig < p); /* repeat until halfway */
}

/* Actual functions just call conversion helper with neg flag set correctly,
   and return pointer to buffer. */

char * _i64toaKAZE (
        long long val,
        char *buf,
        int radix
        )
{
        x64toaKAZE((unsigned long long)val, buf, radix, (radix == 10 && val < 0));
        return buf;
}

char * _ui64toaKAZE (
        unsigned long long val,
        char *buf,
        int radix
        )
{
        x64toaKAZE(val, buf, radix, 0);
        return buf;
}

char * _ui64toaKAZEzerocomma (
        unsigned long long val,
        char *buf,
        int radix
        )
{
                        char *p;
                        char temp;
                        int txpman;
                        int pxnman;
        x64toaKAZE(val, buf, radix, 0);
                        p = buf;
                        do {
                        } while (*++p != '\0');
                        p--; // p points to last digit
                             // buf points to first digit
                        buf[26] = 0;
                        txpman = 1;
                        pxnman = 0;
                        do
                        { if (buf <= p)
                          { temp = *p;
                            buf[26-txpman] = temp; pxnman++;
                            p--;
                            if (pxnman % 3 == 0)
                            { txpman++;
                              buf[26-txpman] = (char) (',');
                            }
                          }
                          else
                          { buf[26-txpman] = (char) ('0'); pxnman++;
                            if (pxnman % 3 == 0)
                            { txpman++;
                              buf[26-txpman] = (char) (',');
                            }
                          }
                          txpman++;
                        } while (txpman <= 26);
        return buf;
}

char * _ui64toaKAZEcomma (
        unsigned long long val,
        char *buf,
        int radix
        )
{
                        char *p;
                        char temp;
                        int txpman;
                        int pxnman;
        x64toaKAZE(val, buf, radix, 0);
                        p = buf;
                        do {
                        } while (*++p != '\0');
                        p--; // p points to last digit
                             // buf points to first digit
                        buf[26] = 0;
                        txpman = 1;
                        pxnman = 0;
                        while (buf <= p)
                        { temp = *p;
                          buf[26-txpman] = temp; pxnman++;
                          p--;
                          if (pxnman % 3 == 0 && buf <= p)
                          { txpman++;
                            buf[26-txpman] = (char) (',');
                          }
                          txpman++;
                        } 
        return buf+26-(txpman-1);
}

char * _ui64toaKAZEzerocomma4 (
        unsigned long long val,
        char *buf,
        int radix
        )
{
                        char *p;
                        char temp;
                        int txpman;
                        int pxnman;
        x64toaKAZE(val, buf, radix, 0);
                        p = buf;
                        do {
                        } while (*++p != '\0');
                        p--; // p points to last digit
                             // buf points to first digit
                        buf[26] = 0;
                        txpman = 1;
                        pxnman = 0;
                        do
                        { if (buf <= p)
                          { temp = *p;
                            buf[26-txpman] = temp; pxnman++;
                            p--;
                            if (pxnman % 4 == 0)
                            { txpman++;
                              buf[26-txpman] = (char) (',');
                            }
                          }
                          else
                          { buf[26-txpman] = (char) ('0'); pxnman++;
                            if (pxnman % 4 == 0)
                            { txpman++;
                              buf[26-txpman] = (char) (',');
                            }
                          }
                          txpman++;
                        } while (txpman <= 26);
        return buf;
}

      char llTOaDigits[27]; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)
      // below duplicates are needed because of one_line_invoking need different buffers.
      char llTOaDigits2[27]; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)
      char llTOaDigits3[27]; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)

#include <stdio.h>
FILE *fp_outLOG;

int main()
{

#ifdef _N_HIGH_PRIORITY
   DWORD dwError, dwPriClass;
#endif

double Spd;

#ifdef _N_HIGH_PRIORITY
   if(!SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS))
   {
//      _tprintf(TEXT("Already REALTIME_PRIORITY.\n"));
//      goto Cleanup;
   } 
   if(!SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS))
   {
//      _tprintf(TEXT("Already REALTIME_PRIORITY.\n"));
//      goto Cleanup;
   } 
   // Display priority class

   dwPriClass = GetPriorityClass(GetCurrentProcess());

   //_tprintf(TEXT("Current priority class is 0x%x\n"), dwPriClass);

   if (dwPriClass==0x00000080) printf("Current priority class is HIGH_PRIORITY_CLASS.\n");
   if (dwPriClass==0x00000100) printf("Current priority class is REALTIME_PRIORITY_CLASS.\n");
#endif

#ifdef _N_HIGH_PRIORITY
// https://habrahabr.ru/post/113682/
// Andrew Aksyonoff [
SetProcessAffinityMask(GetCurrentProcess(), 1);
	//volatile int zomg = 1;
	//for ( int i=1; i<1000000000; i++ )
	//	zomg *= i;
// Andrew Aksyonoff ]
#endif

if( ( fp_outLOG = fopen( "pi_spigot_CIFRITCHKI.txt", "wb" ) ) == NULL ) // TCH; SCH - no other use of 'C'
{ printf( "Leprechaun: Can't open file pi_spigot_CIFRITCHKI.txt.\n" ); exit( 7 ); }
time1=time(NULL); //fix of bigtime
printf ( "%s\n", "Dumping 1,000,000 digits to 'pi_spigot_CIFRITCHKI.txt' ...");

    for(j=N; j; ) 
    {
	q = 0;
	k = LEN+LEN-1;

	for(i=LEN; i; --i) 
	{
	    x = (j == N ? 20 : 10L*a[i-1]) + q*i;
	    q = x / k;
	    a[i-1] = (unsigned)(x-q*k);
	    k -= 2;
	}

	k = x % 10;
	if (k==9)  ++nines;

	else 
	{
	    if (j)
	    {
		--j;
		//printf("%ld", predigit+x/10); 
		fprintf( fp_outLOG, "%s", _ui64toaKAZEcomma(predigit+x/10, llTOaDigits, 10) );
		DigitsSoFar++;
		if (DigitsSoFar==1) fprintf( fp_outLOG, "%s", "." );
	    }

	    for(; nines; --nines)
	    {
		if (j) --j;
 		//printf(x >= 10 ? "0" : "9");
		fprintf( fp_outLOG, "%s", x >= 10 ? "0" : "9" );
		DigitsSoFar++;
	    }

	    predigit = (unsigned)k;
	}

	Melnitchka = Melnitchka & 3; // 0 1 2 3: 00 01 10 11
	Spd = (double)(DigitsSoFar)/(double)(time(NULL) - time1 + 1);
	printf ( "%s; Digits-So-Far = %s; Digits-Per-Second = %s DPS; ETA: %.2f minutes \r", Auberge[Melnitchka++], _ui64toaKAZEcomma(DigitsSoFar, llTOaDigits2, 10), _ui64toaKAZEcomma(Spd, llTOaDigits3, 10), ((double)(N-DigitsSoFar+1)/(Spd+1))/(60) );
	fflush(fp_outLOG);
    }
}
As BroadPwns suggested to keep the most recent roster at the top post:


Code:
-----------------------------------------------------------------------
| Submission |                            Machine | Digits-Per-Second |
-----------------------------------------------------------------------
|   Sanmayce |                    Core 2 2933 MHz |                32 |
|   rares495 |                  i9 9940X 4200 MHz |                38 |
|     Geeboi |                  i7 8700K 4711 MHz |                42 |
|  stealth83 |                  i7 9700K 4901 MHz |                46 |
|   Arctucas |                  i9 9900K 5000 MHz |                46 |
| ThrashZone |                  i9 9940X 5000 MHz |                47 |
|    Avacado |                  i9 9900K 5101 MHz |                47 |
| ThrashZone |                 i9 10900K 5200 MHz |                49 |
| ThrashZone |                 i9 10900K 5297 MHz |                50 |
|       0451 |                 i7 10700K 5500 MHz |                52 |
| mirzet1976 |               AMD FX-8320 4515 MHz |                59 |
|   Redwoodz |              AMD FX-8320e 4677 MHz |                62 |
|   rares495 |             Ryzen 3 3200G ???? MHz |                69 |
|   rares495 |             Ryzen 5 1500X 3591 MHz |                70 |
| mirzet1976 |              Ryzen 5 2600 3668 MHz |                70 |
|   rares495 |              Ryzen 5 3600 4199 MHz |                77 |
| mirzet1976 |              Ryzen 5 3600 4199 MHz |                79 |
|   rares495 |             Ryzen 7 3700X 4341 MHz |                81 |
|   rares495 |            Ryzen 7 3800XT 4702 MHz |                84 |
|     Arni90 |             Ryzen 9 3900X 4497 MHz |                85 |
|   rares495 |              Ryzen 5 3600 4598 MHz |                87 |
|   rares495 |             Ryzen 7 3700X 4598 MHz |                87 |
|   rares495 | Ryzen 7 3800XT allcore OC 4725 MHz |                89 |
-----------------------------------------------------------------------
Note1: In order to obtain stable result, please wait 4 minutes or for the 10,000 computed digits mark.
Note2: To see the disassembly: https://www.overclock.net/showthread.php?p=28579062#post28573094
Note3: Don't worry, virustotal on-line check shows the .ZIP is not problematic: https://www.virustotal.com/gui/file/1b86e08f29a5368660e6c7e544b6e05e3129ba0b032ca8228efadad699db23f4/detection
 

Attachments

·
Just hangin' out
Joined
·
1,071 Posts
OK
 

Attachments

  • Rep+
Reactions: Sanmayce

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #3
Thanks,
those 5000MHz equaling 46 Digits-Per-Second are hard to be beaten.

The dummy math is 5000/2933 = 1.70 has to be roughly 46/32 = 1.43, this disproportion suggests that i9-9900K had to be like: x/32 = 1.70 or x = 32*1.70 = 54, hmm.
 

·
Old Man still Gaming!!!
Joined
·
36 Posts
46
 

Attachments

  • Rep+
Reactions: Sanmayce

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #5
Thanks!
Good to know, wonder whether your machines were cooled properly i.e. they were not throttling, it is good that you have left 100,000 digits to be computed.

One note though, the first thing the bench does is to attempt to enter REAL-TIME mode, also forces the code to be run on CPU 1, thus result to be more stable. However, the attached compile/binary was not compiled with this line:
Code:
icl /O3 pi_spigot.c -D_N_HIGH_PRIORITY
It was compiled without allowing to enter REAL-TIME mode, and the code could bounce across cores, therefore fluctuations are to be expected:
Code:
icl /O3 pi_spigot.c
It was done on purpose, wanted to see how the operating system and the CPU itself schedule the execution.

Also, it is worth mentioning that the actual machine code is around 500 bytes in size - quite small compared to other benchmarks having KBs of code.
 
  • Rep+
Reactions: Geeboi

·
somewhere on ocn
Joined
·
285 Posts
stock 8700k
 

Attachments

  • Rep+
Reactions: Sanmayce

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #7
Thank you Geeboi, now we have 1st and 8th, 9th generations, the current roster:
Code:
------------------------------------------------------
| Submission |           Machine | Digits-Per-Second |
------------------------------------------------------
|   Sanmayce |   Core 2 2933 MHz |                32 |
|     Geeboi | i7 8700K 4711 MHz |                42 |
|  stealth83 | i7 9700K 4901 MHz |                46 |
|   Arctucas | i9 9900K 5000 MHz |                46 |
------------------------------------------------------
 

·
Overclocker in training
Joined
·
12,938 Posts
Hi,
No telling if this is right
 

Attachments

·
Registered
Joined
·
1,522 Posts
Here's my 3900X running at 4.50 GHz
 

Attachments

  • Rep+
Reactions: Sanmayce

·
Rig Advisor
Joined
·
1,963 Posts
My contribution 47. Please lawd don't let me have a virus now. :wheee:
 

Attachments

·
Edgy & on the edge
Joined
·
1,539 Posts
Maxed out Ryzen 3600 => 87 DPS. Stock does around 77 DPS.



 
  • Rep+
Reactions: Sanmayce

·
Overclocker in training
Joined
·
12,938 Posts
Hi,
Had to get 50 49 was bugging me :)
 

Attachments

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #13 (Edited)
Thank you ThrashZone, it is ok.

You dropped the bomb, Arni90, thanks, didn't know nor expected such a huge margin!

Code:
-----------------------------------------------------------
| Submission |                Machine | Digits-Per-Second |
-----------------------------------------------------------
|   Sanmayce |        Core 2 2933 MHz |                32 |
|     Geeboi |      i7 8700K 4711 MHz |                42 |
|  stealth83 |      i7 9700K 4901 MHz |                46 |
|   Arctucas |      i9 9900K 5000 MHz |                46 |
|    Avacado |      i9 9900K 5101 MHz |                47 |
| ThrashZone |     i9 10900K 5200 MHz |                49 |
| ThrashZone |     i9 10900K 5297 MHz |                50 |
|   rares495 |  Ryzen 5 3600 4199 MHz |                77 |
|     Arni90 | Ryzen 9 3900X 4497 MHz |                85 |
|   rares495 |  Ryzen 5 3600 4598 MHz |                87 |
-----------------------------------------------------------

@Avacado
Don't worry, virustotal on-line check shows the .ZIP is not problematic:
https://www.virustotal.com/gui/file/1b86e08f29a5368660e6c7e544b6e05e3129ba0b032ca8228efadad699db23f4/detection
 

·
Overclocker in training
Joined
·
12,938 Posts
Hi,
Yeah that 3900x was sick :)
 

·
Integer Benchmarker
Joined
·
431 Posts
Discussion Starter #15 (Edited)
This etude turns out to be so nifty, from programming, integer performance benchmarking, identifying the CPU vendor (hee-hee), perspective. :p
Just running it on an unknown machine, in two minutes (the DPS number stabilizes quickly) it will coldly spit two digits, then go figure what CPU runs the machine.
The irony is that Intel C compiler ... likes Ryzen.
Thought, the Assembly code has to be known along with some statistics.

Code:
; .B1.77:[00856] - .B1.6:[000c5] + 5 = 1942 bytes - the codesize of the mainloop in main() function
; mark_description "Intel(R) C++ Compiler XE for applications running on IA-32, Version 15.0.0.108 Build 20140726";
; mark_description "-O3 -Fa";
	.686P
...

.B1.6:                          
        xor       eax, eax                                      
        xor       esi, esi                                      
        mov       DWORD PTR [276+esp], eax                      
        mov       DWORD PTR [272+esp], ebx                      
        mov       ebx, eax                                      
        mov       DWORD PTR [156+esp], edi                      
.B1.7:                          
        cmp       DWORD PTR [272+esp], 1000000                  
        jne       .B1.9         
.B1.8:                          
        mov       ecx, 20                                       
        jmp       .B1.10        
.B1.9:                          
        mov       ecx, DWORD PTR [_a+13333332+esi*4]            
        lea       ecx, DWORD PTR [ecx+ecx*4]                    
        add       ecx, ecx                                      
.B1.10:                         
        lea       edi, DWORD PTR [3333334+esi]                  
        imul      eax, edi                                      
        lea       edi, DWORD PTR [6666667+ebx]                  
        add       ecx, eax                                      
        add       ebx, -2                                       
        mov       eax, ecx                                      
        cdq                                                     
        idiv      edi                                           
        imul      edi, eax                                      
        neg       edi                                           
        add       edi, ecx                                      
        mov       DWORD PTR [_a+13333332+esi*4], edi            
        dec       esi                                           
        mov       edi, DWORD PTR [276+esp]                      
        inc       edi                                           
        mov       DWORD PTR [276+esp], edi                      
        cmp       edi, 3333334                                  
        jb        .B1.7         
.B1.11:                         
        mov       DWORD PTR [_q], eax                           
        mov       eax, 1717986919                               
        imul      ecx                                           
        mov       esi, ecx                                      
        sar       edx, 2                                        
        sar       esi, 31                                       
        sub       edx, esi                                      
        mov       ebx, DWORD PTR [272+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
        mov       DWORD PTR [_i], 0                             
        mov       DWORD PTR [_x], ecx                           
        lea       eax, DWORD PTR [edx+edx*4]                    
        add       eax, eax                                      
        neg       eax                                           
        add       eax, ecx                                      
        mov       DWORD PTR [_k], eax                           
        cmp       eax, 9                                        
        je        .B1.76        
.B1.12:                         
        mov       eax, 1717986919                               
        dec       ebx                                           
        imul      ecx                                           
        sar       edx, 2                                        
        xor       esi, esi                                      
        sar       ecx, 31                                       
        sub       edx, ecx                                      
        add       edx, DWORD PTR [_predigit]                    
        mov       DWORD PTR [_j], ebx                           
        mov       ebx, OFFSET FLAT: _llTOaDigits                
        mov       DWORD PTR [156+esp], edi                      
        mov       edi, edx                                      
.B1.13:                         
        push      0                                             
        push      10                                            
        push      esi                                           
        push      edi                                           
        call      __aullrem                                     
.B1.89:                         
        mov       DWORD PTR [216+esp], eax                      
        push      0                                             
        push      10                                            
        push      esi                                           
        push      edi                                           
        call      __aulldiv                                     
.B1.88:                         
        mov       edi, eax                                      
        mov       esi, edx                                      
        cmp       DWORD PTR [216+esp], 9                        
        jbe       .B1.15        
.B1.14:                         
        mov       eax, DWORD PTR [216+esp]                      
        add       eax, 87                                       
        mov       BYTE PTR [ebx], al                            
        inc       ebx                                           
        jmp       .B1.16        
.B1.15:                         
        mov       eax, DWORD PTR [216+esp]                      
        add       eax, 48                                       
        mov       BYTE PTR [ebx], al                            
        inc       ebx                                           
.B1.16:                         
        mov       ecx, esi                                      
        xor       eax, eax                                      
        sub       ecx, eax                                      
        jb        .B1.105       
.B1.81:                         
        or        ecx, edi                                      
        jne       .B1.13        
.B1.105:                        
        mov       edi, DWORD PTR [156+esp]                      
.B1.17:                         
        mov       BYTE PTR [ebx], 0                             
        dec       ebx                                           
        mov       DWORD PTR [212+esp], ebx                      
        mov       ecx, ebx                                      
        mov       DWORD PTR [156+esp], edi                      
        xor       esi, esi                                      
        mov       eax, OFFSET FLAT: _llTOaDigits                
.B1.18:                         
        inc       esi                                           
        inc       eax                                           
        mov       ebx, esi                                      
        dec       ecx                                           
        neg       ebx                                           
        mov       edi, DWORD PTR [212+esp]                      
        mov       DWORD PTR [220+esp], eax                      
        movzx     edx, BYTE PTR [_llTOaDigits-1+esi]            
        movzx     eax, BYTE PTR [1+ebx+edi]                     
        mov       BYTE PTR [1+ebx+edi], dl                      
        mov       BYTE PTR [_llTOaDigits-1+esi], al             
        mov       eax, DWORD PTR [220+esp]                      
        cmp       eax, ecx                                      
        jb        .B1.18        
.B1.19:                         
        mov       edi, DWORD PTR [156+esp]                      
        xor       eax, eax                                      
.B1.20:                         
        inc       eax                                           
        cmp       BYTE PTR [_llTOaDigits+eax], 0                
        jne       .B1.20        
.B1.21:                         
        mov       ecx, OFFSET FLAT: _llTOaDigits                
        lea       edx, DWORD PTR [_llTOaDigits-1+eax]           
        mov       esi, edx                                      
        mov       eax, 1                                        
        sub       esi, ecx                                      
        inc       esi                                           
        mov       BYTE PTR [_llTOaDigits+26], 0                 
        cmp       ecx, edx                                      
        ja        .B1.28        
.B1.22:                         
        mov       DWORD PTR [140+esp], -1                       
        xor       ebx, ebx                                      
        mov       DWORD PTR [200+esp], esi                      
        xor       ecx, ecx                                      
        mov       DWORD PTR [208+esp], eax                      
        mov       DWORD PTR [204+esp], edx                      
        mov       DWORD PTR [156+esp], edi                      
        mov       esi, DWORD PTR [140+esp]                      
.B1.23:                         
        mov       edi, DWORD PTR [204+esp]                      
        inc       ebx                                           
        movzx     eax, BYTE PTR [ecx+edi]                       
        mov       BYTE PTR [_llTOaDigits+26+esi], al            
        mov       eax, 1431655766                               
        imul      ebx                                           
        mov       eax, edx                                      
        mov       edx, ebx                                      
        sar       edx, 31                                       
        sub       eax, edx                                      
        lea       edi, DWORD PTR [eax+eax*2]                    
        cmp       edi, ebx                                      
        jne       .B1.26        
.B1.24:                         
        mov       eax, DWORD PTR [204+esp]                      
        mov       edx, OFFSET FLAT: _llTOaDigits                
        lea       edi, DWORD PTR [-1+ecx+eax]                   
        cmp       edx, edi                                      
        ja        .B1.26        
.B1.25:                         
        dec       esi                                           
        inc       DWORD PTR [208+esp]                           
        mov       BYTE PTR [_llTOaDigits+26+esi], 44            
.B1.26:                         
        inc       DWORD PTR [208+esp]                           
        dec       esi                                           
        dec       ecx                                           
        cmp       ebx, DWORD PTR [200+esp]                      
        jb        .B1.23        
.B1.27:                         
        mov       eax, DWORD PTR [208+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
.B1.28:                         
        mov       edx, OFFSET FLAT: _llTOaDigits                
        sub       edx, eax                                      
        push      edi                                           
        add       edx, 27                                       
        push      edx                                           
        call      _fputs                                        
.B1.90:                         
        add       esp, 8                                        
.B1.29:                         
        mov       eax, DWORD PTR [_DigitsSoFar]                 
        inc       eax                                           
        mov       DWORD PTR [_DigitsSoFar], eax                 
        cmp       eax, 1                                        
        je        .B1.75        
.B1.30:                         
        cmp       DWORD PTR [_nines], 0                         
        je        .B1.37        
.B1.31:                         
        mov       ebx, OFFSET FLAT: [email protected][email protected][email protected]            
.B1.32:                         
        mov       eax, DWORD PTR [_j]                           
        test      eax, eax                                      
        je        .B1.34        
.B1.33:                         
        dec       eax                                           
        mov       DWORD PTR [_j], eax                           
.B1.34:                         
        cmp       DWORD PTR [_x], 10                            
        mov       eax, OFFSET FLAT: [email protected][email protected][email protected]            
        push      DWORD PTR [_fp_outLOG]                        
        cmovge    eax, ebx                                      
        push      eax                                           
        call      _fputs                                        
.B1.91:                         
        add       esp, 8                                        
.B1.35:                         
        inc       DWORD PTR [_DigitsSoFar]                      
        dec       DWORD PTR [_nines]                            
        jne       .B1.32        
.B1.37:                         
        mov       eax, DWORD PTR [_k]                           
        mov       DWORD PTR [_predigit], eax                    
.B1.38:                         
        push      0                                             
        and       DWORD PTR [_Melnitchka], 3                    
        call      __time64                                      
.B1.92:                         
        add       esp, 4                                        
.B1.39:                         
        fild      DWORD PTR [_DigitsSoFar]                      
        sub       eax, DWORD PTR [_time1]                       
        mov       esi, OFFSET FLAT: _llTOaDigits2               
        mov       edi, DWORD PTR [_Melnitchka]                  
        sbb       edx, DWORD PTR [_time1+4]                     
        add       eax, 1                                        
        mov       DWORD PTR [168+esp], eax                      
        adc       edx, 0                                        
        mov       DWORD PTR [172+esp], edx                      
        fild      QWORD PTR [168+esp]                           
        fdivp     st(1), st                                     
        mov       ecx, DWORD PTR [_DigitsSoFar]                 
        mov       eax, ecx                                      
        cdq                                                     
        mov       ebx, DWORD PTR [_Auberge+edi*4]               
        inc       edi                                           
        mov       DWORD PTR [196+esp], ebx                      
        mov       ebx, edx                                      
        mov       DWORD PTR [_Melnitchka], edi                  
        mov       edi, ecx                                      
        mov       DWORD PTR [192+esp], ecx                      
        fstp      QWORD PTR [176+esp]                           
.B1.40:                         
        push      0                                             
        push      10                                            
        push      ebx                                           
        push      edi                                           
        call      __aullrem                                     
.B1.94:                         
        mov       DWORD PTR [248+esp], eax                      
        push      0                                             
        push      10                                            
        push      ebx                                           
        push      edi                                           
        call      __aulldiv                                     
.B1.93:                         
        mov       edi, eax                                      
        mov       ebx, edx                                      
        cmp       DWORD PTR [248+esp], 9                        
        jbe       .B1.42        
.B1.41:                         
        mov       eax, DWORD PTR [248+esp]                      
        add       eax, 87                                       
        mov       BYTE PTR [esi], al                            
        inc       esi                                           
        jmp       .B1.43        
.B1.42:                         
        mov       eax, DWORD PTR [248+esp]                      
        add       eax, 48                                       
        mov       BYTE PTR [esi], al                            
        inc       esi                                           
.B1.43:                         
        mov       edx, ebx                                      
        xor       eax, eax                                      
        sub       edx, eax                                      
        jb        .B1.103       
.B1.82:                         
        or        edx, edi                                      
        jne       .B1.40        
.B1.103:                        
        fld       QWORD PTR [176+esp]                           
        mov       ecx, DWORD PTR [192+esp]                      
.B1.44:                         
        mov       BYTE PTR [esi], 0                             
        dec       esi                                           
        mov       DWORD PTR [260+esp], esi                      
        mov       ebx, esi                                      
        mov       DWORD PTR [192+esp], ecx                      
        xor       edi, edi                                      
        mov       edx, OFFSET FLAT: _llTOaDigits2               
.B1.45:                         
        inc       edi                                           
        inc       edx                                           
        mov       ecx, edi                                      
        dec       ebx                                           
        neg       ecx                                           
        mov       esi, DWORD PTR [260+esp]                      
        mov       DWORD PTR [264+esp], edx                      
        movzx     edx, BYTE PTR [_llTOaDigits2-1+edi]           
        movzx     eax, BYTE PTR [1+ecx+esi]                     
        mov       BYTE PTR [1+ecx+esi], dl                      
        mov       edx, DWORD PTR [264+esp]                      
        cmp       edx, ebx                                      
        mov       BYTE PTR [_llTOaDigits2-1+edi], al            
        jb        .B1.45        
.B1.46:                         
        mov       ecx, DWORD PTR [192+esp]                      
        xor       edx, edx                                      
.B1.47:                         
        inc       edx                                           
        cmp       BYTE PTR [_llTOaDigits2+edx], 0               
        jne       .B1.47        
.B1.48:                         
        mov       ebx, OFFSET FLAT: _llTOaDigits2               
        lea       edx, DWORD PTR [_llTOaDigits2-1+edx]          
        mov       eax, edx                                      
        sub       eax, ebx                                      
        inc       eax                                           
        mov       BYTE PTR [_llTOaDigits2+26], 0                
        cmp       ebx, edx                                      
        mov       DWORD PTR [232+esp], 1                        
        ja        .B1.55        
.B1.49:                         
        xor       esi, esi                                      
        mov       ebx, -1                                       
        mov       DWORD PTR [224+esp], eax                      
        xor       edi, edi                                      
        mov       DWORD PTR [228+esp], edx                      
        mov       DWORD PTR [192+esp], ecx                      
.B1.50:                         
        mov       ecx, DWORD PTR [228+esp]                      
        inc       esi                                           
        movzx     eax, BYTE PTR [edi+ecx]                       
        mov       BYTE PTR [_llTOaDigits2+26+ebx], al           
        mov       eax, 1431655766                               
        imul      esi                                           
        mov       eax, edx                                      
        mov       edx, esi                                      
        sar       edx, 31                                       
        sub       eax, edx                                      
        lea       ecx, DWORD PTR [eax+eax*2]                    
        cmp       ecx, esi                                      
        jne       .B1.53        
.B1.51:                         
        mov       eax, DWORD PTR [228+esp]                      
        mov       edx, OFFSET FLAT: _llTOaDigits2               
        lea       ecx, DWORD PTR [-1+edi+eax]                   
        cmp       edx, ecx                                      
        ja        .B1.53        
.B1.52:                         
        dec       ebx                                           
        inc       DWORD PTR [232+esp]                           
        mov       BYTE PTR [_llTOaDigits2+26+ebx], 44           
.B1.53:                         
        inc       DWORD PTR [232+esp]                           
        dec       ebx                                           
        dec       edi                                           
        cmp       esi, DWORD PTR [224+esp]                      
        jb        .B1.50        
.B1.54:                         
        mov       ecx, DWORD PTR [192+esp]                      
.B1.55:                         
        fld       DWORD PTR [_2il0floatpacket.1]                
        xor       edx, edx                                      
        mov       ebx, -2147483648                              
        mov       esi, OFFSET FLAT: _llTOaDigits3               
        mov       DWORD PTR [192+esp], ecx                      
        fxch      st(1)                                         
        fcom                                                    
        fnstsw    ax                                            
        fsubr     st(1), st                                     
        sahf                                                    
        fst       QWORD PTR [176+esp]                           
        cmovae    edx, ebx                                      
        test      edx, edx                                      
        fcmovne   st, st(1)                                     
        fstp      st(1)                                         
        fnstcw    [144+esp]                                     
        movzx     eax, WORD PTR [144+esp]                       
        or        eax, 3072                                     
        mov       DWORD PTR [152+esp], eax                      
        fldcw     [152+esp]                                     
        fistp     QWORD PTR [160+esp]                           
        fldcw     [144+esp]                                     
        mov       ebx, DWORD PTR [164+esp]                      
        mov       edi, DWORD PTR [160+esp]                      
        add       ebx, edx                                      
.B1.56:                         
        push      0                                             
        push      10                                            
        push      ebx                                           
        push      edi                                           
        call      __aullrem                                     
.B1.96:                         
        mov       DWORD PTR [252+esp], eax                      
        push      0                                             
        push      10                                            
        push      ebx                                           
        push      edi                                           
        call      __aulldiv                                     
.B1.95:                         
        mov       edi, eax                                      
        mov       ebx, edx                                      
        cmp       DWORD PTR [252+esp], 9                        
        jbe       .B1.58        
.B1.57:                         
        mov       eax, DWORD PTR [252+esp]                      
        add       eax, 87                                       
        mov       BYTE PTR [esi], al                            
        inc       esi                                           
        jmp       .B1.59        
.B1.58:                         
        mov       eax, DWORD PTR [252+esp]                      
        add       eax, 48                                       
        mov       BYTE PTR [esi], al                            
        inc       esi                                           
.B1.59:                         
        mov       edx, ebx                                      
        xor       eax, eax                                      
        sub       edx, eax                                      
        jb        .B1.101       
.B1.83:                         
        or        edx, edi                                      
        jne       .B1.56        
.B1.101:                        
        fld       QWORD PTR [176+esp]                           
        mov       ecx, DWORD PTR [192+esp]                      
.B1.60:                         
        mov       BYTE PTR [esi], 0                             
        dec       esi                                           
        mov       DWORD PTR [256+esp], esi                      
        mov       ebx, esi                                      
        mov       DWORD PTR [192+esp], ecx                      
        xor       edi, edi                                      
        mov       edx, OFFSET FLAT: _llTOaDigits3               
.B1.61:                         
        inc       edi                                           
        inc       edx                                           
        mov       ecx, edi                                      
        dec       ebx                                           
        neg       ecx                                           
        mov       esi, DWORD PTR [256+esp]                      
        mov       DWORD PTR [268+esp], edx                      
        movzx     edx, BYTE PTR [_llTOaDigits3-1+edi]           
        movzx     eax, BYTE PTR [1+ecx+esi]                     
        mov       BYTE PTR [1+ecx+esi], dl                      
        mov       edx, DWORD PTR [268+esp]                      
        cmp       edx, ebx                                      
        mov       BYTE PTR [_llTOaDigits3-1+edi], al            
        jb        .B1.61        
.B1.62:                         
        mov       ecx, DWORD PTR [192+esp]                      
        xor       edx, edx                                      
.B1.63:                         
        inc       edx                                           
        cmp       BYTE PTR [_llTOaDigits3+edx], 0               
        jne       .B1.63        
.B1.64:                         
        mov       ebx, OFFSET FLAT: _llTOaDigits3               
        lea       edi, DWORD PTR [_llTOaDigits3-1+edx]          
        mov       eax, edi                                      
        mov       edx, 1                                        
        sub       eax, ebx                                      
        inc       eax                                           
        mov       BYTE PTR [_llTOaDigits3+26], 0                
        cmp       ebx, edi                                      
        ja        .B1.71        
.B1.65:                         
        mov       DWORD PTR [184+esp], -1                       
        xor       esi, esi                                      
        mov       DWORD PTR [192+esp], ecx                      
        xor       ebx, ebx                                      
        mov       DWORD PTR [244+esp], edx                      
        mov       DWORD PTR [236+esp], eax                      
        mov       DWORD PTR [240+esp], edi                      
        mov       ecx, DWORD PTR [184+esp]                      
.B1.66:                         
        mov       edi, DWORD PTR [240+esp]                      
        inc       esi                                           
        movzx     eax, BYTE PTR [ebx+edi]                       
        mov       BYTE PTR [_llTOaDigits3+26+ecx], al           
        mov       eax, 1431655766                               
        imul      esi                                           
        mov       eax, edx                                      
        mov       edx, esi                                      
        sar       edx, 31                                       
        sub       eax, edx                                      
        lea       edi, DWORD PTR [eax+eax*2]                    
        cmp       edi, esi                                      
        jne       .B1.69        
.B1.67:                         
        mov       eax, DWORD PTR [240+esp]                      
        mov       edx, OFFSET FLAT: _llTOaDigits3               
        lea       edi, DWORD PTR [-1+ebx+eax]                   
        cmp       edx, edi                                      
        ja        .B1.69        
.B1.68:                         
        dec       ecx                                           
        inc       DWORD PTR [244+esp]                           
        mov       BYTE PTR [_llTOaDigits3+26+ecx], 44           
.B1.69:                         
        inc       DWORD PTR [244+esp]                           
        dec       ecx                                           
        dec       ebx                                           
        cmp       esi, DWORD PTR [236+esp]                      
        jb        .B1.66        
.B1.70:                         
        mov       edx, DWORD PTR [244+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
.B1.71:                         
        mov       DWORD PTR [esp], OFFSET FLAT: [email protected][email protected]@?$CFs?$DL?5Digits?9So?9Far?5?$DN?5?$CFs?$DL?5Digits?9Per?9S[email protected] 
        mov       esi, OFFSET FLAT: _llTOaDigits2               
        mov       ebx, DWORD PTR [196+esp]                      
        neg       edx                                           
        mov       DWORD PTR [4+esp], ebx                        
        mov       ebx, OFFSET FLAT: _llTOaDigits3               
        mov       edi, DWORD PTR [232+esp]                      
        add       edx, ebx                                      
        neg       edi                                           
        neg       ecx                                           
        add       edi, esi                                      
        add       edx, 27                                       
        add       edi, 27                                       
        add       ecx, 1000001                                  
        mov       DWORD PTR [8+esp], edi                        
        mov       DWORD PTR [12+esp], edx                       
        mov       DWORD PTR [168+esp], ecx                      
        fild      DWORD PTR [168+esp]                           
        fxch      st(1)                                         
        fadd      DWORD PTR [188+esp]                           
        fdivp     st(1), st                                     
        fdiv      QWORD PTR [_2il0floatpacket.0]                
        fstp      QWORD PTR [16+esp]                            
        call      _printf                                       
.B1.72:                         
        mov       edi, DWORD PTR [_fp_outLOG]                   
        push      edi                                           
        call      _fflush                                       
.B1.97:                         
        add       esp, 4                                        
.B1.73:                         
        mov       ebx, DWORD PTR [_j]                           
        test      ebx, ebx                                      
        jne       .B1.6         
.B1.74:                         
        mov       esi, DWORD PTR [128+esp]                      
        xor       eax, eax                                      
        mov       edi, DWORD PTR [132+esp]                      
        mov       ebx, DWORD PTR [136+esp]                      
        mov       esp, ebp                                      
        pop       ebp                                           
        ret                                                     
.B1.75:                         
        push      DWORD PTR [_fp_outLOG]                        
        push      OFFSET FLAT: [email protected][email protected][email protected]                
        call      _fputs                                        
.B1.98:                         
        add       esp, 8                                        
        jmp       .B1.30        
.B1.76:                         
        inc       DWORD PTR [_nines]                            
        jmp       .B1.38        
.B1.77:
In order to visually feel the code being executed, here all 494 instructions are given, sorted:

Code:
        adc       edx, 0                                        
        add       eax, 1                                        
        add       eax, 48                                       
        add       eax, 48                                       
        add       eax, 48                                       
        add       eax, 87                                       
        add       eax, 87                                       
        add       eax, 87                                       
        add       eax, eax                                      
        add       eax, ecx                                      
        add       ebx, -2                                       
        add       ebx, edx                                      
        add       ecx, 1000001                                  
        add       ecx, eax                                      
        add       ecx, ecx                                      
        add       edi, 27                                       
        add       edi, ecx                                      
        add       edi, esi                                      
        add       edx, 27                                       
        add       edx, 27                                       
        add       edx, DWORD PTR [_predigit]                    
        add       edx, ebx                                      
        add       esp, 4                                        
        add       esp, 4                                        
        add       esp, 8                                        
        add       esp, 8                                        
        add       esp, 8                                        
        and       DWORD PTR [_Melnitchka], 3                    
        call      __aulldiv                                     
        call      __aulldiv                                     
        call      __aulldiv                                     
        call      __aullrem                                     
        call      __aullrem                                     
        call      __aullrem                                     
        call      __time64                                      
        call      _fflush                                       
        call      _fputs                                        
        call      _fputs                                        
        call      _fputs                                        
        call      _printf                                       
        cdq                                                     
        cdq                                                     
        cmovae    edx, ebx                                      
        cmovge    eax, ebx                                      
        cmp       BYTE PTR [_llTOaDigits+eax], 0                
        cmp       BYTE PTR [_llTOaDigits2+edx], 0               
        cmp       BYTE PTR [_llTOaDigits3+edx], 0               
        cmp       DWORD PTR [_nines], 0                         
        cmp       DWORD PTR [_x], 10                            
        cmp       DWORD PTR [216+esp], 9                        
        cmp       DWORD PTR [248+esp], 9                        
        cmp       DWORD PTR [252+esp], 9                        
        cmp       DWORD PTR [272+esp], 1000000                  
        cmp       eax, 1                                        
        cmp       eax, 9                                        
        cmp       eax, ecx                                      
        cmp       ebx, DWORD PTR [200+esp]                      
        cmp       ebx, edi                                      
        cmp       ebx, edx                                      
        cmp       ecx, edx                                      
        cmp       ecx, esi                                      
        cmp       edi, 3333334                                  
        cmp       edi, ebx                                      
        cmp       edi, esi                                      
        cmp       edx, ebx                                      
        cmp       edx, ebx                                      
        cmp       edx, ecx                                      
        cmp       edx, edi                                      
        cmp       edx, edi                                      
        cmp       esi, DWORD PTR [224+esp]                      
        cmp       esi, DWORD PTR [236+esp]                      
        dec       DWORD PTR [_nines]                            
        dec       eax                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ebx                                           
        dec       ecx                                           
        dec       ecx                                           
        dec       ecx                                           
        dec       ecx                                           
        dec       edi                                           
        dec       esi                                           
        dec       esi                                           
        dec       esi                                           
        dec       esi                                           
        dec       esi                                           
        fadd      DWORD PTR [188+esp]                           
        fcmovne   st, st(1)                                     
        fcom                                                    
        fdiv      QWORD PTR [_2il0floatpacket.0]                
        fdivp     st(1), st                                     
        fdivp     st(1), st                                     
        fild      DWORD PTR [_DigitsSoFar]                      
        fild      DWORD PTR [168+esp]                           
        fild      QWORD PTR [168+esp]                           
        fistp     QWORD PTR [160+esp]                           
        fld       DWORD PTR [_2il0floatpacket.1]                
        fld       QWORD PTR [176+esp]                           
        fld       QWORD PTR [176+esp]                           
        fldcw     [144+esp]                                     
        fldcw     [152+esp]                                     
        fnstcw    [144+esp]                                     
        fnstsw    ax                                            
        fst       QWORD PTR [176+esp]                           
        fstp      QWORD PTR [16+esp]                            
        fstp      QWORD PTR [176+esp]                           
        fstp      st(1)                                         
        fsubr     st(1), st                                     
        fxch      st(1)                                         
        fxch      st(1)                                         
        idiv      edi                                           
        imul      eax, edi                                      
        imul      ebx                                           
        imul      ecx                                           
        imul      ecx                                           
        imul      edi, eax                                      
        imul      esi                                           
        imul      esi                                           
        inc       DWORD PTR [_DigitsSoFar]                      
        inc       DWORD PTR [_nines]                            
        inc       DWORD PTR [208+esp]                           
        inc       DWORD PTR [208+esp]                           
        inc       DWORD PTR [232+esp]                           
        inc       DWORD PTR [232+esp]                           
        inc       DWORD PTR [244+esp]                           
        inc       DWORD PTR [244+esp]                           
        inc       eax                                           
        inc       eax                                           
        inc       eax                                           
        inc       eax                                           
        inc       eax                                           
        inc       ebx                                           
        inc       ebx                                           
        inc       ebx                                           
        inc       edi                                           
        inc       edi                                           
        inc       edi                                           
        inc       edi                                           
        inc       edx                                           
        inc       edx                                           
        inc       edx                                           
        inc       edx                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        inc       esi                                           
        ja        .B1.26        
        ja        .B1.28        
        ja        .B1.53        
        ja        .B1.55        
        ja        .B1.69        
        ja        .B1.71        
        jb        .B1.101       
        jb        .B1.103       
        jb        .B1.105       
        jb        .B1.18        
        jb        .B1.23        
        jb        .B1.45        
        jb        .B1.50        
        jb        .B1.61        
        jb        .B1.66        
        jb        .B1.7         
        jbe       .B1.15        
        jbe       .B1.42        
        jbe       .B1.58        
        je        .B1.34        
        je        .B1.37        
        je        .B1.75        
        je        .B1.76        
        jmp       .B1.10        
        jmp       .B1.16        
        jmp       .B1.30        
        jmp       .B1.38        
        jmp       .B1.43        
        jmp       .B1.59        
        jne       .B1.13        
        jne       .B1.20        
        jne       .B1.26        
        jne       .B1.32        
        jne       .B1.40        
        jne       .B1.47        
        jne       .B1.53        
        jne       .B1.56        
        jne       .B1.6         
        jne       .B1.63        
        jne       .B1.69        
        jne       .B1.9         
        lea       eax, DWORD PTR [edx+edx*4]                    
        lea       ecx, DWORD PTR [-1+edi+eax]                   
        lea       ecx, DWORD PTR [eax+eax*2]                    
        lea       ecx, DWORD PTR [ecx+ecx*4]                    
        lea       edi, DWORD PTR [-1+ebx+eax]                   
        lea       edi, DWORD PTR [-1+ecx+eax]                   
        lea       edi, DWORD PTR [_llTOaDigits3-1+edx]          
        lea       edi, DWORD PTR [3333334+esi]                  
        lea       edi, DWORD PTR [6666667+ebx]                  
        lea       edi, DWORD PTR [eax+eax*2]                    
        lea       edi, DWORD PTR [eax+eax*2]                    
        lea       edx, DWORD PTR [_llTOaDigits-1+eax]           
        lea       edx, DWORD PTR [_llTOaDigits2-1+edx]          
        mov       BYTE PTR [_llTOaDigits-1+esi], al             
        mov       BYTE PTR [_llTOaDigits+26], 0                 
        mov       BYTE PTR [_llTOaDigits+26+esi], 44            
        mov       BYTE PTR [_llTOaDigits+26+esi], al            
        mov       BYTE PTR [_llTOaDigits2-1+edi], al            
        mov       BYTE PTR [_llTOaDigits2+26], 0                
        mov       BYTE PTR [_llTOaDigits2+26+ebx], 44           
        mov       BYTE PTR [_llTOaDigits2+26+ebx], al           
        mov       BYTE PTR [_llTOaDigits3-1+edi], al            
        mov       BYTE PTR [_llTOaDigits3+26], 0                
        mov       BYTE PTR [_llTOaDigits3+26+ecx], 44           
        mov       BYTE PTR [_llTOaDigits3+26+ecx], al           
        mov       BYTE PTR [1+ebx+edi], dl                      
        mov       BYTE PTR [1+ecx+esi], dl                      
        mov       BYTE PTR [1+ecx+esi], dl                      
        mov       BYTE PTR [ebx], 0                             
        mov       BYTE PTR [ebx], al                            
        mov       BYTE PTR [ebx], al                            
        mov       BYTE PTR [esi], 0                             
        mov       BYTE PTR [esi], 0                             
        mov       BYTE PTR [esi], al                            
        mov       BYTE PTR [esi], al                            
        mov       BYTE PTR [esi], al                            
        mov       BYTE PTR [esi], al                            
        mov       DWORD PTR [_a+13333332+esi*4], edi            
        mov       DWORD PTR [_DigitsSoFar], eax                 
        mov       DWORD PTR [_i], 0                             
        mov       DWORD PTR [_j], eax                           
        mov       DWORD PTR [_j], ebx                           
        mov       DWORD PTR [_k], eax                           
        mov       DWORD PTR [_Melnitchka], edi                  
        mov       DWORD PTR [_predigit], eax                    
        mov       DWORD PTR [_q], eax                           
        mov       DWORD PTR [_x], ecx                           
        mov       DWORD PTR [12+esp], edx                       
        mov       DWORD PTR [140+esp], -1                       
        mov       DWORD PTR [152+esp], eax                      
        mov       DWORD PTR [156+esp], edi                      
        mov       DWORD PTR [156+esp], edi                      
        mov       DWORD PTR [156+esp], edi                      
        mov       DWORD PTR [156+esp], edi                      
        mov       DWORD PTR [168+esp], eax                      
        mov       DWORD PTR [168+esp], ecx                      
        mov       DWORD PTR [172+esp], edx                      
        mov       DWORD PTR [184+esp], -1                       
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [192+esp], ecx                      
        mov       DWORD PTR [196+esp], ebx                      
        mov       DWORD PTR [200+esp], esi                      
        mov       DWORD PTR [204+esp], edx                      
        mov       DWORD PTR [208+esp], eax                      
        mov       DWORD PTR [212+esp], ebx                      
        mov       DWORD PTR [216+esp], eax                      
        mov       DWORD PTR [220+esp], eax                      
        mov       DWORD PTR [224+esp], eax                      
        mov       DWORD PTR [228+esp], edx                      
        mov       DWORD PTR [232+esp], 1                        
        mov       DWORD PTR [236+esp], eax                      
        mov       DWORD PTR [240+esp], edi                      
        mov       DWORD PTR [244+esp], edx                      
        mov       DWORD PTR [248+esp], eax                      
        mov       DWORD PTR [252+esp], eax                      
        mov       DWORD PTR [256+esp], esi                      
        mov       DWORD PTR [260+esp], esi                      
        mov       DWORD PTR [264+esp], edx                      
        mov       DWORD PTR [268+esp], edx                      
        mov       DWORD PTR [272+esp], ebx                      
        mov       DWORD PTR [276+esp], eax                      
        mov       DWORD PTR [276+esp], edi                      
        mov       DWORD PTR [4+esp], ebx                        
        mov       DWORD PTR [8+esp], edi                        
        mov       DWORD PTR [esp], OFFSET FLAT: [email protected][email protected]@?$CFs?$DL?5Digits?9So?9Far?5?$DN?5?$CFs?$DL?5Digits?9Per?9S[email protected] 
        mov       eax, 1                                        
        mov       eax, 1431655766                               
        mov       eax, 1431655766                               
        mov       eax, 1431655766                               
        mov       eax, 1717986919                               
        mov       eax, 1717986919                               
        mov       eax, DWORD PTR [_DigitsSoFar]                 
        mov       eax, DWORD PTR [_j]                           
        mov       eax, DWORD PTR [_k]                           
        mov       eax, DWORD PTR [204+esp]                      
        mov       eax, DWORD PTR [208+esp]                      
        mov       eax, DWORD PTR [216+esp]                      
        mov       eax, DWORD PTR [216+esp]                      
        mov       eax, DWORD PTR [220+esp]                      
        mov       eax, DWORD PTR [228+esp]                      
        mov       eax, DWORD PTR [240+esp]                      
        mov       eax, DWORD PTR [248+esp]                      
        mov       eax, DWORD PTR [248+esp]                      
        mov       eax, DWORD PTR [252+esp]                      
        mov       eax, DWORD PTR [252+esp]                      
        mov       eax, ecx                                      
        mov       eax, ecx                                      
        mov       eax, edi                                      
        mov       eax, edx                                      
        mov       eax, edx                                      
        mov       eax, edx                                      
        mov       eax, edx                                      
        mov       eax, OFFSET FLAT: [email protected][email protected][email protected]            
        mov       eax, OFFSET FLAT: _llTOaDigits                
        mov       ebx, -1                                       
        mov       ebx, -2147483648                              
        mov       ebx, DWORD PTR [_Auberge+edi*4]               
        mov       ebx, DWORD PTR [_j]                           
        mov       ebx, DWORD PTR [136+esp]                      
        mov       ebx, DWORD PTR [164+esp]                      
        mov       ebx, DWORD PTR [196+esp]                      
        mov       ebx, DWORD PTR [272+esp]                      
        mov       ebx, eax                                      
        mov       ebx, edx                                      
        mov       ebx, edx                                      
        mov       ebx, edx                                      
        mov       ebx, esi                                      
        mov       ebx, esi                                      
        mov       ebx, esi                                      
        mov       ebx, OFFSET FLAT: [email protected][email protected][email protected]            
        mov       ebx, OFFSET FLAT: _llTOaDigits                
        mov       ebx, OFFSET FLAT: _llTOaDigits2               
        mov       ebx, OFFSET FLAT: _llTOaDigits3               
        mov       ebx, OFFSET FLAT: _llTOaDigits3               
        mov       ecx, 20                                       
        mov       ecx, DWORD PTR [_a+13333332+esi*4]            
        mov       ecx, DWORD PTR [_DigitsSoFar]                 
        mov       ecx, DWORD PTR [184+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [192+esp]                      
        mov       ecx, DWORD PTR [228+esp]                      
        mov       ecx, ebx                                      
        mov       ecx, edi                                      
        mov       ecx, edi                                      
        mov       ecx, esi                                      
        mov       ecx, OFFSET FLAT: _llTOaDigits                
        mov       edi, DWORD PTR [_fp_outLOG]                   
        mov       edi, DWORD PTR [_Melnitchka]                  
        mov       edi, DWORD PTR [132+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
        mov       edi, DWORD PTR [156+esp]                      
        mov       edi, DWORD PTR [160+esp]                      
        mov       edi, DWORD PTR [204+esp]                      
        mov       edi, DWORD PTR [212+esp]                      
        mov       edi, DWORD PTR [232+esp]                      
        mov       edi, DWORD PTR [240+esp]                      
        mov       edi, DWORD PTR [276+esp]                      
        mov       edi, eax                                      
        mov       edi, eax                                      
        mov       edi, eax                                      
        mov       edi, ecx                                      
        mov       edi, edx                                      
        mov       edx, 1                                        
        mov       edx, DWORD PTR [244+esp]                      
        mov       edx, DWORD PTR [264+esp]                      
        mov       edx, DWORD PTR [268+esp]                      
        mov       edx, ebx                                      
        mov       edx, ebx                                      
        mov       edx, ebx                                      
        mov       edx, esi                                      
        mov       edx, esi                                      
        mov       edx, OFFSET FLAT: _llTOaDigits                
        mov       edx, OFFSET FLAT: _llTOaDigits                
        mov       edx, OFFSET FLAT: _llTOaDigits2               
        mov       edx, OFFSET FLAT: _llTOaDigits2               
        mov       edx, OFFSET FLAT: _llTOaDigits3               
        mov       edx, OFFSET FLAT: _llTOaDigits3               
        mov       esi, DWORD PTR [128+esp]                      
        mov       esi, DWORD PTR [140+esp]                      
        mov       esi, DWORD PTR [256+esp]                      
        mov       esi, DWORD PTR [260+esp]                      
        mov       esi, ecx                                      
        mov       esi, edx                                      
        mov       esi, edx                                      
        mov       esi, OFFSET FLAT: _llTOaDigits2               
        mov       esi, OFFSET FLAT: _llTOaDigits2               
        mov       esi, OFFSET FLAT: _llTOaDigits3               
        mov       esp, ebp                                      
        movzx     eax, BYTE PTR [1+ebx+edi]                     
        movzx     eax, BYTE PTR [1+ecx+esi]                     
        movzx     eax, BYTE PTR [1+ecx+esi]                     
        movzx     eax, BYTE PTR [ebx+edi]                       
        movzx     eax, BYTE PTR [ecx+edi]                       
        movzx     eax, BYTE PTR [edi+ecx]                       
        movzx     eax, WORD PTR [144+esp]                       
        movzx     edx, BYTE PTR [_llTOaDigits-1+esi]            
        movzx     edx, BYTE PTR [_llTOaDigits2-1+edi]           
        movzx     edx, BYTE PTR [_llTOaDigits3-1+edi]           
        neg       eax                                           
        neg       ebx                                           
        neg       ecx                                           
        neg       ecx                                           
        neg       ecx                                           
        neg       edi                                           
        neg       edi                                           
        neg       edx                                           
        or        eax, 3072                                     
        or        ecx, edi                                      
        or        edx, edi                                      
        or        edx, edi                                      
        pop       ebp                                           
        push      0                                             
        push      0                                             
        push      0                                             
        push      0                                             
        push      0                                             
        push      0                                             
        push      0                                             
        push      10                                            
        push      10                                            
        push      10                                            
        push      10                                            
        push      10                                            
        push      10                                            
        push      DWORD PTR [_fp_outLOG]                        
        push      DWORD PTR [_fp_outLOG]                        
        push      eax                                           
        push      ebx                                           
        push      ebx                                           
        push      ebx                                           
        push      ebx                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edi                                           
        push      edx                                           
        push      esi                                           
        push      esi                                           
        push      OFFSET FLAT: [email protected][email protected][email protected]                
        ret                                                     
        sahf                                                    
        sar       ecx, 31                                       
        sar       edx, 2                                        
        sar       edx, 2                                        
        sar       edx, 31                                       
        sar       edx, 31                                       
        sar       edx, 31                                       
        sar       esi, 31                                       
        sbb       edx, DWORD PTR [_time1+4]                     
        sub       eax, DWORD PTR [_time1]                       
        sub       eax, ebx                                      
        sub       eax, ebx                                      
        sub       eax, edx                                      
        sub       eax, edx                                      
        sub       eax, edx                                      
        sub       ecx, eax                                      
        sub       edx, eax                                      
        sub       edx, eax                                      
        sub       edx, eax                                      
        sub       edx, ecx                                      
        sub       edx, esi                                      
        sub       esi, ecx                                      
        test      eax, eax                                      
        test      ebx, ebx                                      
        test      edx, edx                                      
        xor       eax, eax                                      
        xor       eax, eax                                      
        xor       eax, eax                                      
        xor       eax, eax                                      
        xor       eax, eax                                      
        xor       eax, eax                                      
        xor       ebx, ebx                                      
        xor       ebx, ebx                                      
        xor       ecx, ecx                                      
        xor       edi, edi                                      
        xor       edi, edi                                      
        xor       edi, edi                                      
        xor       edx, edx                                      
        xor       edx, edx                                      
        xor       edx, edx                                      
        xor       esi, esi                                      
        xor       esi, esi                                      
        xor       esi, esi                                      
        xor       esi, esi                                      
        xor       esi, esi
It is always informative to know how many conditional and unconditional jumps are there, from above list we have 41 jumps, where only 6 are unconditional:

Code:
        ja        .B1.26        
        ja        .B1.28        
        ja        .B1.53        
        ja        .B1.55        
        ja        .B1.69        
        ja        .B1.71        
        jb        .B1.101       
        jb        .B1.103       
        jb        .B1.105       
        jb        .B1.18        
        jb        .B1.23        
        jb        .B1.45        
        jb        .B1.50        
        jb        .B1.61        
        jb        .B1.66        
        jb        .B1.7         
        jbe       .B1.15        
        jbe       .B1.42        
        jbe       .B1.58        
        je        .B1.34        
        je        .B1.37        
        je        .B1.75        
        je        .B1.76        
        jmp       .B1.10        
        jmp       .B1.16        
        jmp       .B1.30        
        jmp       .B1.38        
        jmp       .B1.43        
        jmp       .B1.59        
        jne       .B1.13        
        jne       .B1.20        
        jne       .B1.26        
        jne       .B1.32        
        jne       .B1.40        
        jne       .B1.47        
        jne       .B1.53        
        jne       .B1.56        
        jne       .B1.6         
        jne       .B1.63        
        jne       .B1.69        
        jne       .B1.9
It means this etude is not that branchy, still no clue how Ryzen pulled off this superb performance, mind you it is 32bit code, the Intel's "native" water. Later, will ask on Twitter some AMD specialists to throw some light...
 

·
Overclocker in training
Joined
·
12,938 Posts
Hi,
Yeah 9940x 14 core at 4.8 was pretty ugly only 45.
Might redo it later but was anticlimactic after a couple minutes so i bailed lol
 

·
Rig Advisor
Joined
·
1,963 Posts
Yea, I'm with Thrash on this one, not satisfied.
 

·
Registered
Joined
·
1,522 Posts
It means this etude is not that branchy, still no clue how Ryzen pulled off this superb performance, mind you it is 32bit code, the Intel's "native" water. Later, will ask on Twitter some AMD specialists to throw some light...
Is it possible that the explanation lies in the µOP cache or retire bandwidth, either Skylake fails to keep the program contained in the µOP cache, or Zen 2 is able to retire more instructions per cycle. If someone with a Zen or Zen+ processor could run a similar test, we could see if Zen 2 makes a difference.
 

·
Edgy & on the edge
Joined
·
1,539 Posts
Is it possible that the explanation lies in the µOP cache or retire bandwidth, either Skylake fails to keep the program contained in the µOP cache, or Zen 2 is able to retire more instructions per cycle. If someone with a Zen or Zen+ processor could run a similar test, we could see if Zen 2 makes a difference.
Here's a stock 3200G(Zen+). 69 DPS. Nice.

 

·
Registered
Joined
·
1,524 Posts
Not quite Ryzen performance.
 

Attachments

  • Rep+
Reactions: Sanmayce
1 - 20 of 52 Posts
Top