Initial check in

A set of OpenCL test programs for testing various implementations
Z

Makefile

@@ -0,0 +1,27 @@
+CC=gcc
+CPP=g++
+INC=
+LIBS=-lOpenCL -lm
+
+all: vecadd1 vecadd2 vecadd3 vecadd4
+
+vecadd1: vecadd1.c
+	$(CC) vecadd1.c -o vecadd1 $(INC) $(LIBS)
+
+vecadd2: vecadd2.c
+	$(CPP) vecadd2.c -o vecadd2 $(INC) $(LIBS)
+
+vecadd3: vecadd3.c vecadd3.cl
+	$(CPP) vecadd3.c -o vecadd3 $(INC) $(LIBS)
+
+vecadd4: vecadd4.c vecadd4.cl
+	$(CPP) vecadd4.c -o vecadd4 $(INC) $(LIBS)
+
+sha256.o: sha256.c
+	$(CPP) -c sha256.c $(INC)
+
+shamain: shamain.cpp sha256.o
+	$(CPP) shamain.cpp -o shamain sha256.o $(INC) $(LIBS) 
+
+clean:
+	rm vecadd1 vecadd2 vecadd3 vecadd4 sha256.o shamain

sha256.c

@@ -0,0 +1,136 @@
+#define _CRT_SECURE_NO_WARNINGS
+#include "sha256.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=3;
+static size_t local_work_size=1;
+static size_t string_len;
+
+void load_source();
+void createDevice();
+void createkernel();
+void create_clobj();
+
+void crypt_all();
+
+
+void sha256_init(size_t user_kpc)
+{
+    kpc = user_kpc;
+    load_source();
+    createDevice();
+    createkernel();
+    create_clobj();
+}
+
+void sha256_crypt(char input[], char* output)
+{
+
+    int i;
+    string_len = strlen(input);
+    global_work_size = 3;
+    datai[0] = SHA256_PLAINTEXT_LENGTH;
+    datai[1] = global_work_size;
+    datai[2] = string_len;
+    memcpy(saved_plain, input, string_len+1);
+
+    crypt_all();
+
+
+    for(i=0; i<SHA256_RESULT_SIZE; i++)
+    {
+        sprintf(output+i*8,"%08x", partial_hashes[i]);
+    }
+    printf("'%s':\n%s\n", input, output);
+
+
+}
+
+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, SHA256_PLAINTEXT_LENGTH * kpc, saved_plain, 0, NULL, NULL);
+    // printf("%s\n",buffer_keys);
+    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_work_size, &local_work_size, 0, NULL, NULL);
+
+    ret = clFinish(command_queue);
+    // read back partial hashes
+    ret = clEnqueueReadBuffer(command_queue, buffer_out, CL_TRUE, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE, 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, NULL, &ret);
+    partial_hashes = (cl_uint *) clEnqueueMapBuffer(command_queue, pinned_partial_hashes, CL_TRUE, CL_MAP_READ, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE, 0, NULL, NULL, &ret);
+    memset(partial_hashes, 0, sizeof(cl_uint) * SHA256_RESULT_SIZE);
+
+    buffer_keys = clCreateBuffer(context, CL_MEM_READ_ONLY, (SHA256_PLAINTEXT_LENGTH) * kpc, NULL, &ret);
+    buffer_out = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(cl_uint) * SHA256_RESULT_SIZE, 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_GPU, 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 = clCreateCommandQueue(context, device_id, 0, &ret);
+}

sha256.cl

@@ -0,0 +1,176 @@
+#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 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;
+
+ //printf(get_global_id(0));
+
+  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] = H0;
+  digest[1] = H1;
+  digest[2] = H2;
+  digest[3] = H3;
+  digest[4] = H4;
+  digest[5] = H5;
+  digest[6] = H6;
+  digest[7] = H7;
+  for(item=0; item<total; item++)
+  {
+
+    A = digest[0];
+    B = digest[1];
+    C = digest[2];
+    D = digest[3];
+    E = digest[4];
+    F = digest[5];
+    G = digest[6];
+    H = digest[7];
+
+#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+get_global_id(0) ; t++){
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 2]) << 8;
+        W[t] |= (uchar)  plain_key[msg_pad + t * 4 + 3];
+   //     printf("W[%u]: %u\n",t,W[t]);
+      }
+      mmod = i % 4;
+      if ( mmod == 3){
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 2]) << 8;
+        W[t] |=  ((uchar) 0x80) ;
+      } else if (mmod == 2) {
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |=  0x8000 ;
+      } else if (mmod == 1) {
+        W[t] = ((uchar)  plain_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] += A;
+    digest[1] += B;
+    digest[2] += C;
+    digest[3] += D;
+    digest[4] += E;
+    digest[5] += F;
+    digest[6] += G;
+    digest[7] += H;
+
+
+  }
+
+
+  // printf("hi");
+
+
+}

sha256.h

@@ -0,0 +1,12 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <CL/opencl.h>
+#include <string.h>
+
+#define SHA256_PLAINTEXT_LENGTH 80
+#define SHA256_RESULT_SIZE 32
+#define MAX_SOURCE_SIZE 16384
+
+void sha256_init(size_t user_kpc);
+void sha256_crypt(char input[], char* output);
+

shamain.cpp

@@ -0,0 +1,55 @@
+#define _CRT_SECURE_NO_WARNINGS
+#include "sha256.h"
+// #include <stdio.h>
+// #include < string.h > 
+
+
+
+void crypt_and_print(char input[])
+{
+  char result[65];
+  char diff[65] = "00000";
+  char *istr;
+  char  buffer2[20];
+  int temp;
+
+  char str2[20];
+
+
+
+  for (int i = 0; i < 1; i++)
+  {
+
+      char string[] = "xqqq";
+
+      sprintf(buffer2, "%d", i);
+      temp = 8 - strlen(buffer2);
+      str2[0] = '\0';
+      while (strlen(str2) != temp)
+          strcat(str2, "0");
+      strcat(str2, buffer2);
+      strcat(string, str2);
+      sha256_crypt(string, result);
+
+      istr = strstr(result, diff);
+
+
+      if (istr != NULL) {
+          printf(istr);
+          break;
+      }
+
+
+  }
+
+}
+
+int main()
+{
+  char result[65];
+
+  sha256_init(2048);
+
+  crypt_and_print((char*)"");
+
+}

shatest.cl

@@ -0,0 +1,223 @@
+#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 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 tacc, wt, wtm2, wtm7, wtm15, wtm16;
+  uint tsh1; // short
+  uint tsh2; // short
+  uchar uch1, uch2, uch3, uch4;
+  uchar uch[4];
+
+ //printf(get_global_id(0));
+  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] = H0;
+  digest[1] = H1;
+  digest[2] = H2;
+  digest[3] = H3;
+  digest[4] = H4;
+  digest[5] = H5;
+  digest[6] = H6;
+  digest[7] = H7;
+  for(item=0; item<total; item++)
+  {
+
+    A = digest[0];
+    B = digest[1];
+    C = digest[2];
+    D = digest[3];
+    E = digest[4];
+    F = digest[5];
+    G = digest[6];
+    H = digest[7];
+
+#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;    
+    }
+
+    if(current_pad>0)
+    {
+      i=current_pad;
+
+      stop =  i/4;
+      for (t = 0 ; t < stop+get_global_id(0) ; t++){
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 2]) << 8;
+        W[t] |= (uchar)  plain_key[msg_pad + t * 4 + 3];
+      }
+      mmod = i % 4;
+      if ( mmod == 3){
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 2]) << 8;
+        W[t] |=  ((uchar) 0x80) ;
+      } else if (mmod == 2) {
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |= ((uchar) plain_key[msg_pad + t * 4 + 1]) << 16;
+        W[t] |=  0x8000 ;
+      } else if (mmod == 1) {
+        W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        W[t] |=  0x800000 ;
+      } else { //if (mmod == 0)
+        W[t] =  0x80000000 ;
+      }
+
+      if (current_pad<56)
+      {
+        W[15] =  ulen*8 ;
+      }
+    }
+    else if(current_pad <0)
+    {
+      if( ulen%64==0)
+        W[0]=0x80000000;
+      W[15]=ulen*8;
+    }
+    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]; // 64-bit
+        // W[t] = (W[t - 2]) + W[t - 7] + (W[t - 15]) + W[t - 16]; // 64-bit
+        // W[t] = (W[t - 2] + W[t - 7] + W[t - 15] + W[t - 16])&0xffffffff; // 64-bit
+        // W[t] = (W[t - 2] + W[t - 7])&0xffffffff; // 64-bit
+        // W[t] = W[t - 2]; // 64-bit // 64-bit
+        // W[t] = 0x0 ^ W[t - 2]; // 64-bit
+        // W[t] = (uint)W[t-2]; // 64-bit
+        // W[t] = 0xffffffff & W[t-2] & 0xffffffff; // 64-bit
+        // W[t] = W[t-2]>>16<<16 + W[t-2]&0x0000ffff; // 64-bit
+        // W[t] = (uint)(W[t-2]>>16); // 64-bit
+        // W[t] = (uint)(W[t-2]/2); // 64-bit
+        // W[t] = (int)(W[0]); // 64-bit
+        // W[t] = W[t] + W[t]; // 64-bit
+        // W[t] = W[t-2]; // 64-bit
+        // W[t] = wtm2 + wtm7 + wtm15 + wtm16; // 64-bit
+        // W[t] = ((uchar)  plain_key[msg_pad + t * 4]) << 24;
+        // W[t] = ((uchar)  uch[0]) << 24; // 64-bit
+        // W[t] |= ((uchar)  uch[1]) << 16; // 64-bit
+        // W[t] |= ((uchar)  uch[2]) << 8; // 64-bit
+        // W[t] |= ((uchar)  uch[3]) << 0; // 64-bit
+        // wt = W[t]; // This works, but reassignment to W[t] fails as 64-bit
+        // wtm2 = W[t-2];
+        // wtm7 = W[t-7];
+        // wtm15 = W[t-15];
+        // wtm16 = W[t-16];
+        // tacc = gamma1(wtm2) + wtm7 + gamma0(wtm15) + wtm16; 
+
+        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;
+
+
+/*
+        tsh1 = (uint)(tacc >> 16);
+        tsh2 = (uint)(tacc & 0xffff);
+        uch1 = (uchar)(tsh1>>8);
+        uch2 = (uchar)(tsh1&0xff);
+        uch3 = (uchar)(tsh2>>8);
+        uch4 = (uchar)(tsh2&0xff);
+        uch[0]=(uchar)uch1;
+        uch[1]=(uchar)uch2;
+        uch[2]=(uchar)uch3;
+        uch[3]=(uchar)uch4;
+        W[t] = t;
+        t = (uchar)uch1;
+        W[t] = (uint)(t);
+        W[0] = (uint)uch1;
+        W[t] |= ((uchar)uch2) << 16;
+        W[t] |= ((uchar)uch3) << 8;
+        W[t] |= (uchar)uch4;
+        tmpi = W[t-2];
+        W[t] = tmpi;
+        W[t] = 0xffffffff << 1;
+        W[t-2] = W[t-2];
+        W[t] = W[t];
+        W[t] = W[t]&0xffffffff;
+*/
+/*
+      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] += A;
+    digest[1] += B;
+    digest[2] += C;
+    digest[3] += D;
+    digest[4] += E;
+    digest[5] += F;
+    digest[6] += G;
+    digest[7] += H;
+  }
+}

vecadd1.c

@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <CL/opencl.h>
+ 
+// OpenCL kernel. Each work item takes care of one element of c
+const char *kernelSource =                                       "\n" \
+"#pragma OPENCL EXTENSION cl_khr_fp64 : enable                    \n" \
+"__kernel void vecAdd(  __global double *a,                       \n" \
+"                       __global double *b,                       \n" \
+"                       __global double *c,                       \n" \
+"                       const unsigned int n)                    \n" \
+"{                                                               \n" \
+"    //Get our global thread ID                                  \n" \
+"    int id = get_global_id(0);                                  \n" \
+"                                                                \n" \
+"    //Make sure we do not go out of bounds                      \n" \
+"    if (id < n)                                                 \n" \
+"        c[id] = a[id] + b[id];                                  \n" \
+"}                                                               \n" \
+                                                                "\n" ;
+ 
+int main( int argc, char* argv[] )
+{
+    // Length of vectors
+    unsigned int n = 100000;
+ 
+    // Host input vectors
+    double *h_a;
+    double *h_b;
+    // Host output vector
+    double *h_c;
+ 
+    // Device input buffers
+    cl_mem d_a;
+    cl_mem d_b;
+    // Device output buffer
+    cl_mem d_c;
+ 
+    cl_platform_id cpPlatform;        // OpenCL platform
+    cl_device_id device_id;           // device ID
+    cl_context context;               // context
+    cl_command_queue queue;           // command queue
+    cl_program program;               // program
+    cl_kernel kernel;                 // kernel
+ 
+    // Size, in bytes, of each vector
+    size_t bytes = n*sizeof(double);
+ 
+    // Allocate memory for each vector on host
+    h_a = (double*)malloc(bytes);
+    h_b = (double*)malloc(bytes);
+    h_c = (double*)malloc(bytes);
+ 
+    // Initialize vectors on host
+    int i;
+    for( i = 0; i < n; i++ )
+    {
+        h_a[i] = sinf(i)*sinf(i);
+        h_b[i] = cosf(i)*cosf(i);
+    }
+ 
+    size_t globalSize, localSize;
+    cl_int err;
+ 
+    // Number of work items in each local work group
+    localSize = 64;
+ 
+    // Number of total work items - localSize must be devisor
+    globalSize = ceil(n/(float)localSize)*localSize;
+ 
+    // Bind to platform
+    err = clGetPlatformIDs(1, &cpPlatform, NULL);
+ 
+    // Get ID for the device
+    err = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, 1, &device_id, NULL);
+ 
+    // Create a context 
+    context = clCreateContext(0, 1, &device_id, NULL, NULL, &err);
+ 
+    // Create a command queue
+    queue = clCreateCommandQueue(context, device_id, 0, &err);
+ 
+    // Create the compute program from the source buffer
+    program = clCreateProgramWithSource(context, 1,
+                            (const char **) & kernelSource, NULL, &err);
+ 
+    // Build the program executable
+    clBuildProgram(program, 0, NULL, NULL, NULL, NULL);
+ 
+    // Create the compute kernel in the program we wish to run
+    kernel = clCreateKernel(program, "vecAdd", &err);
+ 
+    // Create the input and output arrays in device memory for our calculation
+    d_a = clCreateBuffer(context, CL_MEM_READ_ONLY, bytes, NULL, NULL);
+    d_b = clCreateBuffer(context, CL_MEM_READ_ONLY, bytes, NULL, NULL);
+    d_c = clCreateBuffer(context, CL_MEM_WRITE_ONLY, bytes, NULL, NULL);
+ 
+    // Write our data set into the input array in device memory
+    err = clEnqueueWriteBuffer(queue, d_a, CL_TRUE, 0,
+                                   bytes, h_a, 0, NULL, NULL);
+    err |= clEnqueueWriteBuffer(queue, d_b, CL_TRUE, 0,
+                                   bytes, h_b, 0, NULL, NULL);
+ 
+    // Set the arguments to our compute kernel
+    err  = clSetKernelArg(kernel, 0, sizeof(cl_mem), &d_a);
+    err |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &d_b);
+    err |= clSetKernelArg(kernel, 2, sizeof(cl_mem), &d_c);
+    err |= clSetKernelArg(kernel, 3, sizeof(unsigned int), &n);
+ 
+    // Execute the kernel over the entire range of the data set 
+    err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &globalSize, &localSize,
+                                                              0, NULL, NULL);
+ 
+    // Wait for the command queue to get serviced before reading back results
+    clFinish(queue);
+ 
+    // Read the results from the device
+    clEnqueueReadBuffer(queue, d_c, CL_TRUE, 0,
+                                bytes, h_c, 0, NULL, NULL );
+ 
+    //Sum up vector c and print result divided by n, this should equal 1 within error
+    double sum = 0;
+    for(i=0; i<n; i++)
+        sum += h_c[i];
+    printf("final result: %f\n", sum/n);
+ 
+    // release OpenCL resources
+    clReleaseMemObject(d_a);
+    clReleaseMemObject(d_b);
+    clReleaseMemObject(d_c);
+    clReleaseProgram(program);
+    clReleaseKernel(kernel);
+    clReleaseCommandQueue(queue);
+    clReleaseContext(context);
+ 
+    //release host memory
+    free(h_a);
+    free(h_b);
+    free(h_c);
+ 
+    return 0;
+}

vecadd2.c

@@ -0,0 +1,127 @@
+//Includes
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+ 
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+ 
+#define DATA_SIZE 10
+ 
+using namespace std;
+ 
+const char *ProgramSource =
+"__kernel void add(__global float *inputA, __global float *inputB, __global float *output)\n"\
+"{\n"\
+"  size_t id = get_global_id(0);\n"\
+"  output[id] = inputA[id] + 2.0*inputB[id];\n"\
+"}\n";
+ 
+int main(void)
+{
+cl_context context;
+cl_context_properties properties[3];
+cl_kernel kernel;
+cl_command_queue command_queue;
+cl_program program;
+cl_int err;
+cl_uint num_of_platforms=0;
+cl_platform_id platform_id;
+cl_device_id device_id;
+cl_uint num_of_devices=0;
+cl_mem inputA, inputB, output;
+ 
+size_t global;
+ 
+float inputDataA[DATA_SIZE]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+float inputDataB[DATA_SIZE]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+float results[DATA_SIZE]={0};
+ 
+int i;
+ 
+// retreive a list of platforms avaible
+if (clGetPlatformIDs(1, &platform_id, &num_of_platforms)!= CL_SUCCESS)
+{
+printf("Unable to get platform_id\n");
+return 1;
+}
+ 
+// try to get a supported GPU device
+if (clGetDeviceIDs(platform_id, CL_DEVICE_TYPE_GPU, 1, &device_id, &num_of_devices) != CL_SUCCESS)
+{
+printf("Unable to get device_id\n");
+return 1;
+}
+ 
+// context properties list - must be terminated with 0
+properties[0]= CL_CONTEXT_PLATFORM;
+properties[1]= (cl_context_properties) platform_id;
+properties[2]= 0;
+ 
+// create a context with the GPU device
+context = clCreateContext(properties,1,&device_id,NULL,NULL,&err);
+ 
+// create command queue using the context and device
+command_queue = clCreateCommandQueue(context, device_id, 0, &err);
+ 
+// create a program from the kernel source code
+program = clCreateProgramWithSource(context,1,(const char **) &ProgramSource, NULL, &err);
+ 
+// compile the program
+if (clBuildProgram(program, 0, NULL, NULL, NULL, NULL) != CL_SUCCESS)
+{
+printf("Error building program\n");
+return 1;
+}
+ 
+// specify which kernel from the program to execute
+kernel = clCreateKernel(program, "add", &err);
+ 
+// create buffers for the input and ouput
+ 
+inputA = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * DATA_SIZE, NULL, NULL);
+inputB = clCreateBuffer(context, CL_MEM_READ_ONLY, sizeof(float) * DATA_SIZE, NULL, NULL);
+output = clCreateBuffer(context, CL_MEM_WRITE_ONLY, sizeof(float) * DATA_SIZE, NULL, NULL);
+ 
+// load data into the input buffer
+clEnqueueWriteBuffer(command_queue, inputA, CL_TRUE, 0, sizeof(float) * DATA_SIZE, inputDataA, 0, NULL, NULL);
+clEnqueueWriteBuffer(command_queue, inputB, CL_TRUE, 0, sizeof(float) * DATA_SIZE, inputDataB, 0, NULL, NULL);
+ 
+// set the argument list for the kernel command
+clSetKernelArg(kernel, 0, sizeof(cl_mem), &inputA);
+clSetKernelArg(kernel, 1, sizeof(cl_mem), &inputB);
+clSetKernelArg(kernel, 2, sizeof(cl_mem), &output);
+ 
+global=DATA_SIZE;
+ 
+// enqueue the kernel command for execution
+clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global, NULL, 0, NULL, NULL);
+clFinish(command_queue);
+ 
+// copy the results from out of the output buffer
+clEnqueueReadBuffer(command_queue, output, CL_TRUE, 0, sizeof(float) *DATA_SIZE, results, 0, NULL, NULL);
+ 
+// print the results
+printf("output: ");
+ 
+for(i=0;i<DATA_SIZE; i++)
+{
+printf("%f ",results[i]);
+}
+printf("\n");
+ 
+// cleanup - release OpenCL resources
+clReleaseMemObject(inputA);
+clReleaseMemObject(inputB);
+clReleaseMemObject(output);
+clReleaseProgram(program);
+clReleaseKernel(kernel);
+clReleaseCommandQueue(command_queue);
+clReleaseContext(context);
+ 
+return 0;
+ 
+}

vecadd3.c

@@ -0,0 +1,132 @@
+#include <stdio.h>
+#include <stdlib.h>
+ 
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+ 
+#define MAX_SOURCE_SIZE (0x100000)
+ 
+int main(void) {
+    printf("started running\n");
+
+    // Create the two input vectors
+    int i;
+    const int LIST_SIZE = 1024;
+    int *A = (int*)malloc(sizeof(int)*LIST_SIZE);
+    int *B = (int*)malloc(sizeof(int)*LIST_SIZE);
+    for(i = 0; i < LIST_SIZE; i++) {
+        A[i] = i;
+        B[i] = LIST_SIZE - i;
+    }
+ 
+    // Load the kernel source code into the array source_str
+    FILE *fp;
+    char *source_str;
+    size_t source_size;
+ 
+    fp = fopen("vecadd3.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 );
+    printf("kernel loading done\n");
+
+    // Get platform and device information
+    cl_device_id device_id = NULL;   
+    cl_uint ret_num_devices;
+    cl_uint ret_num_platforms;
+    
+	
+	cl_int ret = clGetPlatformIDs(0, NULL, &ret_num_platforms);
+    cl_platform_id *platforms = NULL;
+    platforms = (cl_platform_id*)malloc(ret_num_platforms*sizeof(cl_platform_id));
+    ret = clGetPlatformIDs(ret_num_platforms, platforms, NULL);
+    printf("ret at %d is %d\n", __LINE__, ret);
+    ret = clGetDeviceIDs( platforms[0], CL_DEVICE_TYPE_ALL, 1, &device_id, &ret_num_devices);
+    printf("ret at %d is %d\n", __LINE__, ret);
+
+    // Create an OpenCL context
+    cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
+ 	printf("ret at %d is %d\n", __LINE__, ret);
+
+    // Create a command queue
+    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret);
+ 	printf("ret at %d is %d\n", __LINE__, ret);
+
+    // Create memory buffers on the device for each vector 
+    cl_mem a_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+    cl_mem b_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+    cl_mem c_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+ 
+    // Copy the lists A and B to their respective memory buffers
+    ret = clEnqueueWriteBuffer(command_queue, a_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), A, 0, NULL, NULL);
+    printf("ret at %d is %d\n", __LINE__, ret);
+
+    ret = clEnqueueWriteBuffer(command_queue, b_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), B, 0, NULL, NULL);
+    printf("ret at %d is %d\n", __LINE__, ret);
+ 
+    printf("before building\n");
+
+    // Create a program from the kernel source
+    cl_program program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret);
+    printf("ret at %d is %d\n", __LINE__, ret);
+ 
+    // Build the program
+    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
+    printf("ret at %d is %d\n", __LINE__, ret);
+    printf("after building\n");
+
+    // Create the OpenCL kernel
+    cl_kernel kernel = clCreateKernel(program, "vector_add", &ret);
+    printf("ret at %d is %d\n", __LINE__, ret);
+ 
+    // Set the arguments of the kernel
+    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&a_mem_obj);
+    printf("ret at %d is %d\n", __LINE__, ret);
+
+    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&b_mem_obj);
+    printf("ret at %d is %d\n", __LINE__, ret);
+
+    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&c_mem_obj);
+    printf("ret at %d is %d\n", __LINE__, ret);
+
+    //added this to fix garbage output problem
+    //ret = clSetKernelArg(kernel, 3, sizeof(int), &LIST_SIZE);
+ 
+    printf("before execution\n");
+
+    // Execute the OpenCL kernel on the list
+    size_t global_item_size = LIST_SIZE; // Process the entire lists
+    size_t local_item_size = 12; // Divide work items into groups of 12
+    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_item_size, &local_item_size, 0, NULL, NULL);
+    printf("after execution\n");
+
+    // Read the memory buffer C on the device to the local variable C
+    int *C = (int*)malloc(sizeof(int)*LIST_SIZE);
+    ret = clEnqueueReadBuffer(command_queue, c_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), C, 0, NULL, NULL);
+    printf("after copying\n");
+    // Display the result to the screen
+    for(i = 0; i < 8; i++)
+        printf("%d + %d = %d\n", A[i], B[i], C[i]);
+ 
+    // Clean up
+    ret = clFlush(command_queue);
+    ret = clFinish(command_queue);
+    ret = clReleaseKernel(kernel);
+    ret = clReleaseProgram(program);
+    ret = clReleaseMemObject(a_mem_obj);
+    ret = clReleaseMemObject(b_mem_obj);
+    ret = clReleaseMemObject(c_mem_obj);
+    ret = clReleaseCommandQueue(command_queue);
+    ret = clReleaseContext(context);
+    free(A);
+    free(B);
+    free(C);
+    return 0;
+}

vecadd3.cl

@@ -0,0 +1,8 @@
+__kernel void vector_add(__global const int *A, __global const int *B, __global int *C) {
+ 
+    // Get the index of the current element to be processed
+    int i = get_global_id(0);
+ 
+    // Do the operation
+    C[i] = A[i] + B[i];
+}

vecadd4.c

@@ -0,0 +1,253 @@
+#include <stdio.h>
+#include <stdlib.h>
+ 
+#ifdef __APPLE__
+#include <OpenCL/opencl.h>
+#else
+#include <CL/cl.h>
+#endif
+ 
+#define MAX_SOURCE_SIZE (0x100000)
+
+const char *clErrorString(cl_int error)
+{
+switch(error){
+    // run-time and JIT compiler errors
+    case 0: return "CL_SUCCESS";
+    case -1: return "CL_DEVICE_NOT_FOUND";
+    case -2: return "CL_DEVICE_NOT_AVAILABLE";
+    case -3: return "CL_COMPILER_NOT_AVAILABLE";
+    case -4: return "CL_MEM_OBJECT_ALLOCATION_FAILURE";
+    case -5: return "CL_OUT_OF_RESOURCES";
+    case -6: return "CL_OUT_OF_HOST_MEMORY";
+    case -7: return "CL_PROFILING_INFO_NOT_AVAILABLE";
+    case -8: return "CL_MEM_COPY_OVERLAP";
+    case -9: return "CL_IMAGE_FORMAT_MISMATCH";
+    case -10: return "CL_IMAGE_FORMAT_NOT_SUPPORTED";
+    case -11: return "CL_BUILD_PROGRAM_FAILURE";
+    case -12: return "CL_MAP_FAILURE";
+    case -13: return "CL_MISALIGNED_SUB_BUFFER_OFFSET";
+    case -14: return "CL_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST";
+    case -15: return "CL_COMPILE_PROGRAM_FAILURE";
+    case -16: return "CL_LINKER_NOT_AVAILABLE";
+    case -17: return "CL_LINK_PROGRAM_FAILURE";
+    case -18: return "CL_DEVICE_PARTITION_FAILED";
+    case -19: return "CL_KERNEL_ARG_INFO_NOT_AVAILABLE";
+
+    // compile-time errors
+    case -30: return "CL_INVALID_VALUE";
+    case -31: return "CL_INVALID_DEVICE_TYPE";
+    case -32: return "CL_INVALID_PLATFORM";
+    case -33: return "CL_INVALID_DEVICE";
+    case -34: return "CL_INVALID_CONTEXT";
+    case -35: return "CL_INVALID_QUEUE_PROPERTIES";
+    case -36: return "CL_INVALID_COMMAND_QUEUE";
+    case -37: return "CL_INVALID_HOST_PTR";
+    case -38: return "CL_INVALID_MEM_OBJECT";
+    case -39: return "CL_INVALID_IMAGE_FORMAT_DESCRIPTOR";
+    case -40: return "CL_INVALID_IMAGE_SIZE";
+    case -41: return "CL_INVALID_SAMPLER";
+    case -42: return "CL_INVALID_BINARY";
+    case -43: return "CL_INVALID_BUILD_OPTIONS";
+    case -44: return "CL_INVALID_PROGRAM";
+    case -45: return "CL_INVALID_PROGRAM_EXECUTABLE";
+    case -46: return "CL_INVALID_KERNEL_NAME";
+    case -47: return "CL_INVALID_KERNEL_DEFINITION";
+    case -48: return "CL_INVALID_KERNEL";
+    case -49: return "CL_INVALID_ARG_INDEX";
+    case -50: return "CL_INVALID_ARG_VALUE";
+    case -51: return "CL_INVALID_ARG_SIZE";
+    case -52: return "CL_INVALID_KERNEL_ARGS";
+    case -53: return "CL_INVALID_WORK_DIMENSION";
+    case -54: return "CL_INVALID_WORK_GROUP_SIZE";
+    case -55: return "CL_INVALID_WORK_ITEM_SIZE";
+    case -56: return "CL_INVALID_GLOBAL_OFFSET";
+    case -57: return "CL_INVALID_EVENT_WAIT_LIST";
+    case -58: return "CL_INVALID_EVENT";
+    case -59: return "CL_INVALID_OPERATION";
+    case -60: return "CL_INVALID_GL_OBJECT";
+    case -61: return "CL_INVALID_BUFFER_SIZE";
+    case -62: return "CL_INVALID_MIP_LEVEL";
+    case -63: return "CL_INVALID_GLOBAL_WORK_SIZE";
+    case -64: return "CL_INVALID_PROPERTY";
+    case -65: return "CL_INVALID_IMAGE_DESCRIPTOR";
+    case -66: return "CL_INVALID_COMPILER_OPTIONS";
+    case -67: return "CL_INVALID_LINKER_OPTIONS";
+    case -68: return "CL_INVALID_DEVICE_PARTITION_COUNT";
+
+    // extension errors
+    case -1000: return "CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR";
+    case -1001: return "CL_PLATFORM_NOT_FOUND_KHR";
+    case -1002: return "CL_INVALID_D3D10_DEVICE_KHR";
+    case -1003: return "CL_INVALID_D3D10_RESOURCE_KHR";
+    case -1004: return "CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR";
+    case -1005: return "CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR";
+    default: return "Unknown OpenCL error";
+    }
+} 
+
+void debug(int ret) {
+  if (ret != CL_SUCCESS) {
+    printf(clErrorString(ret));
+    printf("\n");
+  }
+} 
+
+int main(void) {
+    printf("start\n");
+
+    // Create the two input vectors
+    int i;
+    const int LIST_SIZE = 1024;
+    int *A = (int*)malloc(sizeof(int)*LIST_SIZE);
+    int *B = (int*)malloc(sizeof(int)*LIST_SIZE);
+    for(i = 0; i < LIST_SIZE; i++) {
+        A[i] = i;
+        B[i] = LIST_SIZE - i;
+    }
+ 
+    // Load the kernel source code into the array source_str
+    FILE *fp;
+    char *source_str;
+    size_t source_size;
+ 
+    fp = fopen("vecadd4.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 );
+
+    // Get platform and device information
+    cl_device_id device_id = NULL;   
+    cl_uint ret_num_devices;
+    cl_uint ret_num_platforms;
+    
+	
+    cl_int ret = clGetPlatformIDs(0, NULL, &ret_num_platforms);
+    debug(ret);
+    cl_platform_id *platforms = NULL;
+    platforms = (cl_platform_id*)malloc(ret_num_platforms*sizeof(cl_platform_id));
+    ret = clGetPlatformIDs(ret_num_platforms, platforms, NULL);
+    printf("ret at clGetPlatformIDs (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+    ret = clGetDeviceIDs( platforms[0], CL_DEVICE_TYPE_ALL, 1, &device_id, &ret_num_devices);
+    printf("ret at clGetDeviceIDs (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+  
+    // Create an OpenCL context
+    cl_context context = clCreateContext( NULL, 1, &device_id, NULL, NULL, &ret);
+    printf("ret at clCreateContext (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    // Create a command queue
+    cl_command_queue command_queue = clCreateCommandQueue(context, device_id, 0, &ret);
+    printf("ret at clCreateCommandQueue (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    // Create memory buffers on the device for each vector 
+    cl_mem a_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+    cl_mem b_mem_obj = clCreateBuffer(context, CL_MEM_READ_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+    cl_mem c_mem_obj = clCreateBuffer(context, CL_MEM_WRITE_ONLY, LIST_SIZE * sizeof(int), NULL, &ret);
+ 
+    // Copy the lists A and B to their respective memory buffers
+    ret = clEnqueueWriteBuffer(command_queue, a_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), A, 0, NULL, NULL);
+    printf("ret at clEnqueueWriteBuffer (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    ret = clEnqueueWriteBuffer(command_queue, b_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), B, 0, NULL, NULL);
+    printf("ret at clEnqueueWriteBuffer (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+ 
+    // Create a program from the kernel source
+    cl_program program = clCreateProgramWithSource(context, 1, (const char **)&source_str, (const size_t *)&source_size, &ret);
+    printf("ret at clCreateProgramWithSource (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+ 
+    // Build the program
+    ret = clBuildProgram(program, 1, &device_id, NULL, NULL, NULL);
+    printf("ret at clBuildProgram (%d) is %d\n", __LINE__, ret);
+    if (ret != CL_SUCCESS) {
+      printf(clErrorString(ret));
+      printf("\n");
+      cl_build_status status;
+      char * log;
+      size_t log_size;
+      clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, 0, NULL, &log_size);
+      log = (char*)malloc(log_size+1);
+      clGetProgramBuildInfo(program, device_id, CL_PROGRAM_BUILD_LOG, log_size, log, NULL);
+      log[log_size-1]=0;  
+      printf(log);
+      free(log);
+    }
+
+
+    // Create the OpenCL kernel
+    // __kernel void sha256_crypt_kernel(__global uint *data_info,__global char *plain_key,  __global uint *digest) {
+    // cl_kernel kernel = clCreateKernel(program, "sha256_crypt_kernel", &ret);
+    cl_kernel kernel = clCreateKernel(program, "vector_add", &ret);
+    printf("ret at clCreateKernel (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+ 
+    // Set the arguments of the kernel
+    ret = clSetKernelArg(kernel, 0, sizeof(cl_mem), (void *)&a_mem_obj);
+    printf("ret at clSetKernelArg (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    ret = clSetKernelArg(kernel, 1, sizeof(cl_mem), (void *)&b_mem_obj);
+    printf("ret at clSetKernelArg (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    ret = clSetKernelArg(kernel, 2, sizeof(cl_mem), (void *)&c_mem_obj);
+    printf("ret at clSetKernelArg (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    //added this to fix garbage output problem
+    //ret = clSetKernelArg(kernel, 3, sizeof(int), &LIST_SIZE);
+ 
+    // Execute the OpenCL kernel on the list
+    size_t global_item_size = LIST_SIZE; // Process the entire lists
+    size_t local_item_size = 8; // Divide work items into groups of 8 (12 ideally, but 1024 isn't) 
+    ret = clEnqueueNDRangeKernel(command_queue, kernel, 1, NULL, &global_item_size, &local_item_size, 0, NULL, NULL);
+    printf("ret at clEnqueueNDRangeKernel (%d) is %d\n", __LINE__, ret);
+    if (ret!=CL_SUCCESS) {
+        printf(clErrorString(ret));
+        printf("\n");
+    }
+    // Read the memory buffer C on the device to the local variable C
+    int *C = (int*)malloc(sizeof(int)*LIST_SIZE);
+    ret = clEnqueueReadBuffer(command_queue, c_mem_obj, CL_TRUE, 0, LIST_SIZE * sizeof(int), C, 0, NULL, NULL);
+    printf("ret at clEnqueueReadBuffer (%d) is %d\n", __LINE__, ret);
+    debug(ret);
+
+    // Display the result to the screen
+    for(i = 0; i < 8; i++)
+        printf("%d + %d = %d\n", A[i], B[i], C[i]);
+ 
+    // Clean up
+    ret = clFlush(command_queue);
+    debug(ret);
+    ret = clFinish(command_queue);
+    debug(ret);
+    ret = clReleaseKernel(kernel);
+    debug(ret);
+    ret = clReleaseProgram(program);
+    debug(ret);
+    ret = clReleaseMemObject(a_mem_obj);
+    debug(ret);
+    ret = clReleaseMemObject(b_mem_obj);
+    debug(ret);
+    ret = clReleaseMemObject(c_mem_obj);
+    debug(ret);
+    ret = clReleaseCommandQueue(command_queue);
+    debug(ret);
+    ret = clReleaseContext(context);
+    debug(ret);
+
+    free(A);
+    free(B);
+    free(C);
+    return 0;
+}

vecadd4.cl

@@ -0,0 +1,24 @@
+__kernel void vector_add(__global const uint *A, __global const uint *B, __global uint *C) {
+ 
+    // Get the index of the current element to be processed
+    int i = get_global_id(0);
+ 
+    // Do the operation
+    C[i] = (A[i] + B[i]);
+
+    // Now break the compiler
+    uint a[4];
+    uchar c = 0x01;
+    short s = 0x0101;
+    c = 0x23;
+    s = c;
+    for(int t=0;t<4;t++) {
+      a[t]=c;
+    }
+    for(int t=0;t<4;t++) {
+      a[t]=s;
+      if(t>0) {
+        a[t-1]=a[t] + c + s;
+      }
+    }
+}