arno/hashcat
1
0
Fork 0
mirror of https://github.com/hashcat/hashcat.git synced 2025-08-05 13:25:39 +00:00
Code Issues Releases Wiki Activity

Check for allocatable device-memory depending on kernel_accel amplifier before trying to allocate

Browse Source
This commit is contained in:
Jens Steube 2016-02-10 13:31:04 +01:00
parent f190bf11c1
commit e80541d6dd
1 changed files with 142 additions and 83 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

85
src/oclHashcat.c
View File

@ -13547,6 +13547,8 @@ int main (int argc, char **argv)
uint device_processor_cores = device_param->device_processor_cores;
uint kernel_accel = device_param->kernel_accel;
cl_device_type device_type = device_param->device_type;
/**
@ -13574,6 +13576,7 @@ int main (int argc, char **argv)
if (hash_mode == 3200) kernel_threads = 8;
if (hash_mode == 9000) kernel_threads = 8;
// we need to get rid of this
if (device_type & CL_DEVICE_TYPE_CPU)
{
if (benchmark_mode == 0)
@ -13592,18 +13595,25 @@ int main (int argc, char **argv)
}
}
uint kernel_power = device_processors * kernel_threads * device_param->kernel_accel;
uint kernel_blocks = kernel_power;
device_param->kernel_threads = kernel_threads;
device_param->kernel_power_user = kernel_power;
device_param->kernel_blocks_user = kernel_blocks;
kernel_blocks_all += kernel_blocks;
uint size_pws = kernel_power * sizeof (pw_t);
uint kernel_power = 1;
uint kernel_blocks = 1;
uint size_pws = 4;
uint size_tmps = 4;
uint size_hooks = 4;
// find out if we would request too much memory on memory blocks which are based on kernel_accel
while (kernel_accel)
{
kernel_power = device_processors * kernel_threads * kernel_accel;
kernel_blocks = kernel_power;
// size_pws
size_pws = kernel_blocks * sizeof (pw_t);
// size_tmps
switch (hash_mode)
{
@ -13670,19 +13680,66 @@ int main (int argc, char **argv)
case 13000: size_tmps = kernel_blocks * sizeof (pbkdf2_sha256_tmp_t); break;
};
uint size_hooks = 4;
// size_hooks
if ((opts_type & OPTS_TYPE_HOOK12) || (opts_type & OPTS_TYPE_HOOK23))
{
// insert correct hook size
// none yet
}
// we can optimize some stuff here...
// now check if all device-memory sizes which depend on the kernel_accel amplifier are within its boundaries
// if not, decrease amplifier and try again
if (size_pws > device_param->device_maxmem_alloc)
{
kernel_accel--;
continue;
}
if (size_tmps > device_param->device_maxmem_alloc)
{
kernel_accel--;
continue;
}
if (size_hooks > device_param->device_maxmem_alloc)
{
kernel_accel--;
continue;
}
if ((size_pws + size_tmps + size_hooks) > device_param->device_global_mem)
{
kernel_accel--;
continue;
}
break;
}
if (kernel_accel == 0)
{
log_error ("ERROR: Device #%u does not provide enough allocatable device-memory to handle hash-type %u", device_id + 1, data.hash_mode);
return -1;
}
device_param->kernel_threads = kernel_threads;
device_param->kernel_power_user = kernel_power;
device_param->kernel_blocks_user = kernel_blocks;
kernel_blocks_all += kernel_blocks;
device_param->size_pws = size_pws;
device_param->size_tmps = size_tmps;
device_param->size_hooks = size_hooks;
// we can optimize some stuff here...
uint size_root_css = SP_PW_MAX * sizeof (cs_t);
uint size_markov_css = SP_PW_MAX * CHARSIZ * sizeof (cs_t);
@ -13709,6 +13766,8 @@ int main (int argc, char **argv)
uint size_bfs = KERNEL_BFS * sizeof (bf_t);
uint size_tm = 32 * sizeof (bs_word_t);
// scrypt stuff
u64 size_scryptV = 1;
if ((hash_mode == 8900) || (hash_mode == 9300))