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);
}
