diff --git a/.gitignore b/.gitignore index 259148f..5da2634 100644 --- a/.gitignore +++ b/.gitignore @@ -30,3 +30,14 @@ *.exe *.out *.app + +# visual studio build folder +Debug/* +Release/* + +# visual studio project files +.vs/* +median-comparison.sln +median-comparison.vcxproj +median-comparison.vcxproj.filters +median-comparison.vcxproj.user diff --git a/Timing.cpp b/Timing.cpp new file mode 100644 index 0000000..ee5e45f --- /dev/null +++ b/Timing.cpp @@ -0,0 +1,163 @@ +#include +#include +#include +#include "Timing.h" + +Timing* Timing::mInstance = 0; + +/** + * Singleton: Get instance. + */ +Timing* Timing::getInstance() { + if (mInstance == 0) { + mInstance = new Timing(); + } + + return mInstance; +} + +/** + * Start recording time with any name. + */ +void Timing::startRecord(const std::string& name) { + auto start = std::chrono::high_resolution_clock::now(); + + auto it = mRecordings.find(name); + if (it != mRecordings.end()) { + it->second = start; + } else { + mRecordings.insert(std::pair(name, start)); + } + +} + +/** + * Stop recording time with any name. + */ +void Timing::stopRecord(const std::string& name) { + auto end = std::chrono::high_resolution_clock::now(); + + auto it = mRecordings.find(name); + if (it != mRecordings.end()) { + auto start = it->second; + auto result = end - start; + + mResults.insert(std::pair >(name, result)); + } + +} + +/** + * Print measured results human-readable. + * Set prettyPrint to true to display mm:ss.ms instead of ms. + */ +void Timing::print(const bool prettyPrint) const { + std::cout << "-----" << std::endl << "Results: " << std::endl << "-----" << std::endl; + + auto it = mResults.begin(); + while(it != mResults.end()) { + if (prettyPrint) { + std::cout << it->first << ": " << parseDate((int) it->second.count()) << std::endl; + } else { + std::cout << it->first << ": " << it->second.count() << "ms" << std::endl; + } + it++; + } + + std::cout << "-----" << std::endl; +} + +/** + * Parse date from ms to mm:ss.ms. + */ +std::string Timing::parseDate(const int ms) const { + int minutes = (int) (ms / 1000 / 60); + int seconds = (int) ((ms % (1000 * 60)) / 1000); + int milliseconds = (int) (ms % 1000); + + std::ostringstream stringStream; + if (seconds == 60) { + stringStream << minutes + 1 << ":00" << seconds << "."; + } else { + stringStream << minutes << ":" << (seconds < 10 ? "0" : "") << seconds << "."; + } + + if (milliseconds < 100) { + if (milliseconds < 10) { + stringStream << "00" << milliseconds; + } else { + stringStream << "0" << milliseconds; + } + } else { + stringStream << milliseconds; + } + + return stringStream.str(); +} + +/** + * Get results of setup, computation and finalization in form: + * mm:ss.ms;mm:ss.ms;mm.ss.ms + */ +std::string Timing::getResults() const { + std::ostringstream stringStream; + + auto start = mResults.find("setup"); + if (start != mResults.end()) { + stringStream << parseDate((int) start->second.count()) << ";"; + } + + auto computation = mResults.find("computation"); + if (computation != mResults.end()) { + stringStream << parseDate((int) computation->second.count()) << ";"; + } + + auto finalization = mResults.find("finalization"); + if (start != mResults.end()) { + stringStream << parseDate((int) finalization->second.count()); + } + + return stringStream.str(); +} + +/** + * Start recording the setup time. + */ +void Timing::startSetup() { + this->startRecord("setup"); +} + +/** + * Stop recording the setup time. + */ +void Timing::stopSetup() { + this->stopRecord("setup"); +} + +/** + * Start recording the computation time. + */ +void Timing::startComputation() { + this->startRecord("computation"); +} + +/** + * Stop recording the computation time. + */ +void Timing::stopComputation() { + this->stopRecord("computation"); +} + +/** + * Start recording the finalization time. + */ +void Timing::startFinalization() { + this->startRecord("finalization"); +} + +/** + * Stop recording the finalization time. + */ +void Timing::stopFinalization() { + this->stopRecord("finalization"); +} \ No newline at end of file diff --git a/Timing.h b/Timing.h new file mode 100644 index 0000000..dcd9061 --- /dev/null +++ b/Timing.h @@ -0,0 +1,33 @@ +#pragma once +#include +#include +#include + +/** + * Measure high precision time intervals (using std::chrono). + * Author: Karl Hofer + */ +class Timing { +public: + static Timing* getInstance(); + + void startSetup(); + void stopSetup(); + void startComputation(); + void stopComputation(); + void startFinalization(); + void stopFinalization(); + + void startRecord(const std::string& name); + void stopRecord(const std::string& name); + void print(const bool prettyPrint = false) const; + std::string getResults() const; + +private: + Timing() {}; + std::map mRecordings; + std::map > mResults; + std::string parseDate(const int ms) const; + + static Timing* mInstance; +}; diff --git a/fileHandler.h b/fileHandler.h new file mode 100644 index 0000000..9a2317d --- /dev/null +++ b/fileHandler.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include +#include +#include + +std::vector& readFromFile(const char* filePath) +{ + std::vector numbers; + std::cout << "read file: " << filePath << "..." << std::endl; + std::ifstream in(filePath); + if (in.is_open()) + { + std::string line; + std::getline(in, line); + std::cout << "read line " << line << std::endl; + size_t count = std::stoi(line); + + std::cout << "total: " << count << " elems" << std::endl; + + size_t idx = 0; + while (in.good() && idx < count) { + std::getline(in, line); + std::cout << "readline: " << line << std::endl; + //long val = std::stol(line); + //std::cout << "as long: " << val << std::endl; + unsigned long ulval = std::stoul(line); + std::cout << "as unsigned long: " << ulval << std::endl; + numbers.push_back(ulval); + idx++; + } + } + else std::cout << "Error opening " << filePath << std::endl; + + if (!in.eof() && in.fail()) + std::cout << "error reading " << filePath << std::endl; + + in.close(); + return numbers; +} \ No newline at end of file diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..9a6a266 --- /dev/null +++ b/main.cpp @@ -0,0 +1,16 @@ +#include + +#include "fileHandler.h" +#include "Timing.h" + +int main(int argc, char** argv) { + Timing::getInstance()->startRecord("init"); + std::vector numbers = readFromFile("testdata"); + Timing::getInstance()->stopRecord("init"); + + Timing::getInstance()->startRecord("test"); + Timing::getInstance()->stopRecord("test"); + //Timing::getInstance()->getResults(); + Timing::getInstance()->print(); + return 0; +} \ No newline at end of file diff --git a/testdata b/testdata index 67324c9..05b9123 100644 --- a/testdata +++ b/testdata @@ -999998,4 +999998,4 @@ 41388837 1315454792 3184343159 -3292230824 +3292230824 \ No newline at end of file