126 lines
3.0 KiB
C++
126 lines
3.0 KiB
C++
#include <iostream>
|
|
#include <string>
|
|
#include <vector>
|
|
#include <algorithm>
|
|
#include <random>
|
|
#include <thread>
|
|
|
|
#include "SearchJob.hpp"
|
|
#include "TestRunner.hpp"
|
|
|
|
|
|
// Type of our hay stack: a list of strings
|
|
typedef std::vector<std::string> WordList;
|
|
|
|
typedef SearchJob<WordList::const_iterator> WordSearchJob;
|
|
|
|
typedef std::vector<WordSearchJob> SearchJobList;
|
|
|
|
|
|
void create_testdata(WordList& words)
|
|
{
|
|
const char start = 'A';
|
|
const char end = 'Z';
|
|
char str[4] = { 'A', 'A', 'A', 'A' };
|
|
|
|
for (str[0] = start; str[0] <= end; str[0]++)
|
|
for (str[1] = start; str[1] <= end; str[1]++)
|
|
for (str[2] = start; str[2] <= end; str[2]++)
|
|
for (str[3] = start; str[3] <= end; str[3]++)
|
|
words.push_back(std::string(str, 4));
|
|
|
|
}
|
|
|
|
void shuffle_testdata(WordList& words)
|
|
{
|
|
auto rng = std::default_random_engine{};
|
|
std::shuffle(words.begin(), words.end(), rng);
|
|
}
|
|
|
|
void run_wordsearch(WordSearchJob& job)
|
|
{
|
|
job.run();
|
|
}
|
|
|
|
void run_parallel_wordsearch(std::vector<WordSearchJob>& jobList)
|
|
{
|
|
std::vector<std::thread> threads;
|
|
|
|
for (WordSearchJob& job : jobList)
|
|
{
|
|
threads.push_back(std::thread(&WordSearchJob::run, &job));
|
|
}
|
|
|
|
for (std::thread& th : threads)
|
|
{
|
|
th.join();
|
|
}
|
|
}
|
|
|
|
int main()
|
|
{
|
|
double time_span;
|
|
std::string pattern = "ABC";
|
|
|
|
WordList test_data;
|
|
|
|
std::cout << "Hello World." << std::endl;
|
|
|
|
time_span = TestRunner(create_testdata, test_data);
|
|
std::cout << "It took me " << time_span << " seconds to create " << test_data.size() << " words." << std::endl;
|
|
|
|
time_span = TestRunner(shuffle_testdata, test_data);
|
|
std::cout << "It took me " << time_span << " seconds to shuffle " << test_data.size() << " words." << std::endl;
|
|
|
|
SearchJob<WordList::const_iterator> job(test_data.begin(), test_data.end(), pattern);
|
|
|
|
time_span = TestRunner(run_wordsearch, job);
|
|
std::cout << "It took me " << time_span << " seconds to find " << job.GetResult().size() << " matches." << std::endl;
|
|
|
|
|
|
std::vector<WordSearchJob> jobList;
|
|
|
|
unsigned coreCount = std::thread::hardware_concurrency();
|
|
std::size_t bucketSize = test_data.size() / coreCount;
|
|
std::size_t remains = test_data.size() % coreCount;
|
|
|
|
std::cout << "Creating " << coreCount << " search jobs, bucketSize = " << bucketSize << std::endl;
|
|
|
|
std::size_t offset = 0;
|
|
while(offset < test_data.size())
|
|
{
|
|
// compute [first; last( iterators for sub-range
|
|
std::size_t size = bucketSize + remains;
|
|
WordList::const_iterator first = test_data.begin() + offset;
|
|
WordList::const_iterator last = first + bucketSize + remains;
|
|
|
|
std::cout << "offset = " << offset << " size = " << size << std::endl;
|
|
|
|
// add appropriate search job
|
|
jobList.push_back(WordSearchJob(first, last, pattern));
|
|
|
|
// increment offset
|
|
offset += size;
|
|
// clear remains (it has been added to first bucket)
|
|
remains = 0;
|
|
}
|
|
|
|
|
|
|
|
time_span = TestRunner(run_parallel_wordsearch, jobList);
|
|
|
|
// collect search results ...
|
|
unsigned found = 0;
|
|
for (WordSearchJob& job : jobList)
|
|
{
|
|
found += job.GetResult().size();
|
|
}
|
|
std::cout << "It took me " << time_span << " seconds to find " << found << " matches." << std::endl;
|
|
|
|
|
|
|
|
std::cout << std::endl;
|
|
|
|
return 0;
|
|
}
|