int linked_list_contains(LinkedList *list, void *pattern){
/**
* Checks to see if any entry in the provided list matches the data in
* the memory indicated by the provided pointer.
*/
return linked_list_find(list, pattern) != -1;
}
void events_battery_state_service_unsubscribe(EventHandle handle) {
int16_t index = linked_list_find(s_handler_list, handle);
if (index == -1) {
return;
}
free(linked_list_get(s_handler_list, index));
linked_list_remove(s_handler_list, index);
if (linked_list_count(s_handler_list) == 0) {
battery_state_service_unsubscribe();
}
}
void events_app_message_unsubscribe(EventHandle handle) {
int16_t index = linked_list_find(s_handler_list, handle);
if (index == -1) {
return;
}
free(linked_list_get(s_handler_list, index));
linked_list_remove(s_handler_list, index);
if (linked_list_count(s_handler_list) == 0) {
app_message_deregister_callbacks();
}
}
void evg_opencl_command_queue_submit(struct evg_opencl_command_queue_t *command_queue,
struct evg_opencl_command_t *command)
{
struct linked_list_t *command_list;
/* Check that command is not enqueued */
command_list = command_queue->command_list;
linked_list_find(command_list, command);
if (!command_list->error_code)
fatal("%s: command already enqueued", __FUNCTION__);
/* Enqueue command */
linked_list_add(command_list, command);
}
void evg_opencl_command_queue_complete(struct evg_opencl_command_queue_t *command_queue,
struct evg_opencl_command_t *command)
{
struct linked_list_t *command_list;
/* Check that command is in command queue */
command_list = command_queue->command_list;
linked_list_find(command_list, command);
if (command_list->error_code)
fatal("%s: command is not in command queue", __FUNCTION__);
/* Remove command */
linked_list_remove(command_list);
/* x86 contexts might be waiting for the command queue to get empty
* (e.g., suspended in a 'clFinish' call. Check events. */
x86_emu_process_events_schedule();
}
int opengl_vertex_array_obj_repo_remove(struct linked_list_t *vao_repo, struct opengl_vertex_array_obj_t *vao)
{
if (vao->ref_count != 0)
{
opengl_debug("\tVAO #%d [%p] cannot be removed immediately as reference counter = %d\n",
vao->id, vao, vao->ref_count);
return -1;
}
else
{
/* Check that VAO exists */
linked_list_find(vao_repo, vao);
if (vao_repo->error_code)
fatal("%s: VAO does not exist", __FUNCTION__);
linked_list_remove(vao_repo);
opengl_debug("\tVAO #%d [%p] removed from VAO table [%p]\n",
vao->id, vao, vao_repo);
return 1;
}
}
static struct gpu_wavefront_t *gpu_schedule_greedy(struct gpu_compute_unit_t *compute_unit)
{
struct gpu_wavefront_t *wavefront, *temp_wavefront;
struct linked_list_t *wavefront_pool = compute_unit->wavefront_pool;
/* Check all candidates */
temp_wavefront = NULL;
LINKED_LIST_FOR_EACH(wavefront_pool)
{
/* Get wavefront from list */
wavefront = linked_list_get(wavefront_pool);
/* Wavefront must be running,
* and the corresponding slot in fetch buffer must be free. */
assert(wavefront->id_in_compute_unit < gpu->wavefronts_per_compute_unit);
if (!DOUBLE_LINKED_LIST_MEMBER(wavefront->work_group, running, wavefront) ||
compute_unit->cf_engine.fetch_buffer[wavefront->id_in_compute_unit])
continue;
/* Select current wavefront temporarily */
if (!temp_wavefront || temp_wavefront->sched_when < wavefront->sched_when)
temp_wavefront = wavefront;
}
/* No wavefront found */
wavefront = NULL;
if (!temp_wavefront)
return NULL;
/* Wavefront found, remove from pool and return. */
assert(temp_wavefront->clause_kind == GPU_CLAUSE_CF);
linked_list_find(wavefront_pool, temp_wavefront);
assert(!wavefront_pool->error_code);
linked_list_remove(wavefront_pool);
temp_wavefront->sched_when = gpu->cycle;
return temp_wavefront;
}
/* Event handler for EV_MEM_SYSTEM_END_COMMAND.
* The event data is a string of type 'char *' that needs to be deallocated
* after processing this event. */
void mem_system_end_command_handler(int event, void *data)
{
char *command_line = data;
char command[MAX_STRING_SIZE];
char msg[MAX_STRING_SIZE];
char msg_detail[MAX_STRING_SIZE];
char *msg_str = msg;
int msg_size = sizeof msg;
char *msg_detail_str = msg_detail;
int msg_detail_size = sizeof msg_detail;
int test_failed;
struct list_t *token_list;
/* Split command in tokens, skip command */
token_list = str_token_list_create(command_line, " ");
assert(list_count(token_list));
/* Get command */
mem_system_command_get_string(token_list, command_line, command, sizeof command);
/* Messages */
test_failed = 0;
*msg_str = '\0';
*msg_detail_str = '\0';
/* Command 'SetBlock' */
if (!strcasecmp(command, "CheckBlock"))
{
struct mod_t *mod;
int set;
int way;
int tag;
int tag_check;
int state;
int state_check;
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
tag = mem_system_command_get_hex(token_list, command_line);
state = mem_system_command_get_state(token_list, command_line);
mem_system_command_end(token_list, command_line);
/* Check that module serves address */
if (!mod_serves_address(mod, tag))
fatal("%s: %s: module does not serve address 0x%x.\n\t> %s",
__FUNCTION__, mod->name, tag, command_line);
/* Output */
str_printf(&msg_str, &msg_size,
"check module %s, set %d, way %d - state %s, tag 0x%x",
mod->name, set, way, str_map_value(&cache_block_state_map, state), tag);
/* Check */
cache_get_block(mod->cache, set, way, &tag_check, &state_check);
if (tag != tag_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\ttag 0x%x found, but 0x%x expected\n",
tag_check, tag);
}
if (state != state_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tstate %s found, but %s expected\n",
str_map_value(&cache_block_state_map, state_check),
str_map_value(&cache_block_state_map, state));
}
}
/* Command 'CheckOwner' */
else if (!strcasecmp(command, "CheckOwner"))
{
struct mod_t *mod;
struct mod_t *owner;
struct mod_t *owner_check = NULL;
struct net_node_t *net_node;
struct dir_entry_t *dir_entry;
int set;
int way;
int sub_block;
/* Read fields */
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way);
owner = mem_system_command_get_mod(token_list, command_line);
mem_system_command_end(token_list, command_line);
/* Get actual owner */
owner_check = NULL;
if (mod->dir)
{
dir_entry = dir_entry_get(mod->dir, set, way, sub_block);
if (dir_entry->owner >= 0)
{
assert(mod->high_net);
net_node = list_get(mod->high_net->node_list, dir_entry->owner);
owner_check = net_node->user_data;
}
}
/* Message */
str_printf(&msg_str, &msg_size,
"check owner at module %s, set %d, way %d, subblock %d - %s",
mod->name, set, way, sub_block, owner ? owner->name : "None");
/* Check match */
if (owner != owner_check)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\towner %s found, but %s expected\n",
owner_check ? owner_check->name : "None",
owner ? owner->name : "None");
}
}
/* Command 'CheckSharers' */
else if (!strcasecmp(command, "CheckSharers"))
{
struct mod_t *mod;
struct mod_t *sharer;
struct net_node_t *node;
int set;
int way;
int sub_block;
int node_index;
struct linked_list_t *sharers_list;
struct linked_list_t *sharers_check_list;
/* Read fields */
mod = mem_system_command_get_mod(token_list, command_line);
mem_system_command_get_set_way(token_list, command_line, mod, &set, &way);
sub_block = mem_system_command_get_sub_block(token_list, command_line, mod, set, way);
mem_system_command_expect(token_list, command_line);
/* Construct list of expected sharers */
sharers_list = linked_list_create();
while (list_count(token_list))
{
sharer = mem_system_command_get_mod(token_list, command_line);
linked_list_add(sharers_list, sharer);
}
/* Output */
str_printf(&msg_str, &msg_size,
"check sharers at module %s, set %d, way %d, subblock %d - { ",
mod->name, set, way, sub_block);
LINKED_LIST_FOR_EACH(sharers_list)
{
sharer = linked_list_get(sharers_list);
if (sharer)
str_printf(&msg_str, &msg_size, "%s ", sharer->name);
}
str_printf(&msg_str, &msg_size, "}");
/* Construct list of actual sharers */
sharers_check_list = linked_list_create();
assert(mod->high_net);
for (node_index = 0; node_index < mod->high_net->node_count; node_index++)
{
if (!dir_entry_is_sharer(mod->dir, set, way, sub_block, node_index))
continue;
node = list_get(mod->high_net->node_list, node_index);
sharer = node->user_data;
linked_list_add(sharers_check_list, sharer);
}
/* Remove in actual sharers everything from expected sharers */
LINKED_LIST_FOR_EACH(sharers_list)
{
/* Get expected sharer */
sharer = linked_list_get(sharers_list);
if (!sharer)
continue;
/* Check that it's an actual sharer */
linked_list_find(sharers_check_list, sharer);
if (sharers_check_list->error_code)
{
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tsharer %s expected, but not found\n",
sharer->name);
}
/* Remove from actual sharers */
linked_list_remove(sharers_check_list);
}
/* Check that there is no actual sharer left */
LINKED_LIST_FOR_EACH(sharers_check_list)
{
sharer = linked_list_get(sharers_check_list);
test_failed = 1;
str_printf(&msg_detail_str, &msg_detail_size,
"\tsharer %s found, but not expected\n",
sharer->name);
}
/* Free lists */
linked_list_free(sharers_list);
linked_list_free(sharers_check_list);
}
/* Command 'CheckLink' */
else if (!strcasecmp(command, "CheckLink"))
static char* find_invalid(void) {
Object* object = create_object(1);
mu_assert(-1 == linked_list_find(root, object), "Found index for unknown object.");
return 0;
}
static char* find_valid(void) {
Object* object = create_object(1);
linked_list_append(root, object);
mu_assert(0 == linked_list_find(root, object), "Could not find object index.");
return 0;
}