1

我编写了一个小测试函数,它的行为与我想要的不同。

基本上,它应该读取一个数组并写回它的内容(稍后,当它工作时,它应该做更多,但现在即使这样也失败了)。

调试到 GPU 代码,我看到前几次迭代(不知何故并行执行.. 这可能对 GPU 有意义,但当我调试时让我感到惊讶)工作正常.. 但是,在 1-2 次调试后继续(F5),一些以前正确设置的值被 0 覆盖。我真的不明白..当我再次上CPU时,许多值都是0,即使它们不应该是0(基本上,它们应该有原始数据,这是一个简单的测试序列)。

#include "stdafx.h"
#include <amp.h>

typedef unsigned char byte;

using namespace concurrency;

void AMPChangeBrightnessContrastWrapper2(byte* a, int len, float brightness, float contrast)
    {
        array_view<unsigned int> dst(len/4, (unsigned int*)a);
        //dst.discard_data(); 
        parallel_for_each(dst.extent, [=](index<1> idx) restrict(amp) 
        {
            // split into bytes (in floats)
            float temp1 = (dst[idx])  - (dst[idx] >> 8) * 256;
            // this completely fails! float temp1 = dst[idx] & 0xFF;
            float temp2 = (dst[idx] >> 8)  - (dst[idx] >> 16) * 256;
            float temp3 = (dst[idx] >> 16) - (dst[idx] >> 24) * 256;
            float temp4 = (dst[idx] >> 24);
            // convert back to int-array
            dst[idx] = (int)(temp1 + temp2 * 256 + temp3 * 65536 + temp4 * 16777216);

        });
        //dst.synchronize();
    }

int _tmain(int argc, _TCHAR* argv[])
{
    const int size = 30000;
    byte* a = new byte[size];

      // generate some unique test sequence.. first 99 numbers are just 0..98
    for (int i = 0; i < size; ++i)
        a[i] = (byte)((i + i / 99) % 256);

    AMPChangeBrightnessContrastWrapper2(a, size, -10.0f, 1.1f);

    for (int i = 0; i < 50; ++i)
        printf("%i, ", a[i]);
    char out[20];
    scanf_s("%s", out);
    return 0;
}

如此简单(计划)的步骤:

  • 初始化数组
  • 将数组传递给 GPU(作为无符号整数数组)
  • 将每个 unsigned int 拆分为 4 个字节并将它们存储在浮点数中
  • (做一些计算,为简单起见这里省略)
  • 将 bytes-stored-in-floats 再次连接到原始位置
  • (重复)

如果您想知道..那应该是颜色值..

结果是:

  • 一些值符合预期,但大多数值不同
  • 似乎特别是字节0(每个无符号整数)会有一个坏值
  • 我首先尝试使用 & 0xFF 转换 unsigned int->byte->float 但这似乎完全失败了

输出是(但应该只是从 0 开始递增的数字):

0, 1, 2, 3, 0, 5, 6, 7, 0, 9, 10, 11, 16, 13, 14, 15, 0, 17, 18, 19, 32, 21, 22, 23, 32, 25, 26, 27, 32, 29, 30, 31, 0, 33, 34, 35, 64, 37, 38, 39, 64, 41, 42, 43, 64, 45, 46, 47, 64, 49,

问题:

  • 为什么& 0xFF有问题?
  • 为什么每个 unsigned int 的字节 0 都分配了一个奇怪的值?
  • 我想我不能创建一个字节数组视图,我必须使用整数或浮点数?
  • 注释掉 .synchronize 最终并没有改变任何东西 - 怎么会?
4

2 回答 2

4

•我想我不能创建一个字节数组视图,我必须使用整数或浮点数?

您不能创建字节数组或数组视图。C++ AMP 仅支持有限的 C++ 类型子集。您可以使用纹理而不是数组视图。对于图像处理,这有几个优点,尤其是打包和解包速度更快,因为它是由 GPU 的硬件实现的。请参阅下面的完整示例。

• 注释掉 .synchronize 最终没有改变任何东西 - 怎么回事?

您不需要,dst.synchronize()因为dst array_view超出范围会导致数据隐式同步回 CPU 内存。顺便说一句,你不应该dst.discard_data()在函数开始时调用,因为如果你这样做意味着数据a不会被复制到 GPU。

这是一个使用纹理<>的实现。注意事项:

  • 使用 unit_4 纹理可以让您“免费”打包和解包数据。
  • 使用clamp() 比if 子句更好,首先它使用硬件优化的内在函数。一般来说,内核中的分支是不好的,因为它会使所有线程停滞在一个扭曲中,即使它们将条件评估为假。
  • 您需要两个纹理,因为与数组不同,它们不支持锯齿。
  • 我已经删除了一些临时变量。变量使用寄存器空间,这在 GPU 上非常有限。您应该尽量减少对它的使用,以确保您的所有线程都可以在不等待寄存器空间可用的情况下执行。
  • 使用 static_cast<> 进行显式转换意味着更少的编译器警告,并且通常被认为是良好的(现代)C++ 风格。

而且代码...

void AMPChangeBrightnessContrastWrapper3(const byte* a, const int len, 
    const float brightness, const float contrast)
{
    const int pixel_len = len / 4;
    graphics::texture<graphics::uint_4, 1> inputTx(pixel_len, a, len, 8u);
    graphics::texture<graphics::uint_4, 1> outputTx(pixel_len, 8u);
    graphics::writeonly_texture_view<graphics::uint_4, 1> outputTxVw(outputTx);

    parallel_for_each( outputTxVw.extent, [=, &inputTx, &outputTx](index<1> idx) 
        restrict(amp) 
    { 
        const graphics::uint_4 v = inputTx[idx];

        float tmp = static_cast<float>(v.r);
        tmp = (tmp - 128) * contrast + brightness + 128;
        tmp = direct3d::clamp(tmp, 0.0f, 255.0f);
        const unsigned int temp1_ = static_cast<unsigned int>(tmp);

        tmp = static_cast<float>(v.g);
        tmp = (tmp - 128) * contrast + brightness + 128;
        tmp = direct3d::clamp(tmp, 0.0f, 255.0f);
        const unsigned int temp2_ = static_cast<unsigned int>(tmp);

        tmp = static_cast<float>(v.b);
        tmp = (tmp - 128) * contrast + brightness + 128;
        tmp = direct3d::clamp(tmp, 0.0f, 255.0f);
        const unsigned int temp3_ = static_cast<unsigned int>(tmp);

        tmp = static_cast<float>(v.a);
        tmp = (tmp - 128) * contrast + brightness + 128;
        tmp = direct3d::clamp(tmp, 0.0f, 255.0f);
        const unsigned int temp4_ = static_cast<unsigned int>(tmp);        

        outputTxVw.set(idx, graphics::uint_4(temp1_, temp2_, temp3_, temp4_));
    });
    copy(outputTx, (void*)a, len);
}

您可以在AMP Book中找到更多 C++ AMP 示例

于 2013-09-04T16:36:27.803 回答
0

嗯..所以,在经过更多的反复试验和错误之后回答我自己的问题:

  • & 0xFF 工作正常,>> 和 <<
  • 那是我没有生成正确值的问题,特别是,我没有考虑浮点的(非常有限的)精度,它远低于 int 的精度(嗯,尾数)
  • 还不知道
  • 仍然不知道,但它的工作原理相同(结果/速度)有和没有 .synchronize

如果您偶然发现类似的东西或需要它,这里是解决方案(如最初预期的那样),改变亮度值数组中的亮度和对比度:

void AMPChangeBrightnessContrastWrapper
    (byte* a, int len, float brightness, float contrast)
{
    array_view<unsigned int> dst(len/4, (unsigned int*)a);
    parallel_for_each(dst.extent, [=](index<1> idx) restrict(amp) 
    {
        float temp1 = dst[idx] & 0xFF;
        temp1 = (temp1 - 128) * contrast + brightness + 128;
        if (temp1 < 0)
            temp1 = 0;
        if (temp1 > 255)
            temp1 = 255;

        float temp2 = (dst[idx] >> 8) & 0xFF;
        temp2 = (temp2 - 128) * contrast + brightness + 128;
        if (temp2 < 0)
            temp2 = 0;
        if (temp2 > 255)
            temp2 = 255;

        float temp3 = (dst[idx] >> 16) & 0xFF;
        temp3 = (temp3 - 128) * contrast + brightness + 128;
        if (temp3 < 0)
            temp3 = 0;
        if (temp3 > 255)
            temp3 = 255;

        float temp4 = (dst[idx] >> 24);
        temp4 = (temp4 - 128) * contrast + brightness + 128;
        if (temp4 < 0)
            temp4 = 0;
        if (temp4 > 255)
            temp4 = 255;

        unsigned int temp1_ = (unsigned int)temp1;
        unsigned int temp2_ = (unsigned int)temp2;
        unsigned int temp3_ = (unsigned int)temp3;
        unsigned int temp4_ = (unsigned int)temp4;
        unsigned int res = temp1_ + (temp2_ << 8) + (temp3_ << 16) + (temp4_ << 24);
        dst[idx] = res;
    });
    dst.synchronize();
}

此外,即使我(我认为我)做的计算很少,它的运行速度(发布/调试)比使用 Intel HD 4000 的 CPU 快 2-4 倍。

于 2013-07-05T19:15:06.327 回答