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