16
$\begingroup$

Many people consider the performance of MMA when choosing their computers. I feel we need some up-to-date benchmark results across hardware and systems for the major version 13, which will help a lot of people not even limited to users here.

So if you agree, please run the following and post the result as an answer.

Quit[]

then:

1+1;
Needs["Benchmarking`"]
Benchmark[]

Running Quit[] ensures the benchmark is evaluated on a fresh kernel, thus avoiding artificially high results due to caching.

$\endgroup$
17
  • 2
    $\begingroup$ It feels as though this is partially a duplicate of this question, which is the benchmarking thread that got the most traction: mathematica.stackexchange.com/questions/234881/… $\endgroup$
    – Carl Lange
    Apr 25, 2022 at 7:24
  • 2
    $\begingroup$ @CarlLange But maybe it still makes sense to do this in a new thread for major versions? $\endgroup$
    – gwr
    Apr 25, 2022 at 9:36
  • 2
    $\begingroup$ Does this answer your question? Benchmarking with Mathematica v.12 for up to date comparison across different machines $\endgroup$
    – bbgodfrey
    Apr 29, 2022 at 19:02
  • 2
    $\begingroup$ @bbgodfrey I do not understand the reason behind marking this as duplicate. Maybe I am too naive about it, but the post to which you are referring clearly discusses V12 whilst this one is for V13. Could you please elaborate a bit? Many thanks! $\endgroup$
    – bmf
    Apr 29, 2022 at 23:20
  • 4
    $\begingroup$ I think these benchmark posts for major versions are valuable and should not be closed as duplicates of older Q&A. However I also think these should be "Community Wiki", in line with other "share your results/tips" style posts. I am going to 1) close and reopen this post to clear out the votes and 2) mark this and the other v12 post as community wikis. It would help if we could standardize on the output format — this one asks for Benchmark[] whereas the other asks for BenchmarkReport[]. Having consistency across versions would help future readers. $\endgroup$
    – rm -rf
    May 1, 2022 at 14:23

26 Answers 26

4
$\begingroup$
  • $Version 13.3.0 for Microsoft Windows (64-bit) (June 3, 2023)
  • AMD Ryzen 7 4800H with Radeon Graphics 2.90 GHz
  • 16GB RAM
  • Windows 11 Insider Preview 22H2
  • ASUS TUF Gaming A17 (2019)

Score: 2.77

Fresh Quit[] kernel:

{
  "MachineName" -> "tuf", 
  "System" -> "Microsoft Windows (64-bit)", 
  "BenchmarkName" -> "WolframMark", 
  "FullVersionNumber" -> "13.3.0", 
  "Date" -> "July 31, 2023", 
  "BenchmarkResult" -> 2.77, 
  "TotalTime" -> 4.998, 
  "Results" -> {
    {"Data Fitting", 0.435}, 
    {"Digits of Pi", 0.245}, 
    {"Discrete Fourier Transform", 0.452}, 
    {"Eigenvalues of a Matrix", 0.49}, 
    {"Elementary Functions", 0.545}, 
    {"Gamma Function", 0.3}, 
    {"Large Integer Multiplication", 0.283}, 
    {"Matrix Arithmetic", 0.195}, 
    {"Matrix Multiplication", 0.22}, 
    {"Matrix Transpose", 0.46}, 
    {"Numerical Integration", 0.615}, 
    {"Polynomial Expansion", 0.07}, 
    {"Random Number Sort", 0.109}, 
    {"Singular Value Decomposition", 0.272}, 
    {"Solving a Linear System", 0.307}
  }
}

After LaunchKernels[]:

{
  "MachineName" -> "8-node homogeneous cluster", 
  "System" -> "Windows-x86-64", 
  "BenchmarkName" -> "WolframMark", 
  "FullVersionNumber" -> "13.3.0", 
  "Date" -> "July 31, 2023", 
  "BenchmarkResult" -> 6.993, 
  "TotalTime" -> 47.503
}
$\endgroup$
4
$\begingroup$

Linux

  • $Version 13.3.0 for Linux x86 (64-bit) (June 12, 2023)
  • 13th Gen Intel(R) Core(TM) i9-13900K
  • 32GB RAM
  • Parabola GNU/Linux-libre
  • kernel: 5.15.88-gnu-1-lts

Score: 8.435

Fresh Quit[] kernel:

{"MachineName" -> "monad", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.3.0", 
 "Date" -> "July 21, 2023", 
 "BenchmarkResult" -> 8.435, 
 "TotalTime" -> 1.641, 
 "Results" -> {{"Data Fitting", 0.104}, {"Digits of Pi", 0.131}, {"Discrete Fourier Transform", 0.171}, 
   {"Eigenvalues of a Matrix", 0.154}, {"Elementary Functions", 0.051}, {"Gamma Function", 0.184}, 
   {"Large Integer Multiplication", 0.175}, {"Matrix Arithmetic", 0.015}, {"Matrix Multiplication", 0.061}, 
   {"Matrix Transpose", 0.1}, {"Numerical Integration", 0.199}, {"Polynomial Expansion", 0.024}, 
   {"Random Number Sort", 0.023}, {"Singular Value Decomposition", 0.131}, {"Solving a Linear System", 0.118}}}

After LaunchKernels[] (8 kernels):

{"MachineName" -> "8-node homogeneous cluster",
 "System" -> "Linux-x86-64",
 "BenchmarkName" -> "WolframMark",
 "FullVersionNumber" -> "13.3.0",
 "Date" -> "July 21, 2023",
 "BenchmarkResult" -> 25.221,
 "TotalTime" -> 13.172}

Windows 11 Pro

Same machine running Windows 11 Pro

$Version 13.3.0 for Microsoft Windows (64-bit) (June 12, 2023)

Score: 5.739

{"MachineName" -> "pandora", "System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark",
 "FullVersionNumber" -> "13.3.0", "Date" -> "July 30, 2023", "BenchmarkResult" -> 5.739, "TotalTime" -> 2.412,
 "Results" -> {{"Data Fitting", 0.176}, {"Digits of Pi", 0.144}, {"Discrete Fourier Transform", 0.2},
   {"Eigenvalues of a Matrix", 0.248}, {"Elementary Functions", 0.131}, {"Gamma Function", 0.193},
   {"Large Integer Multiplication", 0.203}, {"Matrix Arithmetic", 0.093}, {"Matrix Multiplication", 0.064},
   {"Matrix Transpose", 0.163}, {"Numerical Integration", 0.298}, {"Polynomial Expansion", 0.031},
   {"Random Number Sort", 0.074}, {"Singular Value Decomposition", 0.251}, {"Solving a Linear System", 0.143}}}

LaunchKernels[]

{"MachineName" -> "8-node homogeneous cluster", "System" -> "Windows-x86-64", "BenchmarkName" -> "WolframMark",
 "FullVersionNumber" -> "13.3.0", "Date" -> "July 30, 2023", "BenchmarkResult" -> 19.74, "TotalTime" -> 16.829}

Not sure why there is such a large discrepancy. I am guessing there are significant performance differences in the C runtime between Windows and Linux. Perhaps it comes down to the OS effectively allocating processes across the heterogeneous CPU architecture of the i9 as well.

WSL2 (Windows 11 Pro)

Same computer running WSL2 (Ubuntu 22.04)

  • os: 22.04.2 LTS (Jammy Jellyfish)
  • kernel: 5.15.90.1-microsoft-standard-WSL2

Score: 7.335

$ wolframscript -c 'Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
{MachineName -> pandora, System -> Linux x86 (64-bit), BenchmarkName -> WolframMark, FullVersionNumber -> 13.3.0, Date -> August 5, 2023, BenchmarkResult -> 7.335, TotalTime -> 1.887, Results -> {{Data Fitting, 0.14}, {Digits of Pi, 0.146}, {Discrete Fourier Transform, 0.149}, {Eigenvalues of a Matrix, 0.158}, {Elementary Functions, 0.078}, {Gamma Function, 0.219}, {Large Integer Multiplication, 0.182}, {Matrix Arithmetic, 0.027}, {Matrix Multiplication, 0.072}, {Matrix Transpose, 0.105}, {Numerical Integration, 0.238}, {Polynomial Expansion, 0.112}, {Random Number Sort, 0.031}, {Singular Value Decomposition, 0.118}, {Solving a Linear System, 0.112}}}

LaunchKernels[]:

$ wolframscript -c 'LaunchKernels[]; Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
InputForm[{MachineName -> 8-node homogeneous cluster, System -> Linux-x86-64, BenchmarkName -> WolframMark, FullVersionNumber -> 13.3.0, Date -> August 5, 2023, BenchmarkResult -> 24.476, TotalTime -> 13.573}]

To summarize, for modern Intel processors in 2023 and version 13.3, Wolfram Language (WL) on native Linux performs at 1.5x WL on Windows 11, and WL on WSL2 performs at 1.3x WL on Windows 11. Also, WL under native Linux operates 15% faster than WL on WSL.

Update: High Score on this machine

  • $Version 14.0.0 for Linux x86 (64-bit) (December 13, 2023)
  • Red Hat Enterprise Linux release 9.3 (Plow)
  • kernel: 5.14.0-362.18.1.el9_3.x86_64

The above benchmarks were completed with a cold start of the wolfram engine software. If you run the benchmarks repeatedly with the same kernel active, certain data like shared libraries may be cached, and modern CPUs can adapt to the branching and memory access patterns of the benchmark program. The highest score I have observed from this system when running the benchmark in a loop a couple dozen times:

Score: 9.065

(Note: Even though I updated to version 14.0 and switched OS's, the cold-start single-benchmark score has not changed. The switch has increased the multi-kernel benchmark by about 30%.)

{"MachineName" -> "monad", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "14.0.0", 
 "Date" -> "February 17, 2024", "BenchmarkResult" -> 9.065, 
 "TotalTime" -> 1.527, "Results" -> {{"Data Fitting", 0.096}, 
   {"Digits of Pi", 0.125}, {"Discrete Fourier Transform", 0.125}, 
   {"Eigenvalues of a Matrix", 0.146}, {"Elementary Functions", 0.053}, 
   {"Gamma Function", 0.174}, {"Large Integer Multiplication", 0.167}, 
   {"Matrix Arithmetic", 0.019}, {"Matrix Multiplication", 0.051}, 
   {"Matrix Transpose", 0.108}, {"Numerical Integration", 0.189}, 
   {"Polynomial Expansion", 0.018}, {"Random Number Sort", 0.025}, 
   {"Singular Value Decomposition", 0.133}, {"Solving a Linear System", 
    0.098}}}

After LaunchKernels[8]:

Score: 27.259

{"MachineName" -> "8-node homogeneous cluster", "System" -> "Linux-x86-64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "14.0.0", 
 "Date" -> "February 17, 2024", "BenchmarkResult" -> 27.259, "TotalTime" -> 12.187}
$\endgroup$
2
  • $\begingroup$ Remarkable difference between windows and linux performance, anyone can shed more light on this? $\endgroup$
    – Wicher
    Nov 14, 2023 at 22:02
  • 1
    $\begingroup$ I have no idea where the 50% performance gap is coming from. I would suspect memory allocation performance or some other difference in libc and/or the compiler. It would be cool if someone wanted to strap WL to vtune during the benchmark. It would also be great to get some WRI analysis and input here. $\endgroup$ Nov 19, 2023 at 1:50
3
$\begingroup$

iMac (Mid 2020) 27-inch, 3.6GHz 10-Core Intel i9-10910, 128GB RAM, Radeon 5700, macOS Monterey with MMA 13.0.1

single-core

{"System" -> "Mac OS X x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.1", 
 "Date" -> "April 25, 2022", "BenchmarkResult" -> 4.664, 
 "TotalTime" -> 2.968, "Results" -> {{"Data Fitting", 0.211}, 
   {"Digits of Pi", 0.222}, {"Discrete Fourier Transform", 0.165}, 
   {"Eigenvalues of a Matrix", 0.254}, {"Elementary Functions", 0.16}, 
   {"Gamma Function", 0.319}, {"Large Integer Multiplication", 0.306}, 
   {"Matrix Arithmetic", 0.108}, {"Matrix Multiplication", 0.073}, 
   {"Matrix Transpose", 0.151}, {"Numerical Integration", 0.34}, 
   {"Polynomial Expansion", 0.049}, {"Random Number Sort", 0.346}, 
   {"Singular Value Decomposition", 0.145}, {"Solving a Linear System", 
    0.119}}}

multi-core (LaunchKernels[]; before the test)

{"System" -> "MacOSX-x86-64", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.0.1", "Date" -> "April 25, 2022", 
 "BenchmarkResult" -> 10.574, "TotalTime" -> 39.27}
$\endgroup$
6
  • 1
    $\begingroup$ How many kernels were launched? On PC the benchmark includes this info. $\endgroup$
    – Edmund
    Apr 25, 2022 at 11:17
  • $\begingroup$ @Edmund I presume LaunchKernels[] launches all by default, which is 10 for this machine and is also what I saw in the activity monitor. $\endgroup$
    – xiaohuamao
    Apr 25, 2022 at 13:06
  • $\begingroup$ My 6 Intel cores beat your 10 Mac cores. :-) "BenchmarkResult" -> 7.801, "TotalTime" -> 31.938} $\endgroup$
    – Edmund
    Apr 25, 2022 at 13:12
  • 3
    $\begingroup$ @Edmund Seems that you've got a good machine :) Why not post an answer? BTW, mine is intel as well. $\endgroup$
    – xiaohuamao
    Apr 26, 2022 at 0:08
  • 2
    $\begingroup$ But that's not what's going on. Instead, the wall clock time to run WolframMark with LaunchKernels[] is multiples higher than without it, indicating it's not speeding things up, it's slowing them down. I think what's happening is that, when you execute LaunchKernels[], MMA runs several WolframMarks simultaneously (which is why it takes so much longer) and then does some sort of sum on the individual scores (which is why you get an artificially high score). $\endgroup$
    – theorist
    Jun 11, 2022 at 4:18
3
$\begingroup$

Dell Alienware Aurora-R13 Desktop Device name Stonefish-Alienware-Aurora-R13 Processor 12th Gen Intel(R) Core(TM) i9-12900KF 3.19 GHz Installed RAM 64.0 GB (63.8 GB usable) System type 64-bit operating system, x64-based processor

Quit[]

1 + 1;
Needs["Benchmarking`"]
Benchmark[]

Out[3]//InputForm=
{"MachineName" -> "stonefish-alien", 
"System" -> "Microsoft Windows (64-bit)", 
"BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
"13.0.1", "Date" -> "July 2, 2022", 
"BenchmarkResult" -> 3.687, "TotalTime" -> 3.754, 
"Results" -> {{"Data Fitting", 0.249}, 
{"Digits of Pi", 0.178}, {"Discrete Fourier Transform", 
0.347}, {"Eigenvalues of a Matrix", 0.297}, 
{"Elementary Functions", 0.358}, {"Gamma Function", 0.701}, 
{"Large Integer Multiplication", 0.236}, 
{"Matrix Arithmetic", 0.215}, {"Matrix Multiplication", 
0.097}, {"Matrix Transpose", 0.235}, 
{"Numerical Integration", 0.308}, {"Polynomial Expansion", 
0.029}, {"Random Number Sort", 0.088}, 
{"Singular Value Decomposition", 0.215}, 
{"Solving a Linear System", 0.201}}}
$\endgroup$
2
$\begingroup$

I am sitting on a

MacBook Pro (13-inch, M1, 2020) that has the Apple M1 chip and macOS Monterey 12.3.1

Needs["Benchmarking`"]
Benchmark[]
{"System" -> "Mac OS X ARM (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.0", 
 "Date" -> "April 28, 2022", "BenchmarkResult" -> 3.048, "TotalTime" -> 4.541, 
 "Results" -> {{"Data Fitting", 0.177}, {"Digits of Pi", 0.172}, 
   {"Discrete Fourier Transform", 0.318}, {"Eigenvalues of a Matrix", 0.261}, 
   {"Elementary Functions", 1.047}, {"Gamma Function", 0.232}, 
   {"Large Integer Multiplication", 0.2}, {"Matrix Arithmetic", 0.185}, 
   {"Matrix Multiplication", 0.398}, {"Matrix Transpose", 0.154}, 
   {"Numerical Integration", 0.326}, {"Polynomial Expansion", 0.039}, 
   {"Random Number Sort", 0.406}, {"Singular Value Decomposition", 0.364}, 
   {"Solving a Linear System", 0.262}}}

Also,

LaunchKernels[]

and do the test

{"MachineName" -> "8-node homogeneous cluster", "System" -> "MacOSX-ARM64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.0", 
 "Date" -> "April 28, 2022", "BenchmarkResult" -> 9.175, "TotalTime" -> 36.208}
$\endgroup$
2
  • $\begingroup$ These M1 numbers look bad, but they're not as bad as they could be. When I looked at this on an A12X, it was clear that the Wolfram code was - not using very good bignum code (slow Digits of Pi and Gamma Function) - mostly not using other cores for large vectors/matrices - probably not using SIMD for arrays of special functions. Bignums looks like it's on the way to being fixed. SIMD and multi-core look like they're mostly not yet touched. Likewise looks like no functions are routing to AMX. Probably worth trying again on 13.1 to see further progress. $\endgroup$ Jul 8, 2022 at 23:41
  • $\begingroup$ Wolfram have always been about doing the job right, not quick and easy. So I expect they are taking their time to make sure bignums and SIMD are implemented optimally for ARM64. I'm not sure what the multi-core holdup is except if, perhaps, they want a generic framework that handles het cores (P and E) and/or accelerators (like AMX) optimally and aren't really bothering with moving packed vectors/matrices to multi-core until that framework is in place (which they also need, anyway, for Alder Lake et seq, and Intel's AMX). $\endgroup$ Jul 8, 2022 at 23:44
2
$\begingroup$

I have posted benchmark results for 12.3.1 in this previous thread for my various machines, but this time I tried using Parallelize[]; and LaunchKernels[]; ahead and got varying results.

Macbook Pro M1 13'' 2020, 16GB Ram

Parallelize[];
Benchmark[]

{"MachineName" -> 
  "4-node homogeneous cluster", 
 "System" -> "MacOSX-ARM64", 
 "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "12.3.1", 
 "Date" -> "April 29, 2022", 
 "BenchmarkResult" -> 6.639, 
 "TotalTime" -> 25.021}

Benchmark[]
{"MachineName" -> "laederlappen", "System" -> "Mac OS X ARM (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "12.3.1", 
 "Date" -> "April 29, 2022", "BenchmarkResult" -> 3.178, 
 "TotalTime" -> 4.355, "Results" -> {{"Data Fitting", 0.14}, 
   {"Digits of Pi", 0.171}, {"Discrete Fourier Transform", 0.298}, 
   {"Eigenvalues of a Matrix", 0.303}, {"Elementary Functions", 0.659}, 
   {"Gamma Function", 0.224}, {"Large Integer Multiplication", 0.188}, 
   {"Matrix Arithmetic", 0.104}, {"Matrix Multiplication", 0.183}, 
   {"Matrix Transpose", 0.139}, {"Numerical Integration", 0.766}, 
   {"Polynomial Expansion", 0.062}, {"Random Number Sort", 0.435}, 
   {"Singular Value Decomposition", 0.434}, {"Solving a Linear System", 
    0.249}}}

LaunchKernels[];
Benchmark[]
{"MachineName" -> "4-node homogeneous cluster", "System" -> "MacOSX-ARM64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "12.3.1", 
 "Date" -> "April 29, 2022", "BenchmarkResult" -> 6.853, 
 "TotalTime" -> 24.239}

I have a feeling the benchmark isn't a reliable measure of machine ability.

$\endgroup$
2
$\begingroup$

Laptops don't fair to well against desktops but they are easier to carry.

Lenovo ThinkBook P15 Gen1, Intel Xeon W-10855M (max 5.1 GHz), 128GB DDR4 RAM, NVIDIA Quadro RTX 4000 Max-Q (8 GB), UHD 4k 15in

Needs["Benchmarking`"]
Benchmark[]
{"MachineName" -> "whaleshark", "System" -> "Microsoft Windows (64-bit)"
 , "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.1"
 , "Date" -> "May 1, 2022"
 , "BenchmarkResult" -> 3.483, "TotalTime" -> 3.974
 , "Results" -> {
    {"Data Fitting", 0.258}
    , {"Digits of Pi", 0.249}
    , {"Discrete Fourier Transform", 0.321}
    , {"Eigenvalues of a Matrix", 0.286}
    , {"Elementary Functions", 0.395}
    , {"Gamma Function", 0.362}
    , {"Large Integer Multiplication", 0.338}
    , {"Matrix Arithmetic", 0.242}
    , {"Matrix Multiplication", 0.19}
    , {"Matrix Transpose", 0.369}
    , {"Numerical Integration", 0.388}
    , {"Polynomial Expansion", 0.04}
    , {"Random Number Sort", 0.125}
    , {"Singular Value Decomposition", 0.2}
    , {"Solving a Linear System", 0.211}
   }
}
LaunchKernels[]
Benchmark[]
{"MachineName" -> "6-node homogeneous cluster", "System" -> "Windows-x86-64"
 , "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.1"
 , "Date" -> "May 1, 2022"
 , "BenchmarkResult" -> 7.601, "TotalTime" -> 32.781
}
$\endgroup$
2
$\begingroup$

2019 27" iMac, 8-core 3.6/5.0 GHz i9-9900K (Coffee Lake), 32 GB RAM, Radeon 580X (8 GB).

MacOS Monterey, v. 12.4

MMA 13.0.1.

Score: 4.602

Run on a fresh kernel.

{"MachineName" -> "imac", "System" -> "Mac OS X x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.0.1", 
 "Date" -> "June 10, 2022", "BenchmarkResult" -> 4.602, "TotalTime" -> 3.008, 
 "Results" -> {{"Data Fitting", 0.214}, {"Digits of Pi", 0.194}, 
   {"Discrete Fourier Transform", 0.218}, {"Eigenvalues of a Matrix", 0.233}, 
   {"Elementary Functions", 0.173}, {"Gamma Function", 0.252}, 
   {"Large Integer Multiplication", 0.251}, {"Matrix Arithmetic", 0.11}, 
   {"Matrix Multiplication", 0.102}, {"Matrix Transpose", 0.218}, 
   {"Numerical Integration", 0.33}, {"Polynomial Expansion", 0.049}, 
   {"Random Number Sort", 0.393}, {"Singular Value Decomposition", 0.138}, 
   {"Solving a Linear System", 0.133}}}
$\endgroup$
2
$\begingroup$

Dell Latitude 5411 15.5" Notebook - Full HD - 1920 x 1080 - Core i5 i5-10400H 10th Gen 2.6GHz Quad-core (4 Core) - 8GB RAM - 256GB SSD:

Processor QuadCore Intel(R) Core(TM) i5-10400H CPU @ 2.60GHz
Chipsets Intel Comet Point-H WM490, Intel Comet Lake-H
System Memory 7789 MB (DDR4 SDRAM)
Memory module Micron 8ATF1G64HZ-3G2J1 8 GB (1 rank, 16 banks) DDR4-3200 (1600 MHz)
Storage SSD Toshiba KIOXIA 256GB KXG60ZNV256G NVMe
OS Name Microsoft Windows 10 Pro x64
{"System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.0.1", "Date" -> "April 29, 2022", 
 "BenchmarkResult" -> 2.487, "TotalTime" -> 5.566, 
  "Results" -> {
   {"Data Fitting", 0.319}, 
   {"Digits of Pi", 0.271}, 
   {"Discrete Fourier Transform", 0.581},
   {"Eigenvalues of a Matrix", 0.308}, 
   {"Elementary Functions", 0.683}, 
   {"Gamma Function", 0.387},
   {"Large Integer Multiplication", 0.375}, 
   {"Matrix Arithmetic", 0.358}, 
   {"Matrix Multiplication", 0.308},
   {"Matrix Transpose", 0.703}, 
   {"Numerical Integration", 0.407}, 
   {"Polynomial Expansion", 0.049},
   {"Random Number Sort", 0.156}, 
   {"Singular Value Decomposition", 0.288}, 
   {"Solving a Linear System", 0.373}}}

{"System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.1.0", "Date" -> "July 3, 2022", 
 "BenchmarkResult" -> 2.463`, 
 "TotalTime" -> 5.619`, "Results" -> {
   {"Data Fitting", 0.347`},
   {"Digits of Pi", 0.276`},
   {"Discrete Fourier Transform", 0.583`},
   {"Eigenvalues of a Matrix", 0.331`},
   {"Elementary Functions", 0.633`},
   {"Gamma Function", 0.381`},
   {"Large Integer Multiplication", 0.375`},
   {"Matrix Arithmetic", 0.374`},
   {"Matrix Multiplication", 0.296`},
   {"Matrix Transpose", 0.687`},
   {"Numerical Integration", 0.468`},
   {"Polynomial Expansion", 0.053`},
   {"Random Number Sort", 0.162`},
   {"Singular Value Decomposition", 0.288`},
   {"Solving a Linear System", 0.365`}}}
$\endgroup$
2
$\begingroup$
  • CPU: i5-12500h
  • OS : Ubuntu 22.04
  • RAM : 16G
  • Score : 5.62
{"MachineName" -> "cvgmt", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.0.1", "Date" -> "May 15, 2022", 
 "BenchmarkResult" -> 5.62, "TotalTime" -> 2.463, 
 "Results" -> {{"Data Fitting", 0.153}, 
   {"Digits of Pi", 0.162}, {"Discrete Fourier Transform", 
    0.227}, {"Eigenvalues of a Matrix", 0.261}, 
   {"Elementary Functions", 0.12}, {"Gamma Function", 0.237}, 
   {"Large Integer Multiplication", 0.227}, 
   {"Matrix Arithmetic", 0.046}, {"Matrix Multiplication", 
    0.137}, {"Matrix Transpose", 0.173}, 
   {"Numerical Integration", 0.256}, {"Polynomial Expansion", 
    0.027}, {"Random Number Sort", 0.06}, 
   {"Singular Value Decomposition", 0.228}, 
   {"Solving a Linear System", 0.149}}}
LaunchKernels[]
{"MachineName" -> "12-node homogeneous cluster", 
 "System" -> "Linux-x86-64", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.0.1", "Date" -> "April 30, 2022", 
 "BenchmarkResult" -> 14.951, 
  "TotalTime" -> 33.33}
$\endgroup$
2
$\begingroup$

Running 13th Gen Intel on 24 Cores. "BenchmarkResult" -> 4.309

For some reason I am doing worse than :

  • Apple M1 Max (10Cores) "BenchmarkResult" -> 4.65
  • Linux 12th Gen Intel(R) Core(TM) i7-12700K (12 Cores) "BenchmarkResult" -> 6.08

Any thoughts/tips?


Full details:

CPU: Processor 13th Gen Intel (R) Core (TM) i9 - 13900 KF, 3000 Mhz, 24 Core (s), 32 Logical Processor (s)

OS : Windows 11

RAM : 64GB

1 + 1;
Needs["Benchmarking`"]
Benchmark[]
{"MachineName" -> "IntroductionToProbability", "System" ->
"Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark",  
"FullVersionNumber" -> "13.2.1", "Date" -> "March 8, 2023",
"BenchmarkResult" -> 4.309, "TotalTime" -> 3.212,   "Results" ->
{{"Data Fitting", 0.178}, {"Digits of Pi", 0.146}, {"Discrete Fourier
Transform", 0.209},     {"Eigenvalues of a Matrix", 0.391},
{"Elementary Functions", 0.139}, {"Gamma Function", 0.196},    
{"Large Integer Multiplication", 0.213}, {"Matrix Arithmetic", 0.507},
{"Matrix Multiplication", 0.076},     {"Matrix Transpose", 0.227},
{"Numerical Integration", 0.337}, {"Polynomial Expansion", 0.043},    
{"Random Number Sort", 0.08}, {"Singular Value Decomposition", 0.312},
{"Solving a Linear System", 0.158}}}
$\endgroup$
3
  • $\begingroup$ The running score of i7-12700K is the running score on Linux. $\endgroup$
    – cvgmt
    Mar 8, 2023 at 2:22
  • $\begingroup$ @cvgmt Thanks I will edit to clarify. Would you expect Linux to run fast than Windows? $\endgroup$ Mar 8, 2023 at 3:09
  • $\begingroup$ The score of Linux is the 1.4 times of Windows. $\endgroup$
    – cvgmt
    Mar 8, 2023 at 3:16
2
$\begingroup$

Steam deck running parabola linux :)

  • $Version 13.3.0 for Linux x86 (64-bit) (June 12, 2023)
  • AMD Custom APU 0405
  • 16GB RAM
  • Parabola GNU/Linux-libre
  • kernel: 5.15.88-gnu-1-lts

Score: 2.933

Fresh Quit[] kernel:

{"MachineName" -> "monad", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.0", 
 "Date" -> "July 27, 2023", "BenchmarkResult" -> 2.933, "TotalTime" -> 4.72, 
 "Results" -> {{"Data Fitting", 0.279}, {"Digits of Pi", 0.244}, 
   {"Discrete Fourier Transform", 0.373}, {"Eigenvalues of a Matrix", 0.36}, 
   {"Elementary Functions", 0.382}, {"Gamma Function", 0.304}, 
   {"Large Integer Multiplication", 0.312}, {"Matrix Arithmetic", 0.137}, 
   {"Matrix Multiplication", 0.319}, {"Matrix Transpose", 0.441}, 
   {"Numerical Integration", 0.545}, {"Polynomial Expansion", 0.089}, 
   {"Random Number Sort", 0.158}, {"Singular Value Decomposition", 0.353}, 
   {"Solving a Linear System", 0.424}}}

After LaunchKernels[]:

{"MachineName" -> "4-node homogeneous cluster", "System" -> "Linux-x86-64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.0", 
 "Date" -> "July 27, 2023", "BenchmarkResult" -> 4.578, "TotalTime" -> 36.287}
$\endgroup$
2
$\begingroup$

My apologies in advance for the plethora of data.

System:

  • Hardware: Self-built, Intel i7-12700K or i7-14700K (both at stock speed), 64G DDR4 memory @3600, NVME disks
  • OS: Windows 11 Pro, 22H2
  • OS: Ubuntu Linux 22.04.3, kernel 6.5, for both native and VM (8 CPU’s and 12G specified for VM)
  • VM manager: VMWare Workstation 17.5
  • Mathematica 13.3.1

I had several objectives in mind here:

  • Compare performance on several hardware platforms
  • Compare performance on Windows and Linux
  • Look at performance in a virtualized environment

To do this, I ran the following Mathematica (MMA) benchmarks:

  • On Windows and Linux – same machine, directly on the hardware (native)
  • On a Linux VM, with both Windows and Linux host systems
  • With MMA minimized, to see how performance is affected when moved to the background, particularly in an environment with CPU p and e cores.
  • All of the above, with CPU swapped from 12700K to 14700K on the same machine

The benchmark is an MMA cell consisting of the following (consistent with the original recommendation):

1 + 1;
Needs["Benchmarking`"]
Pause[5]
Benchmark[]
Quit[]

A Quit was issued before executing the cell the first time. Why the “pause”? I found that, when running this as a cell (program) without a pause, the results would be lower and very inconsistent. Pausing effectively seemed to provide the same delay one would get entering manually each time, and resulted in very consistent results. I am guessing that something in the “Needs” does not complete immediately, although I would wait for a Mathematica internals person to comment on that. BTW, I would also assume that the same delay would be required when running benchmarks externally as a script.

The results are below. For each configuration I ran the benchmark multiple times. The results below are the best for each configuration, although the results were almost always within 3-5% of each other. (An exception was minimized native Windows, which varied more.)

So here they are, in bar chart and table form.

enter image description here

enter image description here

enter image description here

enter image description here

A few conclusions from these runs (on this machine):

  • MMA much faster on Linux
  • When MMA moved to the background on Windows, even slower
  • When MMA moved to the background on Linux, as fast or faster (interesting)
  • Performance in a VM was basically as good as native, with ample resources

I hope this has been of interest. Attached below, for backup, are the actual benchmark results.

12700K Native Windows 4.752

{"MachineName" -> "windows-4", "System" -> "Microsoft Windows (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1",
 "Date" -> "January 16, 2024", "BenchmarkResult" -> 4.752,
 "TotalTime" -> 2.913, "Results" -> {{"Data Fitting", 0.202},
   {"Digits of Pi", 0.157}, {"Discrete Fourier Transform", 0.307},
   {"Eigenvalues of a Matrix", 0.236}, {"Elementary Functions",
    0.286}, {"Gamma Function", 0.213},
   {"Large Integer Multiplication", 0.228},
   {"Matrix Arithmetic", 0.126}, {"Matrix Multiplication", 0.093},
   {"Matrix Transpose", 0.29}, {"Numerical Integration", 0.294},
   {"Polynomial Expansion", 0.036}, {"Random Number Sort", 0.089},
   {"Singular Value Decomposition", 0.21},
   {"Solving a Linear System", 0.146}}} 

12700K Native Linux 6.617

{"MachineName" -> "ubuntu-41", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 6.617, "TotalTime" -> 2.092,
 "Results" -> {{"Data Fitting", 0.128},
   {"Digits of Pi", 0.146}, {"Discrete Fourier Transform",
    0.231}, {"Eigenvalues of a Matrix", 0.177},
   {"Elementary Functions", 0.127}, {"Gamma Function", 0.204},
   {"Large Integer Multiplication", 0.204},
   {"Matrix Arithmetic", 0.032}, {"Matrix Multiplication",
    0.104}, {"Matrix Transpose", 0.173},
   {"Numerical Integration", 0.232}, {"Polynomial Expansion",
    0.022}, {"Random Number Sort", 0.048},
   {"Singular Value Decomposition", 0.159},
   {"Solving a Linear System", 0.105}}}


 
12700K Linux VM under Windows 6.585

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 6.585, "TotalTime" -> 2.102,
 "Results" -> {{"Data Fitting", 0.128},
   {"Digits of Pi", 0.165}, {"Discrete Fourier Transform",
    0.245}, {"Eigenvalues of a Matrix", 0.146},
   {"Elementary Functions", 0.122}, {"Gamma Function", 0.223},
   {"Large Integer Multiplication", 0.21},
   {"Matrix Arithmetic", 0.06}, {"Matrix Multiplication",
    0.072}, {"Matrix Transpose", 0.16},
   {"Numerical Integration", 0.228}, {"Polynomial Expansion",
    0.06}, {"Random Number Sort", 0.062},
   {"Singular Value Decomposition", 0.109},
   {"Solving a Linear System", 0.112}}}

12700K Linux VM under Linux 6.825

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 6.825, "TotalTime" -> 2.028,
 "Results" -> {{"Data Fitting", 0.115},
   {"Digits of Pi", 0.157}, {"Discrete Fourier Transform",
    0.241}, {"Eigenvalues of a Matrix", 0.136},
   {"Elementary Functions", 0.138}, {"Gamma Function", 0.216},
   {"Large Integer Multiplication", 0.2},
   {"Matrix Arithmetic", 0.035}, {"Matrix Multiplication",
    0.082}, {"Matrix Transpose", 0.162},
   {"Numerical Integration", 0.226}, {"Polynomial Expansion",
    0.059}, {"Random Number Sort", 0.057},
   {"Singular Value Decomposition", 0.106},
   {"Solving a Linear System", 0.098}}}

 
14700K Native Windows 5.908

{"MachineName" -> "windows-4", "System" -> "Microsoft Windows (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1", 
 "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 5.908, 
 "TotalTime" -> 2.343, "Results" -> {{"Data Fitting", 0.164}, 
   {"Digits of Pi", 0.141}, {"Discrete Fourier Transform", 0.212}, 
   {"Eigenvalues of a Matrix", 0.199}, {"Elementary Functions", 
    0.19}, {"Gamma Function", 0.194}, 
   {"Large Integer Multiplication", 0.201}, 
   {"Matrix Arithmetic", 0.101}, {"Matrix Multiplication", 0.078}, 
   {"Matrix Transpose", 0.201}, {"Numerical Integration", 0.25}, 
   {"Polynomial Expansion", 0.021}, {"Random Number Sort", 0.075}, 
   {"Singular Value Decomposition", 0.184}, 
   {"Solving a Linear System", 0.132}}}


14700K Native Linux 7.951
{"MachineName" -> "ubuntu-41", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 7.951, "TotalTime" -> 1.741, 
 "Results" -> {{"Data Fitting", 0.103}, 
   {"Digits of Pi", 0.132}, {"Discrete Fourier Transform", 
    0.221}, {"Eigenvalues of a Matrix", 0.151}, 
   {"Elementary Functions", 0.077}, {"Gamma Function", 0.184}, 
   {"Large Integer Multiplication", 0.179}, 
   {"Matrix Arithmetic", 0.021}, {"Matrix Multiplication", 
    0.067}, {"Matrix Transpose", 0.126}, 
   {"Numerical Integration", 0.192}, {"Polynomial Expansion", 
    0.019}, {"Random Number Sort", 0.027}, 
   {"Singular Value Decomposition", 0.139}, 
   {"Solving a Linear System", 0.103}}}


 
14700K Linux VM under Windows 7.91

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 7.91, "TotalTime" -> 1.75, 
 "Results" -> {{"Data Fitting", 0.114}, 
   {"Digits of Pi", 0.135}, {"Discrete Fourier Transform", 
    0.211}, {"Eigenvalues of a Matrix", 0.12}, 
   {"Elementary Functions", 0.089}, {"Gamma Function", 0.189}, 
   {"Large Integer Multiplication", 0.181}, 
   {"Matrix Arithmetic", 0.033}, {"Matrix Multiplication", 
    0.075}, {"Matrix Transpose", 0.134}, 
   {"Numerical Integration", 0.193}, {"Polynomial Expansion", 
    0.048}, {"Random Number Sort", 0.048}, 
   {"Singular Value Decomposition", 0.088}, 
   {"Solving a Linear System", 0.092}}}

14700K Linux VM under Linux 7.928

{{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 7.928, "TotalTime" -> 1.746, 
 "Results" -> {{"Data Fitting", 0.112}, 
   {"Digits of Pi", 0.133}, {"Discrete Fourier Transform", 
    0.221}, {"Eigenvalues of a Matrix", 0.14}, 
   {"Elementary Functions", 0.084}, {"Gamma Function", 0.191}, 
   {"Large Integer Multiplication", 0.179}, 
   {"Matrix Arithmetic", 0.035}, {"Matrix Multiplication", 
    0.068}, {"Matrix Transpose", 0.13}, 
   {"Numerical Integration", 0.184}, {"Polynomial Expansion", 
    0.046}, {"Random Number Sort", 0.049}, 
   {"Singular Value Decomposition", 0.084}, 
   {"Solving a Linear System", 0.09}}}
 


12700K Native Windows, MMA minimized 4.149

{"MachineName" -> "windows-4", "System" -> "Microsoft Windows (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1",
 "Date" -> "January 16, 2024", "BenchmarkResult" -> 4.149,
 "TotalTime" -> 3.336, "Results" -> {{"Data Fitting", 0.203},
   {"Digits of Pi", 0.164}, {"Discrete Fourier Transform", 0.269},
   {"Eigenvalues of a Matrix", 0.237}, {"Elementary Functions",
    0.247}, {"Gamma Function", 0.409},
   {"Large Integer Multiplication", 0.287},
   {"Matrix Arithmetic", 0.179}, {"Matrix Multiplication", 0.148},
   {"Matrix Transpose", 0.258}, {"Numerical Integration", 0.338},
   {"Polynomial Expansion", 0.033}, {"Random Number Sort", 0.098},
   {"Singular Value Decomposition", 0.264},
   {"Solving a Linear System", 0.202}}}


12700K Native Linux, MMA minimized 6.668

{"MachineName" -> "ubuntu-41", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 6.668, "TotalTime" -> 2.076,
 "Results" -> {{"Data Fitting", 0.127},
   {"Digits of Pi", 0.146}, {"Discrete Fourier Transform",
    0.232}, {"Eigenvalues of a Matrix", 0.181},
   {"Elementary Functions", 0.122}, {"Gamma Function", 0.204},
   {"Large Integer Multiplication", 0.198},
   {"Matrix Arithmetic", 0.031}, {"Matrix Multiplication",
    0.098}, {"Matrix Transpose", 0.17},
   {"Numerical Integration", 0.226}, {"Polynomial Expansion",
    0.022}, {"Random Number Sort", 0.048},
   {"Singular Value Decomposition", 0.161},
   {"Solving a Linear System", 0.11}}}

 
12700K Linux VM under Windows, MMA minimized 6.973

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 6.973, "TotalTime" -> 1.985,
 "Results" -> {{"Data Fitting", 0.137},
   {"Digits of Pi", 0.157}, {"Discrete Fourier Transform",
    0.244}, {"Eigenvalues of a Matrix", 0.138},
   {"Elementary Functions", 0.112}, {"Gamma Function", 0.22},
   {"Large Integer Multiplication", 0.202},
   {"Matrix Arithmetic", 0.051}, {"Matrix Multiplication",
    0.062}, {"Matrix Transpose", 0.158},
   {"Numerical Integration", 0.223}, {"Polynomial Expansion",
    0.043}, {"Random Number Sort", 0.051},
   {"Singular Value Decomposition", 0.093},
   {"Solving a Linear System", 0.094}}}

12700K Linux VM under Linux, MMA minimized 7.15

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)",
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" ->
  "13.3.1", "Date" -> "January 16, 2024",
 "BenchmarkResult" -> 7.15, "TotalTime" -> 1.936,
 "Results" -> {{"Data Fitting", 0.117},
   {"Digits of Pi", 0.155}, {"Discrete Fourier Transform",
    0.233}, {"Eigenvalues of a Matrix", 0.137},
   {"Elementary Functions", 0.118}, {"Gamma Function", 0.216},
   {"Large Integer Multiplication", 0.202},
   {"Matrix Arithmetic", 0.031}, {"Matrix Multiplication",
    0.062}, {"Matrix Transpose", 0.157},
   {"Numerical Integration", 0.216}, {"Polynomial Expansion",
    0.057}, {"Random Number Sort", 0.051},
   {"Singular Value Decomposition", 0.091},
   {"Solving a Linear System", 0.093}}}
 

14700K Native Windows, MMA minimized 5.237

{"MachineName" -> "windows-4", "System" -> "Microsoft Windows (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1", 
 "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 5.237, 
 "TotalTime" -> 2.643, "Results" -> {{"Data Fitting", 0.175}, 
   {"Digits of Pi", 0.138}, {"Discrete Fourier Transform", 0.207}, 
   {"Eigenvalues of a Matrix", 0.198}, {"Elementary Functions", 
    0.151}, {"Gamma Function", 0.193}, 
   {"Large Integer Multiplication", 0.195}, 
   {"Matrix Arithmetic", 0.097}, {"Matrix Multiplication", 0.077}, 
   {"Matrix Transpose", 0.251}, {"Numerical Integration", 0.36}, 
   {"Polynomial Expansion", 0.03}, {"Random Number Sort", 0.085}, 
   {"Singular Value Decomposition", 0.254}, 
   {"Solving a Linear System", 0.232}}}

14700K Native Linux, MMA minimized 7.978

{"MachineName" -> "ubuntu-41", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 7.978, "TotalTime" -> 1.735, 
 "Results" -> {{"Data Fitting", 0.102}, {"Digits of Pi", 0.13}, 
   {"Discrete Fourier Transform", 0.22}, 
   {"Eigenvalues of a Matrix", 0.153}, {"Elementary Functions", 
    0.076}, {"Gamma Function", 0.185}, 
   {"Large Integer Multiplication", 0.179}, 
   {"Matrix Arithmetic", 0.022}, {"Matrix Multiplication", 
    0.067}, {"Matrix Transpose", 0.13}, 
   {"Numerical Integration", 0.195}, {"Polynomial Expansion", 
    0.018}, {"Random Number Sort", 0.026}, 
   {"Singular Value Decomposition", 0.136}, 
   {"Solving a Linear System", 0.096}}}


 

14700K Linux VM under Windows, MMA minimized 8.171

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 8.171, "TotalTime" -> 1.694, 
 "Results" -> {{"Data Fitting", 0.103}, 
   {"Digits of Pi", 0.142}, {"Discrete Fourier Transform", 
    0.209}, {"Eigenvalues of a Matrix", 0.126}, 
   {"Elementary Functions", 0.081}, {"Gamma Function", 0.187}, 
   {"Large Integer Multiplication", 0.18}, 
   {"Matrix Arithmetic", 0.038}, {"Matrix Multiplication", 
    0.052}, {"Matrix Transpose", 0.134}, 
   {"Numerical Integration", 0.181}, {"Polynomial Expansion", 
    0.039}, {"Random Number Sort", 0.044}, 
   {"Singular Value Decomposition", 0.089}, 
   {"Solving a Linear System", 0.089}}}

14700K Linux VM under Linux, MMA minimized 8.191

{"MachineName" -> "vm-ubuntu-61", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> 
  "13.3.1", "Date" -> "January 25, 2024", 
 "BenchmarkResult" -> 8.191, "TotalTime" -> 1.69, 
 "Results" -> {{"Data Fitting", 0.098}, 
   {"Digits of Pi", 0.132}, {"Discrete Fourier Transform", 
    0.205}, {"Eigenvalues of a Matrix", 0.121}, 
   {"Elementary Functions", 0.083}, {"Gamma Function", 0.187}, 
   {"Large Integer Multiplication", 0.178}, 
   {"Matrix Arithmetic", 0.034}, {"Matrix Multiplication", 
    0.066}, {"Matrix Transpose", 0.125}, 
   {"Numerical Integration", 0.186}, {"Polynomial Expansion", 
    0.05}, {"Random Number Sort", 0.047}, 
   {"Singular Value Decomposition", 0.088}, 
   {"Solving a Linear System", 0.09}}}
$\endgroup$
1
$\begingroup$

Core i7-6700 @3.4GHz, Windows 10, 32GB, MMA 13.1 Score 1.767

{"MachineName" -> "desktop-23at6mr", "System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.1.0", "Date" -> "May 3, 2023", "BenchmarkResult" -> 1.767, "TotalTime" -> 7.834, "Results" -> {{"Data Fitting", 0.94}, {"Digits of Pi", 0.414}, {"Discrete Fourier Transform", 0.809}, {"Eigenvalues of a Matrix", 0.785}, {"Elementary Functions", 0.517}, {"Gamma Function", 0.394}, {"Large Integer Multiplication", 0.397}, {"Matrix Arithmetic", 0.395}, {"Matrix Multiplication", 0.317}, {"Matrix Transpose", 0.56}, {"Numerical Integration", 1.213}, {"Polynomial Expansion", 0.141}, {"Random Number Sort", 0.193}, {"Singular Value Decomposition", 0.372}, {"Solving a Linear System", 0.387}}}

$\endgroup$
1
$\begingroup$

window 10 pro, 128 GB RAM. Mathematica V 13.2.1

Final score is 4.857

enter image description here

Mathematica graphics

$\endgroup$
1
$\begingroup$

Galaxy Book Pro 360

  • $Version 13.3.0 for Linux x86 (64-bit) (June 12, 2023)
  • 11th Gen Intel(R) Core(TM) i7-1165G7 @ 2.80GHz
  • 16 GB RAM
  • Parabola GNU/Linux-libre
  • kernel: 6.4.0-gnu-1-vanilla

Score: 5.163

Fresh kernel:

$ wolframscript -c 'Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
{MachineName -> monad, System -> Linux x86 (64-bit), BenchmarkName -> WolframMark,
FullVersionNumber -> 13.3.0, Date -> July 29, 2023,
BenchmarkResult -> 5.163, TotalTime -> 2.681, 
Results -> {{Data Fitting, 0.152}, {Digits of Pi, 0.222}, {Discrete Fourier Transform, 0.161}, {Eigenvalues of a Matrix, 0.203}, {Elementary Functions, 0.111}, {Gamma Function, 0.324}, {Large Integer Multiplication, 0.309}, {Matrix Arithmetic, 0.061}, {Matrix Multiplication, 0.152}, {Matrix Transpose, 0.171}, {Numerical Integration, 0.308}, {Polynomial Expansion, 0.047}, {Random Number Sort, 0.116}, {Singular Value Decomposition, 0.176}, {Solving a Linear System, 0.168}}}

After LaunchKernels[] / LaunchKernels[8]:

$ wolframscript -c 'LaunchKernels[]; Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
{MachineName -> 4-node homogeneous cluster, System -> Linux-x86-64, BenchmarkName -> WolframMark, FullVersionNumber -> 13.3.0, Date -> July 29, 2023,
BenchmarkResult -> 9.395, TotalTime -> 17.68}
$ wolframscript -c 'LaunchKernels[8]; Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
{MachineName -> 8-node homogeneous cluster, System -> Linux-x86-64, BenchmarkName -> WolframMark, FullVersionNumber -> 13.3.0, Date -> July 29, 2023, 
BenchmarkResult -> 10.405, TotalTime -> 31.928}
$\endgroup$
1
$\begingroup$

Wolfram Cloud

  • $Version 13.3.0 for Linux x86 (64-bit) (June 3, 2023)
  • 2-core x86-64??
  • 32 GB RAM
  • Linux x86 (64-bit)??
  • kernel??
$ wolframscript -c 'Print[ToString /@ {$ProcessorType, $ProcessorCount, $MachineType, $OperatingSystem, $System}]' -o
{x86-64, 2, PC, Unix, Linux x86 (64-bit)}

Score: 1.432

Fresh kernel:

$ wolframscript -o -c 'Needs["Benchmarking`"]; Benchmarking`Benchmark[]'
{MachineName -> wolframcloud-prd-cmp-4j-16,
System -> Linux x86 (64-bit),
BenchmarkName -> WolframMark,
FullVersionNumber -> 13.3.0,
Date -> July 29, 2023, 
BenchmarkResult -> 1.432, 
TotalTime -> 9.663, Results -> {{Data Fitting, 0.437}, {Digits of Pi, 0.39}, {Discrete Fourier Transform, 0.9}, {Eigenvalues of a Matrix, 0.486}, {Elementary Functions, 0.87}, {Gamma Function, 0.842}, {Large Integer Multiplication, 0.61}, {Matrix Arithmetic, 0.458}, {Matrix Multiplication, 0.843}, {Matrix Transpose, 1.267}, {Numerical Integration, 1.}, {Polynomial Expansion, 0.242}, {Random Number Sort, 0.341}, {Singular Value Decomposition, 0.499}, {Solving a Linear System, 0.478}}}

LaunchKernels[] not supported.

$\endgroup$
0
1
$\begingroup$

Asus ROG Ally running Parabola linux

  • $Version 13.3.0 for Linux x86 (64-bit) (June 12, 2023)
  • AMD Ryzen Z1 Extreme
  • 12 GB RAM
  • Parabola GNU/Linux-libre
  • kernel: 5.15.88-gnu-1-lts

Score: 5.233

Fresh Quit[] kernel:

{"MachineName" -> "monad", "System" -> "Linux x86 (64-bit)", "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.0", "Date" -> "July 28, 2023", "BenchmarkResult" -> 5.233, 
 "TotalTime" -> 2.645, "Results" -> {{"Data Fitting", 0.192}, {"Digits of Pi", 0.178}, {"Discrete Fourier Transform", 0.259}, {"Eigenvalues of a Matrix", 0.207}, 
   {"Elementary Functions", 0.194}, {"Gamma Function", 0.231}, {"Large Integer Multiplication", 0.21}, {"Matrix Arithmetic", 0.042}, {"Matrix Multiplication", 0.131}, 
   {"Matrix Transpose", 0.236}, {"Numerical Integration", 0.315}, {"Polynomial Expansion", 0.05}, {"Random Number Sort", 0.066}, {"Singular Value Decomposition", 0.158}, 
   {"Solving a Linear System", 0.176}}}

After LaunchKernels[]:

{"MachineName" -> "8-node homogeneous cluster", "System" -> "Linux-x86-64", "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.0", "Date" -> "July 28, 2023", 
 "BenchmarkResult" -> 10.783, "TotalTime" -> 30.809}
$\endgroup$
1
$\begingroup$

On Apple M2 - 2023, 8GB RAM. Performs way better than I expected!

MachineName: amairahs-macbook-air
System: Mac OS X ARM (64-bit)
BenchmarkName: WolframMark
FullVersionNumber: 13.3.0
Date: July 31, 2023
BenchmarkResult: 4.197
TotalTime: 3.298

Results:
  {"Data Fitting", 0.153}
  {"Digits of Pi", 0.147}
  {"Discrete Fourier Transform", 0.268}
  {"Eigenvalues of a Matrix", 0.214}
  {"Elementary Functions", 0.6}
  {"Gamma Function", 0.191}
  {"Large Integer Multiplication", 0.166}
  {"Matrix Arithmetic", 0.083}
  {"Matrix Multiplication", 0.189}
  {"Matrix Transpose", 0.136}
  {"Numerical Integration", 0.272}
  {"Polynomial Expansion", 0.035}
  {"Random Number Sort", 0.355}
  {"Singular Value Decomposition", 0.275}
  {"Solving a Linear System", 0.214}
$\endgroup$
1
$\begingroup$
Quit[]
Needs["Benchmarking`"]
Benchmark[]

 {"MachineName" -> "Mac Studio M1 Max 64GB RAM", 
  "System" -> "Mac OS X ARM (64-bit)", 
  "BenchmarkName" -> "WolframMark", 
  "FullVersionNumber" -> "13.3.0", 
  "Date" -> "July 31, 2023", 
  "BenchmarkResult" -> 4.583, "TotalTime" -> 3.02, 
  "Results" -> {{"Data Fitting", 0.183}, 
    {"Digits of Pi", 0.162}, 
    {"Discrete Fourier Transform", 0.226}, 
    {"Eigenvalues of a Matrix", 0.252}, 
    {"Elementary Functions", 0.298}, 
    {"Gamma Function", 0.209}, 
    {"Large Integer Multiplication", 0.181}, 
    {"Matrix Arithmetic", 0.055}, 
    {"Matrix Multiplication", 0.119}, 
    {"Matrix Transpose", 0.096}, 
    {"Numerical Integration", 0.359}, 
    {"Polynomial Expansion", 0.05}, 
    {"Random Number Sort", 0.378}, 
    {"Singular Value Decomposition", 0.284}, 
    {"Solving a Linear System", 0.168}}}

 Quit[]
 Needs["Benchmarking`"]
 LaunchKernels[]
 Benchmark[]

 {"MachineName" -> "8-node homogeneous cluster", 
  "System" -> "MacOSX-ARM64", "BenchmarkName" -> 
  "WolframMark", "FullVersionNumber" -> "13.3.0", 
  "Date" -> "July 31, 2023", 
  "BenchmarkResult" -> 14.612, "TotalTime" -> 22.736}
$\endgroup$
1
$\begingroup$

I'm running Mathematica 13.3.1 in my new laptop and the performance is not as good as expected. Anyone have some suggestions?

Asus Zenbook 14x

  • 13th Gen Intel(R) Core(TM) i7-13700H 2.40 GHz
  • 16 GB RAM (15.6 GB usable)
  • Windows 11 Home (64-bit)

In a fresh kernel:

Score 2.576

{"MachineName" -> "perlanegra", "System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.3.1", "Date" -> "September 22, 2023", "BenchmarkResult" -> 2.576, "TotalTime" -> 5.374, 
 "Results" -> {{"Data Fitting", 0.328}, {"Digits of Pi", 0.461}, {"Discrete Fourier Transform", 0.338}, 
   {"Eigenvalues of a Matrix", 0.545}, {"Elementary Functions", 0.288}, {"Gamma Function", 0.328}, 
   {"Large Integer Multiplication", 0.302}, {"Matrix Arithmetic", 0.172}, {"Matrix Multiplication", 0.153}, 
   {"Matrix Transpose", 0.347}, {"Numerical Integration", 0.56}, {"Polynomial Expansion", 0.114}, {"Random Number Sort", 0.222}, 
   {"Singular Value Decomposition", 0.409}, {"Solving a Linear System", 0.807}}}

Although, in the multicore running the things gets better.

Score 12.415

{"MachineName" -> "14-node homogeneous cluster", "System" -> "Windows-x86-64", "BenchmarkName" -> "WolframMark", 
 "FullVersionNumber" -> "13.3.1", "Date" -> "September 22, 2023", "BenchmarkResult" -> 12.415, "TotalTime" -> 46.827}
$\endgroup$
1
$\begingroup$

Desktop pc, Amd Ryzen 5900X, Windows 11, Wsl 2 Ubuntu

$ wolframscript

Wolfram Language 13.3.0 Engine for Linux x86 (64-bit) Copyright 1988-2023 Wolfram Research, Inc.

In[1]:= 1+1;
In[2]:= Needs["Benchmarking`"]
Out[3]//InputForm=
{"MachineName" -> "desktop-xxx", "System" -> "Linux x86 (64-bit)", "BenchmarkName" -> "WolframMark",
"FullVersionNumber" -> "13.3.0", "Date" -> "September 23, 2023", 
"BenchmarkResult" -> 5.59, "TotalTime" -> 2.476,
"Results" -> {{"Data Fitting", 0.178}, {"Digits of Pi", 0.161}, 
{"Discrete Fourier Transform", 0.206},
{"Eigenvalues of a Matrix", 0.196}, {"Elementary Functions", 0.17}, {"Gamma Function", 0.215},
{"Large Integer Multiplication", 0.214}, {"Matrix Arithmetic", 0.039}, {"Matrix Multiplication", 0.109},
{"Matrix Transpose", 0.284}, {"Numerical Integration", 0.299}, 
{"Polynomial Expansion", 0.072},
{"Random Number Sort", 0.065}, {"Singular Value Decomposition", 0.137}, {"Solving a Linear System", 0.131}}}
$\endgroup$
1
$\begingroup$

Apple Pro M1 Pro 32GB memory

{"MachineName" -> "macbook-pro-2", "System" -> "Mac OS X ARM (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.1.0", 
 "Date" -> "January 4, 2024", "BenchmarkResult" -> 3.981, "TotalTime" -> 3.477, 
 "Results" -> {{"Data Fitting", 0.191}, {"Digits of Pi", 0.168}, 
   {"Discrete Fourier Transform", 0.281}, {"Eigenvalues of a Matrix", 0.298}, 
   {"Elementary Functions", 0.481}, {"Gamma Function", 0.213}, 
   {"Large Integer Multiplication", 0.194}, {"Matrix Arithmetic", 0.087}, 
   {"Matrix Multiplication", 0.138}, {"Matrix Transpose", 0.12}, 
   {"Numerical Integration", 0.305}, {"Polynomial Expansion", 0.051}, 
   {"Random Number Sort", 0.384}, {"Singular Value Decomposition", 0.361}, 
   {"Solving a Linear System", 0.205}}}
$\endgroup$
1
  • $\begingroup$ With 13.3.1 same computer, same macOS, 4.28 - about 10% faster. Just upgraded it. $\endgroup$ Jan 7 at 18:26
0
$\begingroup$

CPU: AMD Ryzen 7700X (stock)

RAM: 32 GiB DDR5 @ 6000 MHz

Mathematica (Wolfram Engine): 13.3.0

RESULT: 6.9

Using Windows 11 with WSL2 (Ubuntu 5.15.133.1-microsoft-standard-WSL2)

Out[3]//InputForm=
{"MachineName" -> "7700x", "System" -> "Linux x86 (64-bit)", "BenchmarkName" -> "WolframMark",
 "FullVersionNumber" -> "13.3.0", "Date" -> "January 20, 2024", "BenchmarkResult" -> 6.9, "TotalTime" -> 2.006,
 "Results" -> {{"Data Fitting", 0.134}, {"Digits of Pi", 0.151}, {"Discrete Fourier Transform", 0.142},
   {"Eigenvalues of a Matrix", 0.165}, {"Elementary Functions", 0.148}, {"Gamma Function", 0.215},
   {"Large Integer Multiplication", 0.181}, {"Matrix Arithmetic", 0.032}, {"Matrix Multiplication", 0.1},
   {"Matrix Transpose", 0.163}, {"Numerical Integration", 0.247}, {"Polynomial Expansion", 0.042},
   {"Random Number Sort", 0.041}, {"Singular Value Decomposition", 0.134}, {"Solving a Linear System", 0.111}}}

Going direct from Windows 11 (command prompt) with Wolfram Engine

RESULT: 5.763

Out[3]//InputForm=
{"MachineName" -> "7700x", "System" -> "Microsoft Windows (64-bit)", "BenchmarkName" -> "WolframMark",
 "FullVersionNumber" -> "13.3.0", "Date" -> "January 20, 2024", "BenchmarkResult" -> 5.763, "TotalTime" -> 2.402,
   {"Eigenvalues of a Matrix", 0.174}, {"Elementary Functions", 0.206}, {"Gamma Function", 0.205},
   {"Large Integer Multiplication", 0.198}, {"Matrix Arithmetic", 0.08}, {"Matrix Multiplication", 0.111},
   {"Matrix Transpose", 0.225}, {"Numerical Integration", 0.3}, {"Polynomial Expansion", 0.025},
   {"Random Number Sort", 0.074}, {"Singular Value Decomposition", 0.139}, {"Solving a Linear System", 0.127}}}

Edit: Also tried running it through Jupyter Lab (running from the Ubuntu - WSL2 installation).

Result: 6.639

{"MachineName" -> "7700x", "System" -> "Linux x86 (64-bit)", 
>    "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.0", 
>    "Date" -> "January 20, 2024", "BenchmarkResult" -> 6.639, "TotalTime" -> 2.085, 
>    "Results" -> {{"Data Fitting", 0.133}, {"Digits of Pi", 0.151}, 
>      {"Discrete Fourier Transform", 0.151}, {"Eigenvalues of a Matrix", 0.182}, 
>      {"Elementary Functions", 0.155}, {"Gamma Function", 0.231}, 
>      {"Large Integer Multiplication", 0.181}, {"Matrix Arithmetic", 0.023}, 
>      {"Matrix Multiplication", 0.111}, {"Matrix Transpose", 0.163}, 
>      {"Numerical Integration", 0.253}, {"Polynomial Expansion", 0.041}, 
>      {"Random Number Sort", 0.048}, {"Singular Value Decomposition", 0.136}, 
>      {"Solving a Linear System", 0.126}}}
$\endgroup$
0
$\begingroup$

On Linux 6.6.13-x64v1-xanmod1

   1   | processor   : 0
   2   │ vendor_id   : AuthenticAMD
   3   │ cpu family  : 25
   4   │ model       : 97
   5   │ model name  : AMD Ryzen 9 7900X 12-Core Processor
   6   │ stepping    : 2
   7   │ microcode   : 0xa601203
   8   │ cpu MHz     : 400.000
   9   │ cache size  : 1024 KB
  10   │ physical id : 0
  11   │ siblings    : 24
  12   │ core id     : 0
  13   │ cpu cores   : 12
  14   │ apicid      : 0
  15   │ initial apicid  : 0
  16   │ fpu     : yes
  17   │ fpu_exception   : yes
  18   │ cpuid level : 16
  19   │ wp      : yes
  20   │ flags       : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht sy
       │ scall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good amd_lbr_v2 nopl nonstop_tsc cpuid extd_apicid aperfm
       │ perf rapl pni pclmulqdq monitor ssse3 fma cx16 sse4_1 sse4_2 x2apic movbe popcnt aes xsave avx f16c rdrand lahf_lm cm
       │ p_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt tce topoext perfctr_core perf
       │ ctr_nb bpext perfctr_llc mwaitx cpb cat_l3 cdp_l3 hw_pstate ssbd mba perfmon_v2 ibrs ibpb stibp ibrs_enhanced vmmcall
       │  fsgsbase bmi1 avx2 smep bmi2 erms invpcid cqm rdt_a avx512f avx512dq rdseed adx smap avx512ifma clflushopt clwb avx5
       │ 12cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 xsaves cqm_llc cqm_occup_llc cqm_mbm_total cqm_mbm_local user_s
       │ hstk avx512_bf16 clzero irperf xsaveerptr rdpru wbnoinvd cppc arat npt lbrv svm_lock nrip_save tsc_scale vmcb_clean f
       │ lushbyasid decodeassists pausefilter pfthreshold avic v_vmsave_vmload vgif x2avic v_spec_ctrl vnmi avx512vbmi umip pk
       │ u ospke avx512_vbmi2 gfni vaes vpclmulqdq avx512_vnni avx512_bitalg avx512_vpopcntdq rdpid overflow_recov succor smca
       │  fsrm flush_l1d
  21   │ bugs        : sysret_ss_attrs spectre_v1 spectre_v2 spec_store_bypass srso
  22   │ bogomips    : 9381.98
  23   │ TLB size    : 3584 4K pages
  24   │ clflush size    : 64
  25   │ cache_alignment : 64
  26   │ address sizes   : 48 bits physical, 48 bits virtual
  27   │ power management: ts ttp tm hwpstate cpb eff_freq_ro [13] [14]

I have

1 + 1
Needs["Benchmarking`"]
Benchmark[]

returning

{"MachineName" -> "tanelorn", "System" -> "Linux x86 (64-bit)", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1", 
 "Date" -> "January 21, 2024", "BenchmarkResult" -> 5.032, "TotalTime" -> 2.751, 
 "Results" -> {{"Data Fitting", 0.168}, {"Digits of Pi", 0.143}, 
   {"Discrete Fourier Transform", 0.375}, {"Eigenvalues of a Matrix", 0.184}, 
   {"Elementary Functions", 0.086}, {"Gamma Function", 0.187}, 
   {"Large Integer Multiplication", 0.501}, {"Matrix Arithmetic", 0.026}, 
   {"Matrix Multiplication", 0.079}, {"Matrix Transpose", 0.256}, 
   {"Numerical Integration", 0.33}, {"Polynomial Expansion", 0.062}, 
   {"Random Number Sort", 0.038}, {"Singular Value Decomposition", 0.151}, 
   {"Solving a Linear System", 0.165}}}

and

LaunchKernels[]
1 + 1
Needs["Benchmarking`"]
Benchmark[]

returning

{"MachineName" -> "8-node homogeneous cluster", "System" -> "Linux-x86-64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.3.1", 
 "Date" -> "January 21, 2024", "BenchmarkResult" -> 18.214, "TotalTime" -> 18.239}
$\endgroup$
0
$\begingroup$
Needs["Benchmarking`"]
Benchmark[]

{"MachineName" -> "4-node homogeneous cluster", "System" -> "MacOSX-ARM64", 
 "BenchmarkName" -> "WolframMark", "FullVersionNumber" -> "13.1.0", 
 "Date" -> "January 29, 2024", "BenchmarkResult" -> 7.749, "TotalTime" -> 21.436}
$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.