Что происходит в тестах на разных CPU?

$ ./prosto-test 
3.106 sec 

CPU: Intel i7-2600 (8) @ 4.200GHz

gcc версия 13.2.1 20230801 (GCC)

#include <iostream>
#include <cmath>
#include <time.h>

using namespace std;

bool isPrime(int num)
{
    if (num == 2) {
        return true;
    }
    if (num <= 1 || num % 2 == 0) {
        return false;
    }

    double sqrt_num = sqrt(double(num));
    for (int div = 3; div <= sqrt_num; div +=2)
    {
        if (num % div == 0) {
            return false;
        }
    }
    return true;
}


int main()
{
    int N = 10000000;
    clock_t start, end;
    start = clock();
    for (int i = 0; i < N; i++) {
        isPrime(i);
    }
    end = clock();
    cout << (end - start) / ((double) CLOCKS_PER_SEC);
    cout << " sec \n";
    return 0;
}

#include <iostream>
#include <cmath>
#include <time.h>

using namespace std;

bool isPrime(int num)
{
    if (num == 2) {
        return true;
    }
    if (num <= 1 || num % 2 == 0) {
        return false;
    }

    double sqrt_num = sqrt(double(num));
    for (int div = 3; div <= sqrt_num; div +=2)
    {
        if (num % div == 0) {
            return false;
        }
    }
    return true;
}


int main()
{
    int N = 10000000;
    clock_t start, end;
    int result = 0;
    start = clock();
    for (int i = 0; i < N; i++) {
        result+=(int)isPrime(i);
    }
    end = clock();
    cout << (end - start) / ((double) CLOCKS_PER_SEC);
    cout << " sec \n";
    cout<<result<<"\n";
    return 0;
}

$ g++ -O0 test-cpp.cpp -o test-cpp-O0 && ./test-cpp-O0
4.34338 sec 
664579

$ g++ -O1 test-cpp.cpp -o test-cpp-O1 && ./test-cpp-O1
4.30605 sec

$ g++ -O2 test-cpp.cpp -o test-cpp-O1 && ./test-cpp-O2
4.30437 sec

g++ -O3 test-cpp.cpp -o test-cpp-O3 && ./test-cpp-O3
4.30343 sec

g++ -O3 2.cpp -o test-cpp-O3 && ./test-cpp-O3
2.76109 sec 

g++ -O3 2.cpp -o test-cpp-O3 && ./test-cpp-O3
3.59535 sec

g++ -O3 2.cpp -o test-cpp-O3 && ./test-cpp-O3
2.36739 sec

g++ -O3 2.cpp -o test-cpp-O3 && ./test-cpp-O3
4.54539 sec 

$ g++ -Ofast test-cpp.cpp -o test-cpp-Ofast && ./test-cpp-Ofast
4.30136 sec 
664579

$ g++ -Ofast -march=native test-cpp.cpp -o test-cpp-Ofast-native && ./test-cpp-Ofast-native
4.29901 sec

$ g++ -Ofast -march=native -flto test-cpp.cpp -o test-cpp-Ofast-native-flto && ./test-cpp-Ofast-native-flto
4.29844 sec

~/Documents/cpp ❯ g++ -O2 -march=native -o testO2 ./test.cpp && ./testO2
664579 prime count
1.07422 sec 

#include <iostream>
#include <cmath>
#include <time.h>

using namespace std;


int main()
{
    clock_t start, end;
    // double result = 0.0;
    int result = 0;
    start = clock();
    for (int k1 = 1; k1 < 10000; k1++) {
        for (int k2 = 1; k2 < 100000; k2++) {
            // result += (double)k1 / (double)k2;
            result += k1 % k2;
        }
    }
    end = clock();
    cout << (end - start) / ((double) CLOCKS_PER_SEC);
    cout << " sec \n";
    cout<<result<<"\n";
    return 0;
}

3.98982 sec 
855312446

4.65588 sec 
6.04446e+08

1.24623 sec 
855312446

0.901353 sec 
6.04446e+08

:~$ cat /proc/cpuinfo  | grep 'model name' | tail -n1
model name      : Intel(R) Xeon(R) CPU           L5420  @ 2.50GHz
:~$ ./a.out
3.64062 sec
:~$ gcc --version
gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

~/Documents/cpp ❯ g++ -ltbb -O2 -march=native -o testThreads ./test.cpp && ./testThreads
32 threads
93ms
664579 prime count

#include <iostream>
#include <cmath>
#include <algorithm>
#include <execution>
#include <vector>
#include <chrono>
#include <thread>


using namespace std;

bool isPrime(int num)
{
    if (num == 2) {
        return true;
    }
    if (num <= 1 || num % 2 == 0) {
        return false;
    }

    double sqrt_num = sqrt(double(num));
    for (int div = 3; div <= sqrt_num; div +=2)
    {
        if (num % div == 0) {
            return false;
        }
    }
    return true;
}



int main()
{
    int N = 10000000;

    int num_phreads = std::thread::hardware_concurrency();
    std::cout << num_phreads << " threads\n";

    std::vector<int> it(num_phreads),res(num_phreads,0);
    std::iota (std::begin(it), std::end(it), 0);
    int K = N / num_phreads;
    auto begin = std::chrono::high_resolution_clock::now();

    std::for_each(std::execution::par_unseq, std::begin(it), std::end(it), [&](int j) {
    int start_num= j*K;
    int end_num = start_num+K;
    for (int i = start_num; i < end_num; i++) {
            if(isPrime(i)){
                res[j]++;
            }
        }
    });

    auto end = std::chrono::high_resolution_clock::now();
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end-begin).count() << "ms" << std::endl;

    cout << std::reduce(res.begin(), res.end());;
    cout << " prime count\n";
    return 0;
}

#include <iostream>
#include <cmath>
#include <chrono>
#include <omp.h>


using namespace std;

bool isPrime(int num)
{
    if (num == 2) {
        return true;
    }
    if (num <= 1 || num % 2 == 0) {
        return false;
    }

    double sqrt_num = sqrt(double(num));
    for (int div = 3; div <= sqrt_num; div +=2)
    {
        if (num % div == 0) {
            return false;
        }
    }
    return true;
}



int main()
{
    int N = 10000000;
    int c =0;

    #pragma omp parallel
    {
        #pragma omp single
        std::cout << omp_get_num_threads() << " threads\n";
    }

    auto begin = std::chrono::high_resolution_clock::now();

    #pragma omp parallel for reduction(+:c)
    for (int i = 0; i < N; i++) {
        c+=isPrime(i);
    }

    auto end = std::chrono::high_resolution_clock::now();
    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end-begin).count() << "ms" << std::endl;

    cout << c;
    cout << " prime count\n";
    return 0;
}

~/Documents/cpp ❯ g++ -fopenmp -O2 -march=native -o test-omp ./test-omp.cpp &&OMP_NUM_THREADS=512 ./test-omp
512 threads
70ms
664579 prime count

~/Documents/cpp ❯ g++ -fopenmp -O2 -march=native -o test-omp ./test-omp.cpp &&OMP_NUM_THREADS=512 ./test-omp
512 threads
47ms
664579 prime count

#include <iostream>
#include <chrono>
#include <omp.h>

bool isPrime(int x)
{
    if(x <= 1) return false;
    if(x == 2 || x == 3) return true;
    if(x % 2 == 0 || x % 3 == 0) return false;
    if((x - 1) % 6 != 0 && (x + 1) % 6 != 0) return false;
    for(int i = 5; i * i <= x; i += 6) if(x % i == 0 || x % (i + 2) == 0) return false;
    return true;
}

int main()
{
    int N = 10000000;
    int prime_count =0;

    #pragma omp parallel
    #pragma omp single
    std::cout << omp_get_num_threads() << " threads\n";

    auto begin = std::chrono::high_resolution_clock::now();

    #pragma omp parallel for reduction(+:prime_count)
    for (int i = 0; i < N; i++) prime_count+=isPrime(i);

    auto end = std::chrono::high_resolution_clock::now();

    std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(end-begin).count() << "ms" << std::endl;
    std::cout << prime_count << " prime count" << std::endl;
    return 0;
}

рабочая: 12 threads 783ms
VPS-AMD: 2 threads 1110ms
VPS-Intel: 2 threads 1696ms

4.25124 sec 
855312446

1.51601 sec 
6.04446e+08

        mov     rax, QWORD PTR [rbp-24]
        cqo
        idiv    QWORD PTR [rbp-8]

        mov     eax, DWORD PTR [rbp-20]
        cdq
        idiv    DWORD PTR [rbp-4]

Zen2
IDIV r8/m8   1 12-15 12-15
IDIV r16/m16 2 13-20 13-20
IDIV r32/m32 2 13-28 13-28
IDIV r64/m64 2 13-44 13-44

Zen3
IDIV r8/m8   2 11    4
IDIV r16/m16 2 11-12 4
IDIV r32/m32 2 9-12  6
IDIV r64/m64 2 9-17  7-12