I have set up a new Intel performance machine for experiments. The processor is a i5-13500H in a Geekom MiniIT13 mini-PC.

Following are some of the major parameters. This comparison is with Ryzen 7840 which will be my AMD comparison microprocessor

Item	Ryzen 7840HS	i5-13500H	Notes
Architecture	Zen4	Raptor Lake
Cores	8	12 4 performance (raptor cove) 8 efficiency (gracemont)
Threads	16	16
Base Clock	3.8 GHz	2.6 GHz, 1.9 GHz
Boost Clock	5.1 GHz	4.7 GHz, 3.5 GHz
TDP	35-45W	45W-95W	Set by vendor
Memory	32 GB (2 x 16 GiB) DDR5 - 5600 2 Memory Channels	16 GB DDR4 - 3200 2 Memory Channels	Check BIOS for actual speed
Stream	Copy: 71400 MB/s Scale: 70300 MB/s Add: 73600 MB/s Triad: 73000 MB/s	Copy: 39200 MB/s Scale: 39100 MB/s Add: 40100 MB/s Triad: 40000 MB/s	Measured
Cache	L1 - 32kB, 8 way, 4 clocks L2 - 1 MB, 8-way, 14 clocks L3 - 16MB, 24 way, 47 clocks	L1 - 48 kB, 12-way/8-way, 3/5 clocks L2 - 1 MB, 10-way/16-way, 15-20 clocks L3 - 18 MB, 10-way, 65-20 clocks	Agner Fog architecture document and likwid-topology
lmbench	L1 - 0.8 ns L2 - 3 ns L3 - 8 ns	L1 - 1.3 ns, 1.0 ns L2 - 4.4 ns, 8ns L3 - 12 ns, 19ns	Measured in Nanoseconds
Graphics	Radeon 780M 12 cores 2700 MHz	Intel Iris Xe
Phoronix stream	Average: 40604 MB/s	Average: 35422 MB/s	1.15x ratio smaller than optimized compiler results above
Phoronix coremark	Average 464076 Iterations/second	Average 388569 Iterations/second	1.19 ratio

Following is the topology shown by likwid-topology. From the thread topology and description of the hardware we have:

• Four raptor-cove performance cores (cores 0,1,2,3 and threads 0-7)
• Eight gracemont efficiency cores (cores 4-11 and threads 8-15)

Depending on the thread binding we use, we can experiment with either types of cores or take pot luck to see what happens.

--------------------------------------------------------------------------------
CPU name:	13th Gen Intel(R) Core(TM) i5-13500H
CPU type:	Unknown Intel Processor
CPU stepping:	2
********************************************************************************
Hardware Thread Topology
********************************************************************************
Sockets:		1
Cores per socket:	12
Threads per core:	2
--------------------------------------------------------------------------------
HWThread	Thread		Core		Socket		Available
0		0		0		0		*
1		1		0		0		*
2		0		1		0		*
3		1		1		0		*
4		0		2		0		*
5		1		2		0		*
6		0		3		0		*
7		1		3		0		*
8		0		4		0		*
9		0		5		0		*
10		0		6		0		*
11		0		7		0		*
12		0		8		0		*
13		0		9		0		*
14		0		10		0		*
15		0		11		0		*
--------------------------------------------------------------------------------
Socket 0:		( 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 )
--------------------------------------------------------------------------------
********************************************************************************
Cache Topology
********************************************************************************
Level:			1
Size:			48 kB
Cache groups:		( 0 1 ) ( 2 3 ) ( 4 5 ) ( 6 7 ) ( 8 9 ) ( 10 11 ) ( 12 13 ) ( 14 15 )
--------------------------------------------------------------------------------
Level:			2
Size:			1 MB
Cache groups:		( 0 1 ) ( 2 3 ) ( 4 5 ) ( 6 7 ) ( 8 9 ) ( 10 11 ) ( 12 13 ) ( 14 15 )
--------------------------------------------------------------------------------
Level:			3
Size:			18 MB
Cache groups:		( 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 )
--------------------------------------------------------------------------------
********************************************************************************
NUMA Topology
********************************************************************************
NUMA domains:		1
--------------------------------------------------------------------------------
Domain:			0
Processors:		( 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 )
Distances:		10
Free memory:		9261.24 MB
Total memory:		15750.9 MB
--------------------------------------------------------------------------------

Following are the outputs from stream using the Intel compiler with -qopt-streaming-stores and running on cores 0 and 2.

-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 100000000 (elements), Offset = 0 (elements)
Memory per array = 762.9 MiB (= 0.7 GiB).
Total memory required = 2288.8 MiB (= 2.2 GiB).
Each kernel will be executed 100 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Number of Threads requested = 2
Number of Threads counted = 2
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 44926 microseconds.
   (= 44926 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:           38956.0     0.041797     0.041072     0.042758
Scale:          35684.8     0.046104     0.044837     0.048052
Add:            37673.7     0.064326     0.063705     0.068297
Triad:          37558.7     0.064531     0.063900     0.065920
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------

This seems to be slightly slower than running with aocc (AMD) compiler so perhaps not picking optimal Intel compiler settings?

-------------------------------------------------------------
STREAM version $Revision: 5.10 $
-------------------------------------------------------------
This system uses 8 bytes per array element.
-------------------------------------------------------------
Array size = 100000000 (elements), Offset = 0 (elements)
Memory per array = 762.9 MiB (= 0.7 GiB).
Total memory required = 2288.8 MiB (= 2.2 GiB).
Each kernel will be executed 100 times.
 The *best* time for each kernel (excluding the first iteration)
 will be used to compute the reported bandwidth.
-------------------------------------------------------------
Number of Threads requested = 2
Number of Threads counted = 2
-------------------------------------------------------------
Your clock granularity/precision appears to be 1 microseconds.
Each test below will take on the order of 43205 microseconds.
   (= 43205 clock ticks)
Increase the size of the arrays if this shows that
you are not getting at least 20 clock ticks per test.
-------------------------------------------------------------
WARNING -- The above is only a rough guideline.
For best results, please be sure you know the
precision of your system timer.
-------------------------------------------------------------
Function    Best Rate MB/s  Avg time     Min time     Max time
Copy:           39250.2     0.041471     0.040764     0.041949
Scale:          39164.8     0.041535     0.040853     0.042097
Add:            40115.0     0.060216     0.059828     0.060848
Triad:          40038.7     0.060927     0.059942     0.061662
-------------------------------------------------------------
Solution Validates: avg error less than 1.000000e-13 on all three arrays
-------------------------------------------------------------

Following are outputs from lmbench using the performance cores

"stride=1024
0.00098 1.319
0.00195 1.319
0.00293 1.319
0.00391 1.319
0.00586 1.319
0.00781 1.319
0.01172 1.319
0.01562 1.319
0.02344 1.319
0.03125 1.319
0.04688 1.319
0.06250 3.003
0.09375 3.957
0.12500 3.957
0.18750 3.957
0.25000 3.957
0.37500 3.957
0.50000 4.418
0.75000 4.419
1.00000 5.134
1.50000 7.942
2.00000 9.243
3.00000 9.315
4.00000 9.855
6.00000 9.361
8.00000 10.209
12.00000 12.617
16.00000 17.291
24.00000 27.485
32.00000 32.916
48.00000 39.200
64.00000 40.679
96.00000 43.083
128.00000 43.493
192.00000 44.343
256.00000 45.184
384.00000 44.791
512.00000 45.646
768.00000 44.740
1024.00000 45.498
1536.00000 46.423
2048.00000 45.713
3072.00000 46.404
4096.00000 46.764
6144.00000 45.805
8192.00000 46.870

Following are outputs from lmbench using the efficiency cores. This measurement has L1 access slightly faster and L2/L3 access slower.

"stride=1024
0.00098 1.074
0.00195 1.074
0.00293 1.074
0.00391 1.074
0.00586 1.074
0.00781 1.074
0.01172 1.079
0.01562 1.079
0.02344 1.079
0.03125 1.078
0.04688 6.395
0.06250 7.162
0.09375 6.746
0.12500 7.162
0.18750 7.163
0.25000 7.968
0.37500 7.975
0.50000 7.980
0.75000 7.976
1.00000 7.980
1.50000 8.823
2.00000 11.131
3.00000 14.390
4.00000 16.334
6.00000 15.335
8.00000 15.241
12.00000 19.302
16.00000 27.135
24.00000 46.186
32.00000 51.094
48.00000 51.997
64.00000 51.977
96.00000 52.156
128.00000 52.119
192.00000 52.228
256.00000 52.197
384.00000 52.085
512.00000 51.583
768.00000 51.018
1024.00000 51.002
1536.00000 50.598
2048.00000 50.765
3072.00000 50.612
4096.00000 50.774
6144.00000 50.952
8192.00000 49.313

Following are selected entries from output from lshw.

Motherboard: Default string
BIOS: American Megatrends - 1.09 11/10/2023
Memory: LD4S08G32C22ST
NVMe - KINGSTON OM8SEP4512Q-A01 - 512 Mb
SCSI - Samsung SSD 870 - 4 Gb

There are not specific benchmarks of this processor on phoronix.com. However, following are two benchmark articles for more powerful versions of the same processor:

• The i5-13600H is a 14-core/20-thread version – https://www.phoronix.com/review/intel-core-i5-13600k
• The i5-13900H is a 24 core/32-thread version – https://www.phoronix.com/review/intel-core-i9-13900k

These articles provide some addition areas for deeper analysis to understand how workloads exercise my processor.

Overall, I now have a somewhat recent version of both Intel and AMD microprocessors to compare. Specifications for the AMD processor are more powerful, but both are close enough. Both run 16-threads though the core configurations are different.