aca-tasks/task1/main.cpp
2023-11-03 09:03:36 +01:00

107 lines
3.6 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include <fmt/format.h>
#include <vector>
#include <fstream>
#include <string>
#include <chrono>
#include <mergesort.h>
/*
Create a simple sorting application that uses the mergesort algorithm to sort a
large collection (e.g., 10^7 ) of 32-bit integers. The input data and output results
should be stored in files, and the I/O operations should be considered a
sequential part of the application. Mergesort is an algorithm that is considered
appropriate for parallel execution, although it cannot be equally divided between
an arbitrary number of processors, as Amdahls and Gustafson-Barsis laws
require.
Assuming that this equal division is possible, estimate α, i.e., the part of the
program that can be parallelized, by using a profiler like gprof or valgrind to
measure the duration of sorts execution relative to the overall execution
time. Use this number to estimate the predicted speedup for your program.
Does α depend on the size of the input? If it does, how should you modify
your predictions and their graphical illustration?
*/
template<typename T>
auto parse_file(std::ifstream &stream, std::vector<T> &vec) -> void {
std::string buf;
T convbuf;
while (std::getline(stream, buf)) {
convbuf = static_cast<T>(std::stoul(buf));
vec.emplace_back(std::move(convbuf));
}
}
auto main(int argc, char *argv[]) -> int {
try {
std::ifstream file("dataset.dat", std::ios_base::in);
if (!file.is_open()) {
fmt::print("Error opening file");
return -1;
}
fmt::print("Opened file {} sucessfully\n", "dummy");
std::vector<int32_t> dataset;
parse_file(file, dataset);
fmt::print("Read {} values from {}\n", dataset.size(), "dummy");
auto dataset_par = dataset;
auto dataset_seq = dataset;
auto t1 = std::chrono::high_resolution_clock::now();
algo::MergeSort_mt::sort(dataset_seq, [](int32_t a, int32_t b) {
return (a > b);
}, 0);
auto t2 = std::chrono::high_resolution_clock::now();
auto delay_ms = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);
fmt::print("Sorted {} entries within {} ms in sequential\n", dataset_seq.size(), delay_ms.count());
//const int max_depth = std::thread::hardware_concurrency();
const int max_depth = 4;
t1 = std::chrono::high_resolution_clock::now();
algo::MergeSort_mt::sort(dataset_par, [](int32_t a, int32_t b) {
return (a > b);
}, max_depth);
t2 = std::chrono::high_resolution_clock::now();
delay_ms = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1);
fmt::print("Sorted {} entries within {} ms in parallel using {} threads\n", dataset_seq.size(), delay_ms.count(), max_depth);
auto eq = (dataset_seq == dataset_par);
fmt::print("Equality: {}\n", eq);
fmt::print("Parallel dataset: {}; Sequential dataset: {}\n", dataset_par.size(), dataset_seq.size());
//fmt::print("Created {} recurstions", algo::MergeSort_v1::get_recursions());
std::ofstream ofile("dataset.out.dat", std::ios_base::out);
if(!ofile.is_open()) {
fmt::print("Error writing to file");
return -1;
}
for(auto &element : dataset_seq) {
ofile << std::to_string(element) << '\n';
}
file.close();
ofile.flush();
ofile.close();
fmt::print("Written to output file\n");
return 0;
} catch (std::exception e) {
fmt::print("Error occured: {}", e.what());
return -1;
}
}