Question

我尝试在cuda中实现高效的rc4密码算法。我使用共享内存来存储内部置换状态，在经线中使用并行线程访问来处理存储区内存布局到时间损失。我还试图最小化访问次数，利用“i”索引的读/写访问是连续的，并且可以用32位字打包。最后，我利用常量内存来初始化置换状态。

尽管有这些“聪明”的技巧，我可以期望只获得最佳报告实施的大约50％的吞吐量（例如参见guapdf cracker），甚至考虑到主机和gpu之间的无阻塞通信可以部分用于涵盖计算。我无法理解为什么，我正在寻找新的改进想法或对我可能做出的错误假设的评论。

这是我的KSA（密钥设置）内核的玩具实现，密钥减少到4个字节。

__constant__ unsigned int c_init[256*32/4];

__global__ void rc4Block(unsigned int *d_out, unsigned int *d_in)
{
__shared__ unsigned int s_data[256*32/4];

int inOffset  = blockDim.x * blockIdx.x;
int in  = inOffset + threadIdx.x;
unsigned int key, u;

// initialization 
key = d_in[in];

for(int i=0; i<(256/4); i++) {  // read from constant memory
  s_data[i*32+threadIdx.x] = c_init[i*32+threadIdx.x];
}
// key mixing
unsigned char j = 0;
unsigned char k0 = key & 0xFF;
unsigned char k1 = (key >> 8) & 0xFF;
unsigned char k2 = (key >> 8) & 0xFF;
unsigned char k3 = (key >> 8) & 0xFF;

for(int i=0; i<256; i+=4) { // unrolled

  unsigned int u, sj, v;
  unsigned int si = s_data[(i/4)*32+threadIdx.x];
  unsigned int shiftj;

  u = si & 0xff;
  j = (j + k0 + u) & 0xFF;
  sj = s_data[(j/4)*32+threadIdx.x];
  shiftj = 8*(j%4);
  v = (sj >> shiftj) & 0xff;
  si = (si & 0xffffff00) | v;
  sj = (sj & ~(0xFFu << (8*(j%4)))) | (u << shiftj);
  s_data[(j/4)*32+threadIdx.x] = sj;

  u = (si >> 8) & 0xff;
  j = (j + k1 + u) & 0xFF;
  sj = s_data[(j/4)*32+threadIdx.x];
  shiftj = 8*(j%4);
  v = (sj >> shiftj) & 0xff;
  si = (si & 0xffff00ff) | (v<<8);
  sj = (sj & ~(0xFFu << (8*(j%4)))) | (u << shiftj);
  s_data[(j/4)*32+threadIdx.x] = sj;

  u = (si >> 16) & 0xff;
  j = (j + k2 +u) & 0xFF;
  sj = s_data[(j/4)*32+threadIdx.x];
  shiftj = 8*(j%4);
  v = (sj >> shiftj) & 0xff;
  si = (si & 0xff00ffff) | (v<<16);
  sj = (sj & ~(0xFFu << (8*(j%4)))) | (u << shiftj);
  s_data[(j/4)*32+threadIdx.x] = sj;

  u = (si >> 24) & 0xff;
  j = (j + k3 + u) & 0xFF;
  sj = s_data[(j/4)*32+threadIdx.x];
  shiftj = 8*(j%4);
  v = (sj >> shiftj) & 0xff;
  si = (si & 0xffffff) | (v<<24);
  sj = (sj & ~(0xFFu << (8*(j%4)))) | (u << shiftj);
  s_data[(j/4)*32+threadIdx.x] = sj;

  s_data[(i/4)*32+threadIdx.x] = si;
}
d_out[in] = s_data[threadIdx.x]; // unrelevant debug output 
}

Answer 1

似乎代码至少部分涉及重新排序字节。如果您使用的是Fermi级GPU，您可以考虑使用__byte_perm（）内在函数，该内在函数映射到Fermi级设备上的硬件指令，并允许更高效地重新排序字节。

我假设当你与其他实现相比时它是苹果对苹果，即在相同类型的GPU上。此代码看起来完全是计算绑定的，因此吞吐量在很大程度上取决于GPU的整数指令吞吐量，并且性能范围很广。

用cuda优化rc4

1 个答案: