 1 - 20 of 52 Posts

#### Sanmayce

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
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 = {"|\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,
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,
)
{
x64toaKAZE((unsigned long long)val, buf, radix, (radix == 10 && val < 0));
return buf;
}

char * _ui64toaKAZE (
unsigned long long val,
char *buf,
)
{
return buf;
}

char * _ui64toaKAZEzerocomma (
unsigned long long val,
char *buf,
)
{
char *p;
char temp;
int txpman;
int pxnman;
p = buf;
do {
} while (*++p != '\0');
p--; // p points to last digit
// buf points to first digit
buf = 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,
)
{
char *p;
char temp;
int txpman;
int pxnman;
p = buf;
do {
} while (*++p != '\0');
p--; // p points to last digit
// buf points to first digit
buf = 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,
)
{
char *p;
char temp;
int txpman;
int pxnman;
p = buf;
do {
} while (*++p != '\0');
p--; // p points to last digit
// buf points to first digit
buf = 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; // 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; // 9,223,372,036,854,775,807: 1(sign or carry)+19(digits)+1('\0')+6(,)
char llTOaDigits3; // 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))
{
//      goto Cleanup;
}
if(!SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS))
{
//      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 [
//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

• 98.3 KB Views: 344
• 541.8 KB Views: 52

·
Joined
·
1,071 Posts
OK

#### Attachments

• Sanmayce

#### Sanmayce

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
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.

·
Joined
·
36 Posts
46

#### Attachments

• Sanmayce

#### Sanmayce

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
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.

• Geeboi

·
Joined
·
285 Posts
stock 8700k

#### Attachments

• Sanmayce

#### Sanmayce

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
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 |
------------------------------------------------------``````

#### ThrashZone

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

#### Arni90

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

#### Attachments

• Sanmayce

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

#### rares495

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

• Sanmayce

#### ThrashZone

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

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
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 |
-----------------------------------------------------------``````

Don't worry, virustotal on-line check shows the .ZIP is not problematic:

#### ThrashZone

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

·
##### Integer Benchmarker
Joined
·
431 Posts
Discussion Starter
This etude turns out to be so nifty, from programming, integer performance benchmarking, identifying the CPU vendor (hee-hee), perspective. 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: - .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]
.B1.10:
lea       edi, DWORD PTR [3333334+esi]
imul      eax, edi
lea       edi, DWORD PTR [6666667+ebx]
mov       eax, ecx
cdq
idiv      edi
imul      edi, eax
neg       edi
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]
neg       eax
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
mov       DWORD PTR [_j], ebx
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]
mov       BYTE PTR [ebx], al
inc       ebx
jmp       .B1.16
.B1.15:
mov       eax, DWORD PTR [216+esp]
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
.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     eax, BYTE PTR [1+ebx+edi]
mov       BYTE PTR [1+ebx+edi], dl
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
jne       .B1.20
.B1.21:
mov       esi, edx
mov       eax, 1
sub       esi, ecx
inc       esi
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       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]
lea       edi, DWORD PTR [-1+ecx+eax]
cmp       edx, edi
ja        .B1.26
.B1.25:
dec       esi
inc       DWORD PTR [208+esp]
.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:
sub       edx, eax
push      edi
push      edx
call      _fputs
.B1.90:
.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:
.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:
.B1.39:
fild      DWORD PTR [_DigitsSoFar]
sub       eax, DWORD PTR [_time1]
mov       edi, DWORD PTR [_Melnitchka]
sbb       edx, DWORD PTR [_time1+4]
mov       DWORD PTR [168+esp], eax
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]
mov       BYTE PTR [esi], al
inc       esi
jmp       .B1.43
.B1.42:
mov       eax, DWORD PTR [248+esp]
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
.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     eax, BYTE PTR [1+ecx+esi]
mov       BYTE PTR [1+ecx+esi], dl
mov       edx, DWORD PTR [264+esp]
cmp       edx, ebx
jb        .B1.45
.B1.46:
mov       ecx, DWORD PTR [192+esp]
xor       edx, edx
.B1.47:
inc       edx
jne       .B1.47
.B1.48:
mov       eax, edx
sub       eax, ebx
inc       eax
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       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]
lea       ecx, DWORD PTR [-1+edi+eax]
cmp       edx, ecx
ja        .B1.53
.B1.52:
dec       ebx
inc       DWORD PTR [232+esp]
.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       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]
.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]
mov       BYTE PTR [esi], al
inc       esi
jmp       .B1.59
.B1.58:
mov       eax, DWORD PTR [252+esp]
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
.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     eax, BYTE PTR [1+ecx+esi]
mov       BYTE PTR [1+ecx+esi], dl
mov       edx, DWORD PTR [268+esp]
cmp       edx, ebx
jb        .B1.61
.B1.62:
mov       ecx, DWORD PTR [192+esp]
xor       edx, edx
.B1.63:
inc       edx
jne       .B1.63
.B1.64:
mov       eax, edi
mov       edx, 1
sub       eax, ebx
inc       eax
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       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]
lea       edi, DWORD PTR [-1+ebx+eax]
cmp       edx, edi
ja        .B1.69
.B1.68:
dec       ecx
inc       DWORD PTR [244+esp]
.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       ebx, DWORD PTR [196+esp]
neg       edx
mov       DWORD PTR [4+esp], ebx
mov       edi, DWORD PTR [232+esp]
neg       edi
neg       ecx
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)
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:
.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:
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
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       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
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 [3333334+esi]
lea       edi, DWORD PTR [6666667+ebx]
lea       edi, DWORD PTR [eax+eax*2]
lea       edi, DWORD PTR [eax+eax*2]
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       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       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       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       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       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]
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...

#### ThrashZone

·
##### 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

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

#### Arni90

·
##### 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.

#### rares495

·
##### 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.

#### 0451

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

#### Attachments

• Sanmayce
1 - 20 of 52 Posts