int test_sky_data_file_deduplicate_insertion_event_data() { struct tagbstring STR1 = bsStatic("foo"); struct tagbstring STR2 = bsStatic("bar"); struct tagbstring STR3 = bsStatic("zzz"); int rc; sky_event *event; sky_data_file *data_file; INIT_DATA_FILE("tests/fixtures/data_files/dedup/0/a", 0); // Add initial event. event = sky_event_create(1, 10LL, 1); event->data_count = 8; event->data = calloc(event->data_count, sizeof(*event->data)); event->data[0] = sky_event_data_create_string(-1, &STR2); event->data[1] = sky_event_data_create_int(-2, 200); event->data[2] = sky_event_data_create_double(-3, 1.0); event->data[3] = sky_event_data_create_boolean(-4, false); event->data[4] = sky_event_data_create_string(1, &STR1); event->data[5] = sky_event_data_create_int(2, 100); event->data[6] = sky_event_data_create_double(3, 100.2); event->data[7] = sky_event_data_create_boolean(4, true); rc = sky_data_file_add_event(data_file, event); mu_assert_int_equals(rc, 0); ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/b"); // Add the same event data, different timestamp. event->timestamp = 11LL; rc = sky_data_file_add_event(data_file, event); mu_assert_int_equals(rc, 0); sky_event_free(event); ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/c"); // Add somewhat different object state event. event = sky_event_create(1, 12LL, 0); event->data_count = 4; event->data = calloc(event->data_count, sizeof(*event->data)); event->data[0] = sky_event_data_create_string(1, &STR3); event->data[1] = sky_event_data_create_int(2, 20); event->data[2] = sky_event_data_create_double(3, 100.2); event->data[3] = sky_event_data_create_boolean(4, false); rc = sky_data_file_add_event(data_file, event); mu_assert_int_equals(rc, 0); sky_event_free(event); ASSERT_DATA_FILE("tests/fixtures/data_files/dedup/0/d"); sky_data_file_free(data_file); return 0; }
// Action-only event. int test_sky_event_action_event_sizeof() { sky_event *event = sky_event_create(0, 1325376000000LL, 20); size_t sz = sky_event_sizeof(event); mu_assert_long_equals(sz, 13L); sky_event_free(event); return 0; }
// Action + data event. int test_sky_event_action_data_event_sizeof() { sky_event *event = sky_event_create(0, 1325376000000LL, 100); sky_event_set_data(event, 1, &foo); sky_event_set_data(event, 2, &bar); size_t sz = sky_event_sizeof(event); mu_assert_long_equals(sz, 27L); sky_event_free(event); return 0; }
// Action event. int test_sky_event_action_event_pack() { size_t sz; void *addr = calloc(ACTION_EVENT_DATA_LENGTH, 1); sky_event *event = sky_event_create(0, 30LL, 20); sky_event_pack(event, addr, &sz); sky_event_free(event); mu_assert_long_equals(sz, ACTION_EVENT_DATA_LENGTH); mu_assert_mem(addr, &ACTION_EVENT_DATA, ACTION_EVENT_DATA_LENGTH); free(addr); return 0; }
int test_sky_event_create() { sky_event *event = sky_event_create(10, 1325376000000LL, 200); mu_assert(event != NULL, "Unable to allocate event"); mu_assert(event->timestamp == 1325376000000LL, "Event timestamp not assigned"); mu_assert(event->object_id == 10, "Event object id not assigned"); mu_assert(event->action_id == 200, "Event action id not assigned"); mu_assert(event->data == NULL, "Event data non-null"); mu_assert(event->data_count == 0, "Event data count not initialized"); sky_event_free(event); return 0; }
// Data event. int test_sky_event_data_event_pack() { size_t sz; void *addr = calloc(DATA_EVENT_DATA_LENGTH, 1); sky_event *event = sky_event_create(0, 30LL, 0); sky_event_set_data(event, 1, &foo); sky_event_set_data(event, 2, &bar); sky_event_pack(event, addr, &sz); sky_event_free(event); mu_assert_long_equals(sz, DATA_EVENT_DATA_LENGTH); mu_assert_mem(addr, &DATA_EVENT_DATA, DATA_EVENT_DATA_LENGTH); free(addr); return 0; }
int test_sky_block_get_path_stats_with_event_in_existing_path() { sky_data_file *data_file; INIT_DATA_FILE("tests/fixtures/blocks/path_stats/a"); sky_block_path_stat *paths = NULL; uint32_t path_count = 0; sky_event *event = sky_event_create(3, 7LL, 20); int rc = sky_block_get_path_stats(data_file->blocks[0], event, &paths, &path_count); mu_assert_int_equals(rc, 0); mu_assert_int_equals(path_count, 2); ASSERT_PATH_STAT(paths[0], 3, 0L, 41L, 52L); ASSERT_PATH_STAT(paths[1], 10, 41L, 60L, 19L); sky_event_free(event); sky_data_file_free(data_file); return 0; }
// Action event. int test_sky_event_action_event_unpack() { size_t sz; sky_event *event = sky_event_create(0, 0, 0); sky_event_unpack(event, &ACTION_EVENT_DATA, &sz); mu_assert_long_equals(sz, ACTION_EVENT_DATA_LENGTH); mu_assert_int64_equals(event->timestamp, 30LL); mu_assert(event->action_id == 20, "Expected action id to equal 20"); mu_assert(event->object_id == 0, "Expected object id to equal 0"); mu_assert(event->data == NULL, "Expected data to be NULL"); mu_assert(event->data_count == 0, "Expected data count to be 0"); sky_event_free(event); return 0; }
// Removes a path reference from memory. // // path - The path to free. void sky_path_free(sky_path *path) { if(path) { // Destroy events. uint32_t i=0; for(i=0; i<path->event_count; i++) { sky_event_free(path->events[i]); path->events[i] = NULL; } if(path->events) free(path->events); path->events = NULL; path->event_count = 0; free(path); } }
int test_sky_event_unset_data() { sky_event_data *data = NULL; sky_event *event = sky_event_create(0, 0, 0); sky_event_set_data(event, 10, &foo); sky_event_set_data(event, 20, &bar); mu_assert(event->data_count == 2, "Expected data count to be 2"); sky_event_unset_data(event, 10); mu_assert(event->data_count == 1, "Expected data count to be 1"); sky_event_get_data(event, 10, &data); mu_assert(data == NULL, "Expected data 10 be NULL"); sky_event_get_data(event, 20, &data); mu_assert(biseqcstr(data->string_value, "bar"), "Expected data 20 to equal 'bar'"); sky_event_free(event); return 0; }
// Action+Data event. int test_sky_event_action_data_event_unpack() { size_t sz; sky_event *event = sky_event_create(0, 0, 0); sky_event_unpack(event, &ACTION_DATA_EVENT_DATA, &sz); mu_assert_long_equals(sz, ACTION_DATA_EVENT_DATA_LENGTH); mu_assert_int64_equals(event->timestamp, 30LL); mu_assert(event->action_id == 20, "Expected action id to equal 20"); mu_assert(event->object_id == 0, "Expected object id to equal 0"); mu_assert(event->data != NULL, "Expected data to not be NULL"); mu_assert(event->data_count == 2, "Expected data count to be 2"); sky_event_data *data = NULL; sky_event_get_data(event, 1, &data); mu_assert(biseqcstr(data->string_value, "foo"), "Expected data 1 to equal 'foo'"); sky_event_get_data(event, 2, &data); mu_assert(biseqcstr(data->string_value, "bar"), "Expected data 1 to equal 'bar'"); sky_event_free(event); return 0; }
int sky_importer_process_event(sky_importer *importer, bstring source, jsmntok_t *tokens, uint32_t *index) { int rc; sky_event *event = NULL; assert(importer != NULL); assert(source != NULL); assert(tokens != NULL); assert(index != NULL); jsmntok_t *event_token = &tokens[*index]; (*index)++; // Open table if it hasn't been already. if(!importer->table->opened) { check(sky_table_open(importer->table) == 0, "Unable to open table"); } // Create the event object. event = sky_event_create(0, 0, 0); check_mem(event); // Process over child tokens. int32_t i; for(i=0; i<(event_token->size/2); i++) { jsmntok_t *token = &tokens[*index]; (*index)++; if(sky_importer_tokstr_equal(source, token, "timestamp")) { bstring timestamp = sky_importer_token_parse_bstring(source, &tokens[(*index)++]); rc = sky_timestamp_parse(timestamp, &event->timestamp); check(rc == 0, "Unable to parse timestamp"); bdestroy(timestamp); } else if(sky_importer_tokstr_equal(source, token, "objectId")) { event->object_id = (sky_object_id_t)sky_importer_token_parse_int(source, &tokens[(*index)++]); } else if(sky_importer_tokstr_equal(source, token, "action")) { sky_action *action = NULL; bstring action_name = sky_importer_token_parse_bstring(source, &tokens[(*index)++]); rc = sky_action_file_find_action_by_name(importer->table->action_file, action_name, &action); bdestroy(action_name); check(rc == 0, "Unable to find action: %s", bdata(action_name)); event->action_id = action->id; } else if(sky_importer_tokstr_equal(source, token, "data")) { rc = sky_importer_process_event_data(importer, event, source, tokens, index); check(rc == 0, "Unable to import event data"); } else { sentinel("Invalid token at char %d", tokens[*index].start); } } // Add event. rc = sky_table_add_event(importer->table, event); check(rc == 0, "Unable to add event"); sky_event_free(event); return 0; error: sky_event_free(event); return -1; }
// Executes the benchmark over the database to compute step counts in order to // generate a directed acyclic graph (DAG). // // options - A list of options to use. void benchmark_dag(Options *options) { int rc; sky_event *event = NULL; uint32_t event_count = 0; int32_t action_count = 100; // TODO: Retrieve action count from actions file. // Initialize table. sky_table *table = sky_table_create(); check_mem(table); rc = sky_table_set_path(table, options->path); check(rc == 0, "Unable to set path on table"); // Open table rc = sky_table_open(table); check(rc == 0, "Unable to open table"); // Loop for desired number of iterations. int i; for(i=0; i<options->iterations; i++) { sky_path_iterator iterator; sky_path_iterator_init(&iterator); // Attach data file. rc = sky_path_iterator_set_data_file(&iterator, table->data_file); check(rc == 0, "Unable to initialze path iterator"); // Create a square matrix of structs. Step *steps = calloc(action_count*action_count, sizeof(Step)); // Iterate over each path. while(!iterator.eof) { sky_action_id_t action_id, prev_action_id; // Retrieve the path pointer. void *path_ptr; rc = sky_path_iterator_get_ptr(&iterator, &path_ptr); check(rc == 0, "Unable to retrieve the path iterator pointer"); // Initialize the cursor. sky_cursor cursor; sky_cursor_init(&cursor); rc = sky_cursor_set_path(&cursor, path_ptr); check(rc == 0, "Unable to set cursor path"); // Increment total event count. event_count++; // Initialize the previous action. rc = sky_cursor_get_action_id(&cursor, &prev_action_id); check(rc == 0, "Unable to retrieve first action"); // Find next event. rc = sky_cursor_next(&cursor); check(rc == 0, "Unable to find next event"); // Loop over each event in the path. while(!cursor.eof) { // Increment total event count. event_count++; // Retrieve action. rc = sky_cursor_get_action_id(&cursor, &action_id); check(rc == 0, "Unable to retrieve first action"); // Aggregate step information. int32_t index = ((prev_action_id-1)*action_count) + (action_id-1); steps[index].count++; // Assign current action as previous action. prev_action_id = action_id; // Find next event. rc = sky_cursor_next(&cursor); check(rc == 0, "Unable to find next event"); } rc = sky_path_iterator_next(&iterator); check(rc == 0, "Unable to find next path"); } // Show DAG data. //int x; //int total=0; //for(x=0; x<action_count*action_count; x++) { // printf("%06d %d\n", x, steps[x].count); // total += steps[x].count; //} //printf("total: %d\n", total); } // Clean up rc = sky_table_close(table); check(rc == 0, "Unable to close table"); sky_table_free(table); // Show stats. printf("Total events processed: %d\n", event_count); return; error: sky_event_free(event); sky_table_free(table); }