桌面平台CPU性能测试（单核）裸机程序：C++计算圆周率500位

星空天神

看前面有人用js和rust实现,试了试c++. 需要boost库和MPIR c++17

1. 
   
2. #include <boost/multiprecision/gmp.hpp>
   
3. #include <boost/math/special_functions/gamma.hpp>
   
4. #include <iostream>
   
5. #include <string>
   
6. #include <string_view>
   
7. #include <chrono>
   
8. using namespace boost::multiprecision;
   
9. using namespace std::chrono;
   
10. void pi500()
    
11. {
    
12.         const auto start = steady_clock::now();
    
13.         mpf_float::default_precision(1000);
    
14.         size_t bit = 500;
    
15.         mpf_float polygon{ 6 }, r{ 1 }, M{1};
    
16.         auto i = 0;
    
17.         while(true)
    
18.         {
    
19.                 mpf_float G = sqrt(pow(r, 2) - pow(M / 2, 2));
    
20.                 mpf_float j = r - G;
    
21.                 mpf_float m = sqrt(pow(M / 2, 2) + pow(j, 2));
    
22.                 polygon *= 2;
    
23.                 mpf_float perimeter = m * polygon;
    
24.                 mpf_float pi = perimeter / 2;
    
25.                 M = m;
    
26.                 i++;
    
27.                 auto piStr = pi.str();
    
28.                 std::string_view piStrV{ piStr.c_str(),std::min(bit + 2,piStr.size())};
    
29.                 constexpr const char* PI{ "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989" };
    
30.                 if (piStrV == std::string_view(PI, bit + 2))
    
31.                         break;
    
32.         }
    
33.         const auto end = steady_clock::now();
    
34.         duration<double, std::milli> diff = end - start;
    
35.         std::cout <<"step " << i << '\n';
    
36.         std::cout << "cost " << diff.count() <<"ms"<< '\n';
    
37. }
    
38. 
    
39. int main()
    
40. {
    
41.         pi500();
    
42.         std::string str;
    
43.         std::getline(std::cin, str);
    
44.         return 0;
    
45. }
    

复制代码

锐龙5900x
step 830
cost 26.8446ms

lshzh.hi

M3 max开O3优化是7.75 ms

论坛助手,iPhone

lshzh.hi

另外老哥你应该循环个三五百次取平均，不然只跑一次十几二十毫秒调度器都反应不过来测不准的

c++: 什么叫真正的高性能语言啊(战术后仰

论坛助手,iPhone

zmw_831110

9800X3D PBO+200 金核银核-15,其余-25
step 830
cost 19.9704ms

Xerxes_2

目前大数字运算最快的还是 MPFR 吧，用 Rust 调 MPFR 再优化算法的话可以做到几十 us

一样的暴力算法

1. use rug::{
   
2.     Float, Integer,
   
3.     float::Round,
   
4.     ops::{AddAssignRound, DivAssignRound},
   
5. };
   
6. fn main() {
   
7.     println!("开始计算, 100次……");
   
8.     let mut res = Vec::with_capacity(100);
   
9.     const BIT: usize = 500;
   
10.     for _ in 0..100 {
    
11.         let start = std::time::Instant::now();
    
12.         let mut polygon = Integer::from(6);
    
13.         const R: &Integer = Integer::ONE;
    
14.         let mut big_m = Float::with_val(1669, 1);
    
15. 
    
16.         loop {
    
17.             big_m.square_mut();
    
18.             big_m.div_assign_round(4, Round::Nearest);
    
19.             let big_g = (R - big_m.to_owned()).sqrt();
    
20.             let j = R - big_g;
    
21.             big_m.add_assign_round(j.square(), Round::Nearest);
    
22.             big_m.sqrt_mut();
    
23.             polygon *= 2;
    
24.             let perimeter = big_m.to_owned() * &polygon;
    
25.             let mut pi = perimeter;
    
26.             pi.div_assign_round(2, Round::Nearest);
    
27.             let pi_string = pi.to_string();
    
28.             const PI: &str = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989";
    
29.             if let Some(slice) = pi_string.get(0..BIT + 2) {
    
30.                 if slice == &PI[0..BIT + 2] {
    
31.                     res.push(start.elapsed());
    
32.                     break;
    
33.                 }
    
34.             }
    
35.         }
    
36.     }
    
37.     let sum = res.iter().sum::<std::time::Duration>();
    
38.     let min = res.iter().min().unwrap();
    
39.     let max = res.iter().max().unwrap();
    
40.     let avg = sum / res.len() as u32;
    
41.     println!("平均耗时: {:?}", avg);
    
42.     println!("最短耗时: {:?}", min);
    
43.     println!("最长耗时: {:?}", max);
    
44.     let variance = res
    
45.         .iter()
    
46.         .map(|x| {
    
47.             let x = x.as_secs_f64() * 1_000.0;
    
48.             (x - avg.as_secs_f64() * 1_000.0).powi(2)
    
49.         })
    
50.         .sum::<f64>()
    
51.         / res.len() as f64;
    
52.     println!("标准差: {}ms", variance.sqrt());
    
53.     println!("按Enter退出……");
    
54.     let _ = std::io::stdin().read_line(&mut String::new());
    
55. }
    

复制代码

开始计算, 100次……
平均耗时: 3.645485ms
最短耗时: 3.428667ms
最长耗时: 5.163209ms
标准差: 0.30984631479181735ms
按Enter退出……

—— 来自 Google Pixel 9 Pro, Android 15, 鹅球 v3.3.95-debug

Jet.Black

最近都把泥潭当成leetcode了？怎么全在算圆周率

星空天神

lshzh.hi 发表于 2024-12-15 06:17
另外老哥你应该循环个三五百次取平均，不然只跑一次十几二十毫秒调度器都反应不过来测不准的

c++: 什么叫 ...

改了改,跑100次. 加了使用mpfr的优化逻辑.不过win上mpfr只有个很老的13年前的库,跑下来平均7.7ms懒得去编译最新版了.

1. #include <boost/multiprecision/gmp.hpp>
   
2. #include <boost/multiprecision/mpfr.hpp>
   
3. #include <boost/math/special_functions/gamma.hpp>
   
4. #include <iostream>
   
5. #include <string>
   
6. #include <string_view>
   
7. #include <chrono>
   
8. using namespace boost::multiprecision;
   
9. using namespace std::chrono;
   
10. double pi500_v1()
    
11. {
    
12.         const auto start = steady_clock::now();
    
13.         mpfr_float::default_precision(1000);
    
14.         size_t bit = 500;
    
15.         mpfr_float  polygon{ 6 }, r{ 1 }, M{ 1 };
    
16.         auto i = 0;
    
17.         while(true)
    
18.         {               
    
19.                 mpfr_float  G = sqrt(pow(r, 2) - pow(M / 2, 2));
    
20.                 mpfr_float  j = r - G;
    
21.                 mpfr_float  m = sqrt(pow(M / 2, 2) + pow(j, 2));
    
22.                 polygon *= 2;
    
23.                 mpfr_float  perimeter = m * polygon;
    
24.                 mpfr_float  pi = perimeter / 2;
    
25.                 M = m;
    
26.                 i++;
    
27.                 auto piStr = pi.str();
    
28.                 std::string_view piStrV{ piStr.c_str(),std::min(bit + 2,piStr.size())};
    
29.                 constexpr const char* PI{ "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989" };
    
30.                 if (piStrV == std::string_view(PI, bit + 2))
    
31.                         break;
    
32.         }
    
33.         const auto end = steady_clock::now();
    
34.         duration<double, std::milli> diff = end - start;
    
35.         return diff.count();
    
36. }
    
37. double pi500_v2()
    
38. {
    
39.         const auto start = steady_clock::now();
    
40.         mpfr_float::default_precision(1000);
    
41.         size_t bit = 500;
    
42.         size_t i{ 0 };
    
43.         mpfr_float len{ 1 };
    
44.         mpfr_float a{ 1 };
    
45.         while (true)
    
46.         {
    
47.                 len = 2 - sqrt(4 - len);
    
48.                 a *= 2;
    
49.                 mpfr_float pi = sqrt(len) * a * 3;
    
50.                 i++;
    
51.                 auto piStr = pi.str(bit + 2);
    
52.                 std::string_view piStrV{ piStr.c_str(),std::min(bit + 2,piStr.size()) };
    
53.                 constexpr const char* PI{ "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989" };
    
54.                 if (piStrV == std::string_view(PI, bit + 2))
    
55.                         break;
    
56.         }
    
57.         const auto end = steady_clock::now();
    
58.         duration<double, std::milli> diff = end - start;
    
59.         return diff.count();
    
60. }
    
61. #include <vector>
    
62. #include <numeric>
    
63. #include <algorithm>
    
64. constexpr uint32_t loop{ 100 };
    
65. int main()
    
66. {
    
67.         std::vector<double> results;
    
68.         results.resize(loop);
    
69.         for(uint32_t i{0};i < loop;i++)
    
70.                 results[i] = pi500_v2();
    
71.         std::cout << "max cost " << *std::max_element(results.begin(), results.end()) << "ms" << '\n';
    
72.         std::cout << "min cost " << *std::min_element(results.begin(), results.end()) << "ms" << '\n';
    
73.         std::cout << "avg cost " << std::reduce(results.begin(), results.end()) / loop << "ms" << '\n';
    
74.         std::string str;
    
75.         std::getline(std::cin, str);
    
76.         return 0;
    
77. }

复制代码

lixianfyss

Jet.Black 发表于 2024-12-15 11:47
最近都把泥潭当成leetcode了？怎么全在算圆周率

讲道理，这种帖子在你谭还算高质量有信息量的帖子。

phorcys02

第一版
step 830
cost 19.6639ms  //-Ofast
cost 19.8149ms  //-O2
cost 20.0936ms  //-O3
cost 24.1712ms  // 无优化

第二版
//无优化
max cost 19.009ms
min cost 18.2873ms
avg cost 18.3688ms
//-O2
max cost 16.579ms
min cost 15.5659ms
avg cost 15.7237ms

//-O3
max cost 15.6974ms
min cost 15.5868ms
avg cost 15.6042ms
//-Ofast
max cost 15.6873ms
min cost 15.569ms
avg cost 15.5864ms


龙芯3C6000

c/c++ 运行太快，误差其实有点大，大头可能在其他地方咯...

星空天神

phorcys02 发表于 2024-12-15 15:46
第一版
step 830
cost 19.6639ms  //-Ofast

大头其实是在字符串生成和比较上

Xerxes_2

星空天神 发表于 2024-12-15 15:55
大头其实是在字符串生成和比较上

msys2上的 libgmp 应该都带了吧
https://packages.msys2.org/packages/mingw-w64-x86_64-gmp

星空天神

Xerxes_2 发表于 2024-12-15 15:58
msys2上的 libgmp 应该都带了吧
https://packages.msys2.org/packages/mingw-w64-x86_64-gmp

不想整了,那位用m3 max的老哥试试吧,估计他能压到3ms以内

Xerxes_2

星空天神 发表于 2024-12-15 16:03
不想整了,那位用m3 max的老哥试试吧,估计他能压到3ms以内

我不知道他怎么编译的反正我这里编不起来，C++的编译报错也根本看不懂

chachi

m4 max
无优化
max cost 5.14612ms
min cost 3.59454ms
avg cost 3.93417ms

0WHan0

phorcys02 发表于 2024-12-15 15:46
第一版
step 830
cost 19.6639ms  //-Ofast

龙芯3A4000

无优化
max cost 25.6228ms
min cost 25.2168ms
avg cost 25.3106ms

-O2
max cost 20.1907ms
min cost 19.8703ms
avg cost 19.9706ms

-O3
max cost 20.2468ms
min cost 19.8624ms
avg cost 19.962ms

-Ofast
max cost 20.226ms
min cost 19.904ms
avg cost 19.9884ms

星空天神

又找了找圆周率算法发现了很多专业选手
专业选手1 梅钦公式

1. #include <iostream>
   
2. #include <string>
   
3. #include <chrono>
   
4. using namespace std::chrono;
   
5. 
   
6. constexpr const int32_t bit{500};
   
7. 
   
8. double pi500_pro_v1()
   
9. {
   
10.         const auto start = steady_clock::now();
    
11.         int32_t a[2] = {956, 80}, b[2] = {57121, 25}, i = 0, j, k, p, q, r, s = 2, t, u, v, N{bit}, M = 10000;
    
12.         N = N / 4 + 3;
    
13.         int32_t *pi = new int32_t[N], *e = new int32_t[N];
    
14.         while (i < N)
    
15.                 pi[i++] = 0;
    
16.         while (--s + 1)
    
17.         {
    
18.                 for (*e = a[k = s], i = N; --i;)
    
19.                         e[i] = 0;
    
20.                 for (q = 1; j = i - 1, i < N; e[i] ? 0 : ++i, q += 2, k = !k)
    
21.                         for (r = v = 0; ++j < N; pi[j] += k ? u : -u)
    
22.                                 u = (t = v * M + (e[j] = (p = r * M + e[j]) / b[s])) / q, r = p % b[s], v = t % q;
    
23.         }
    
24.         while (--i)
    
25.                 (pi[i] = (t = pi[i] + s) % M) < 0 ? pi[i] += M, s = t / M - 1 : s = t / M;
    
26.         // for (std::cout << "3."; ++i < N - 2;)
    
27.         //         printf("%04id", pi[i]);
    
28.         delete[] pi, delete[] e;
    
29.         const auto end = steady_clock::now();
    
30.         duration<double, std::milli> diff = end - start;
    
31.         return diff.count();
    
32. }
    
33. #include <vector>
    
34. #include <numeric>
    
35. #include <algorithm>
    
36. constexpr uint32_t loop{100};
    
37. int main()
    
38. {
    
39.         std::vector<double> results;
    
40.         results.resize(loop);
    
41.         for (uint32_t i{0}; i < loop; i++)
    
42.                 results[i] = pi500_pro_v1();
    
43.         std::cout << "max cost " << *std::max_element(results.begin(), results.end()) << "ms" << '\n';
    
44.         std::cout << "min cost " << *std::min_element(results.begin(), results.end()) << "ms" << '\n';
    
45.         std::cout << "avg cost " << std::reduce(results.begin(), results.end()) / loop << "ms" << '\n';
    
46.         std::string str;
    
47.         std::getline(std::cin, str);
    
48.         return 0;
    
49. }

复制代码

6800u


max cost 0.2177ms
min cost 0.1604ms
avg cost 0.169834ms

0WHan0

星空天神 发表于 2024-12-16 15:32
又找了找圆周率算法发现了很多专业选手
专业选手1 梅钦公式

3A4000


g++ 14.2.0 -Ofast
max cost 0.756162ms
min cost 0.702652ms
avg cost 0.704955ms


clang++ 18.1.8 -Ofast
max cost 0.399699ms
min cost 0.388413ms
avg cost 0.389215ms

ayanamilin

Intel(R) Xeon(R) Gold 6152 CPU @ 2.10GHz
第二版：
max cost 13.3654ms
min cost 6.5841ms
avg cost 6.73705ms

小野賢章

编译参数：c++ -O3 -I`brew --prefix boost`/include `pkg-config --cflags --libs mpfr gmp` foo.cpp

1. clang++ 19.1.5
   
2. ===
   
3. step 830
   
4. cost 16.5006ms #M4 Pro
   
5. cost 23.7123ms #M2 Max
   
6. ===
   
7. max cost 8.85958ms #M4 Pro
   
8. min cost 3.04883ms
   
9. avg cost 3.48595ms
   
10. max cost 10.331ms #M2 Max
    
11. min cost 4.22104ms
    
12. avg cost 4.62733ms
    
13. ===
    
14. 
    
15. g++ 14.2.0
    
16. ===
    
17. step 830
    
18. cost 12.122ms #M4 Pro
    
19. cost 12.699ms #M2 Max
    
20. ===
    
21. max cost 6.224ms #M4 Pro
    
22. min cost 3.139ms
    
23. avg cost 3.41423ms
    
24. max cost 8.466ms #M2 Max
    
25. min cost 4.335ms
    
26. avg cost 4.62142ms
    
27. ===

复制代码

Xerxes_2

星空天神 发表于 2024-12-16 15:32
又找了找圆周率算法发现了很多专业选手
专业选手1 梅钦公式

为啥比 Rust 慢这么多写傻了
M2 Pro 跑了下已经微秒级了

开始计算, 100次……
平均耗时: 159.107µs
最短耗时: 118.125µs
最长耗时: 241.458µs
标准差: 0.03174605343078096ms
按Enter退出……

1. use std::time::Duration;
   
2. 
   
3. const BIT: usize = 500;
   
4. const ITER: usize = 10000;
   
5. 
   
6. fn pi500_pro_v1() -> Duration {
   
7.     let start = std::time::Instant::now();
   
8.     const A: [i32; 2] = [956, 80];
   
9.     const B: [i32; 2] = [57121, 25];
   
10.     const N: usize = BIT / 4 + 3;
    
11.     const M: i32 = 10000;
    
12.     let mut pi = vec![0; N];
    
13.     let mut e = vec![0; N];
    
14.     for s in [true, false] {
    
15.         let mut k = s;
    
16.         e.fill(0);
    
17.         e[0] = A[s as usize];
    
18.         let mut q = 1;
    
19.         let mut i = 0;
    
20.         while i < N as i32 {
    
21.             let mut r = 0;
    
22.             let mut v = 0;
    
23.             for (e, pi) in e.iter_mut().zip(pi.iter_mut()).skip(i as usize) {
    
24.                 let p = r * M + *e;
    
25.                 *e = p / B[s as usize];
    
26.                 let t = v * M + *e;
    
27.                 let u = t / q;
    
28.                 r = p % B[s as usize];
    
29.                 v = t % q;
    
30.                 *pi += if k { u } else { -u };
    
31.             }
    
32. 
    
33.             if e[i as usize] == 0 {
    
34.                 i += 1;
    
35.             }
    
36.             q += 2;
    
37.             k = !k;
    
38.         }
    
39.     }
    
40.     let mut s = -1;
    
41.     for i in pi.iter_mut().skip(1).rev() {
    
42.         let t = *i + s;
    
43.         *i = t % M;
    
44.         if *i < 0 {
    
45.             *i += M;
    
46.             s = t / M - 1
    
47.         } else {
    
48.             s = t / M
    
49.         }
    
50.     }
    
51.     let elapsed = start.elapsed();
    
52.     // print!("3.");
    
53.     // for i in pi.iter().skip(1).take(N - 3) {
    
54.     //     print!("{:04}", i);
    
55.     // }
    
56.     elapsed
    
57. }
    
58. 
    
59. fn main() {
    
60.     println!("开始计算, {ITER}次……");
    
61.     let mut res = Vec::with_capacity(ITER);
    
62.     for _ in 0..ITER {
    
63.         res.push(pi500_pro_v1());
    
64.     }
    
65.     let sum = res.iter().sum::<Duration>();
    
66.     let min = res.iter().min().unwrap();
    
67.     let max = res.iter().max().unwrap();
    
68.     let avg = sum / res.len() as u32;
    
69.     println!("平均耗时: {:?}", avg);
    
70.     println!("最短耗时: {:?}", min);
    
71.     println!("最长耗时: {:?}", max);
    
72.     let variance = res
    
73.         .iter()
    
74.         .map(|x| {
    
75.             let x = x.as_secs_f64() * 1_000_000.0;
    
76.             (x - avg.as_secs_f64() * 1_000_000.0).powi(2)
    
77.         })
    
78.         .sum::<f64>()
    
79.         / res.len() as f64;
    
80.     println!("标准差: {}µs", variance.sqrt());
    
81.     println!("按Enter退出……");
    
82.     let _ = std::io::stdin().read_line(&mut String::new());
    
83. }

复制代码

星空天神

Xerxes_2 发表于 2024-12-16 19:46
为啥比 Rust 慢这么多
M2 Pro 跑了下已经微秒级了

你自己再想想160微秒等于多少毫秒？

5900x

max cost 138.6us
min cost 102.2us
avg cost 107.606us

—— 来自 OnePlus LE2120, Android 14上的 S1Next-鹅版 v2.5.4

Xerxes_2

星空天神 发表于 2024-12-16 19:51
你自己再想想160微秒等于多少毫秒？

—— 来自 OnePlus LE2120, Android 14上的 S1Next-鹅版 v2.5.4 ...

草，脑子写傻了，确实差不多

时间太短了得改到 10000 次了

m2 pro

开始计算, 10000次……
平均耗时: 124.634µs
最短耗时: 117.833µs
最长耗时: 328.917µs
标准差: 13.893461866467945µs
按Enter退出……


5900x

开始计算, 10000次……
平均耗时: 98.975µs
最短耗时: 98.2µs
最长耗时: 220µs
标准差: 5.06429921114463µs
按Enter退出……

hgfdsa

几十年前superpi都是跑1M，你都上c++了，好歹跑个1W位吧。

Xerxes_2

hgfdsa 发表于 2024-12-16 20:27
几十年前superpi都是跑1M，你都上c++了，好歹跑个1W位吧。

https://github.com/sekika/compute-pi
On a MacBook Air (Apple M1, 16 GB), pi to 1 million digits was computed in 1.5 seconds, and to 320 million digits in 24 minutes
你要的 1M