Grace_Hash_Join::initialize_counter();

int relation_1_start = min_lba;

int relation_1_end = min_lba + (max_lba - min_lba) * r1;

int relation_2_start = relation_1_end + 1;

int relation_2_end = relation_2_start + (max_lba - min_lba) * r2;

int temp_space_start = relation_2_end + 1;

int temp_space_end = max_lba;

Thread* first = new Asynchronous_Sequential_Trimmer(temp_space_start, temp_space_end);

Thread* preceding_thread = first;

for (int i = 0; i < 1000; i++) {

Thread* grace_hash_join = new Grace_Hash_Join( relation_1_start, relation_1_end,

relation_2_start, relation_2_end,

temp_space_start, temp_space_end,

use_flexible_reads, false, 32, 31 * i + 1);

preceding_thread->add_follow_up_thread(grace_hash_join);

preceding_thread = grace_hash_join;

}

vector<Thread*> threads(1, first);

return threads;

Simple_Thread* init_write = new Asynchronous_Sequential_Writer(min_lba, max_lba);

for (int i = 0; i < num_threads; i++) {

int seed = 23621 * i + 62;

Simple_Thread* writer = new Synchronous_Random_Writer(min_lba, max_lba, seed);

Simple_Thread* reader = new Synchronous_Random_Reader(min_lba, max_lba, seed * 136);

init_write->add_follow_up_thread(reader);

init_write->add_follow_up_thread(writer);

writer->set_num_ios(INFINITE);

reader->set_num_ios(INFINITE);

}

vector<Thread*> threads(1, init_write);

return threads;

//Simple_Thread* init_write = new Asynchronous_Sequential_Writer(min_lba, max_lba);

Simple_Thread* thread = new Asynchronous_Random_Reader_Writer(min_lba, max_lba, 2521, writes_probability);

Individual_Threads_Statistics::init();

Individual_Threads_Statistics::register_thread(thread, "");

//init_write->add_follow_up_thread(thread);

//init_write->set_statistics_gatherer(stats);

//init_write->set_experiment_thread(true);

vector<Thread*> threads(1, thread);

return threads;

Simple_Thread* init_write = new Asynchronous_Sequential_Writer(min_lba, max_lba);

Simple_Thread* thread = new Asynchronous_Random_Writer(min_lba, max_lba, 23623);

//Simple_Thread* thread1 = new Asynchronous_Random_Reader(min_lba, max_lba, 2363);

init_write->add_follow_up_thread(thread);

//init_write->add_follow_up_thread(thread1);

vector<Thread*> threads(1, init_write);

return threads;

int seed = 235325;

int num_files = INFINITE;

int max_file_size = 1000;

Thread* fm = new File_Manager(min_lba, max_lba, num_files, max_file_size, seed * 13);

vector<Thread*> threads(1, fm);

return threads;

long log_space_per_thread = max_lba / 4;

long max_file_size = log_space_per_thread / 8;

Simple_Thread* seq = new Asynchronous_Sequential_Writer(0, log_space_per_thread * 2);

Simple_Thread* t1 = new Asynchronous_Random_Writer(0, log_space_per_thread * 2, 35722);

Simple_Thread* t2 = new Asynchronous_Random_Reader(0, log_space_per_thread * 2, 3456);

Thread* t3 = new File_Manager(log_space_per_thread * 2 + 1, log_space_per_thread * 4, INFINITE, max_file_size, 713);

//Thread* t4 = new File_Manager(log_space_per_thread * 3 + 1, log_space_per_thread * 4, INFINITE, max_file_size, 5);

seq->add_follow_up_thread(t1);

//seq->add_follow_up_thread(t2);

seq->add_follow_up_thread(t3);

vector<Thread*> threads;

threads.push_back(t3);

//threads.push_back(t4);

Individual_Threads_Statistics::init();

Individual_Threads_Statistics::register_thread(seq, "Asynchronous Sequential Writer Thread");

Individual_Threads_Statistics::register_thread(t1, "Asynchronous Random Thread Reader");

Individual_Threads_Statistics::register_thread(t2, "Asynchronous Random Thread Writer");

Individual_Threads_Statistics::register_thread(t3, "File Manager 1");

//Individual_Threads_Statistics::register_thread(t4, "File Manager 2");

return threads;