标签: reduction

我正在写一个CUDA内核,它涉及计算给定矩阵的最大值,我正在评估可能性.我能找到的最好方法是:

强制每个线程在共享内存中存储一​​个值,然后使用减少算法来确定最大值(pro:最小差异缺点:共享内存在2.0设备上限制为48Kb)

我无法使用原子操作,因为它有读取和写入操作,因此线程无法通过同步线程同步.

还有其他想法进入你的脑海吗？

嗨,我是Haskell的新手,主要是从LYAH和Hutton读书.最近我遇到了这个状态monad的Functor实例的片段,表示为:

instance Functor (State st) where
    fmap f m = State $ \st -> let (a, s) = runState m st in (f a, s)

这可以简化为:

instance Functor (State st) where 
    fmap f m = State $ (\(a,s) -> (f a,s)) . runState m

谁能解释这种减少背后的工作流程？

关于如何学习这种减少技术,还有哪些好的资源/建议？

我有一个像这样的绘图仪:

我必须实现的任务是将24位BMP转换为该绘图仪的指令集.在绘图仪中,我可以改变16种常见颜色.我面临的第一个复杂性是颜色减少.我面临的第二个复杂性是如何将像素转换为一组绘图指令.

作为使用油漆的绘图工具刷将被使用.这意味着绘图仪绘制线不会那么小,而且它们会相对较短.

请提出可用于解决此图像数据转换问题的算法？

一些初步结果:

我是 CUDA 的新手并试图掌握基本知识，所以如果我问或说的东西听起来过于简单，我深表歉意。我用 C 编写了一些串行代码，用于生成一个带有随机数的数组，然后在该数组中找到最大值。

    #include <stdio.h>
    #include <stdlib.h> /* srand, rand */
    #include <time.h> /* time */

    #define num 100000

    int *arr,max = -1;

    int getRand() {
        double r1=rand()/(double)RAND_MAX; // Generates value between 0 & 1
        return (r1 * num) + 1;
    }
    void generateRandom(int M) {
        int i;
        for(i=0;i<M;i++) {
            arr[i] = getRand();
        }
    }
    void getMax(int M) {
        int i;
        for(i=0;i<M;i++) {
            if(arr[i] > max)
                max = arr[i];
            }
    }

    int main(int argc, char *argv[] ){
        if …

我正在努力做到在Nvidia Reduction上看到的所有优化.我已经实现了前四个部分,但我在第22个幻灯片中遇到了第5部分.

我无法理解为什么提供的代码可以在没有任何syncthreads()的情况下工作的原因.线程可以访问输出中的相同内存位置.

此外,幻灯片表明,如果变量未设置为volatile,则代码将不起作用.在这方面如何变得不稳定？如果我不想调用内核,那么编程它的最佳方法是什么？

我也把这些代码放在这里供参考.

__device__ void warpReduce(volatile int* sdata, int tid) {
sdata[tid] += sdata[tid + 32];
sdata[tid] += sdata[tid + 16];
sdata[tid] += sdata[tid + 8];
sdata[tid] += sdata[tid + 4];
sdata[tid] += sdata[tid + 2];
sdata[tid] += sdata[tid + 1];
}

for (unsigned int s=blockDim.x/2; s>32; s>>=1) {
if (tid < s)
sdata[tid] += sdata[tid + s];
__syncthreads();
}

if (tid < 32) warpReduce(sdata, tid);

在此先感谢您的帮助.如果需要更多信息,请评论.

我有一个关于咖啡减少层的问题。我还没有找到任何关于如何在我的 .prototxt 文件中使用该层的示例。因此，如果有人能给我一个如何使用该层的简短示例，我将不胜感激。

这是文档：http://caffe.berkeleyvision.org/doxygen/classcaffe_1_1ReductionLayer.html，但没有给出示例：-/

我想使用这一层将 1x18x18 的输出矩阵减少到一个标量值。所以我想要这个矩阵的绝对和。

我想计算 CUDA 中数组所有元素的总和。我想出了这个代码。它编译没有任何错误。但结果始终为零。我从cudaMemcpyFromSymbol. 我不能使用任何库，如 Thrust 或 Cublas。

#define TRIALS_PER_THREAD 4096
#define NUM_BLOCKS 256
#define NUM_THREADS 256
double *dev;
__device__ volatile double pi_gpu = 0;

__global__ void ArraySum(double *array)

{
unsigned int tid = threadIdx.x + blockDim.x * blockIdx.x;
pi_gpu = pi_gpu + array[tid];
__syncthreads();
}

int main (int argc, char *argv[]) {
cudaMalloc((void **) &dev, NUM_BLOCKS * NUM_THREADS * sizeof(double));
    double pi_gpu_h;

ArraySum<<<NUM_BLOCKS, NUM_THREADS>>>(dev);
cudaDeviceSynchronize();
cudaError err = cudaMemcpyFromSymbol(&pi_gpu_h, &pi_gpu, sizeof(double), cudaMemcpyDeviceToHost);
if( cudaSuccess != err )
{ …

我正在编写一个使用 CUDA C++ API 实现的向量缩减算法的教程，我很挣扎，因为我真的不明白我做错了什么，因为结果是 (device: 4386.000000 host: 260795.000000)

我使用的代码如下（问题大小固定为 512）。

编辑：不幸的是问题尚未解决，我仍然得到相同的结果。我已经更新了代码，提供了完整的代码。目标是相同的，即对包含 512 个元素的浮点数组的所有元素求和。

    #define NUM_ELEMENTS 512
__global__ void reduction(float *g_data, int n)
{
        __shared__ float s_data[NUM_ELEMENTS];
      int tid = threadIdx.x;
      int index = tid + blockIdx.x*blockDim.x;
      s_data[tid] = 0.0;
      if (index < n){
        s_data[tid] = g_data[index];
      }
      __syncthreads();

      for (int s = 2; s <= blockDim.x; s = s * 2){
        if ((tid%s) == 0){
          s_data[tid] += s_data[tid + s / 2];
        }
        __syncthreads();
      }

      if (tid == 0){ …

此代码适用于 3*3 矩阵。我需要它适用于 ant m*n 矩阵。

import numpy as np
b=np.arange(1,10).reshape(3,3)

这会检查矩阵的形状，但仅适用于 3*3 矩阵

if b.shape[0]==b.shape[1]:
    for i in range(b.shape[0]): 
        for j in range(b.shape[1]):
            if i==1:
                b[i]=b[i-i][j]*b[i]-[b[i][j]*b[i-i]]
                i=i+1
                b[i]=b[i-i][j]*b[i]-[b[i][j]*b[i-i]]
                j=j+1
                b[i]=b[i]-[b[i-1]*(b[i][j]/b[i-1][j])]
print(b)

我正在寻找合适的基于流的归约操作来查找双列表的最大差异。（请不要使用旧式嵌套 for 循环的解决方案......）

假设我的双重列表是
List<Double> list = List.of(1.1, 0.3, 7.8, 1.0, 9.1, 2.3);
最大差异将导致的值
9.1 - 0.3 = 8.8

我使用 java-streams 的第一个工作方法是：

List<Double> list = List.of(1.1, 0.3, 7.8, 1.0, 9.1, 2.3);
double maxDiff = list.stream().max(Double::compareTo).get()
    - list.stream().min(Double::compareTo).get();

如何实现自定义累加器和组合器来进行归约操作Stream.reduce()以实现相同的效果？