static void fmt_ssha_init(struct fmt_main *pFmt) { char *kpc; opencl_init("$JOHN/ssha_opencl_kernel.cl", gpu_id); // create kernel to execute crypt_kernel = clCreateKernel(program[gpu_id], "sha1_crypt_kernel", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?"); if( (kpc = getenv("LWS")) == NULL){ create_clobj(SSHA_NUM_KEYS); find_best_workgroup(); release_clobj(); }else { local_work_size = atoi(kpc); } if( (kpc = getenv("KPC")) == NULL){ max_keys_per_crypt = SSHA_NUM_KEYS; create_clobj(SSHA_NUM_KEYS); } else { if (atoi(kpc) == 0){ //user chose to die of boredom max_keys_per_crypt = SSHA_NUM_KEYS; create_clobj(SSHA_NUM_KEYS); find_best_kpc(); } else { max_keys_per_crypt = atoi(kpc); create_clobj(max_keys_per_crypt); } } printf("Local work size (LWS) %d, Keys per crypt (KPC) %d\n",(int)local_work_size,max_keys_per_crypt); pFmt->params.max_keys_per_crypt = max_keys_per_crypt; }
static void fmt_ssha_init(struct fmt_main *pFmt) { char *temp; opencl_init("$JOHN/ssha_kernel.cl", gpu_id, platform_id); // create kernel to execute crypt_kernel = clCreateKernel(program[gpu_id], "sha1_crypt_kernel", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?"); if ((temp = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, LWS_CONFIG))) local_work_size = atoi(temp); if ((temp = getenv("LWS"))) local_work_size = atoi(temp); if (!local_work_size) { create_clobj(SSHA_NUM_KEYS); find_best_workgroup(); release_clobj(); } if ((temp = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, KPC_CONFIG))) max_keys_per_crypt = atoi(temp); else max_keys_per_crypt = SSHA_NUM_KEYS; if ((temp = getenv("KPC"))) max_keys_per_crypt = atoi(temp); if (max_keys_per_crypt) { create_clobj(max_keys_per_crypt); } else { //user chose to die of boredom max_keys_per_crypt = SSHA_NUM_KEYS; create_clobj(SSHA_NUM_KEYS); find_best_kpc(); } printf("Local work size (LWS) %d, Keys per crypt (KPC) %d\n",(int)local_work_size,max_keys_per_crypt); pFmt->params.max_keys_per_crypt = max_keys_per_crypt; }
static void init(struct fmt_main *pFmt) { assert(sizeof(hccap_t) == HCCAP_SIZE); inbuffer = (wpapsk_password *) malloc(sizeof(wpapsk_password) * MAX_KEYS_PER_CRYPT); outbuffer = (wpapsk_hash *) malloc(sizeof(wpapsk_hash) * MAX_KEYS_PER_CRYPT); mic = (mic_t *) malloc(sizeof(mic_t) * MAX_KEYS_PER_CRYPT); //listOpenCLdevices(); opencl_init("$JOHN/wpapsk_kernel.cl", gpu_id, platform_id); /// Alocate memory cl_int cl_error; mem_in = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, insize, NULL, &cl_error); HANDLE_CLERROR(cl_error, "Error alocating mem in"); mem_setting = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, settingsize, NULL, &cl_error); HANDLE_CLERROR(cl_error, "Error alocating mem setting"); mem_out = clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL, &cl_error); HANDLE_CLERROR(cl_error, "Error alocating mem out"); crypt_kernel = clCreateKernel(program[gpu_id], "wpapsk", &cl_error); HANDLE_CLERROR(cl_error, "Error creating kernel"); clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in); clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out); clSetKernelArg(crypt_kernel, 2, sizeof(mem_setting), &mem_setting); find_best_workgroup(); atexit(release_all); }
static void init(struct fmt_main *pFmt) { opencl_init("$JOHN/cryptmd5_opencl_kernel.cl", gpu_id); ///Alocate memory on the GPU cl_int cl_error; mem_in = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, insize, NULL, &cl_error); mem_salt = clCreateBuffer(context[gpu_id], CL_MEM_READ_ONLY, saltsize, NULL, &cl_error); mem_out = clCreateBuffer(context[gpu_id], CL_MEM_WRITE_ONLY, outsize, NULL, &cl_error); ///Assign kernel parameters crypt_kernel = clCreateKernel(program[gpu_id], KERNEL_NAME, &cl_error); clSetKernelArg(crypt_kernel, 0, sizeof(mem_in), &mem_in); clSetKernelArg(crypt_kernel, 1, sizeof(mem_out), &mem_out); clSetKernelArg(crypt_kernel, 2, sizeof(mem_salt), &mem_salt); find_best_workgroup(); //atexit(release_all); }
/* ------- Initialization ------- */ static void init(struct fmt_main * self) { char * tmp_value; char * task = "$JOHN/sha256_kernel.cl"; opencl_init_dev(ocl_gpu_id, platform_id); source_in_use = device_info[ocl_gpu_id]; if ((tmp_value = getenv("_TYPE"))) source_in_use = atoi(tmp_value); opencl_build_kernel(task, ocl_gpu_id); // create kernel(s) to execute crypt_kernel = clCreateKernel(program[ocl_gpu_id], "kernel_crypt", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?"); cmp_kernel = clCreateKernel(program[ocl_gpu_id], "kernel_cmp", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel_cmp. Double-check kernel name?"); global_work_size = get_task_max_size(); local_work_size = 0; if (source_in_use != device_info[ocl_gpu_id]) { device_info[ocl_gpu_id] = source_in_use; fprintf(stderr, "Selected runtime id %d, source (%s)\n", source_in_use, task); } if ((tmp_value = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, LWS_CONFIG))) local_work_size = atoi(tmp_value); if ((tmp_value = getenv("LWS"))) local_work_size = atoi(tmp_value); //Check if local_work_size is a valid number. if (local_work_size > get_task_max_work_group_size()){ fprintf(stderr, "Error: invalid local work size (LWS). Max value allowed is: %zd\n" , get_task_max_work_group_size()); local_work_size = 0; //Force find a valid number. } self->params.max_keys_per_crypt = global_work_size; if (!local_work_size) { local_work_size = get_task_max_work_group_size(); create_clobj(global_work_size, self); find_best_workgroup(self); release_clobj(); } if ((tmp_value = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, GWS_CONFIG))) global_work_size = atoi(tmp_value); if ((tmp_value = getenv("GWS"))) global_work_size = atoi(tmp_value); //Check if a valid multiple is used. global_work_size = get_multiple(global_work_size, local_work_size); if (global_work_size) create_clobj(global_work_size, self); else { //user chose to die of boredom global_work_size = get_task_max_size(); find_best_gws(self); } fprintf(stderr, "Local work size (LWS) %d, global work size (GWS) %zd\n", (int) local_work_size, global_work_size); self->params.max_keys_per_crypt = global_work_size; }
size_t select_device(int jtrUniqDevNo, struct fmt_main *fmt) { cl_int err; const char *errMsg; opencl_init_opt("$JOHN/kernels/pbkdf2_kernel.cl", jtrUniqDevNo, NULL); globalObj[jtrUniqDevNo].krnl[0] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_preprocess", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_preprocess FAILED\n"); return 0; } globalObj[jtrUniqDevNo].krnl[1] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_iter", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_iter FAILED\n"); return 0; } globalObj[jtrUniqDevNo].krnl[2] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_postprocess", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_postprocess FAILED\n"); return 0; } errMsg = "Create Buffer FAILED"; globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_ONLY, 4 * MAX_KEYS_PER_CRYPT * sizeof(cl_uint), NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu == (cl_mem)0) HANDLE_CLERROR(err,errMsg ); globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_ONLY, (MAX_SALT_LENGTH / 2 + 1) * sizeof(cl_uint), NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_WRITE_ONLY, 4 * MAX_KEYS_PER_CRYPT * sizeof(cl_uint), NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_WRITE, MAX_KEYS_PER_CRYPT * sizeof(temp_buf), NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu), "Set Kernel 0 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 1, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu), "Set Kernel 0 Arg 1 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 4, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 0 Arg 4 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[1], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 1 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[2], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 2 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[2], 1, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu), "Set Kernel 2 Arg 1 :FAILED"); if (((!global_work_size) || ((!local_work_size) && global_work_size)) || (active_dev_ctr != 0)) find_best_workgroup(jtrUniqDevNo); else { size_t maxsize, maxsize2; maxsize = get_kernel_preferred_work_group_size(jtrUniqDevNo, globalObj[jtrUniqDevNo].krnl[0]); maxsize2 = get_kernel_preferred_work_group_size(jtrUniqDevNo, globalObj[jtrUniqDevNo].krnl[1]); if (maxsize2 > maxsize) maxsize = maxsize2; maxsize2 = get_kernel_preferred_work_group_size(jtrUniqDevNo, globalObj[jtrUniqDevNo].krnl[2]); if (maxsize2 > maxsize) maxsize = maxsize2; while (local_work_size > maxsize) local_work_size /= 2; if (options.verbosity > 3) fprintf(stderr, "Local worksize (LWS) forced to %zu\n", local_work_size); globalObj[jtrUniqDevNo].lws = local_work_size; } if ((!global_work_size) || (active_dev_ctr != 0)) find_best_gws(jtrUniqDevNo, fmt); else { if (options.verbosity > 3) fprintf(stderr, "Global worksize (GWS) forced to %zu\n", global_work_size); fmt -> params.max_keys_per_crypt = global_work_size; fmt -> params.min_keys_per_crypt = max_lws(); } active_dev_ctr++; return globalObj[jtrUniqDevNo].lws; }
/* ------- Initialization ------- */ static void init(struct fmt_main * self) { char * tmp_value; char * task = "$JOHN/cryptsha512_kernel_DEFAULT.cl"; uint64_t startTime, runtime; opencl_init_dev(ocl_gpu_id, platform_id); startTime = (unsigned long) time(NULL); source_in_use = device_info[ocl_gpu_id]; if ((tmp_value = getenv("_TYPE"))) source_in_use = atoi(tmp_value); if ((tmp_value = getenv("_FAST"))) fast_mode = TRUE; if (use_local(source_in_use)) task = "$JOHN/cryptsha512_kernel_LOCAL.cl"; else if (gpu(source_in_use)) { fprintf(stderr, "Building the kernel, this could take a while\n"); task = "$JOHN/cryptsha512_kernel_GPU.cl"; } fflush(stdout); opencl_build_kernel(task, ocl_gpu_id); if ((runtime = (unsigned long) (time(NULL) - startTime)) > 2UL) fprintf(stderr, "Elapsed time: %lu seconds\n", runtime); fflush(stdout); // create kernel(s) to execute crypt_kernel = clCreateKernel(program[ocl_gpu_id], "kernel_crypt", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel. Double-check kernel name?"); if (gpu(source_in_use) || use_local(source_in_use)) { prepare_kernel = clCreateKernel(program[ocl_gpu_id], "kernel_prepare", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel_prepare. Double-check kernel name?"); final_kernel = clCreateKernel(program[ocl_gpu_id], "kernel_final", &ret_code); HANDLE_CLERROR(ret_code, "Error creating kernel_final. Double-check kernel name?"); } global_work_size = get_task_max_size(); local_work_size = get_default_workgroup(); if (source_in_use != device_info[ocl_gpu_id]) fprintf(stderr, "Selected runtime id %d, source (%s)\n", source_in_use, task); if ((tmp_value = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, LWS_CONFIG))) local_work_size = atoi(tmp_value); if ((tmp_value = getenv("LWS"))) local_work_size = atoi(tmp_value); //Check if local_work_size is a valid number. if (local_work_size > get_task_max_work_group_size()){ local_work_size = 0; //Force find a valid number. } self->params.max_keys_per_crypt = global_work_size; if (!local_work_size) { local_work_size = get_task_max_work_group_size(); create_clobj(global_work_size, self); find_best_workgroup(self); release_clobj(); } if ((tmp_value = cfg_get_param(SECTION_OPTIONS, SUBSECTION_OPENCL, GWS_CONFIG))) global_work_size = atoi(tmp_value); if ((tmp_value = getenv("GWS"))) global_work_size = atoi(tmp_value); //Check if a valid multiple is used. global_work_size = get_multiple(global_work_size, local_work_size); if (global_work_size) create_clobj(global_work_size, self); else { //user chose to die of boredom global_work_size = get_task_max_size(); find_best_gws(self); } fprintf(stderr, "Local work size (LWS) %d, global work size (GWS) %zd\n", (int) local_work_size, global_work_size); self->params.max_keys_per_crypt = global_work_size; }
size_t select_device(int jtrUniqDevNo, struct fmt_main *fmt) { cl_int err; const char *errMsg; size_t memAllocSz; active_dev_ctr++; opencl_init("$JOHN/kernels/pbkdf2_kernel.cl", jtrUniqDevNo, NULL); globalObj[jtrUniqDevNo].krnl[0] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_preprocess_short", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_preprocess_short FAILED\n"); return 0; } globalObj[jtrUniqDevNo].krnl[1] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_preprocess_long", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_preprocess_long FAILED\n"); return 0; } globalObj[jtrUniqDevNo].krnl[2] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_iter", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_iter FAILED\n"); return 0; } globalObj[jtrUniqDevNo].krnl[3] = clCreateKernel(program[jtrUniqDevNo], "pbkdf2_postprocess", &err); if (err) { fprintf(stderr, "Create Kernel pbkdf2_postprocess FAILED\n"); return 0; } errMsg = "Create Buffer FAILED"; memAllocSz = 4 * MAX_KEYS_PER_CRYPT * sizeof(cl_uint); memAllocSz = memAllocSz < get_max_mem_alloc_size(jtrUniqDevNo) ? memAllocSz : get_max_mem_alloc_size(jtrUniqDevNo) / 4 * 4; globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_ONLY, memAllocSz, NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu == (cl_mem)0) HANDLE_CLERROR(err,errMsg ); globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_ONLY, (MAX_SALT_LENGTH / 2 + 1) * sizeof(cl_uint), NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_WRITE_ONLY, memAllocSz, NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); memAllocSz = MAX_KEYS_PER_CRYPT * sizeof(temp_buf); memAllocSz = memAllocSz < get_max_mem_alloc_size(jtrUniqDevNo) ? memAllocSz : get_max_mem_alloc_size(jtrUniqDevNo) / 4 * 4; globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_WRITE, memAllocSz, NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); memAllocSz = 5 * MAX_KEYS_PER_CRYPT * sizeof(cl_uint); memAllocSz = memAllocSz < get_max_mem_alloc_size(jtrUniqDevNo) ? memAllocSz : get_max_mem_alloc_size(jtrUniqDevNo) / 4 * 4; globalObj[jtrUniqDevNo].gpu_buffer.hmac_sha1_gpu = clCreateBuffer(context[jtrUniqDevNo], CL_MEM_READ_WRITE, memAllocSz, NULL, &err); if (globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu == (cl_mem)0) HANDLE_CLERROR(err, errMsg); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu), "Set Kernel 0 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 1, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.salt_gpu), "Set Kernel 0 Arg 1 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[0], 3, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 0 Arg 3 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[1], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.pass_gpu), "Set Kernel 1 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[1], 1, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 1 Arg 1 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[1], 2, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.hmac_sha1_gpu), "Set Kernel 1 Arg 2 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[2], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 2 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[3], 0, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.temp_buf_gpu), "Set Kernel 3 Arg 0 :FAILED"); HANDLE_CLERROR(clSetKernelArg(globalObj[jtrUniqDevNo].krnl[3], 1, sizeof(cl_mem), &globalObj[jtrUniqDevNo].gpu_buffer.hash_out_gpu), "Set Kernel 3 Arg 1 :FAILED"); if (!local_work_size) find_best_workgroup(jtrUniqDevNo, quick_bechmark(jtrUniqDevNo)); else { size_t maxsize, maxsize2; globalObj[jtrUniqDevNo].lws = local_work_size; // Obey limits HANDLE_CLERROR(clGetKernelWorkGroupInfo(globalObj[jtrUniqDevNo].krnl[0], devices[jtrUniqDevNo], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize), &maxsize, NULL), "Error querying max LWS"); HANDLE_CLERROR(clGetKernelWorkGroupInfo(globalObj[jtrUniqDevNo].krnl[1], devices[jtrUniqDevNo], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize2), &maxsize2, NULL), "Error querying max LWS"); if (maxsize2 > maxsize) maxsize = maxsize2; HANDLE_CLERROR(clGetKernelWorkGroupInfo(globalObj[jtrUniqDevNo].krnl[2], devices[jtrUniqDevNo], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize2), &maxsize2, NULL), "Error querying max LWS"); if (maxsize2 > maxsize) maxsize = maxsize2; HANDLE_CLERROR(clGetKernelWorkGroupInfo(globalObj[jtrUniqDevNo].krnl[3], devices[jtrUniqDevNo], CL_KERNEL_WORK_GROUP_SIZE, sizeof(maxsize2), &maxsize2, NULL), "Error querying max LWS"); if (maxsize2 > maxsize) maxsize = maxsize2; while (globalObj[jtrUniqDevNo].lws > maxsize) globalObj[jtrUniqDevNo].lws /= 2; if (options.verbosity > 3) fprintf(stderr, "Local worksize (LWS) forced to "Zu"\n", globalObj[jtrUniqDevNo].lws); globalObj[jtrUniqDevNo].exec_time_inv = 1; } if (!global_work_size) find_best_gws(jtrUniqDevNo, fmt); else { if (options.verbosity > 3) fprintf(stderr, "Global worksize (GWS) forced to "Zu"\n", global_work_size); fmt -> params.max_keys_per_crypt = global_work_size; fmt -> params.min_keys_per_crypt = max_lws(); } return globalObj[jtrUniqDevNo].lws; }