OpenCL SHA-256 GPU cannot compute more than 7670 hashes - c++

Question

I am trying to rearrange this algorithm for SHA-256 I found online for use on multiple threads, so that I can compute many hashes really fast. It is basically just to show the difference between CPU and GPU work time. So far it works relatively fine, I just ran into a problem, that I cannot compute more than around 7670 hashes somehow. If I go bigger than that I will get a segfault.
My question is if someone maybe knows a fix to that problem.
Do I need a bigger buffer or do I have to set the globalworksize static? If so, how may I be able to manage that.
I am completely new to OpenCL and this is my first try on it. It does not have to be perfect, my goal is only to show that I can complete repetitive tasks faster on a GPU than on a CPU.
Thanks for your time and help!
Best regards.
My main:
#include <iostream>
#include "sha256.h"
#include <string>
#include <chrono>
#include <random>
#define STRING_LENGTH 8
using std::cout;
using std::cin;
using std::endl;
int TOTAL_HASHES;
std::string generate(int max_length) {
using namespace std;
string possible_characters = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
random_device rd;
mt19937 engine(rd());
uniform_int_distribution<> dist(0, possible_characters.size() - 1);
string ret = "";
for (int i = 0; i < max_length; i++) {
int random_index = dist(engine); //get index between 0 and possible_characters.size()-1
ret += possible_characters[random_index];
}
return ret;
}
void crypt(char* input)
{
char result[sizeof(cl_uint)*65*TOTAL_HASHES];
sha256_crypt(input, result, TOTAL_HASHES);
}
int main()
{
cout << "Wieviele Hashes?"; cin >> TOTAL_HASHES;
std::string str1;
char* cstr = new char[TOTAL_HASHES * (STRING_LENGTH + 1)];
for (int i = 0; i < TOTAL_HASHES; i++)
{
str1 = generate(STRING_LENGTH);
strcpy((cstr+i * STRING_LENGTH), str1.c_str());
}
std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
crypt((char*)cstr);
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
std::cout << "Time elapsed = " << std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() << "[micros]" << std::endl;
std::cout << "Time elapsed = " << std::chrono::duration_cast<std::chrono::milliseconds>(end - begin).count() << "[ms]" << std::endl;
std::cout << "Time elapsed = " << std::chrono::duration_cast<std::chrono::seconds>(end - begin).count() << "[s]" << std::endl;
cout << "----------------------------------------------------------------------" << endl;
cout << endl;
}
My sha256.c
#include "sha256.h"
#include <time.h>
static cl_platform_id platform_id = NULL;
static cl_device_id device_id = NULL;
static cl_uint ret_num_devices;
static cl_uint ret_num_platforms;
static cl_context context;
static cl_int ret;
static char* source_str;
static size_t source_size;
static cl_program program;
static cl_kernel kernel;
static cl_command_queue command_queue;
static cl_mem pinned_saved_keys, pinned_partial_hashes, buffer_out, buffer_keys, data_info;
static cl_uint* partial_hashes;
static cl_uint* res_hashes;
static char* saved_plain;
static unsigned int datai[3];
static int have_full_hashes;
static size_t kpc = 4;
static size_t global_work_size = 1;
static size_t local_work_size = 1;
static size_t string_len;
void load_source();
void createDevice();
void createkernel();
void create_clobj();
void print_hashes();
void crypt_all();
void MeasureIt();
void sha256_init(size_t user_kpc)
{
kpc = user_kpc;
load_source();
createDevice();
createkernel();
create_clobj();
}
size_t total_hashes;
void print_hashes(char* input) {
int offset = -1 * datai[2]; // -8
for (int j = 0; j < total_hashes; j++)
{
offset += datai[2];
/*printf("%x\n", partial_hashes[0]);
printf("%x\n", partial_hashes[1]);*/
//printf("offset: %i\n", offset);
printf("input: ");
for (int k = 0; k < SHA256_RESULT_SIZE; k++)
{
printf("%c", input[k + offset]);
}
printf("\noutput: ");
for (int i = 0; i < SHA256_RESULT_SIZE; i++)
{
printf("%08X", partial_hashes[i + offset]);
}
printf("\n");
}
}
void sha256_crypt(char* input, char* output, int total)
{
string_len = strlen(input);
total_hashes = total;
global_work_size = total;
datai[0] = SHA256_PLAINTEXT_LENGTH; //64
datai[1] = total_hashes;
datai[2] = string_len/total_hashes;
sha256_init(2048);
memcpy(saved_plain, input, string_len + 1);
crypt_all();
//print_hashes(input);
}
void crypt_all()
{
//printf("%s\n",saved_plain);
ret = clEnqueueWriteBuffer(command_queue, data_info, CL_TRUE, 0, sizeof(unsigned int) * 3, datai, 0, NULL, NULL);
ret = clEnqueueWriteBuffer(command_queue, buffer_keys, CL_TRUE, 0, sizeof(char) * string_len, saved_plain, 0, NULL, NULL);
// printf("%s\n",buffer_keys);
//zeit messen und Kernel starten
clock_t start = clock();
ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL);
clock_t end = clock();
float seconds = (float)(end - start) / CLOCKS_PER_SEC;
float milliseconds = seconds / 1000;
float microseconds = milliseconds / 1000/1000/1000/1000;
printf("Zeit in s: %f\n", seconds);
printf("Zeit in micros: %f\n", microseconds);
ret = clFinish(command_queue);
// read back partial hashes
ret = clEnqueueReadBuffer(command_queue, buffer_out, CL_TRUE, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE* total_hashes, partial_hashes, 0, NULL, NULL);
have_full_hashes = 0;
}
void load_source()
{
FILE* fp;
fp = fopen("sha256.cl", "r");
if (!fp) {
fprintf(stderr, "Failed to load kernel.\n");
exit(1);
}
source_str = (char*)malloc(MAX_SOURCE_SIZE);
source_size = fread(source_str, 1, MAX_SOURCE_SIZE, fp);
fclose(fp);
}
void create_clobj() {
pinned_saved_keys = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, (SHA256_PLAINTEXT_LENGTH)*kpc, NULL, &ret);
saved_plain = (char*)clEnqueueMapBuffer(command_queue, pinned_saved_keys, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, (SHA256_PLAINTEXT_LENGTH)*kpc, 0, NULL, NULL, &ret);
memset(saved_plain, 0, SHA256_PLAINTEXT_LENGTH * kpc);
res_hashes = (cl_uint*)malloc(sizeof(cl_uint) * SHA256_RESULT_SIZE);
memset(res_hashes, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE);
pinned_partial_hashes = clCreateBuffer(context, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR, sizeof(cl_uint) * SHA256_RESULT_SIZE* total_hashes, NULL, &ret);
partial_hashes = (cl_uint*)clEnqueueMapBuffer(command_queue, pinned_partial_hashes, CL_TRUE, CL_MAP_READ, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE* total_hashes, 0, NULL, NULL, &ret);
memset(partial_hashes, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE* total_hashes);
buffer_keys = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(char) * string_len, NULL, &ret);
buffer_out = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_uint) * SHA256_RESULT_SIZE* total_hashes, NULL, &ret);
data_info = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(unsigned int) * 3, NULL, &ret);
clSetKernelArg(kernel, 0, sizeof(data_info), (void*)&data_info);
clSetKernelArg(kernel, 1, sizeof(buffer_keys), (void*)&buffer_keys);
clSetKernelArg(kernel, 2, sizeof(buffer_out), (void*)&buffer_out);
}
void createDevice()
{
ret = clGetPlatformIDs(1, &platform_id, &ret_num_platforms);
ret = clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_ALL, 1, &device_id, &ret_num_devices);
context = clCreateContext(NULL, 1, &device_id, NULL, NULL, &ret);
}
void createkernel()
{
program = clCreateProgramWithSource(context, 1, (const char**)&source_str, (const size_t*)&source_size, &ret);
ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
kernel = clCreateKernel(program, "sha256_crypt_kernel", &ret);
command_queue = clCreateCommandQueueWithProperties(context, device_id, 0, &ret);
}
And finally my sha256.cl
#ifndef uint32_t
#define uint32_t unsigned int
#endif
#define H0 0x6a09e667
#define H1 0xbb67ae85
#define H2 0x3c6ef372
#define H3 0xa54ff53a
#define H4 0x510e527f
#define H5 0x9b05688c
#define H6 0x1f83d9ab
#define H7 0x5be0cd19
uint rotr(uint x, int n) {
if (n < 32) return (x >> n) | (x << (32 - n));
return x;
}
uint ch(uint x, uint y, uint z) {
return (x & y) ^ (~x & z);
}
uint maj(uint x, uint y, uint z) {
return (x & y) ^ (x & z) ^ (y & z);
}
uint sigma0(uint x) {
return rotr(x, 2) ^ rotr(x, 13) ^ rotr(x, 22);
}
uint sigma1(uint x) {
return rotr(x, 6) ^ rotr(x, 11) ^ rotr(x, 25);
}
uint gamma0(uint x) {
return rotr(x, 7) ^ rotr(x, 18) ^ (x >> 3);
}
uint gamma1(uint x) {
return rotr(x, 17) ^ rotr(x, 19) ^ (x >> 10);
}
__kernel void sha256_crypt_kernel(__global uint *data_info,__global char *plain_key, __global uint *digest){
int workUnit = (int)get_global_id(0);
// printf("workUnit: %i\n", workUnit);
// printf("plain_key %s\n", plain_key);
char real_key[8+1];
int offset = 8*workUnit;
for (int i = 0; i < data_info[2]; i++){
real_key[i] = plain_key[i+offset];
}
// printf("real key: %s \n", real_key);
int t, gid, msg_pad;
int stop, mmod;
uint i, ulen, item, total;
uint W[80], temp, A,B,C,D,E,F,G,H,T1,T2;
uint num_keys = data_info[1];
int current_pad;
uint K[64]={
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
msg_pad=0;
ulen = data_info[2];
total = ulen%64>=56?2:1 + ulen/64;
//printf("ulen: %u total:%u\n", ulen, total);
digest[0+offset] = H0;
digest[1+offset] = H1;
digest[2+offset] = H2;
digest[3+offset] = H3;
digest[4+offset] = H4;
digest[5+offset] = H5;
digest[6+offset] = H6;
digest[7+offset] = H7;
for(item=0; item<total; item++)
{
A = digest[0+offset];
B = digest[1+offset];
C = digest[2+offset];
D = digest[3+offset];
E = digest[4+offset];
F = digest[5+offset];
G = digest[6+offset];
H = digest[7+offset];
#pragma unroll
for (t = 0; t < 80; t++){
W[t] = 0x00000000;
}
msg_pad=item*64;
if(ulen > msg_pad)
{
current_pad = (ulen-msg_pad)>64?64:(ulen-msg_pad);
}
else
{
current_pad =-1;
}
// printf("current_pad: %d\n",current_pad);
if(current_pad>0)
{
i=current_pad;
stop = i/4;
// printf("i:%d, stop: %d msg_pad:%d\n",i,stop, msg_pad);
for (t = 0 ; t < stop ; t++){
W[t] = ((uchar) real_key[msg_pad + t * 4]) << 24;
W[t] |= ((uchar) real_key[msg_pad + t * 4 + 1]) << 16;
W[t] |= ((uchar) real_key[msg_pad + t * 4 + 2]) << 8;
W[t] |= (uchar) real_key[msg_pad + t * 4 + 3];
//printf("W[%u]: %u\n",t,W[t]);
}
mmod = i % 4;
if ( mmod == 3){
W[t] = ((uchar) real_key[msg_pad + t * 4]) << 24;
W[t] |= ((uchar) real_key[msg_pad + t * 4 + 1]) << 16;
W[t] |= ((uchar) real_key[msg_pad + t * 4 + 2]) << 8;
W[t] |= ((uchar) 0x80) ;
} else if (mmod == 2) {
W[t] = ((uchar) real_key[msg_pad + t * 4]) << 24;
W[t] |= ((uchar) real_key[msg_pad + t * 4 + 1]) << 16;
W[t] |= 0x8000 ;
} else if (mmod == 1) {
W[t] = ((uchar) real_key[msg_pad + t * 4]) << 24;
W[t] |= 0x800000 ;
} else /*if (mmod == 0)*/ {
W[t] = 0x80000000 ;
}
if (current_pad<56)
{
W[15] = ulen*8 ;
//printf("ulen avlue 2 :w[15] :%u\n", W[15]);
}
}
else if(current_pad <0)
{
if( ulen%64==0)
W[0]=0x80000000;
W[15]=ulen*8;
//printf("ulen avlue 3 :w[15] :%u\n", W[15]);
}
for (t = 0; t < 64; t++) {
if (t >= 16)
W[t] = gamma1(W[t - 2]) + W[t - 7] + gamma0(W[t - 15]) + W[t - 16];
T1 = H + sigma1(E) + ch(E, F, G) + K[t] + W[t];
T2 = sigma0(A) + maj(A, B, C);
H = G; G = F; F = E; E = D + T1; D = C; C = B; B = A; A = T1 + T2;
}
digest[0+offset] += A;
digest[1+offset] += B;
digest[2+offset] += C;
digest[3+offset] += D;
digest[4+offset] += E;
digest[5+offset] += F;
digest[6+offset] += G;
digest[7+offset] += H;
// for (t = 0; t < 80; t++)
// {
// printf("W[%d]: %u\n",t,W[t]);
// }
}
// for (int t = 0; t < 8; t++)
// {
// printf("%x", digest[t]);
// }
// printf("\n");
}