标签: gpu

我的问题是关于使用函数cudaEventElapsedTime来测量多流应用程序中的执行时间。根据CUDA文档

如果任一事件最后记录在非 NULL 流中，则结果时间可能会比预期时间长（即使两者使用相同的流句柄）。发生这种情况是因为 cudaEventRecord() 操作是异步发生的，并且不能保证测量的延迟实际上只是在两个事件之间。任意数量的其他不同的流操作可以在两个测量事件之间执行，从而以显着的方式改变时间。

我真的很难理解上面粗体的句子。看来，使用默认流来测量时间更准确。但我想明白为什么？如果我想测量流中的执行时间，我发现通过该流而不是默认流附加开始/停止事件更符合逻辑。请澄清一下吗？谢谢

我正在关注Joshua L. Mitchell 的PyTorch 教程。本教程的压轴戏是以下 PyTorch 训练脚本。我在脚本的第一行中对一个元素（批量大小）进行了参数化，并在新启动的 Jupyter 笔记本中运行该脚本。有问题的关键参数是 BIGGER_BATCH，最初设置为 4：

BIGGER_BATCH=4

import numpy as np
import torch # Tensor Package (for use on GPU)
import torch.nn as nn ## Neural Network package
import torch.optim as optim # Optimization package
import torchvision # for dealing with vision data
import torchvision.transforms as transforms # for modifying vision data to run it through models
from torch.autograd import Variable # for computational graph
import torch.nn.functional as F # Non-linearities package
import …

这里找到一篇文章OpenGL ES vs Vulkan，谁是性能之王？提到：

“OpenGL ES 3.1 的问题在于，虽然图形看起来比 OpenGL ES 2.0 好得多，但性能受到的影响非常大，以至于游戏基本上无法玩，查看上面在我的 Nexus 6P 上比较 OpenGL ES 2.0 和 3.1 的图像可以看出，与 OpenGL ES 2.0 相比，完全相同的场景以每秒三分之一的帧速度运行。这就是 Vulkan 的用武之地，它提供至少相同的图形质量，但性能有所提高。那么 Vulkan 表现如何呢？

我无法想象相同场景下 3.1 会比 2.0 慢。作者是不是把图搞错了？看来右图有 GI。

我创建了一个火炬张量，我希望它进入 GPU，但它没有。这太破了。怎么了？

def test_model_works_on_gpu():
    with torch.cuda.device(0) as cuda:
        some_random_d_model = 2 ** 9
        five_sentences_of_twenty_words = torch.from_numpy(np.random.random((5, 20, T * d))).float()
        five_sentences_of_twenty_words_mask = torch.from_numpy(np.ones((5, 1, 20))).float()
        pytorch_model = make_sentence_model(d_model=some_random_d_model, T_sgnn=T, d_sgnn=d)

        five_sentences_of_twenty_words.to(cuda)
        five_sentences_of_twenty_words_mask.to(cuda)
        print(type(five_sentences_of_twenty_words), type(five_sentences_of_twenty_words_mask))
        print(five_sentences_of_twenty_words.is_cuda, five_sentences_of_twenty_words_mask.is_cuda)
        pytorch_model.to(cuda)
        output_before_match = pytorch_model(five_sentences_of_twenty_words, five_sentences_of_twenty_words_mask)

        assert output_before_match.shape == (5, some_random_d_model)
        print(type(output_before_match))
        print(output_before_match.is_cuda, output_before_match.get_device())

tests/test_model.py:58: RuntimeError

<class 'torch.Tensor'> <class 'torch.Tensor'>
False False
<class 'torch.Tensor'>

>       print(output_before_match.is_cuda, output_before_match.get_device())
E       RuntimeError: get_device is not implemented for tensors with CPU backend

还：

>>> torch.cuda.is_available()
True
>>> torch.cuda.device_count()
2 …

我正在使用 Ubuntu 16.04，并运行我的程序来训练深度学习模型。纪元数看起来很大，但程序太慢了。我想确保我的程序在 GPU 上运行？

我怎么知道呢？

谢谢！

从这个答案看来，GPU制造商只是为特定的GPU API提供了驱动程序，并且不存在GPU组装这样的东西，或者至少，永远不会有像AMD64程序员手册那样出版的GPU组装编程手册

然而，据我了解，所有进程运行都经过CPU，并且可以被反汇编。

我的问题是：使用 GPU 的程序汇编会是什么样子？我的假设是，它将使用系统调用来操作代表 GPU 的设备文件。这个假设正确吗？

我正在使用 cuda 进行实验。

我认为如果二级缓存命中率高，性能就会提高。

然而，从nvprof来看，尽管L2缓存命中率约为93%，但L2缓存利用率较低。

为什么会出现这种情况？有没有例子可以实现这一点？

VkInstance是一个程序的实例

VkPhysicalDevice代表一个物理设备。因此，如果我有一个 Intel HD Graphics 和一个 GTX 1660，则各有VkPhysicalDevice一个

QueueFamily目前，它将是一个有助于从 GPU 发送和接收内容的队列。有很多队列，例如一个用于从内存传输数据，另一个处理计算命令等。

AVkDevice是与队列系列关联的 VkPhysicalDevice。VkDevice同一个 VkPhysicalDevice可以有多个，这是有道理的。我们可以同时使用 GPU 来做很多事情，比如解码视频和渲染 3D 场景。我想这就是它的用途。

我们需要 aVkSurfaceKHR来显示东西，因为 Vulkan 与设备无关，所以我们需要向它传递一个窗口是有意义的。

现在来了 SwapChain 的概念。我无法将它与队列（来自 QueueFamily）区分开来。Queue 不是用于从 GPU 发送和接收图像的结构吗？为什么不简单地使用队列来呈现图像VkSurfaceKHR？

还有帧缓冲区的概念。对我来说，帧缓冲区是显示在屏幕上的渲染图像，因此它是SwapChain.

我有两个相当大的数组，长度分别为 N 和 M 元素。对于 N 个元素中的每一个，我需要对 M 个元素中的每一个进行计算，然后减少这些结果以获得长度为 N 的另一个数组。这听起来像是非常适合 GPU 加速的问题类型，而且我因此想使用 Numba CUDA 来实现它，但我正在努力找出如何处理这个问题的减少部分。关于归约的 Numba 文档https://numba.pydata.org/numba-doc/dev/cuda/reduction.html仅显示如何将所有内容归约为一个数字，但我本质上需要归约为一个数组。下面是一个超级简化的示例，基本上说明了我想要实现的目标

from numba import cuda
import numpy as np

@cuda.jit
def processArr(A, B):
    i = cuda.grid(1)
    if i < A.size:
        A[i] = A[i] * B

@cuda.jit
def reduceArr(A, B, C):
    i = cuda.grid(1)
    if i < A.size:
        total = 1
        processArr(A[i], B[i])

        for j in range(A.shape[1]):
            total *= A[i, j]

        C[i] = total

a = np.array([[0, 0], [1, 1], [1, 2]]) …

Spacy 'train' 命令使用命令行选项 --gpu 0，允许在使用 GPU 训练和不使用 GPU 训练（仅使用 CPU）之间进行“最后一刻”选择。

但是，使用https://spacy.io/usage/training#quickstart在 GPU 和 CPU 之间进行选择会导致（基本）配置存在重大差异。就我而言（处理 NER），我有两个不同的管道：

• 对于 CPU： pipeline = [" tok2vec ","ner"]
• 对于 GPU：管道 = [“变压器”，“ner”]

（具有非常不同的以下组件设置）。

由于我的 GPU 只有 6GB 内存，所以我很快就用完了 GPU 内存 - 无法使用它。但是当我切换到仅使用 CPU 时，两个管道之间的训练行为有很大不同：

[“tok2vec”，“ner”] 管道几乎在单核上运行，在几个小时内训练我的模型（8,000 个训练，2000 个开发/验证文档）。明显比 Spacy 2 快（即使使用 GPU），尽管有时会使用大量内存（高达 30G）。

["transformer","ner"] 管道爆炸性地使用多达 20 个核心（在 40 个逻辑核心的机器上），因此我希望它能够快速运行。但它似乎会永远运行。在一个小时内，我只完成了第一个“纪元”，然后（在下一个纪元）它崩溃了（见下文）。由于我的数据（每个批处理 100 个“文档”的 DocBin 文件）是相同的，因此下面的崩溃（无序 B/I 标记）很难解释。

我的主要问题是为什么针对 GPU 和 CPU 时的管道不同？如果以 GPU 为目标，向量在哪里？

碰撞： ...

 File "C:\Work\ML\Spacy3\lib\site-packages\spacy\training\loop.py", line 98, in …