int si_work_item_get_pred(struct si_work_item_t *work_item)
{
struct si_wavefront_t *wavefront = work_item->wavefront;
assert(work_item->id_in_wavefront >= 0 && work_item->id_in_wavefront < wavefront->work_item_count);
return bit_map_get(wavefront->pred, work_item->id_in_wavefront, 1);
}
//{{{ void test_bit_map(void)
void test_bit_map(void)
{
struct bit_map *bm = bit_map_init(100);
TEST_ASSERT_EQUAL(0, bit_map_get(bm, 1000));
bit_map_set(bm, 1000);
TEST_ASSERT_EQUAL(1, bit_map_get(bm, 1000));
uint32_t A[500];
uint32_t i;
A[0] = 1000;
for (i = 1; i < 500; ++i) {
A[i] = rand() % 10000;
bit_map_set(bm, A[i]);
}
qsort(A, 500, sizeof(uint32_t), uint32_t_cmp);
uint32_t j;
for (i = 0; i < 499; ++i) {
TEST_ASSERT_EQUAL(1, bit_map_get(bm, A[i]));
for (j = A[i]+1; j < A[i+1]; ++j)
TEST_ASSERT_EQUAL(0, bit_map_get(bm, j));
}
char *file_name = "test_bit_map.out";
FILE *f = fopen(file_name, "wb");
bit_map_store(bm, f, file_name);
fclose(f);
f = fopen(file_name, "rb");
struct bit_map *bm_r = bit_map_load(f, file_name);
fclose(f);
TEST_ASSERT_EQUAL(bm->num_bits, bm_r->num_bits);
TEST_ASSERT_EQUAL(bm->num_ints, bm_r->num_ints);
for (i = 0; i < 499; ++i) {
TEST_ASSERT_EQUAL(1, bit_map_get(bm_r, A[i]));
for (j = A[i]+1; j < A[i+1]; ++j)
TEST_ASSERT_EQUAL(0, bit_map_get(bm_r, j));
}
bit_map_destroy(&bm);
bit_map_destroy(&bm_r);
remove(file_name);
}
void evg_faults_insert(void)
{
struct evg_fault_t *fault;
struct evg_compute_unit_t *compute_unit;
for (;;)
{
linked_list_head(evg_fault_list);
fault = linked_list_get(evg_fault_list);
if (!fault || fault->cycle > evg_gpu->cycle)
break;
/* Insert fault depending on fault type */
switch (fault->type)
{
case evg_fault_ams:
{
struct evg_work_group_t *work_group;
struct evg_wavefront_t *wavefront;
struct evg_work_item_t *work_item;
int work_group_id; /* in compute unit */
int wavefront_id; /* in compute unit */
int value;
/* Initial debug */
evg_faults_debug("fault clk=%lld cu=%d type=\"ams\" stack=%d am=%d bit=%d ",
evg_gpu->cycle,
fault->compute_unit_id, fault->stack_id,
fault->active_mask_id, fault->bit);
assert(fault->cycle == evg_gpu->cycle);
compute_unit = evg_gpu->compute_units[fault->compute_unit_id];
/* If compute unit is idle, dismiss */
if (!compute_unit->work_group_count)
{
evg_faults_debug("effect=\"cu_idle\"");
goto end_loop;
}
/* Get work-group and wavefront. If wavefront ID exceeds current number, dismiss */
work_group_id = fault->stack_id / evg_gpu->ndrange->wavefronts_per_work_group;
wavefront_id = fault->stack_id % evg_gpu->ndrange->wavefronts_per_work_group;
if (work_group_id >= evg_gpu_max_work_groups_per_compute_unit
|| !compute_unit->work_groups[work_group_id])
{
evg_faults_debug("effect=\"wf_idle\"");
goto end_loop;
}
work_group = compute_unit->work_groups[work_group_id];
wavefront = work_group->wavefronts[wavefront_id];
/* If active_mask_id exceeds stack top, dismiss */
if (fault->active_mask_id > wavefront->stack_top)
{
evg_faults_debug("effect=\"am_idle\"");
goto end_loop;
}
/* If 'bit' exceeds number of work-items in wavefront, dismiss */
if (fault->bit >= wavefront->work_item_count)
{
evg_faults_debug("effect=\"wi_idle\"");
goto end_loop;
}
/* Fault caused an error, show affected software entities */
work_item = wavefront->work_items[fault->bit];
evg_faults_debug("effect=\"error\" wg=%d wf=%d wi=%d",
work_group->id,
wavefront->id,
work_item->id);
/* Inject fault */
value = bit_map_get(wavefront->active_stack,
fault->active_mask_id * wavefront->work_item_count
+ fault->bit, 1);
bit_map_set(wavefront->active_stack,
fault->active_mask_id * wavefront->work_item_count
+ fault->bit, 1, !value);
evg_fault_errors++;
break;
}
case evg_fault_reg:
{
struct evg_opencl_kernel_t *kernel = evg_gpu->ndrange->kernel;
int work_group_id_in_compute_unit;
struct evg_work_group_t *work_group;
struct evg_wavefront_t *wavefront;
int num_registers_per_work_group;
int work_item_id_in_compute_unit;
int work_item_id_in_work_group;
struct evg_work_item_t *work_item;
struct linked_list_t *fetch_queue;
struct evg_uop_t *inst_buffer;
struct evg_uop_t *exec_buffer;
struct heap_t *event_queue;
struct evg_uop_t *uop;
int lo_reg;
/* Initial debug */
evg_faults_debug("fault clk=%lld cu=%d type=\"reg\" reg=%d bit=%d ",
evg_gpu->cycle,
fault->compute_unit_id,
fault->reg_id,
fault->bit);
assert(fault->cycle == evg_gpu->cycle);
compute_unit = evg_gpu->compute_units[fault->compute_unit_id];
/* If compute unit is idle, dismiss */
if (!compute_unit->work_group_count)
{
evg_faults_debug("effect=\"cu_idle\"");
goto end_loop;
}
/* Get work-group */
num_registers_per_work_group = kernel->bin_file->enc_dict_entry_evergreen->num_gpr_used
* kernel->local_size;
work_group_id_in_compute_unit = fault->reg_id / num_registers_per_work_group;
if (work_group_id_in_compute_unit >= evg_gpu_max_work_groups_per_compute_unit)
{
evg_faults_debug("effect=\"reg_idle\"");
goto end_loop;
}
/* Get work-group (again) */
work_group = compute_unit->work_groups[work_group_id_in_compute_unit];
if (!work_group)
{
evg_faults_debug("effect=\"reg_idle\"");
goto end_loop;
}
/* Get affected entities */
work_item_id_in_compute_unit = fault->reg_id
/ kernel->bin_file->enc_dict_entry_evergreen->num_gpr_used;
work_item_id_in_work_group = work_item_id_in_compute_unit % kernel->local_size;
work_item = work_group->work_items[work_item_id_in_work_group];
wavefront = work_item->wavefront;
lo_reg = fault->reg_id % kernel->bin_file->enc_dict_entry_evergreen->num_gpr_used;
/* Fault falling between Fetch and Read stage of an instruction
* consuming register. This case cannot be modeled due to functional
* simulation skew. */
fetch_queue = compute_unit->alu_engine.fetch_queue;
inst_buffer = compute_unit->alu_engine.inst_buffer;
for (linked_list_head(fetch_queue); !linked_list_is_end(fetch_queue);
linked_list_next(fetch_queue))
{
uop = linked_list_get(fetch_queue);
if (evg_stack_faults_is_idep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_read\"");
goto end_loop;
}
}
uop = inst_buffer;
if (uop && evg_stack_faults_is_idep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_read\"");
goto end_loop;
}
/* Fault falling between Fetch and Write stage of an instruction
* writing on the register. The instruction will overwrite the fault,
* so this shouldn't cause its injection. */
exec_buffer = compute_unit->alu_engine.exec_buffer;
for (linked_list_head(fetch_queue); !linked_list_is_end(fetch_queue);
linked_list_next(fetch_queue))
{
uop = linked_list_get(fetch_queue);
if (evg_stack_faults_is_odep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_write\"");
goto end_loop;
}
}
uop = inst_buffer;
if (uop && evg_stack_faults_is_odep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_write\"");
goto end_loop;
}
uop = exec_buffer;
if (uop && evg_stack_faults_is_odep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_write\"");
goto end_loop;
}
event_queue = compute_unit->alu_engine.event_queue;
for (heap_first(event_queue, (void **) &uop); uop;
heap_next(event_queue, (void **) &uop))
{
if (evg_stack_faults_is_odep(uop, wavefront, lo_reg))
{
evg_faults_debug("effect=\"reg_write\"");
goto end_loop;
}
}
/* Fault caused error */
evg_faults_debug("effect=\"error\" ");
evg_faults_debug("wg=%d wf=%d wi=%d lo_reg=%d ",
work_group->id, work_item->wavefront->id, work_item->id, lo_reg);
/* Insert the fault */
if (fault->bit < 32)
work_item->gpr[lo_reg].elem[0] ^= 1 << fault->bit;
else if (fault->bit < 64)
work_item->gpr[lo_reg].elem[1] ^= 1 << (fault->bit - 32);
else if (fault->bit < 96)
work_item->gpr[lo_reg].elem[2] ^= 1 << (fault->bit - 64);
else
work_item->gpr[lo_reg].elem[3] ^= 1 << (fault->bit - 96);
evg_fault_errors++;
break;
}
case evg_fault_mem:
{
struct evg_work_group_t *work_group;
int work_group_id_in_compute_unit;
unsigned char value;
/* Initial debug */
evg_faults_debug("fault clk=%lld cu=%d type=\"mem\" byte=%d bit=%d ",
evg_gpu->cycle,
fault->compute_unit_id,
fault->byte,
fault->bit);
assert(fault->cycle == evg_gpu->cycle);
compute_unit = evg_gpu->compute_units[fault->compute_unit_id];
/* If compute unit is idle, dismiss */
if (!compute_unit->work_group_count)
{
evg_faults_debug("effect=\"cu_idle\"");
goto end_loop;
}
/* Check if there is any local memory used at all */
if (!evg_gpu->ndrange->local_mem_top)
{
evg_faults_debug("effect=\"mem_idle\"");
goto end_loop;
}
/* Get work-group */
work_group_id_in_compute_unit = fault->byte / evg_gpu->ndrange->local_mem_top;
if (work_group_id_in_compute_unit >= evg_gpu_max_work_groups_per_compute_unit)
{
evg_faults_debug("effect=\"mem_idle\"");
goto end_loop;
}
/* Get work-group (again) */
work_group = compute_unit->work_groups[work_group_id_in_compute_unit];
if (!work_group)
{
evg_faults_debug("effect=\"mem_idle\"");
goto end_loop;
}
/* Inject fault */
evg_faults_debug("effect=\"error\" wg=%d ",
work_group->id);
mem_read(work_group->local_mem, fault->byte, 1, &value);
value ^= 1 << fault->bit;
mem_write(work_group->local_mem, fault->byte, 1, &value);
evg_fault_errors++;
break;
}
default:
panic("invalid fault type");
}
end_loop:
/* Extract and free */
free(fault);
linked_list_remove(evg_fault_list);
evg_faults_debug("\n");
/* If all faults were inserted and no error was caused, end simulation */
if (!linked_list_count(evg_fault_list) && !evg_fault_errors)
esim_finish = esim_finish_evg_no_faults;
}
}
