为什么对于两个相似的CPU，同一程序的执行时间不同？

我试图弄明白为什么在英特尔（R）Core（TM）i5-3210M CPU@2.50GHz上使用两个踏板而不是四个踏板时程序（下面的代码）运行得更快，但在英特尔（R）Core（TM）i7-4510U CPU@2.00GHz上，四线程版本运行得比同一程序的两个线程版本快

# include <stdlib.h>
# include <stdio.h>
# include <math.h>
# include <time.h>
# include <omp.h>

int main ( void );
void timestamp ( void );

int main ( void )
{
    double a[500][500];
    double angle;
    double b[500][500];
    double c[500][500];
    int i;
    int j;
    int k;
    int n = 500;
    double pi = M_PI;
    double s;
    int thread_num;
    double wtime;

    timestamp ( );

    printf ( "\n" );
    printf ( "MXM_OPENMP:\n" );
    printf ( "  C/OpenMP version\n" );
    printf ( "  Compute matrix product C = A * B.\n" );

    omp_set_dynamic(0);
    omp_set_num_threads(2);  /* Change param to modify number of threads */

    thread_num = omp_get_max_threads ( );

    printf ( "\n" );
    printf ( "  The number of processors available = %d\n", omp_get_num_procs ( ) );
    printf ( "  The number of threads available    = %d\n", thread_num );

    printf ( "  The matrix order N                 = %d\n", n );

    /*Loop 1: Evaluate A.*/

    s = 1.0 / sqrt ( ( double ) ( n ) );

    wtime = omp_get_wtime ( );

    # pragma omp parallel shared ( a, b, c, n, pi, s ) private ( angle, i, j, k )
        {
        # pragma omp for
            for ( i = 0; i < n; i++ )
            {
                for ( j = 0; j < n; j++ )
                {
                    angle = 2.0 * pi * i * j / ( double ) n;
                    a[i][j] = s * ( sin ( angle ) + cos ( angle ) );
                }
         }

/* Loop 2: Copy A into B.*/

       # pragma omp for
           for ( i = 0; i < n; i++ )
           {
               for ( j = 0; j < n; j++ )
                   {
                   b[i][j] = a[i][j];
                   }
           }

/* Loop 3: Compute C = A * B.*/

        # pragma omp for
            for ( i = 0; i < n; i++ )
            {
                for ( j = 0; j < n; j++ )
                {
                    c[i][j] = 0.0;
                    for ( k = 0; k < n; k++ )
                    {
                        c[i][j] = c[i][j] + a[i][k] * b[k][j];
                    }
                }
            }
        printf ( "  The number of threads used    = %d\n", omp_get_num_threads() );
    }
    wtime = omp_get_wtime ( ) - wtime;
    printf ( "  Elapsed seconds = %g\n", wtime );
    printf ( "  C(100,100)  = %g\n", c[99][99] );
    /*Terminate.*/
    printf ( "\n" );
    printf ( "MXM_OPENMP:\n" );
    printf ( "  Normal end of execution.\n" );

    printf ( "\n" );
    timestamp ( );
    return 0;
}
void timestamp ( void )
{
# define TIME_SIZE 40
    static char time_buffer[TIME_SIZE];
    const struct tm *tm;
    time_t now;

    now = time ( NULL );
    tm = localtime ( &now );

    strftime ( time_buffer, TIME_SIZE, "%d %B %Y %I:%M:%S %p", tm );

    printf ( "%s\n", time_buffer );

    return;
# undef TIME_SIZE
}

#包括
#包括
#包括
#包括
#包括
int main（无效）；
无效时间戳（void）；
内部主（空）
{
双a[500][500]；
双角度；
双b[500][500]；
双c[500][500]；
int i；
int j；
int k；
int n=500；
双π=M_π；
双s；
int线程数；
双倍时间；
时间戳（）；
printf（“\n”）；
printf（“MXM_OPENMP:\n”）；
printf（“C/OpenMP版本\n”）；
printf（“计算矩阵乘积C=A*B.\n”）；
omp_集_动态（0）；
omp_set_num_threads（2）；/*更改参数以修改线程数*/
thread_num=omp_get_max_threads（）；
printf（“\n”）；
printf（“可用的处理器数量=%d\n”，omp\u get\u num\u procs（））；
printf（“可用线程数=%d\n”，线程数）；
printf（“矩阵顺序N=%d\N”，N）；
/*循环1：评估A*/
s=1.0/sqrt（（双）（n））；
wtime=omp_get_wtime（）；
#pragma omp并行共享（a，b，c，n，pi，s）私有（角度，i，j，k）
{
#pragma omp for
对于（i=0；i

即使您拥有完全相同的机器，所有相同的功能仍然可能会有不同的执行时间。为什么？ 因为，当可能在机器1中时，200个服务正在运行，而在机器2中，225则机器2中的程序在处理器/资源上的时间会减少，这可能会导致额外的时间

---

这完全取决于运行的服务（后台和前台都有）。

第一行说“两个线程”运行得更快；最后一行说“4线程”运行得更快。那是哪一个呢？您有多少个处理器单元？在堆栈上放置超过5兆字节可能是个坏主意。两个处理器都有相同数量的物理核（2），并且都支持超线程，但架构上存在细微差异，这可能解释了您观察到的差异。这种差异是否显著且系统化？查看此比较页面，这些处理器之间唯一显著的差异是：缓存大小和扩展指令的可用性。这不是一个真正的解释。也许超线程架构在更现代的i7上更有效。Chqrlie你比其他人更了解我的问题。我希望有人能解释架构之间的区别。是的，差异是显著的和系统的。我们在两台机器上运行了两个版本的程序30次，得到了一致的结果。您仍然使用不同的机器。是的，我使用不同的机器，但运行服务的参数无效，因为我在这两台机器上都实时启动了Ubuntu 15.04。