hello from RPCEmu on Apple M1 Max :)

to everyone interested,
I managed to build RPCEmu for Apple M1 (native). Everything seems to be working fine (tested with both RISC OS 5 Direct and RISC OS 3.70 bundles).

If anyone is interested, plese let me know and I’ll make the DMG available for testing.

Thanks :)

What’s the performance like, compared to a decent spec’d x86 box?

Alternatively, just use the DMGs that have been available for months, here:

https://github.com/Septercius/rpcemu-dev/releases/

David: only the interpreter build works on Apple Silicon Macs, as there isn’t yet support for arm64 CPUs which is needed for the recompiler build to work. So performance is good, but probably not as good as an x86 running the recompiler.

@ Timothy

Alternatively, just use the DMGs that have been available for months

Had no idea you did the work already for the M1, that would have spared me some work…

@ Druck

What’s the performance like, compared to a decent spec’d x86 box?

It took me a bit to find a “comparable” system on my rack of modern PCs, however I have a Zen3 Ryzen 9 5950X 16-Cores Motherboard with RAM in SODIMM format and no discrete video card, which is the closest I can get to my M1 Max.

I am running some benchmark between my native built of the interpreter and a native build of the interpreter on the AMD.

The AMD has DDR4 (but they are faster than the DDR5 on the M1), so it should provide data to the CPU with a lower latency and a smaller bandwidth, while the M1 should (in theory) have a slightly higher latency and a higher bandwidth.

In the case of RPCEmu, given it’s an emulator using a single core, the larger bandwidth will not make a lot of difference and it will all boil down to the performance per core of both RAM and CPU. The Ryzen 9 5950X has a higher score of performance per CPU core than the M1 Max.

Both RPCEmu running the exact same RISC OS (Direct) and both set at the same video resolution.

Early memory bandwidth tests (with a test I wrote to identify also the cache factor between RAM and cache), ran via FrontEnd (so in “semi-multitask”), report the following results:

Apple M1 Max (CPU Max clock speed 3.2Ghz, with 64GB LPDDR 5 RAM):

Memory block size 1024 bytes (test time set to 10 seconds)
operation: memory copy        = 330.200000 MB/s
operation: memory set         = 675.900000 MB/s
operation: block sum unrolled = 268.000000 MB/s

Memory block size 8388608 bytes (test time set to 10 seconds)

operation: memory copy        = 345.600000 MB/s

operation: memory set         = 813.600000 MB/s

operation: block sum unrolled = 258.400000 MB/s
Average cache to main memory factor: 0.898773

AMD Ryzen 9 5950X (CPU Max Clock Speed 4.9 Ghz, with 64GB LPDDR 4 RAM, RAM clock 3.2Ghz at Cas Latency 18):

Memory block size 1024 bytes (test time set to 10 seconds)
operation: memory copy        = 395.900000 MB/s
operation: memory set         = 817.200000 MB/s
operation: block sum unrolled = 293.500000 MB/s

Memory block size 8388608 bytes (test time set to 10 seconds)

operation: memory copy        = 431.200000 MB/s

operation: memory set         = 948.800000 MB/s

operation: block sum unrolled = 336.800000 MB/s
Average cache to main memory factor: 0.877563

As a comparison with a Raspberry Pi 4 (running RISC OS natively) at standard clock (1500Mhz, 8GB RAM):

Memory block size 1024 bytes (test time set to 10 seconds)
operation: memory copy        = 6962.000000 MB/s
operation: memory set         = 9155.200000 MB/s
operation: block sum unrolled = 5008.600000 MB/s

Memory block size 8388608 bytes (test time set to 10 seconds)

operation: memory copy        = 2286.400000 MB/s

operation: memory set         = 3024.000000 MB/s

operation: block sum unrolled = 3577.600000 MB/s
Average cache to main memory factor: 2.376890

If it is of interest I can run more tests.

In summary, considering that the AMD R9 5950X is a 105Watt TDP with max clock of 4.9Ghz, the Apple M1 Max compares really well, so (so far) I am impressed by the results. However, interpreted emulation is not the future, clearly ;)

Can you make the DMG available for the M1?
There are several tests i would like to run.

Thanks Paolo, those figures for the interpreter pretty good, but its the recompiler performance I’m really looking forward to.

@ Jan Rinze

Can you make the DMG available for the M1?

Sure, will do, but if you are in a hurry you can have a look at the link posted by Timothy. I don’t think there will be performance differences between the two builds. Also, given that RPCEmu is single task, there shouldn’t be a lot of difference between M1, M1 Pro and M1 Max either.

@ Druck

its the recompiler performance I’m really looking forward to.

Me too actually, but for that one we’ll have to wait. The recompiler at the moment generates only x86 code. I was thinking of “rerouting” it through Rosetta 2, but that will be some work and it’s probably quicker to just run the entire RPCEmu under Rosetta 2, if I have some time I’ll give it a try and see how it goes and if produces anything meaningful.

For the interpreter results yup, impressive, compared to a much faster AMD machine.

All,
adding some early test of the Recompiler on M1 + Rosetta (basically having the binary processed through Rosetta). The bandwidth is clearly much higher than the interpreter, however the screen redraw is slower, so I will need to figure this out.

Apple M1 Max (CPU Max clock speed 3.2Ghz, with 64GB LPDDR 5 RAM, RPCEmu-Recompiler with x86 code executed via Rosetta 2):

Memory block size 1024 bytes (test time set to 10 seconds)
operation: memory copy        = 1187.000000 MB/s
operation: memory set         = 1598.200000 MB/s
operation: block sum unrolled = 1316.600000 MB/s

Memory block size 8388608 bytes (test time set to 10 seconds)
operation: memory copy        = 1700.400000 MB/s

operation: memory set         = 2091.000000 MB/s

operation: block sum unrolled = 1537.600000 MB/s
Average cache to main memory factor: 0.799742

Palol,

I would be very interested in any testing, I have just bought a new MacBook Pro M1 Max 64GB, I have RPCEmu running on my new Mac but is very very slow, not sure why? All that I did was to copy and then transfer across, any ideas.

How slow is very, very slow exactly?
RPCEmu is very slow. Here it is more than 4 times slower than VirtualAcorn on the same computer (premium HP with Windows 11) – and many, many times slower than the real thing (4té2).

Here it is more than 4 times slower than VirtualAcorn on the same computer

VirtualAcorn, or VirtualRPC?
(in other words, are you comparing a RiscPC emulation with an A5000 emulation?)

I understand that VRPC has been fairly aggressively optimised, so it was quick even on the older hardware of a decade or two ago.
But… is it still being developed? Is the OS that it is supplied with?

and many, many times slower than the real thing (4té2).

Could say the same thing comparing a 4té2 against any sort of RiscPC, ever. ;)

VirtualAcorn, or VirtualRPC?

Apologise, it’s a VirtualRPC-SA. But I never realised that RPCEmu was emulating a different thing.
Anyhow, the VRPC hasn’t been developed for many years, as far as I know. And it’s still running RISC OS 4.02.

I have RPCEmu running on my new Mac but is very very slow,

The interpreter build is the better option on the M1 Mac, from here.