This is Part 2 of our special feature on the M1. In the next section, we look at further benchmarks and some real-world app tests. Importantly, our real-world apps are not yet Apple Silicon native so they are tested under Rosetta 2 Intel X86 emulation.
Let’s begin with further benchmarks all native to the M1.
This GPU benchmark is built on top of the Rocksolid proprietary rendering engine coded in C++. The Helsinki-based software company touts the objectivity of this benchmark for multiple operating systems. Rocksolid Engine architecture abstracts resources and rendering, effectively neutralizing the comparison as all tests run with the same workload regardless of the operating system.
In this test, the M1 was easily defeated by the Pro Vega 56 GPU in the 2017 iMac Pro. It also was less performant than the previously mentioned Quadro P2000, which was nearly 50 percent faster in this test. We suspect the abstraction layer in the C++ codebase neutralizes the streamlining benefits between silicon engineered for Metal’s code and vice versa. This would apply to all graphics APIs, and we can see their importance in GFXbench results where graphics APIs are reported along with the same card at different scores for different APIs.
Speedometer 2.0 Web Benchmark
We tested M1’s web browser performance using Speedometer 2.0. This measures browser web app responsiveness by running simulated user interactions common to web applications.
As noted here at Anandtech.com, Apple’s CPUs in mobile have dominated in browser-benchmarks. Now having that ARM-based architecture on the Mac platform brings superior web application performance to Apple Silicon-based Macs. This is important because more professional applications happen via browser-based SaaS tools. (see emTech section below and comments by Tech Soft 3D)
As we can see, the M1 Mac mini has blistering web performance, more than 2x the 2017 iMac Pro performance. The M1 is also 55 percent faster than the AMD Ryzen 9-5950X (based on an Anandtech.com score). Apple has highly prioritized web browser performance, as can be seen in even the iPhone 12 Pro (A14 chip), obtaining a 202.2 score (based on Anandtech.com score). As a further point of reference, my Touch-bar, 2016 MacBook Pro with 2.6GHz Intel i7 received a score of 85.8, about 22 percent slower than the iMac Pro.
Real-World App Tests
Typically Architosh does real-world performance tests with a series of files we have accumulated or built over a decade and a half. These files are used during our product reviews to look at performance from version to version.
We test using the Timer app (a digital stopwatch with 1/10 a second indicator) and the Apple Developers tool, Quartz Debug, which includes a Frames Per Second (FPS) meter. And we record the whole thing in QuickTime. After clean restarts, only these tiny apps plus the “test app” are running. The apps are loaded into the system in the exact same order: (1) test app, (2) QuickTime, (3) Timer, and finally (4) Quartz Debug.
Our test files are a series of SketchUp and Vectorworks Architect files, two programs we have most been asked (and performed) product reviews for. As a result, we have built up some test files.
Importantly, both of these tools were running under Rosetta 2 because they have not been re-coded for Apple Silicon Macs yet.
In our SketchUp 2021 tests, the M1 ran reasonably well under Rosetta, but it was outperformed by the native SketchUp for Intel on the iMac Pro 2017.
In the top row in the image below, our Turning Torso tower model (a quite complex but repeating geometry) runs through four scenes and turns. We calculate achieved Frame Rates per Second using Apple’s Quartz Debug app. The iMac Pro achieved 70+ FPS in the first scene transition, compared to the M1 Mac mini, which only reached 40 FPS. (M1 on upper left, iMac Pro on upper right).
On the Falkestrasse model, an odd but well-published creation by the architect Coop Himmelblau, the M1 Mac mini achieved greater than 50 FPS scores during its scene transitions. But again, the iMac Pro with its Pro Vega 56 GPU card achieved greater than 80 FPS. (M1 on lower right and iMac Pro on left).
Both models are simple OpenGL shaded models with transparency (glass), with the Falkestrasse containing some limited texture mapping. We noticed that when the scene passes over the texture-mapping section of the Falkestrasse facade on both machines, the FPS speeds up noticeably.
In our third SketchUp model with intensive photographic landscape props, the M1 Mac mini performed exceptionally well and was on par with the iMac Pro. Overall, we think Rosetta 2 is impacting a penalty on the performance, but even under Rosetta 2, SketchUp on the M1-based Mac was more than serviceable—it was quite good.
Vectorworks Architect 2021
We have three files for Vectorworks testing. One area that seems to tax Vectorworks performance in regular 2D work is when a file utilizes many external references on a “design layer” in viewports on that layer. The application is incredibly flexible in the creation and use of viewports, internally and externally referenced. That’s a good thing. However, many of them on a visible layer (including iterations of the same viewport) cause a noticeable impact on performance.
In our test, we save different scenes with different combinations of viewports visible. Going from scene to scene and using the pan tool to move the screen around represents real-life user-interaction scenarios where screen drawing is taxed.
In this particular test, the M1 Mac mini performed a bit better than the 2017 iMac Pro. Although Vectorworks 2021 was running in Rosetta 2 on the M1 Mac mini and not natively like on the iMac Pro 2017, the screen redraws performance was quite solid.
There are many more tests we could run on Vectorworks, in particular, due to several other test files we have used over the years during product reviews. We have 2D scroll tests and we have some 3D rendering test files. We really don’t want too far at the moment given that Rosetta 2 is processing both SketchUp and Vectorworks. But we plan on re-testing on both of these applications with all of the test files we actually have once both applications—popular in the Mac 3D and CAD space—are released native for Apple Silicon.
To summarize a bit, SketchUp like all 3D modeling applications is nearly entirely single-threaded. There is a great post on multithreading over at the SketchUp Forums here that discusses why this is. In a nutshell, 3D model calculations are linear in nature and must be processed in sequence on a single thread. Breaking up the calculations for 3D modeling is very limited. The areas where SketchUp may take up code that can be multithreaded are in rendering. But this is true, generally, of all 3D tools. For the moment, since Sketchup is almost entirely single-thread based, the best single-core processing chip on the market is going to be your fastest SketchUp machine, all other things being equal like cache size, memory bandwidth, etcetera. This places the M1 Mac mini is a good place, particularly once SketchUp is native for Apple Silicon.
Both SketchUp and Vectorworks 2021 (and VW 2020) run well under Rosetta 2 emulation. But we will be really excited to test again under native app conditions.
next page — Critical Summary, Floating Point, Nuvia, AMD, and Closing Analysis