Generate Index с использованием CUDA-C

Я пытаюсь создать набор индексов ниже:Generate Index с использованием CUDA-C

У меня есть блок Cuda, который состоит из 20 блоков (blockIdx: от 0 -19) с каждым блоком, разделенном на 4-х блоков (суб блок Idx: 0,1,2 и 3).

Я пытаюсь создать индекс шаблон, как это:

threadIdx (TID), SubBlockIdxA (SA), SubBlockIdxB (SB), BlockIdxA (BA), BlockIdxB (BB)

  Required       Obtained   
    tid SBA SBB BA BB SBA SBB BA BB 
    0 0 1 0 0  0 1 0 0 
    1 1 0 0 1  1 0 0 1 
    2 0 1 1 1  0 1 1 1 
    3 1 0 1 2  1 0 1 2 
    4 0 1 2 2  0 1 2 2 
    5 1 0 2 3  1 0 2 3 
    6 0 1 3 3  0 1 3 3 
    7 1 0 3 4  1 0 3 4 
    8 2 3 0 0  2 3 0 0 
    9 3 2 0 1  3 2 0 1 
    10 2 3 1 1  2 3 1 1 
    11 3 2 1 2  3 2 1 2 
    12 2 3 2 2  2 3 2 2 
    13 3 2 2 3  3 2 2 3 
    14 2 3 3 3  2 3 3 3 
    15 3 2 3 4  3 2 3 4 
    16 0 1 5 5  0 1 5 5 
    17 1 0 5 6  1 0 5 6 
    18 0 1 6 6  0 1 6 6 
    19 1 0 6 7  1 0 6 7 
    20 0 1 7 7  0 1 7 7 
    21 1 0 7 8  1 0 7 8 
    22 0 1 8 8  0 1 8 8 
    23 1 0 8 9  1 0 8 9 
    24 0 1 10 10  2 3 5 5 
    25 1 0 10 11  3 2 5 6 
    26 0 1 11 11  2 3 6 6 
    27 1 0 11 12  3 2 6 7 
    28 0 1 12 12  2 3 7 7 
    29 1 0 12 13  3 2 7 8 
    30 0 1 13 13  2 3 8 8 
    31 1 0 13 14  3 2 8 9 
    32 2 3 10 10  0 1 10 10 
    33 3 2 10 11  1 0 10 11 
    34 2 3 11 11  0 1 11 11 
    35 3 2 11 12  1 0 11 12 
    36 2 3 12 12  0 1 12 12 
    37 3 2 12 13  1 0 12 13 
    38 2 3 13 13  0 1 13 13 
    39 3 2 13 14  1 0 13 14 
    40 0 1 15 15  2 3 10 10 
    41 1 0 15 16  3 2 10 11 
    42 0 1 16 16  2 3 11 11 
    43 1 0 16 17  3 2 11 12 
    44 0 1 17 17  2 3 12 12 
    45 1 0 17 18  3 2 12 13 
    46 0 1 18 18  2 3 13 13 
    47 1 0 18 19  3 2 13 14

Пожалуйста см. мой код ниже:

static __device__ void function() 
    { 
     uint16 uBlockIdxA, uBlockIdxB, uSubBlockIdxA, usubBlockIdxB; 
     if threadIdx.x < 48) 
     { 
      uint16 uY = threadIdx.x/8; 
      uint16 uX = threadIdx.x - (uY * 8);  
      uSubBlockIdxA = ((uY & 0x01) << 1) + (uX & 0x01); 
      uSubBlockIdxB = ((uY & 0x01) << 1) + ((uX + 1) & 0x01); 
      uBlockIdxB = (uY >> 1) * 5 + ((1 + uX) >> 1); 
      uBlockIdxA = (uY >> 1) * 5 + ((0 + uX) >> 1);  
      func (uBlockIdxA, uBlockIdxB, uSubBlockIdxA, uSubBlockIdxB); 
     } 
    }

Я пытаюсь представить логику для достижения того, что я ищу. Я не прав, но не уверен, чего не хватает.

Логика о том, как сгенерировать это, будет полезна. Код приветствуется. Пожалуйста помоги.

Заранее спасибо.

источник

2013-06-27 searocks

Если вы уже знаете значения ваших 4-субиндексов для каждого возможного значения индекса потока, которое будет считывать ядро, для чего вам нужен алгоритм для их вычисления? Не могли бы вы просто положить их в таблицу поиска и прочитать их прямо? , Похоже, что один 'char4' на поток будет всем, что требуется – talonmies

Это нужно сделать так, так как то, что у меня выше, представляет собой только один блок cuda. Я имею дело со многими такими блоками cuda, где изменяется блок idx, и таблица поиска будет огромной. Следовательно, поиск табличного подхода не будет хорошей идеей и, следовательно, захочет сделать это с использованием алгоритмического подхода. – searocks

Но код, который вы показали, может подсчитывать только эти 48 индексов, независимо от того, сколько блоков или потоков вы используете. – talonmies

код для генерации индексов ниже:

Разделить нити в два раза с индексами от первой половины могут быть использованы во второй половине со смещением 10 и мелких изменений.

static __device__ void function() 
{ 
    uint16 uBlockIdxA, uBlockIdxB, uSubBlockIdxA, usubBlockIdxB; 

    if(threadIdx.x < 48) 
    { 
     uint16 uY = threadIdx.x/8; 
     uint16 uX = threadIdx.x - (uY * 8); 

     if (threadIdx.x < 24) 
     { 

      uSubBlockIdxA = ((uY & 0x01) << 1) + (uX & 0x01); 
      uSubBlockIdxB = ((uY & 0x01) << 1) + ((uX + 1) & 0x01); 
      uBlockIdxB = (uY >> 1) * 5 + ((1 + uX) >> 1); 
      uBlockIdxA = (uY >> 1) * 5 + ((0 + uX) >> 1);  

     } 
     else if 
     { 
      uSubBlockIdxA = (((uY - 3) & 0x01) << 1) + (uX & 0x01); 
      uSubBlockIdxB = (((uY - 3) & 0x01) << 1) + ((uX + 1) & 0x01); 
      uBlockIdxB = ((uY - 3) >> 1) * 5 + ((1 + uX) >> 1) + 10; 
      uBlockIdxA = ((uY - 3) >> 1) * 5 + ((0 + uX) >> 1) + 10; 
     } 
    } 
    func (uBlockIdxA, uBlockIdxB, uSubBlockIdxA, uSubBlockIdxB);   
}

источник

2013-06-29 22:21:51 searocks

Generate Index с использованием CUDA-C

ответ

Смежные вопросы