vector<Thread*> File_System_With_Noise::generate() {
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(seq);
//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;
}
vector<Thread*> Example_Workload::generate() {
// This workload begins with a large sequential write of the entire logical address space.
Simple_Thread* init_write = new Synchronous_No_Collision_Random_Writer(min_lba, max_lba, 135);
//Simple_Thread* init_write = new Synchronous_Sequential_Writer(min_lba, max_lba);
init_write->set_io_size(1);
init_write->set_num_ios(NUMBER_OF_ADDRESSABLE_PAGES() * OVER_PROVISIONING_FACTOR);
vector<Thread*> starting_threads;
starting_threads.push_back(init_write);
//init_write->set_num_ios(10000);
// Once the sequential write above is finished, two threads start.
// One performs random writes across the logical address space. The other performs random reads.
// These workloads are synchronous. This means they operate with IO depth 1. The next IO is submitted to the IO
// queue only once the previously subitted IO has finished.
//
// Each thread has an array of threads that it can invoke once it has finished executing all of its IOs.
// This allows creating sophisticated workloads in a modular fashion.
// The method add_follow_up_thread simply makes the init_write thread invoke the two other threads once it has finished.
// The set_num_ios method is just the number of IOs each thread submits before they stop.
// In this case, we let the threads continue submitting IOs indefinitely.
// Nevertheless, in the main method below, we set the number of IOs that are allowed to occur before EagleTree shuts down
// and prints statistics.
int seed1 = 13515;
int seed2 = 264;
Simple_Thread* writer = new Synchronous_Random_Writer(min_lba, max_lba, seed1);
Simple_Thread* reader = new Synchronous_Random_Reader(min_lba, max_lba, seed2);
init_write->add_follow_up_thread(reader);
init_write->add_follow_up_thread(writer);
writer->set_num_ios(INFINITE);
reader->set_num_ios(INFINITE);
return starting_threads;
}
vector<Thread*> Random_Workload::generate() {
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;
}
