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);
}
