static void init(struct fmt_main *self) { int i ; //Prepare OpenCL environment. opencl_preinit(); ///Allocate memory key_host = mem_calloc(self -> params.max_keys_per_crypt, sizeof(*key_host)) ; dcc_hash_host = (cl_uint*)mem_alloc(4 * sizeof(cl_uint) * MAX_KEYS_PER_CRYPT) ; dcc2_hash_host = (cl_uint*)mem_alloc(4 * sizeof(cl_uint) * MAX_KEYS_PER_CRYPT) ; hmac_sha1_out = (cl_uint*)mem_alloc(5 * sizeof(cl_uint) * MAX_KEYS_PER_CRYPT) ; memset(dcc_hash_host, 0, 4 * sizeof(cl_uint) * MAX_KEYS_PER_CRYPT) ; memset(dcc2_hash_host, 0, 4 * sizeof(cl_uint) * MAX_KEYS_PER_CRYPT) ; /* Read LWS/GWS prefs from config or environment */ opencl_get_user_preferences(FORMAT_LABEL); for( i=0; i < get_number_of_devices_in_use(); i++) select_device(gpu_device_list[i], self) ; dcc2_warning() ; if (pers_opts.target_enc == UTF_8) { self->params.plaintext_length *= 3; if (self->params.plaintext_length > 125) self->params.plaintext_length = 125; } }
static void init(struct fmt_main *self) { cl_ulong maxsize; size_t selected_gws; opencl_init_opt("$JOHN/kernels/pwsafe_kernel.cl", ocl_gpu_id, NULL); init_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_INIT_NAME, &ret_code); HANDLE_CLERROR(ret_code, "Error while creating init kernel"); crypt_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_RUN_NAME, &ret_code); HANDLE_CLERROR(ret_code, "Error while creating crypt kernel"); finish_kernel = clCreateKernel(program[ocl_gpu_id], KERNEL_FINISH_NAME, &ret_code); HANDLE_CLERROR(ret_code, "Error while creating finish kernel"); local_work_size = cpu(device_info[ocl_gpu_id]) ? 1 : 64; global_work_size = 0; opencl_get_user_preferences(CONFIG_NAME); //Initialize openCL tuning (library) for this format. opencl_init_auto_setup(STEP, ROUNDS_DEFAULT/8, 8, split_events, warn, &multi_profilingEvent[3], self, create_clobj, release_clobj, sizeof(pwsafe_pass), 0); self->methods.crypt_all = crypt_all_benchmark; selected_gws = global_work_size; /* Note: we ask for the kernels' max sizes, not the device's! */ maxsize = get_current_work_group_size(ocl_gpu_id, init_kernel); maxsize = MIN(get_current_work_group_size(ocl_gpu_id, crypt_kernel), maxsize); maxsize = MIN(get_current_work_group_size(ocl_gpu_id, finish_kernel), maxsize); while (local_work_size > maxsize) local_work_size >>= 1; self->params.max_keys_per_crypt = (global_work_size ? global_work_size: MAX_KEYS_PER_CRYPT); if (!local_work_size) { create_clobj(self->params.max_keys_per_crypt, self); find_best_lws(self, ocl_gpu_id); release_clobj(); } global_work_size = selected_gws; if (global_work_size) create_clobj(global_work_size, self); else //user chose to die of boredom find_best_gws(self, ocl_gpu_id); self->params.min_keys_per_crypt = local_work_size; self->params.max_keys_per_crypt = global_work_size; self->methods.crypt_all = crypt_all; if (options.verbosity > 2) fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n", (int)local_work_size, (int)global_work_size); }
static void init(struct fmt_main *self) { saved_key = mem_calloc(BF_N, sizeof(*saved_key)) ; global_work_size = 0 ; //Prepare OpenCL environment. opencl_preinit(); // Check if specific LWS/GWS was requested opencl_get_user_preferences(FORMAT_LABEL); // BF_select_device(platform,device); //platform_id = get_platform_id(gpu_id); BF_select_device(self) ; keys_mode = 'a' ; sign_extension_bug = 0 ; //fprintf(stderr, "****Please see 'opencl_bf_std.h' for device specific optimizations****\n"); }
static void set_lws_gws(int defaultLWS, int defaultGWS) { local_work_size = global_work_size = 0; opencl_get_user_preferences(CONFIG_NAME); if (!local_work_size) { #ifdef DEBUG fprintf(stderr, "Forcing LWS = %d\n", defaultLWS); #endif local_work_size = DEFAULT_LWS; } if (!global_work_size) { #ifdef DEBUG fprintf(stderr, "Forcing GWS = %d\n", defaultGWS); #endif global_work_size = DEFAULT_GWS; } }
static void init(struct fmt_main *self) { size_t maxsize; /* Read LWS/GWS prefs from config or environment */ opencl_get_user_preferences(OCL_CONFIG); if (!local_work_size) local_work_size = cpu(device_info[gpu_id]) ? 1 : 64; if (!global_work_size) global_work_size = MAX_KEYS_PER_CRYPT; opencl_init("$JOHN/kernels/sha512_kernel.cl", gpu_id, NULL); gkey = mem_calloc(global_work_size * sizeof(sha512_key)); ghash = mem_calloc(global_work_size * sizeof(sha512_hash)); ///Allocate memory on the GPU mem_in = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, insize, NULL, &ret_code); HANDLE_CLERROR(ret_code,"Error while allocating memory for passwords"); mem_out = clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL, &ret_code); HANDLE_CLERROR(ret_code,"Error while allocating memory for hashes"); mem_binary = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, sizeof(uint64_t), NULL, &ret_code); HANDLE_CLERROR(ret_code,"Error while allocating memory for binary"); mem_cmp = clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, sizeof(uint32_t), NULL, &ret_code); HANDLE_CLERROR(ret_code,"Error while allocating memory for cmp_all result"); ///Assign crypt kernel parameters crypt_kernel = clCreateKernel(program[gpu_id], KERNEL_NAME, &ret_code); HANDLE_CLERROR(ret_code,"Error while creating crypt_kernel"); clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in); clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out); ///Assign cmp kernel parameters cmp_kernel = clCreateKernel(program[gpu_id], CMP_KERNEL_NAME, &ret_code); HANDLE_CLERROR(ret_code,"Error while creating cmp_kernel"); clSetKernelArg(cmp_kernel, 0, sizeof(mem_binary), &mem_binary); clSetKernelArg(cmp_kernel, 1, sizeof(mem_out), &mem_out); clSetKernelArg(cmp_kernel, 2, sizeof(mem_cmp), &mem_cmp); /* Note: we ask for the kernel's max size, not the device's! */ maxsize = get_kernel_max_lws(gpu_id, crypt_kernel); if (local_work_size > maxsize) { local_work_size = maxsize; global_work_size = (global_work_size + local_work_size - 1) / local_work_size * local_work_size; } self->params.max_keys_per_crypt = global_work_size; if (!local_work_size) opencl_find_best_workgroup(self); self->params.min_keys_per_crypt = local_work_size; if (options.verbosity > 2) fprintf(stderr, "Local worksize (LWS) %d, Global worksize (GWS) %d\n",(int)local_work_size, (int)global_work_size); }