如果只使用 1 个线程，我可以轻松编写一个程序来利用 Intel 的四核或 i7 芯片吗？

Question

我想知道如果我的程序中只有 1 个线程，我可以编写它以便四核或 i7 实际上可以利用不同的核心吗？ 通常，当我在四核计算机上编写程序时，CPU 使用率只会达到 25% 左右，并且工作似乎被分配给 4 个核心，如任务管理器所示。 （我写的程序通常是Ruby、Python或PHP，所以它们可能没有那么优化）。

更新：如果我用 C 或 C++ 编写它，然后

for (i = 0; i < 100000000; i++) {
  a = i * 2;
  b = i + 1;
  if (a == ...  || b == ...) { ... }
}

使用编译器的最高级别优化会怎么样。 编译器能否使乘法发生在一个内核上，而加法发生在另一个内核上，从而使 2 个内核同时工作？ 使用 2 个核心不是一个相当简单的优化吗？

Answer 1

隐式并行可能就是您正在寻找的。

Answer 2

如果您的应用程序代码是单线程的，则仅在以下情况下才会使用多个处理器/内核：

• 您使用的库正在使用多线程（可能将此用法隐藏在简单的接口后面）
• 您的应用程序生成其他进程来执行其操作的某些部分

Ruby，然而，Python 和 PHP 应用程序都可以编写为使用多线程。

Answer 3

一个单线程程序只会使用一个核心。 操作系统很可能决定不时地在核心之间转移程序 - 根据一些规则来平衡负载等。因此，您将看到总体使用率仅为 25%，并且所有四个核心都在工作 - 但同时只有一个核心在工作。

Answer 4

不使用多线程而使用多核的唯一方法是使用多个程序。

在上面的示例中，一个程序可以处理 0-2499999，下一个程序可以处理 2500000-4999999，依此类推。 同时关闭所有四个，它们将使用所有四个核心。

通常，您最好编写一个（单）多线程程序。

Answer 5

对于 C/C++，您可以使用 OpenMP。 这是带有编译指示的 C 代码，就像

#pragma omp parallel for
for(..) {
...
}

说这个 for 将并行运行。
这是一种并行化某些东西的简单方法，但有时您必须了解并行程序如何执行，并且会遇到并行编程错误。

Answer 6

如果您想并行选择评估为“true”的“i”，您的语句 if (a == ... || b == ...) 那么您可以这样做使用 PLINQ（在 .NET 4.0 中）：

        //note the "AsParallel"; that's it, multicore support.
        var query = from i in Enumerable.Range(0, 100000000).AsParallel()
                    where (i % 2 == 1 && i >= 10) //your condition
                    select i;

        //while iterating, the query is evaluated in parallel! 
        //Result will probably never be in order (eg. 13, 11, 17, 15, 19..)
        foreach (var selected in query)
        {
            //not parallel here!
        }

如果您想要并行化操作，您将能够执行以下操作：

Parallel.For(0, 100000000, i =>
{
    if (i > 10)           //your condition here
        DoWork(i);        //Thread-safe operation
});

Answer 7

由于您正在谈论“任务管理器”，因此您似乎正在 Windows 上运行。 然而，如果您在那里运行一个具有多个进程的网络服务器（对于具有 fcgi 或 Apache 预分叉的 Ruby 或 PHP，以及较小程度的其他 Apache 工作人员），那么它们往往会分布在多个核心上。

如果只有一个没有线程的程序正在运行，那么，不，不会产生任何显着的优势 - 除了操作系统驱动的后台进程之外，您一次只会破坏一件事。

Answer 8

不。您需要使用线程在多个 CPU（无论是真实的还是虚拟的）上同时执行多个路径...一个线程的执行本质上绑定到一个 CPU，因为这维护了语句之间的“先发生”关系，这是核心程序如何工作。

Answer 9

首先，除非在程序中创建多个线程，否则该程序中只有一个执行线程。

如果看到该程序使用了 25% 的 CPU 资源，则表明四个核心中有一个核心的利用率为 100%，但所有其他核心均未使用。 如果使用所有核心，那么理论上该进程可能会占用 100% 的 CPU 资源。

顺便说一句，Windows 任务管理器中显示的图表是当时运行的所有进程的 CPU 利用率，而不仅仅是一个进程的 CPU 利用率。

其次，您提供的代码可以分为可以在两个单独的线程上执行的代码，以便在两个核心上执行。 我猜您想表明 a 和 b 彼此独立，并且它们仅依赖于 i。 在这种情况下，像下面这样分离 for 循环的内部可能会允许多线程操作，从而提高性能：

// Process this in one thread:
for (int i = 0; i < 1000; i++) {
    a = i * 2;
}

// Process this in another thread:
for (int i = 0; i < 1000; i++) {
    b = i + 1;
}

但是，棘手的是是否需要有一个时间需要评估两个单独线程的结果，就像稍后的 if 语句所暗示的那样：

for (i = 0; i < 1000; i++) {
  // manipulate "a" and "b"
  if (a == ...  || b == ...) { ... }
}

这将要求 a 和 b 驻留在单独线程（在单独处理器上执行）中的值需要查找，这是一个非常令人头痛的问题。

没有真正好的保证两个线程的 i 值同时相同（毕竟，乘法和加法可能需要不同的执行时间），这意味着在比较与依赖值对应的 a 和 b 之前，一个线程可能需要等待另一个线程的 i 值同步。代码>我。 或者，我们是否创建第三个线程用于两个线程的值比较和同步？ 无论哪种情况，复杂性都开始快速增加，所以我认为我们可以同意我们开始看到严重的混乱——在线程之间共享状态可能非常棘手。

因此，您提供的代码示例只是部分可并行化，不需要太多努力，但是，一旦需要比较两个变量，分离两个操作很快就会变得非常困难。

涉及并发编程时的一些经验法则：

当任务可以分解为涉及完全独立于其他数据及其结果（状态）的数据处理的部分时，并行化会非常容易。

例如，两个从输入计算值的函数（以伪代码形式）：

f(x) = { return 2x }
g(x) = { return x+1 }

这两个函数不相互依赖，因此它们可以毫无痛苦地并行执行。 此外，由于它们不是在计算之间共享或处理的状态，即使需要计算多个 x 值，甚至这些也可以进一步拆分：

x = [1, 2, 3, 4]
foreach t in x:
    runInThread(f(t))
foreach t in x:
    runInThread(g(t))

现在，在这个示例中，我们可以有 8 个独立的线程执行计算。 对于并发编程来说，没有副作用可能是一件非常好的事情。

然而，一旦依赖于其他计算的数据和结果（这也意味着存在副作用），并行化就变得极其困难。 在许多情况下，这些类型的问题必须串行执行，因为它们等待其他计算返回的结果。

也许问题归结为，为什么编译器不能找出可以自动并行化的部分并执行这些优化？ 我不是编译器方面的专家，所以我不能说，但是有一篇关于自动并行化的文章< /a> 在维基百科上可能有一些信息。

Answer 10

我非常了解英特尔芯片。

根据您的代码，“if (a == ... || b == ...)”是一个障碍，否则处理器核心将并行执行所有代码，无论编译器做了什么样的优化。 那只要求编译器不是一个非常“愚蠢”的编译器。 这意味着硬件本身具有能力，而不是软件。 因此，在这种情况下，线程编程或 OpenMP 并不是必需的，尽管它们有助于改进并行计算。 注意这里并不意味着超线程，只是普通的多核处理器功能。

请谷歌“处理器管道多端口并行”以了解更多信息。

这里我想举一个经典的例子，可以通过多核/多通道IMC平台（例如Intel Nehalem系列，如Core i7）并行执行，不需要额外的软件优化。

char buffer0[64];
char buffer1[64];
char buffer2[64];
char buffer[192];

int i;
for (i = 0; i < 64; i++) {
    *(buffer + i) = *(buffer0 + i);
    *(buffer + 64 + i) = *(buffer1 + i);
    *(buffer + 128 + i) = *(buffer2 + i);
}

为什么？ 3个原因。

1 Core i7具有三通道IMC，其总线宽度为192位，每通道64位； 内存地址空间在每个高速缓存行的基础上在通道之间交错。 缓存行长度为 64 字节。 所以基本上 buffer0 位于通道 0 上，buffer1 位于通道上，buffer2 位于通道 2 上； 而对于 buffer[192]，它在 3 个通道之间均匀地交错，每个通道 64 个。 IMC 支持同时从多个通道加载数据或向多个通道存储数据。 这是具有最大吞吐量的多通道 MC 突发。 在下面的描述中，我只会说每个通道 64 字节，即每个通道带有 BL x8（突发长度 8，8 x 8 = 64 字节 = 高速缓存行）。

2 buffer0..2 和 buffer 在内存空间中是连续的（在虚拟和物理上的特定页面上，堆栈内存）。 运行时，buffer0、1、2 和 buffer 被加载/提取到处理器缓存中，总共 6 个缓存行。 所以在开始执行上面的“for(){}”代码后，根本不需要访问内存，因为所有数据都在缓存中，三级缓存是非核心部分，由所有核心共享。 这里我们不讨论L1/2。 在这种情况下，每个核心都可以拾取数据，然后独立计算它们，唯一的要求是操作系统支持MP并且允许窃取任务，例如运行时调度和亲和力共享。

3 buffer0、1、2 和 buffer 之间没有任何依赖关系，因此不存在执行停顿或障碍。 例如，execute *(buffer + 64 + i) = *(buffer1 + i) 不需要等待 *(buffer + i) = *(buffer0 + i) 的执行完成。

不过，最重要和最困难的一点是“窃取任务、运行时调度和亲和性共享”，这是因为对于给定的任务，只有一个任务执行上下文，并且应该由所有核心共享以执行并行执行。 任何人如果能明白这一点，他/她就是世界顶尖的专家。 我正在寻找这样的专家来配合我的开源项目，负责并行计算和最新的 HPC 架构相关工作。

请注意，在上面的示例代码中，您还可以使用一些 SIMD 指令，例如 movntdq/a，它将绕过处理器缓存并直接写入内存。 在进行软件级优化时，这也是一个非常好的主意，尽管访问内存非常昂贵，例如访问缓存（L1）可能只需要 1 个周期，但在以前的 x86 芯片上访问内存需要 142 个周期。

请访问 http://effocore.googlecode.com 和 http://effogpled.googlecode.com 了解详细信息。