Skip to content

Commit

Permalink
Fixing issue uncovered during benchmarking
Browse files Browse the repository at this point in the history
  • Loading branch information
@zcobell
zcobell committed Sep 30, 2020
1 parent 2cbbb65 commit 7d32d12
Show file tree
Hide file tree
Showing 3 changed files with 64 additions and 65 deletions.
34 changes: 18 additions & 16 deletions bench/main.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -31,6 +31,7 @@ std::vector<std::string> functionList(c_functionSize);
std::vector<int> intList(c_functionSize);

void initializer() {
srand(time(NULL));
t_init = std::chrono::high_resolution_clock::now();
SmartStack::Stack::startSession("Benchmark");
SmartStack::Stack::startFunction("myfunction");
Expand All @@ -43,62 +44,63 @@ void initializer() {
}
}

static void bench_vectorRandomLookup(benchmark::State& state) {
static void bench_vectorRandomLookup(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(functionList[rand() % c_functionSize]);
}
state.SetItemsProcessed(state.iterations());
}

static void bench_compareStrings(benchmark::State& state) {
static void bench_compareStrings(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(functionList[rand() % c_functionSize] ==
functionList[rand() % c_functionSize]);
functionList[rand() % c_functionSize]);
}
state.SetItemsProcessed(state.iterations());
}

static void bench_compareInts(benchmark::State& state) {
static void bench_compareInts(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(intList[rand() % c_functionSize] ==
intList[rand() % c_functionSize]);
intList[rand() % c_functionSize]);
}
state.SetItemsProcessed(state.iterations());
}

static void bench_getFunctionPointer(benchmark::State& state) {
static void bench_getFunctionPointer(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(SmartStack::Stack::get().getFunctionPointer(
functionList[rand() % c_functionSize]));
}
state.SetItemsProcessed(state.iterations());
}

static void bench_getPointerAndStart(benchmark::State& state) {
static void bench_getPointerAndStart(benchmark::State &state) {
while (state.KeepRunning()) {
Function* f = SmartStack::Stack::get().getFunctionPointer(
Function *f = SmartStack::Stack::get().getFunctionPointer(
functionList[rand() % c_functionSize]);
f->startFunction();
}
state.SetItemsProcessed(state.iterations());
}

static void bench_lookupRandomExistingFunction(benchmark::State& state) {
static void bench_lookupRandomExistingFunction(benchmark::State &state) {
while (state.KeepRunning()) {
SmartStack::Stack::startFunction(functionList[rand() % c_functionSize]);
SmartStack::Stack::endFunction();
}
state.SetItemsProcessed(state.iterations());
}

static void bench_lookupSameExistingFunction(benchmark::State& state) {
static void bench_lookupSameExistingFunction(benchmark::State &state) {
while (state.KeepRunning()) {
SmartStack::Stack::startFunction("function_00010000");
SmartStack::Stack::endFunction();
}
state.SetItemsProcessed(state.iterations());
}
static void bench_createFunctionString(benchmark::State& state) {

static void bench_createFunctionString(benchmark::State &state) {
size_t i = 0;
while (state.KeepRunning()) {
i++;
Expand All @@ -108,7 +110,7 @@ static void bench_createFunctionString(benchmark::State& state) {
state.SetItemsProcessed(state.iterations());
}

static void bench_lookupNewFunction(benchmark::State& state) {
static void bench_lookupNewFunction(benchmark::State &state) {
size_t i = 0;
while (state.KeepRunning()) {
i++;
Expand All @@ -120,13 +122,13 @@ static void bench_lookupNewFunction(benchmark::State& state) {
state.SetItemsProcessed(state.iterations());
}

static void bench_startTimer(benchmark::State& state) {
static void bench_startTimer(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(std::chrono::high_resolution_clock::now());
}
}

static void bench_endTimerAndCount(benchmark::State& state) {
static void bench_endTimerAndCount(benchmark::State &state) {
while (state.KeepRunning()) {
std::chrono::high_resolution_clock::time_point b =
std::chrono::high_resolution_clock::now();
Expand All @@ -136,7 +138,7 @@ static void bench_endTimerAndCount(benchmark::State& state) {
}
}

static void bench_hashString(benchmark::State& state) {
static void bench_hashString(benchmark::State &state) {
while (state.KeepRunning()) {
benchmark::DoNotOptimize(std::hash<std::string>()("function_name"));
}
Expand All @@ -155,7 +157,7 @@ BENCHMARK(bench_startTimer);
BENCHMARK(bench_endTimerAndCount);
BENCHMARK(bench_hashString);

int main(int argc, char** argv) {
int main(int argc, char **argv) {
initializer();
::benchmark::Initialize(&argc, argv);
::benchmark::RunSpecifiedBenchmarks();
Expand Down
86 changes: 43 additions & 43 deletions libsmartstack/stack.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,62 +18,66 @@
//------------------------------------------------------------------------//
#include "stack.h"

#include <stdio.h>

#include <cstdio>
#include <algorithm>
#include <fstream>
#include <iostream>

using namespace SmartStack;

bool sortFunctionTimeDecending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->elapsed() > b.get()->timer()->elapsed();
Stack &Stack::get() {
static Stack instance;
return instance;
}

bool sortFunctionTimeDescending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->elapsed() > b->timer()->elapsed();
}

bool sortFunctionTimeAscending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->elapsed() < b.get()->timer()->elapsed();
return a->timer()->elapsed() < b->timer()->elapsed();
}

bool sortFunctionCallsDecending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->numCalls() > b.get()->numCalls();
bool sortFunctionCallsDescending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->numCalls() > b->numCalls();
}

bool sortFunctionCallsAscending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->numCalls() < b.get()->numCalls();
return a->numCalls() < b->numCalls();
}

bool sortFunctionMeanTimeDecending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanDuration() > b.get()->meanDuration();
bool sortFunctionMeanTimeDescending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanDuration() > b->meanDuration();
}

bool sortFunctionMeanTimeAscending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanDuration() < b.get()->meanDuration();
return a->meanDuration() < b->meanDuration();
}

bool sortFunctionMeanTotalTimeAscending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanGlobalDuration() < b.get()->meanGlobalDuration();
return a->meanGlobalDuration() < b->meanGlobalDuration();
}

bool sortFunctionMeanTotalTimeDecending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanGlobalDuration() > b.get()->meanGlobalDuration();
bool sortFunctionMeanTotalTimeDescending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->meanGlobalDuration() > b->meanGlobalDuration();
}

bool sortFunctionTotalTimeAscending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->globalElapsed() < b.get()->timer()->globalElapsed();
return a->timer()->globalElapsed() < b->timer()->globalElapsed();
}

bool sortFunctionTotalTimeDecending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->globalElapsed() > b.get()->timer()->globalElapsed();
bool sortFunctionTotalTimeDescending(const std::unique_ptr<Function> &a,
const std::unique_ptr<Function> &b) {
return a->timer()->globalElapsed() > b->timer()->globalElapsed();
}

Stack::Stack()
Expand Down Expand Up @@ -135,7 +139,7 @@ std::string Stack::getCurrentFunction() {
void Stack::printTimingReport(const SortType &st, const SortOrder &so) {
std::vector<std::string> report =
Stack::get().generateTableTimingReport(st, so);
Stack::get().m_printTimingReport(report);
Stack::m_printTimingReport(report);
}

void Stack::saveTimingReport(const std::string &filename,
Expand All @@ -148,7 +152,7 @@ void Stack::saveTimingReport(const std::string &filename,
} else {
std::vector<std::string> report =
Stack::get().generateTableTimingReport(st, so);
Stack::get().m_saveTableTimimgReport(report, filename);
Stack::m_saveTableTimimgReport(report, filename);
}
}

Expand Down Expand Up @@ -206,9 +210,8 @@ Function *Stack::getFunctionPointer(const std::string &functionName) {
}

Function *Stack::createFunction(const std::string &name) {
std::unique_ptr<Function> f(new Function(name));
this->m_functionLookup[name] = f.get();
this->m_functions.push_back(std::move(f));
this->m_functions.emplace_back(std::make_unique<Function>(name));
this->m_functionLookup[name] = this->m_functions.back().get();
return this->m_functions.back().get();
}

Expand All @@ -219,7 +222,6 @@ void Stack::m_startFunction(const std::string &functionName) {
Function *f = this->getFunctionPointer(functionName);
f->startFunction();
this->m_functionStack.push_back(f);
return;
}

void Stack::m_endFunction() {
Expand All @@ -229,7 +231,6 @@ void Stack::m_endFunction() {
if (!this->m_functionStack.empty()) {
this->m_functionStack.back()->restartFunction();
}
return;
}

void Stack::m_printCurrentStack(const std::string &message) const {
Expand Down Expand Up @@ -303,34 +304,34 @@ void Stack::sortFunctions(const SortType &st, const SortOrder &so) {
sortFunctionTimeAscending);
} else if (st == Time && so == Descending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionTimeDecending);
sortFunctionTimeDescending);
} else if (st == Calls && so == Ascending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionCallsAscending);
} else if (st == Calls && so == Descending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionCallsDecending);
sortFunctionCallsDescending);
} else if (st == MeanTime && so == Ascending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionMeanTimeAscending);
} else if (st == MeanTime && so == Descending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionMeanTimeDecending);
sortFunctionMeanTimeDescending);
} else if (st == MeanTotalTime && so == Descending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionMeanTotalTimeDecending);
sortFunctionMeanTotalTimeDescending);
} else if (st == MeanTotalTime && so == Ascending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionMeanTotalTimeAscending);
} else if (st == TotalTime && so == Descending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionTotalTimeDecending);
sortFunctionTotalTimeDescending);
} else if (st == TotalTime && so == Ascending) {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionTotalTimeAscending);
} else {
std::sort(this->m_functions.begin(), this->m_functions.end(),
sortFunctionTimeDecending);
sortFunctionTimeDescending);
}
}

Expand Down Expand Up @@ -382,7 +383,7 @@ std::vector<std::string> Stack::generateTableTimingReport(const SortType &st,
meanTotalDurationCode;
this->getSortCodes(callCode, durationCode, meanDurationCode,
totalDurationCode, meanTotalDurationCode, st, so);
std::string unit = this->m_unitsString(this->m_reportUnits, false);
std::string unit = SmartStack::Stack::m_unitsString(this->m_reportUnits, false);

std::vector<std::string> table;

Expand Down Expand Up @@ -423,7 +424,7 @@ void Stack::m_setReportUnits(const Stack::TimeUnits &units) {
}

std::string Stack::m_unitsString(const Stack::TimeUnits &units,
bool trim) const {
bool trim) {
if (!trim) {
switch (units) {
case Microseconds:return "(us)";
Expand All @@ -444,11 +445,10 @@ std::string Stack::m_unitsString(const Stack::TimeUnits &units,
return "?";
}

void Stack::m_printTimingReport(const std::vector<std::string> &report) const {
void Stack::m_printTimingReport(const std::vector<std::string> &report) {
for (auto &s : report) {
std::cout << s << std::endl;
}
return;
}

void Stack::m_saveCsvTimingReport(const std::string &filename) {
Expand Down Expand Up @@ -495,12 +495,12 @@ std::string Stack::m_getFunctionReportLine(
break;
}

double ts = this->convertTimeUnitsDouble(f->timer()->elapsed(), multiplier);
double mts = this->convertTimeUnitsDouble(f->meanDuration(), multiplier);
double ts = SmartStack::Stack::convertTimeUnitsDouble(f->timer()->elapsed(), multiplier);
double mts = SmartStack::Stack::convertTimeUnitsDouble(f->meanDuration(), multiplier);
double ats =
this->convertTimeUnitsDouble(f->timer()->globalElapsed(), multiplier);
SmartStack::Stack::convertTimeUnitsDouble(f->timer()->globalElapsed(), multiplier);
double amts =
this->convertTimeUnitsDouble(f->meanGlobalDuration(), multiplier);
SmartStack::Stack::convertTimeUnitsDouble(f->meanGlobalDuration(), multiplier);

if (format == Stack::Table) {
size_t fnnamemx = this->maxNumFunctionChars(13);
Expand Down
9 changes: 3 additions & 6 deletions libsmartstack/stack.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -99,7 +99,7 @@ class Stack {
void m_startFunction(const std::string &functionName);
void m_printCurrentFunction(const std::string &message = std::string()) const;
void m_printCurrentStack(const std::string &message = std::string()) const;
void m_printTimingReport(const std::vector<std::string> &report) const;
static void m_printTimingReport(const std::vector<std::string> &report) ;
static void m_saveTableTimimgReport(const std::vector<std::string> &report,
const std::string &filename) ;
void m_saveCsvTimingReport(const std::string &filename);
Expand All @@ -117,7 +117,7 @@ class Stack {
std::vector<std::string> generateTableTimingReport(const SortType &st,
const SortOrder &so);
void m_setReportUnits(const Stack::TimeUnits &units);
std::string m_unitsString(const Stack::TimeUnits &units, bool trim) const;
static std::string m_unitsString(const Stack::TimeUnits &units, bool trim) ;
static double convertTimeUnitsDouble(long long time,
double multiplier) ;
size_t maxNumFunctionChars(size_t lowerLimit = 0) const;
Expand All @@ -133,10 +133,7 @@ class Stack {
~Stack();

//...Returns a static instance to the SmartStack
static Stack &get() {
static Stack instance;
return instance;
}
static Stack &get();
};
} // namespace SmartStack

Expand Down

0 comments on commit 7d32d12

Please sign in to comment.