void full_cursor_test(Stats_Log *log, Buffer_Set *buffers, int pos,
float *wrap_ys, float *advance_data, float font_height, float max_width,
int test_repitions, void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
Full_Cursor cursor, cursor2;
for (int i = 0; i < test_repitions; ++i){
start(&machine);
cursor = buffer_cursor_from_pos(&buffers->buffer, pos, wrap_ys, max_width, font_height, advance_data);
machine.samples[i].buffer = stop(&machine);
start(&machine);
cursor2 = buffer_cursor_from_pos(&buffers->gap_buffer, pos, wrap_ys, max_width, font_height, advance_data);
machine.samples[i].gap_buffer = stop(&machine);
if (i == 0) assert_4tech(cursor_eq(cursor, cursor2));
start(&machine);
cursor2 = buffer_cursor_from_pos(&buffers->multi_gap_buffer, pos, wrap_ys, max_width, font_height, advance_data);
machine.samples[i].multi_gap_buffer = stop(&machine);
if (i == 0) assert_4tech(cursor_eq(cursor, cursor2));
start(&machine);
cursor2 = buffer_cursor_from_pos(&buffers->rope_buffer, pos, wrap_ys, max_width, font_height, advance_data);
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0) assert_4tech(cursor_eq(cursor, cursor2));
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("full-cursor-seek"), stats_out, machine.samples, machine.count);
}
void batch_edit_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions, float *advance_data,
Buffer_Edit *batch, char *str_base, int batch_size,
void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
printf("batch size: %d\n", replay->replay.count);
log_data_item(log, litstr("batch-size"), replay->replay.count);
int i;
for (i = 0; i < test_repitions; ++i){
start(&machine);
batch_edit(&buffers->buffer, advance_data, batch, str_base, batch_size, scratch, scratch_size);
machine.samples[i].buffer = stop(&machine);
start(&machine);
batch_edit(&buffers->gap_buffer, advance_data, batch, str_base, batch_size, scratch, scratch_size);
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
batch_edit(&buffers->multi_gap_buffer, advance_data, batch, str_base, batch_size, scratch, scratch_size);
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
batch_edit(&buffers->rope_buffer, advance_data, batch, str_base, batch_size, scratch, scratch_size);
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0){
stream_check_test(buffers, scratch, scratch_size);
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("batch-edit"), stats_out, machine.samples, machine.count);
}
void measure_starts_widths_test(Stats_Log *log, Buffer_Set *set, int test_repitions, void *scratch,
int scratch_size, Record_Statistics *stats_out, float *font_widths){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
for (int i = 0; i < test_repitions; ++i){
start(&machine);
measure_starts_widths(&set->buffer, font_widths);
machine.samples[i].buffer = stop(&machine);
start(&machine);
measure_starts_widths(&set->gap_buffer, font_widths);
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
measure_starts_widths(&set->multi_gap_buffer, font_widths);
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
measure_starts_widths(&set->rope_buffer, font_widths);
machine.samples[i].rope_buffer = stop(&machine);
if (i+1 != test_repitions){
free(set->buffer.line_starts);
free(set->gap_buffer.line_starts);
free(set->multi_gap_buffer.line_starts);
free(set->rope_buffer.line_starts);
free(set->buffer.line_widths);
free(set->gap_buffer.line_widths);
free(set->multi_gap_buffer.line_widths);
free(set->rope_buffer.line_widths);
set->buffer.line_max = 0;
set->buffer.line_starts = 0;
set->buffer.widths_max = 0;
set->buffer.line_widths = 0;
set->gap_buffer.line_max = 0;
set->gap_buffer.line_starts = 0;
set->gap_buffer.widths_max = 0;
set->gap_buffer.line_widths = 0;
set->multi_gap_buffer.line_max = 0;
set->multi_gap_buffer.line_starts = 0;
set->multi_gap_buffer.widths_max = 0;
set->multi_gap_buffer.line_widths = 0;
set->rope_buffer.line_max = 0;
set->rope_buffer.line_starts = 0;
set->rope_buffer.widths_max = 0;
set->rope_buffer.line_widths = 0;
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("measure-starts-widths"), stats_out, machine.samples, machine.count);
}
void insert_top_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions, float *advance_data,
int edit_count, void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
char word[] = "stuff";
int word_len = sizeof(word) - 1;
int i, j;
for (i = 0; i < test_repitions; ++i){
start(&machine);
for (j = 0; j < edit_count; ++j){
insert_top(&buffers->buffer, word, word_len,
advance_data, scratch, scratch_size);
}
machine.samples[i].buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
insert_top(&buffers->gap_buffer, word, word_len,
advance_data, scratch, scratch_size);
}
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
insert_top(&buffers->multi_gap_buffer, word, word_len,
advance_data, scratch, scratch_size);
}
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
insert_top(&buffers->rope_buffer, word, word_len,
advance_data, scratch, scratch_size);
}
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0){
stream_check_test(buffers, scratch, scratch_size);
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("insert-top"), stats_out, machine.samples, machine.count);
}
void delete_bottom_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions, float *advance_data,
int edit_count, void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
int len = 5;
int i, j;
for (i = 0; i < test_repitions; ++i){
start(&machine);
for (j = 0; j < edit_count; ++j){
delete_bottom(&buffers->buffer, len,
advance_data, scratch, scratch_size);
}
machine.samples[i].buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
delete_bottom(&buffers->gap_buffer, len,
advance_data, scratch, scratch_size);
}
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
delete_bottom(&buffers->multi_gap_buffer, len,
advance_data, scratch, scratch_size);
}
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
for (j = 0; j < edit_count; ++j){
delete_bottom(&buffers->rope_buffer, len,
advance_data, scratch, scratch_size);
}
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0){
stream_check_test(buffers, scratch, scratch_size);
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("delete-bottom"), stats_out, machine.samples, machine.count);
}
float* measure_wraps_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions, void *scratch,
int scratch_size, Record_Statistics *stats_out, float font_height, float max_width){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
float *wrap_ys, *wrap_ys2;
wrap_ys = (float*)malloc(sizeof(float)*buffers->buffer.line_count);
wrap_ys2 = (float*)malloc(sizeof(float)*buffers->buffer.line_count);
for (int i = 0; i < test_repitions; ++i){
start(&machine);
buffer_measure_wrap_y(&buffers->buffer, wrap_ys, font_height, max_width);
machine.samples[i].buffer = stop(&machine);
start(&machine);
buffer_measure_wrap_y(&buffers->gap_buffer, wrap_ys2, font_height, max_width);
machine.samples[i].gap_buffer = stop(&machine);
if (i == 0)
page_compare((char*)wrap_ys, (char*)wrap_ys2, sizeof(float)*buffers->buffer.line_count);
start(&machine);
buffer_measure_wrap_y(&buffers->multi_gap_buffer, wrap_ys2, font_height, max_width);
machine.samples[i].multi_gap_buffer = stop(&machine);
if (i == 0)
page_compare((char*)wrap_ys, (char*)wrap_ys2, sizeof(float)*buffers->buffer.line_count);
start(&machine);
buffer_measure_wrap_y(&buffers->rope_buffer, wrap_ys2, font_height, max_width);
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0)
page_compare((char*)wrap_ys, (char*)wrap_ys2, sizeof(float)*buffers->buffer.line_count);
}
free(wrap_ys2);
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("measure-wrap-ys"), stats_out, machine.samples, machine.count);
return wrap_ys;
}
int main(int argc, char* argv[]){
Scode * stat;
if(argc != 2){
fprintf(stderr, "%s %s %s\n", "\tUsage: ", argv[0], "filename");
exit(0);
}
start_machine(argv[1]);
while((stat = &prog[pc++])->op != S_HALT){
exec(stat);
#if DEBUG
printf("ap: %d, op: %d, ip: %d\n", ap, op, ip);
#endif
}
#if DEBUG
printf("\n");
print_str_c_table();
#endif
end_machine();
return 0;
}
void initialization_test(Stats_Log *log, Buffer_Set *set, File_Data file, int test_repitions,
void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
for (int i = 0; i < test_repitions; ++i){
start(&machine);
init_buffer(&set->buffer, file, scratch, scratch_size);
machine.samples[i].buffer = stop(&machine);
start(&machine);
init_buffer(&set->gap_buffer, file, scratch, scratch_size);
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
init_buffer(&set->multi_gap_buffer, file, scratch, scratch_size);
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
init_buffer(&set->rope_buffer, file, scratch, scratch_size);
machine.samples[i].rope_buffer = stop(&machine);
if (i+1 != test_repitions){
free(set->buffer.data);
free(set->gap_buffer.data);
for (int j = 0; j < set->multi_gap_buffer.chunk_alloced; ++j){
free(set->multi_gap_buffer.gaps[j].data);
}
free(set->multi_gap_buffer.gaps);
free(set->rope_buffer.data);
free(set->rope_buffer.nodes);
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("initialization"), stats_out, machine.samples, machine.count);
}
void word_seek_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions,
int incremental_position, char *word, int len,
void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
assert_4tech(scratch_size >= len);
int pos, pos2, old_pos;
old_pos = 0;
for (int i = 0; i < machine.count; ++i){
start(&machine);
pos = buffer_find_string(&buffers->buffer, old_pos, word, len, (char*)scratch);
machine.samples[i].buffer = stop(&machine);
start(&machine);
pos2 = buffer_find_string(&buffers->gap_buffer, old_pos, word, len, (char*)scratch);
machine.samples[i].gap_buffer = stop(&machine);
assert_4tech(pos2 == pos);
start(&machine);
pos2 = buffer_find_string(&buffers->multi_gap_buffer, old_pos, word, len, (char*)scratch);
machine.samples[i].multi_gap_buffer = stop(&machine);
assert_4tech(pos2 == pos);
start(&machine);
pos2 = buffer_find_string(&buffers->rope_buffer, old_pos, word, len, (char*)scratch);
machine.samples[i].rope_buffer = stop(&machine);
assert_4tech(pos2 == pos);
if (incremental_position) old_pos = pos;
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("word-seek"), stats_out, machine.samples, machine.count);
}
void natural_edits_test(Stats_Log *log, Buffer_Set *buffers, int test_repitions, float *advance_data,
Replay *replay, void *scratch, int scratch_size, Record_Statistics *stats_out){
Sample_Machine machine;
machine = begin_machine(test_repitions, &scratch, &scratch_size);
printf("edit count: %d\n", replay->replay.count);
log_data_item(log, litstr("edit-count"), replay->replay.count);
int i, j;
for (i = 0; i < test_repitions; ++i){
j = i*buffer_size(&buffers->buffer) / (1+test_repitions);
start(&machine);
natural_edits(&buffers->buffer, advance_data, replay, j, scratch, scratch_size);
machine.samples[i].buffer = stop(&machine);
start(&machine);
natural_edits(&buffers->gap_buffer, advance_data, replay, j, scratch, scratch_size);
machine.samples[i].gap_buffer = stop(&machine);
start(&machine);
natural_edits(&buffers->multi_gap_buffer, advance_data, replay, j, scratch, scratch_size);
machine.samples[i].multi_gap_buffer = stop(&machine);
start(&machine);
natural_edits(&buffers->rope_buffer, advance_data, replay, j, scratch, scratch_size);
machine.samples[i].rope_buffer = stop(&machine);
if (i == 0){
stream_check_test(buffers, scratch, scratch_size);
}
}
end_machine(&machine, stats_out, __FUNCTION__);
log_sample_set(log, litstr("natural-edits"), stats_out, machine.samples, machine.count);
}
