我公司有两台 GTX 295，所以一台服务器总共有 4 个 GPU，我们有几台服务器。与 GPU 0、2 和 3 相比，我们 GPU 1 特别慢，所以我写了一个小速度测试来帮助找出问题的原因。

结果是

GPU0 cudaMalloc 耗时 0.908640 ms 复制到 GPU 耗时 296.058777 ms 测试内核耗时 326.721283 ms

GPU1 cudaMalloc 耗时 0.913568 ms 复制到 GPU 耗时663.182251 ms 测试内核耗时 326.710785 ms

GPU2 cudaMalloc 耗时 0.925600 ms 复制到 GPU 耗时 296.915039 ms 测试内核耗时 327.127930 ms

GPU3 cudaMalloc 耗时 0.920416 ms 复制到 GPU 耗时 296.968384 ms 测试内核耗时 327.038696 ms

如您所见，GPU 的 cudaMemcpy 是 GPU1 时间量的两倍。这在我们所有的服务器之间都是一致的，总是 GPU1 很慢。任何想法为什么会这样？所有服务器都运行 Windows XP。

在 Mac OS X 中，每个显示器都CGDirectDisplayID分配有一个唯一的编号。您可以使用CGGetActiveDisplayList() 或[NSScreen screens]访问它们等。根据Apple 的文档：

显示 ID 可以跨进程和系统重新启动持续存在，并且只要某些显示参数不更改，通常保持不变。

在 2010 年中期更新的 MacBook Pro 上，Apple 开始使用自动切换 Intel/nVidia 显卡。笔记本电脑有两个 GPU，一个低功耗的 Intel 和一个高性能的 nVidia。以前的双 GPU 笔记本电脑（2009 年型号）没有自动 GPU 切换功能，并且需要用户进行设置更改、注销，然后再次登录才能进行 GPU 切换。即使是较旧的系统也只有一个 GPU。

2010 年中期的型号存在一个问题，当显示器从一个 GPU 切换到下一个 GPU 时，CGDirectDisplayID 不会保持不变。例如：

1. 笔记本电脑开机。
2. 内置LCD 屏幕由 Intel 芯片组驱动。显示 ID： 30002
3. 外接显示器已插入。
4. 内置 LCD 屏幕切换到 nVidia 芯片组。它的显示ID更改： 30004
5. 外接显示器由 nVidia 芯片组驱动。
6. ...此时，英特尔芯片组处于休眠状态...
7. 用户拔下外接显示器。
8. 内置LCD 屏幕切换回 Intel 芯片组。它的显示ID变回原来的：30002

我的问题是，当旧的显示 ID 由于 GPU 更改而改变时，如何将旧显示 ID 与新显示 ID 匹配？

想过：

我注意到显示 ID 仅更改 2，但我没有足够的测试 Mac 可用来确定这是否适用于所有新的 MacBook Pro，或者只是我的。无论如何，如果“只检查彼此相差 +/-2 的显示 ID”，那是一种混搭。

试过：

CGDisplayRegisterReconfigurationCallback()，它在显示将要更改时通知前后，没有匹配的逻辑。将这样的东西放在用它注册的方法中是行不通的：

上面发生的事情是：

1. 在显示设置更改之前，我正在缓存oldInfoDict 。
2. 等待显示设置更改
3. 然后使用比较oldInfoDict和newInfoDictIODisplayMatchDictionaries()
4. IODisplayMatchDictionaries()返回一个 BOOL，要么是它们相同，要么不它们不同。

不幸的是，IODisplayMatchDictionaries()如果相同的显示器更改了 GPU，则不会返回 YES。这是它正在比较的字典的示例（查看IODisplayLocation键）：

如您所见，IODisplayLocation切换 GPU 时键会发生变化，因此IODisplayMatchDictionaries()不起作用。

从理论上讲，我可以只比较DisplayProductID和DisplayVendorID键，但我正在编写最终用户软件，并且担心用户插入两个或多个相同显示器的情况（这意味着它们都将具有相同的 DisplayProductID/DisplayVendorID） . 换句话说，这是一个不太完美的解决方案，可能会出现潜在故障。

任何帮助是极大的赞赏！:)

使用 CUDA / MPI 等进行编程的最佳 IDE / IDE 插件 / 工具等是什么？

我在这些框架中工作了一段时间，但感觉 IDE 在扩展和作业处理交互方面可能会做更多的工作。

（我通常使用 Eclipse 或 Netbeans，通常在 C/C++ 中偶尔使用 Java，这是一个模糊的问题，但我想不出更具体的方式来表达它）

我当前用于 CUDA 应用程序的系统有一张旧的 NVIDIA 卡，8800 GTX。我正在考虑在不更新主板的情况下再添加一张卡。是不是只要我有两个PCI-E插槽，两个就可以了？或者我必须购买支持 SLI 支持的新主板？

Screen.AllScreens无论硬件配置如何，所有显示是否都从 .NET 返回？例如，在单台 PC 上，您可以拥有：

1. 显卡输出到两个显示器 = 总共 2 个显示器
2. 显卡各出 1 个显示器 = 总共 2 个显示器，
3. 显卡各出 2 个显示器 = 6 个显示器，
4. Eyefinity 卡输出到 6 个显示器（在显示端口上）

在所有这些情况下，如果我使用，我Screen.AllScreens可以单独访问每个显示器吗？

另外，如果我有一张处于扩展模式的卡，这意味着 2 个显示器插入一张卡但它只是一个大桌面（我在工作中使用的）？我还能指定内容显示在一个屏幕上吗？

有人在 Cuda4 上成功测试过这个功能吗？似乎我无法让它正常工作，不确定这是我的代码中的错误还是该功能尚未完全实现。

例如，我想在将内存从 1 个 gpu 复制到另一个 gpu 后进行内核调用。流 0，mem0 在 gpu0 上创建流 1，mem1 在 gpu1 上创建。两者都是费米特斯拉（C2070）

有时似乎内存还没有为内核准备好，所以结果不正确。如果我在 Gpu0 上添加一个 cudaDeviceSynchronize 那么它工作正常。

谢谢

PyCUDA，尽管有很多缺点，但通常会提供非常好的示例/可从 wiki 下载。但是我在示例或文档（或粗略的谷歌搜索）中找不到任何东西，展示了 PyCUDA 将工作负载动态分配给多个设备的方式。

任何人都可以暗示我应该做什么或指出我的例子吗？

突然出现在我脑海中的一个想法是使用多处理，生成一个由 N 个进程组成的池，每个进程都绑定到一个设备，然后在调用该类时（我将所有 gpu 函数放在一个单独的类中；可能不是最好的主意，但它工作）它循环的多进程。这是一个多么好的/迟钝的想法？

PS 我的开发机器是 1 个 GPU，我的测试机器是 4 个 GPU，所以我需要任何能够处理动态数量的设备的解决方案（它们的计算能力不同也无济于事，但这就是生活）

我目前正在为 GPU 集群开发机器学习工具包。我在多个 GPU 上测试了逻辑回归分类器。

我正在使用 Master-Worker 方法，其中一个主 CPU 创建多个 POSIX 线程，并且矩阵在 GPU 之间进行划分。

但我遇到的问题是如何存储无法存储在单台机器上的大型矩阵。是否有任何库或方法可以在节点之间共享数据？

问题

我有一个 OpenGL 应用程序，它将在具有多种多 GPU 配置（可能还有不同的 Windows 版本，从 XP 到 7）的机器上运行。有没有一种通用的方法来选择将作为 OpenGL 渲染器的特定 GPU 独立于 GPU 组合（例如 NVIDIA + NVIDIA、NVIDIA + AMD、NVIDIA + Intel 等）？它必须是可以从应用程序代码应用的解决方案，即直接在 C++ 中应用，或者是从应用程序调用的脚本，无需最终用户干预。

以下是我为尝试找到解决方案所做的几个测试的详细信息，从非常具体的案例开始，但也许有一个解决方案可以在所有或大多数情况下工作。

是否有任何可靠的方法来强制哪个 GPU 进行 OpenGL 渲染？

任何提示将不胜感激。提前致谢！

尝试了可能的解决方案

带有两个 NVIDIA Quadro 的 Windows XP 64

使用两张 Quadro 卡的组合进行测试

• Quadro FX 1700 + Quadro FX 570
• Quadro FX 1700 + Quadro FX 540
• Quadro FX 1700 + Quadro NVS 285

在 Windows XP 64 位下使用相同的驱动程序（版本 275.36），我已经通过各种方法取得了相对成功，例如：

• 让司机决定。
  只要两张卡使用相同的驱动程序并决定使用所需的卡，此解决方案才有效。所以它太具体了，也许是不可预测的。

• 在让驱动程序决定之前使用NVAPI更改代码中的驱动程序设置。
  使用此解决方案，理论上可以让驱动程序按我的意愿决定，但这很难，需要两张卡使用相同的驱动程序并且并不总是有效（使用 FX 1700 + NVS 285 它不起作用）。

• 更改主屏幕。
  这具有应用程序默认在所选主屏幕中打开的效果。该解决方案仅适用于 FX 1700 + FX 570 组合。对于 FX 1700 + FX 540，渲染器取决于驱动程序设置，独立于主屏幕，对于 FX 1700 + NVS 285，渲染器始终是 FX 1700。

• 当窗口位于特定屏幕时创建 OpenGL 上下文。
  可以在所需的屏幕中创建窗口，独立于哪个是主屏幕，但它与上述解决方案存在相同的问题。

• 创建 OpenGL 上下文，仅启用所需图形卡中的屏幕，然后启用其他/s。
  这是我发现使用 NVS 285 作为渲染器的唯一方法，但它很难看，我不知道它是否可以自动化，或者它是否适用于所有情况。

• 尝试使用WGL_NV_gpu_affinity扩展选择渲染 GPU。
  通过 FX 1700 和 FX 570 的组合，扩展报告两个 GPU 兼容，我可以将渲染限制为其中一个。使用 FX 1700 + FX 540 对，扩展只报告一个兼容的 GPU，这是驱动程序决定用于 OpenGL 渲染的一个。使用 FX 1700 + NVS 285 组合，始终只报告 FX 1700（我认为 NVS 285 不支持此扩展，因为如果它是唯一使用的卡，扩展仍然不会报告）。

Windows 7 64 与 Intel 和 AMD

该系统运行 Windows 7 64 位，显卡是一张 Intel HD Graphics 2000（集成在 CPU（Sandy Bridge）中）和一张 AMD Radeon HD 6450。在所有情况下，两个屏幕都可以渲染，但渲染 GPU 会有所不同取决于一些变量：

• 如果主屏幕连接到 AMD 并在此屏幕中打开窗口，则 AMD 是渲染器。
• 如果主屏连接AMD，窗口在另一个屏打开，那么渲染器是“GDI Generic”，很慢。
• 如果主屏幕连接到 Intel，则 Intel 是渲染器，与打开窗口的位置无关。

使用这个系统，我还尝试了 OpenGL 论坛中提出的解决方案。TL;DR：选择 OpenGL 使用的驱动程序是一种 hacky 方法，因此它可以在使用不同驱动程序的 GPU 之间进行选择，但不能在使用相同驱动程序的卡之间进行选择。我得到了以下结果：

• 如果主屏幕连接到 AMD，我可以选择任何 GPU 作为渲染器。
• 如果主屏幕连接到英特尔，我可以选择英特尔作为渲染器（没用，因为这是自动的），但如果我尝试选择 AMD 则会出错；我认为这可能是驱动程序中的错误。

Can I have two mixed chipset/generation AMD gpus in my desktop; a 6950 and 4870, and dedicate one gpu (4870) for opencl/gpgpu purposes only, eliminating the device from video output or display driving consideration by the OS, allowing the 4870 to essentially remain in a deep sleep or appear ejected/disabled until it's stream processors are called upon?

Compared to the 4870, the 6950 is a heavyweight in opencl calculations; enough so that it can crunch numbers and still allow an active user session, and even web browsing. HOWEVER, as soon as I navigate to a webpage with embedded flash video, forget what I have running and open media player or media center- basically any gpu-accelerated video task that requires the 6950 to initialize UVD, the display system hangs.

I'm looking for a way to plug my 4870 in an open pcie slot, have it sit in a dormant state with near-0 heat production and power consumption (essentially only maintain the interface signalling, like an ethernet card in a powered-off desktop maintaining the line and waiting for a WOL command), and attain a D0 state (I don't even care if the latency of this wake event is on the scale of seconds) to then run opencl calculations ON ITS OWN. I do not wish to achieve a non-CF heterogeneous gpu teaming setup! In my example of a UVD hung situation I would see manually stopping the opencl calculations on the 6950, beginning those calculations then on the 4870 to free up the 6950 for multimedia usage/gaming as my desire outcome (granted, with a hit to the calculation rate). Even better if the two gpus could independently run similar calculations while no one is using the desktop. I don't even mind if I have to initiate the power-state transitions of the 4870 from/into an 'OFF' state (say, by a shortcut on the desktop), as long as it doesn't require a system restart, ending the user session and logging off... and the manual ON/OFF 'switch' for the 4870 is something any proficient windows end-user could do- like click a shortcut to run a script, or even go into device manage and toggle enable/disable. As long as the 4870 isn't wastefully idling by for 1 sole use that may occur sporadically.

I couldn't think of a solution to facilitate this function besides writing a new ini for the 4870 to override the typical power management characteristics written for usage of the device as a typical graphics card (say to drop in/out of powered state w/o relinquishing irq or other allocated resources to 'hold the door open' on interface availability and addressing). But that is an endeavor that is both well above my abilities, and I easily see an additional involvement of licensing being necessitated to achieve.