问题标签 [hyperthreading]

阅读此内容，特别是阅读 Microsoft 文档，看起来它应该返回物理处理器的数量，并且您应该使用 GetLogicalProcessorInformation 来确定您拥有多少逻辑处理器。

这是我在 SYSTEM_INFO 结构中找到的文档：http: //msdn.microsoft.com/en-us/library/ms724958 (v=VS.85).aspx 这是关于 GetLogicalProcessorInformation 的文档：（添加空格以通过垃圾邮件过滤器） http://msdn.microsoft.com/en-us/library/ms683194.aspx

不过，进一步阅读它，在我发现的关于这个主题的大多数讨论中，开发人员说 GetSystemInfo（和 SYSTEM_INFO 结构）报告逻辑处理器的数量。

当我再次搜索时，我发现 MS 确实发布了一些关于此的信息（和一个热修复），这里（添加空格以通过垃圾邮件过滤器）： http://support。microsoft.com/kb/936235

读起来，听起来像是在 Xp，pre-service Pack 3 上，GetSystemInfo 报告 SYSTEM_INFO 结构中的 LOGICAL 处理器的数量。它还告诉我，在 Windows Vista 和 Windows 7 上，GetSystemInfo 应该报告物理处理器的数量（不同于 Windows XP pre-service Pack 3）。

有谁知道它实际上是做什么的？GetSystemInfo 是否真的以不同的方式报告物理处理器的数量（在同一台计算机上），这取决于它运行在哪个操作系统上？

我有一个在 Windows、Mac 和一些 Linux 版本上运行的多线程 c++ 应用程序。

长话短说：为了让它以最高效率运行，我必须能够为每个物理处理器/内核实例化一个线程。创建比物理处理器/内核更多的线程会大大降低我的程序的性能。我已经可以在所有这三个平台上正确检测逻辑处理器/内核的数量。为了能够正确检测物理处理器/内核的数量，我必须检测是否支持超线程并处于活动状态。

因此，我的问题是是否有办法检测是否支持和启用超线程？如果是这样，具体如何。

我已经可以在所有这三个平台上正确检测逻辑处理器的数量。

为了能够正确检测物理处理器/内核的数量，我必须检测是否支持超线程并且处于活动状态（或者如果您愿意，可以启用），如果是，则将逻辑处理器的数量除以 2 以确定物理处理器的数量.

也许我应该提供一个例子：

启用了超线程的四核 Intel CPU 有 4 个物理内核，还有 8 个逻辑处理器（超线程创建了 4 个逻辑处理器）。所以我当前的功能将检测到 8 而不是所需的 4。

因此，我的问题是是否有办法检测是否支持和启用超线程？

我很好奇 Linux 中的 CPU 排序是什么。假设我在超线程系统上将一个线程绑定到 cpu0，另一个绑定到 cpu1，它们是否都将位于同一个物理内核上。给定具有 4 个内核和超线程的 Core i7 920，/proc/cpuinfo 的输出让我认为 cpu0 和 cpu1 是不同的物理内核，而 cpu0 和 cpu4 在同一个物理内核上。

谢谢。

We have recently purchased a dual Intel X5650 workstation to run a floating-point intensive simulation, under Ubuntu 10.04.

Each X5650 has 6 cores, so there are 12 cores in total. The code is trivially parallel, so I have been running it mostly with 12 threads, and observing approximately "1200%" processor utilization through "top".

HyperThreading is enabled in the BIOS, so the operating system nominally sees 24 cores available. If I increase the number of threads to 24, top reports approximately 2000% processor utilization - however, it does not appear that the actual code performance increases by 20/12.

My question is - how does HyperThreading actually work on the latest generation of Xeons? Would a floating-point intensive code benefit from scheduling more than one thread per core? Does the answer change if the working set is on the order of the cache size, as compared to several times larger, or if there are substantial I/O operations (e.g. writing simulation outputs to disk)?

Additionally - how should I interpret processor utilization percentages from "top" when hyperthreading is enabled?

Say if I have a processor like this which says # cores = 4, # threads = 4 and without Hyper-threading support.

Does that mean I can run 4 simultaneous program/process (since a core is capable of running only one thread)? Or does that mean I can run 4 x 4 = 16 program/process simultaneously?

From my digging, if no Hyper-threading, there will be only 1 thread (process) per core. Correct me if I am wrong.

我们有一个 12 核的 MacPro 来做一些蒙特卡罗计算。它的英特尔至强处理器启用了超线程 (HT)，因此实际上应该有 24 个进程并行运行才能充分利用它们。但是，我们的计算在 12x100% 上比 24x50% 上运行更有效，因此我们尝试通过系统偏好设置中的窗格关闭超线程Processor，以获得更高的性能。也可以通过以下方式关闭 HT

然后我们进行了一些测试，结果如下：

1. 12 个并行任务在不带或不带 HT 的情况下同时运行，令我们失望。
2. 如果 HT 关闭，24 个并行任务会丢失 20%（不是我们想象的 -50%）
3. 开启 HT 后，从 24 个任务切换到 12 个任务会降低 20% 的效率（同样令人惊讶）
4. 当 HT 关闭时，从 24 切换到 12 不会改变任何内容。

似乎超线程只会降低我们计算的性能，而且没有办法避免它。我们用于计算的程序是用 Fortran 编写并用gfortran. 有没有办法让这块硬件更高效？

更新：我们的蒙特卡洛计算 (MCC) 通常分步进行，以避免数据丢失和其他原因（并非总是可以避免此类步骤）。在我们的例子中，每个步骤都包含许多持续时间可变的模拟。由于每个步骤都分为多个并行任务，因此它们也具有可变的持续时间。本质上，所有较快的任务都必须等到最慢的任务完成。这一事实迫使我们采取更大的步骤，由于平均，这些步骤在时间上的偏差更小，因此处理器不会浪费时间在等待上。这是我们使用 12*2.66 GHz 而不是 24*1.33 GHz 的动机。如果可以关闭 HT，那么通过从 24 个任务 w/HT 切换到 12 个任务 w/o HT，我们将获得大约 +10% 的性能。然而，测试表明我们损失了 20%。

对于测试，我使用了相当大的步骤，但通常步骤更短，因此效率更高。

还有一个原因 - 我们的某些计算需要 3-5 GB 的内存，因此您可能会看到我们拥有 12 个快速任务是多么经济。我们正在努力实现共享内存，但这将是一个长期的项目。因此，我们需要找出如何使现有的硬件/软件尽可能快。

If a multithreaded program runs safe on a single-core CPU with hyperthreading, will it also run safe on a dual-core CPU with hyperthreading? Concerning thread-safety etc.

EDIT

Ok, I try to be more specific. I mean the bad source code lines, where I will have forgotten or failed to make sure, that they won't be an (concurrency) issue.

So, maybe the 1-core htt "lies" by preventing dead-locks, crashes, cpu spikes or anything that my code causes on a 2-core machine. I'm unsure, how exactly 2 (logical) processors of a htt PC are different from 2 processors of a dual-core PC, how transparent htt is. If there's any issue, I'll probably buy a second PC just for that, that's why I asked.

我的 win32 应用程序如何以编程方式确定它是否在具有超线程技术的 CPU 的机器上运行？

If you're spawning multiple threads (or processes) concurrently, is it better to spawn as many as the number of physical processors or the number of logical processors, assuming the task is CPU-bound? Or is it better to do something in between (say, 3 threads)?

Does the performance depend on the kind of instructions that are getting executed (say, would non-local memory access be much different from cache hits)? If so, in which cases is it better to take advantage of hyperthreading?

Update:

The reason I'm asking is, I remember reading somewhere that if you have as many tasks as the number of virtual processors, tasks on the same physical core can sometimes starve some CPU resources and prevent each other from getting as many resources as needed, possibly decreasing performance. That's why I'm wondering if having as many threads as virtual cores is a good idea.