mirror of https://github.com/mosra/magnum.git
Browse Source
Replaces the old & extremely useless Profiler. Doesn't have everything I want yet (missing stddev and fancier GPU queries), that'll come later.pull/432/merge
Vladimír Vondruš
6 years ago
12 changed files with 2905 additions and 3 deletions
@ -0,0 +1,112 @@ |
|||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 |
||||||
|
Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <sstream> |
||||||
|
#include <Corrade/Utility/DebugStl.h> |
||||||
|
|
||||||
|
#include "Magnum/DebugTools/FrameProfiler.h" |
||||||
|
|
||||||
|
/* Hacking around the fugly windowlessapp setup by including OpenGLTester */ |
||||||
|
#include "Magnum/GL/OpenGLTester.h" |
||||||
|
|
||||||
|
using namespace Magnum; |
||||||
|
|
||||||
|
class FrameProfiler: public Platform::WindowlessApplication { |
||||||
|
public: |
||||||
|
explicit FrameProfiler(const Arguments& arguments); |
||||||
|
|
||||||
|
int exec() override { return 0; } |
||||||
|
}; |
||||||
|
|
||||||
|
FrameProfiler::FrameProfiler(const Arguments& arguments): Platform::WindowlessApplication{arguments} { |
||||||
|
/* Enable everything in the GL profiler and then introspect it to fake
|
||||||
|
its output 1:1 */ |
||||||
|
DebugTools::GLFrameProfiler glProfiler{ |
||||||
|
DebugTools::GLFrameProfiler::Value::FrameTime| |
||||||
|
DebugTools::GLFrameProfiler::Value::CpuDuration| |
||||||
|
DebugTools::GLFrameProfiler::Value::GpuDuration| |
||||||
|
DebugTools::GLFrameProfiler::Value::VertexFetchRatio| |
||||||
|
DebugTools::GLFrameProfiler::Value::PrimitiveClipRatio |
||||||
|
, 50}; |
||||||
|
|
||||||
|
DebugTools::FrameProfiler profiler{{ |
||||||
|
DebugTools::FrameProfiler::Measurement{ |
||||||
|
glProfiler.measurementName(0), |
||||||
|
glProfiler.measurementUnits(0), |
||||||
|
glProfiler.measurementDelay(2), |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt, UnsignedInt) { |
||||||
|
return UnsignedLong{16651567}; |
||||||
|
}, nullptr}, |
||||||
|
DebugTools::FrameProfiler::Measurement{ |
||||||
|
glProfiler.measurementName(1), |
||||||
|
glProfiler.measurementUnits(1), |
||||||
|
glProfiler.measurementDelay(2), |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt, UnsignedInt) { |
||||||
|
return UnsignedLong{14720000}; |
||||||
|
}, nullptr}, |
||||||
|
DebugTools::FrameProfiler::Measurement{ |
||||||
|
glProfiler.measurementName(2), |
||||||
|
glProfiler.measurementUnits(2), |
||||||
|
glProfiler.measurementDelay(2), |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt, UnsignedInt) { |
||||||
|
return UnsignedLong{10890000}; |
||||||
|
}, nullptr}, |
||||||
|
DebugTools::FrameProfiler::Measurement{ |
||||||
|
glProfiler.measurementName(3), |
||||||
|
glProfiler.measurementUnits(3), |
||||||
|
glProfiler.measurementDelay(3), |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt, UnsignedInt) { |
||||||
|
return UnsignedLong{240}; |
||||||
|
}, nullptr}, |
||||||
|
DebugTools::FrameProfiler::Measurement{ |
||||||
|
glProfiler.measurementName(4), |
||||||
|
glProfiler.measurementUnits(4), |
||||||
|
glProfiler.measurementDelay(4), |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void*, UnsignedInt, UnsignedInt) { |
||||||
|
return UnsignedLong{59670}; |
||||||
|
}, nullptr}, |
||||||
|
}, 50}; |
||||||
|
|
||||||
|
for(std::size_t i = 0; i != 100; ++i) { |
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
} |
||||||
|
|
||||||
|
std::ostringstream out; /* we don't want a TTY */ |
||||||
|
profiler.printStatistics(Debug{&out}, 1); |
||||||
|
Debug{Debug::Flag::NoNewlineAtTheEnd} << out.str(); |
||||||
|
} |
||||||
|
|
||||||
|
MAGNUM_WINDOWLESSAPPLICATION_MAIN(FrameProfiler) |
||||||
@ -0,0 +1,665 @@ |
|||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 |
||||||
|
Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include "FrameProfiler.h" |
||||||
|
|
||||||
|
#include <chrono> |
||||||
|
#include <sstream> |
||||||
|
#include <Corrade/Containers/EnumSet.hpp> |
||||||
|
#include <Corrade/Containers/GrowableArray.h> |
||||||
|
#include <Corrade/Utility/DebugStl.h> |
||||||
|
#include <Corrade/Utility/FormatStl.h> |
||||||
|
|
||||||
|
#include "Magnum/Math/Functions.h" |
||||||
|
#ifdef MAGNUM_TARGET_GL |
||||||
|
#include "Magnum/GL/TimeQuery.h" |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
#include "Magnum/GL/PipelineStatisticsQuery.h" |
||||||
|
#endif |
||||||
|
#endif |
||||||
|
|
||||||
|
namespace Magnum { namespace DebugTools { |
||||||
|
|
||||||
|
FrameProfiler::Measurement::Measurement(const std::string& name, const Units units, void(*const begin)(void*), UnsignedLong(*const end)(void*), void* const state): _name{name}, _end{nullptr}, _state{state}, _units{units}, _delay{0} { |
||||||
|
_begin.immediate = begin; |
||||||
|
_query.immediate = end; |
||||||
|
} |
||||||
|
|
||||||
|
FrameProfiler::Measurement::Measurement(const std::string& name, const Units units, const UnsignedInt delay, void(*const begin)(void*, UnsignedInt), void(*const end)(void*, UnsignedInt), UnsignedLong(*const query)(void*, UnsignedInt, UnsignedInt), void* const state): _name{name}, _state{state}, _units{units}, _delay{delay} { |
||||||
|
CORRADE_ASSERT(delay >= 1, "DebugTools::FrameProfiler::Measurement: delay can't be zero", ); |
||||||
|
_begin.delayed = begin; |
||||||
|
_end = end; |
||||||
|
_query.delayed = query; |
||||||
|
} |
||||||
|
|
||||||
|
FrameProfiler::FrameProfiler() noexcept = default; |
||||||
|
|
||||||
|
FrameProfiler::FrameProfiler(Containers::Array<Measurement>&& measurements, std::size_t maxFrameCount) noexcept { |
||||||
|
setup(std::move(measurements), maxFrameCount); |
||||||
|
} |
||||||
|
|
||||||
|
FrameProfiler::FrameProfiler(const std::initializer_list<Measurement> measurements, const std::size_t maxFrameCount): FrameProfiler{Containers::array(measurements), maxFrameCount} {} |
||||||
|
|
||||||
|
FrameProfiler::FrameProfiler(FrameProfiler&& other) noexcept: |
||||||
|
_enabled{other._enabled}, |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
_beginFrameCalled{other._beginFrameCalled}, |
||||||
|
#endif |
||||||
|
_currentData{other._currentData}, |
||||||
|
_maxFrameCount{other._maxFrameCount}, |
||||||
|
_measuredFrameCount{other._measuredFrameCount}, |
||||||
|
_measurements{std::move(other._measurements)}, |
||||||
|
_data{std::move(other._data)} |
||||||
|
{ |
||||||
|
/* For all state pointers that point to &other patch them to point to this
|
||||||
|
instead, to account for 90% of use cases of derived classes */ |
||||||
|
for(Measurement& measurement: _measurements) |
||||||
|
if(measurement._state == &other) measurement._state = this; |
||||||
|
} |
||||||
|
|
||||||
|
FrameProfiler& FrameProfiler::operator=(FrameProfiler&& other) noexcept { |
||||||
|
using std::swap; |
||||||
|
swap(_enabled, other._enabled); |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
swap(_beginFrameCalled, other._beginFrameCalled); |
||||||
|
#endif |
||||||
|
swap(_currentData, other._currentData); |
||||||
|
swap(_maxFrameCount, other._maxFrameCount); |
||||||
|
swap(_measuredFrameCount, other._measuredFrameCount); |
||||||
|
swap(_measurements, other._measurements); |
||||||
|
swap(_data, other._data); |
||||||
|
|
||||||
|
/* For all state pointers that point to &other patch them to point to this
|
||||||
|
instead, to account for 90% of use cases of derived classes */ |
||||||
|
for(Measurement& measurement: _measurements) |
||||||
|
if(measurement._state == &other) measurement._state = this; |
||||||
|
|
||||||
|
/* And the same the other way to avoid the other instance accidentally
|
||||||
|
affecting out measurements */ |
||||||
|
for(Measurement& measurement: other._measurements) |
||||||
|
if(measurement._state == this) measurement._state = &other; |
||||||
|
|
||||||
|
return *this; |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::setup(Containers::Array<Measurement>&& measurements, const std::size_t maxFrameCount) { |
||||||
|
CORRADE_ASSERT(maxFrameCount >= 1, "DebugTools::FrameProfiler::setup(): max frame count can't be zero", ); |
||||||
|
|
||||||
|
_maxFrameCount = maxFrameCount; |
||||||
|
_measurements = std::move(measurements); |
||||||
|
arrayReserve(_data, maxFrameCount*_measurements.size()); |
||||||
|
|
||||||
|
/* Calculate the max delay, which signalizes when data will be available.
|
||||||
|
Non-delayed measurements are distinguished by _delay set to 0, so start |
||||||
|
with 1 to exclude these. */ |
||||||
|
for(const Measurement& measurement: _measurements) { |
||||||
|
/* Max frame count is always >= 1, so even if _delay is 0 the condition
|
||||||
|
makes sense and we don't need to do a max() */ |
||||||
|
CORRADE_ASSERT(maxFrameCount >= measurement._delay, |
||||||
|
"DebugTools::FrameProfiler::setup(): max delay" << measurement._delay << "is larger than max frame count" << maxFrameCount, ); |
||||||
|
} |
||||||
|
|
||||||
|
/* Reset to have a clean slate in case we did some other measurements
|
||||||
|
before */ |
||||||
|
enable(); |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::setup(const std::initializer_list<Measurement> measurements, const std::size_t maxFrameCount) { |
||||||
|
setup(Containers::array(measurements), maxFrameCount); |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::enable() { |
||||||
|
_enabled = true; |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
_beginFrameCalled = false; |
||||||
|
#endif |
||||||
|
_currentData = 0; |
||||||
|
_measuredFrameCount = 0; |
||||||
|
arrayResize(_data, 0); |
||||||
|
|
||||||
|
/* Wipe out no longer relevant moving sums from all measurements, and
|
||||||
|
delayed measurement indices as well (tho for these it's not so |
||||||
|
important) */ |
||||||
|
for(Measurement& measurement: _measurements) { |
||||||
|
measurement._movingSum = 0; |
||||||
|
measurement._current = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::disable() { |
||||||
|
_enabled = false; |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::beginFrame() { |
||||||
|
if(!_enabled) return; |
||||||
|
|
||||||
|
CORRADE_ASSERT(!_beginFrameCalled, "DebugTools::FrameProfiler::beginFrame(): expected end of frame", ); |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
_beginFrameCalled = true; |
||||||
|
#endif |
||||||
|
|
||||||
|
/* For all measurements call the begin function */ |
||||||
|
for(const Measurement& measurement: _measurements) { |
||||||
|
if(!measurement._delay) |
||||||
|
measurement._begin.immediate(measurement._state); |
||||||
|
else |
||||||
|
measurement._begin.delayed(measurement._state, measurement._current); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* For delay = 1 returns _currentData */ |
||||||
|
std::size_t FrameProfiler::delayedCurrentData(UnsignedInt delay) const { |
||||||
|
CORRADE_INTERNAL_ASSERT(delay >= 1); |
||||||
|
|
||||||
|
/* The delayed frame is current or before current */ |
||||||
|
if(_currentData >= delay - 1) |
||||||
|
return _currentData - delay + 1; |
||||||
|
|
||||||
|
/* If we have all data, wrap around. If we don't have all data yet, such
|
||||||
|
value doesn't exist and thus this will return an OOB index. If |
||||||
|
everything is implemented correctly, it won't be accessed in any way. */ |
||||||
|
return _maxFrameCount + _currentData - delay + 1; |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::endFrame() { |
||||||
|
if(!_enabled) return; |
||||||
|
|
||||||
|
CORRADE_ASSERT(_beginFrameCalled, "DebugTools::FrameProfiler::endFrame(): expected begin of frame", ); |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
_beginFrameCalled = false; |
||||||
|
#endif |
||||||
|
|
||||||
|
/* If we don't have all frames yet, enlarge the array */ |
||||||
|
if(++_measuredFrameCount <= _maxFrameCount) { |
||||||
|
CORRADE_INTERNAL_ASSERT(_measurements.empty() || _currentData == _data.size()/_measurements.size()); |
||||||
|
arrayAppend(_data, Containers::NoInit, _measurements.size()); |
||||||
|
} |
||||||
|
|
||||||
|
/* Wrap up measurements for this frame */ |
||||||
|
for(std::size_t i = 0; i != _measurements.size(); ++i) { |
||||||
|
Measurement& measurement = _measurements[i]; |
||||||
|
const UnsignedInt measurementDelay = Math::max(1u, measurement._delay); |
||||||
|
|
||||||
|
/* Where to save currently queried data. For _delay of 0 or 1,
|
||||||
|
delayedCurrentData(Math::max(1u, measurement._delay)) is equal to |
||||||
|
_currentData. */ |
||||||
|
UnsignedLong& currentMeasurementData = _data[delayedCurrentData(measurementDelay)*_measurements.size() + i]; |
||||||
|
|
||||||
|
/* If we're wrapping around, subtract the oldest data from the moving
|
||||||
|
average so we can reuse the memory for currently queried data */ |
||||||
|
if(_measuredFrameCount > _maxFrameCount + measurementDelay - 1) { |
||||||
|
CORRADE_INTERNAL_ASSERT(measurement._movingSum >= currentMeasurementData); |
||||||
|
measurement._movingSum -= currentMeasurementData; |
||||||
|
} |
||||||
|
|
||||||
|
/* Simply save the data if not delayed */ |
||||||
|
if(!measurement._delay) |
||||||
|
currentMeasurementData = measurement._query.immediate(measurement._state); |
||||||
|
|
||||||
|
/* For delayed measurements call the end function for current frame and
|
||||||
|
then save the data for the delayed frame */ |
||||||
|
else { |
||||||
|
measurement._end(measurement._state, measurement._current); |
||||||
|
|
||||||
|
/* The slot from which we just retrieved a delayed value will be
|
||||||
|
reused for a a new value next frame */ |
||||||
|
const UnsignedInt previous = (measurement._current + 1) % measurement._delay; |
||||||
|
if(_measuredFrameCount >= measurement._delay) { |
||||||
|
currentMeasurementData = |
||||||
|
measurement._query.delayed(measurement._state, previous, measurement._current); |
||||||
|
} |
||||||
|
measurement._current = previous; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
/* Process the new data if we have enough frames even for the largest
|
||||||
|
delay */ |
||||||
|
for(std::size_t i = 0; i != _measurements.size(); ++i) { |
||||||
|
Measurement& measurement = _measurements[i]; |
||||||
|
const UnsignedInt measurementDelay = Math::max(1u, measurement._delay); |
||||||
|
|
||||||
|
/* If we have enough frames, add the new measurement to the moving sum.
|
||||||
|
For _delay of 0 or 1, delayedCurrentData(Math::max(1u, measurement._delay)) |
||||||
|
is equal to _currentData. */ |
||||||
|
if(_measuredFrameCount >= measurementDelay) |
||||||
|
_measurements[i]._movingSum += _data[delayedCurrentData(measurementDelay)*_measurements.size() + i]; |
||||||
|
} |
||||||
|
|
||||||
|
/* Advance & wraparound the index where data will be saved for the next
|
||||||
|
frame */ |
||||||
|
_currentData = (_currentData + 1) % _maxFrameCount; |
||||||
|
} |
||||||
|
|
||||||
|
std::string FrameProfiler::measurementName(const std::size_t id) const { |
||||||
|
CORRADE_ASSERT(id < _measurements.size(), |
||||||
|
"DebugTools::FrameProfiler::measurementName(): index" << id << "out of range for" << _measurements.size() << "measurements", {}); |
||||||
|
return _measurements[id]._name; |
||||||
|
} |
||||||
|
|
||||||
|
FrameProfiler::Units FrameProfiler::measurementUnits(const std::size_t id) const { |
||||||
|
CORRADE_ASSERT(id < _measurements.size(), |
||||||
|
"DebugTools::FrameProfiler::measurementUnits(): index" << id << "out of range for" << _measurements.size() << "measurements", {}); |
||||||
|
return _measurements[id]._units; |
||||||
|
} |
||||||
|
|
||||||
|
UnsignedInt FrameProfiler::measurementDelay(const std::size_t id) const { |
||||||
|
CORRADE_ASSERT(id < _measurements.size(), |
||||||
|
"DebugTools::FrameProfiler::measurementDelay(): index" << id << "out of range for" << _measurements.size() << "measurements", {}); |
||||||
|
return Math::max(_measurements[id]._delay, 1u); |
||||||
|
} |
||||||
|
|
||||||
|
bool FrameProfiler::isMeasurementAvailable(const std::size_t id) const { |
||||||
|
CORRADE_ASSERT(id < _measurements.size(), |
||||||
|
"DebugTools::FrameProfiler::measurementDelay(): index" << id << "out of range for" << _measurements.size() << "measurements", {}); |
||||||
|
return _measuredFrameCount >= Math::max(_measurements[id]._delay, 1u); |
||||||
|
} |
||||||
|
|
||||||
|
Double FrameProfiler::measurementDataInternal(const Measurement& measurement) const { |
||||||
|
return Double(measurement._movingSum)/ |
||||||
|
Math::min(_measuredFrameCount - Math::max(measurement._delay, 1u) + 1, _maxFrameCount); |
||||||
|
} |
||||||
|
|
||||||
|
Double FrameProfiler::measurementMean(const std::size_t id) const { |
||||||
|
CORRADE_ASSERT(id < _measurements.size(), |
||||||
|
"DebugTools::FrameProfiler::measurementMean(): index" << id << "out of range for" << _measurements.size() << "measurements", {}); |
||||||
|
CORRADE_ASSERT(_measuredFrameCount >= Math::max(_measurements[id]._delay, 1u), "DebugTools::FrameProfiler::measurementMean(): measurement data available after" << Math::max(_measurements[id]._delay, 1u) - _measuredFrameCount << "more frames", {}); |
||||||
|
|
||||||
|
return measurementDataInternal(_measurements[id]); |
||||||
|
} |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
/* Based on Corrade/TestSuite/Implementation/BenchmarkStats.h */ |
||||||
|
|
||||||
|
void printValue(Utility::Debug& out, const Double mean, const Double divisor, const char* const unitPrefix, const char* const units) { |
||||||
|
out << Debug::boldColor(Debug::Color::Green) |
||||||
|
<< Utility::formatString("{:.2f}", mean/divisor) << Debug::resetColor |
||||||
|
<< Debug::nospace << unitPrefix << Debug::nospace << units; |
||||||
|
} |
||||||
|
|
||||||
|
void printTime(Utility::Debug& out, const Double mean) { |
||||||
|
if(mean >= 1000000000.0) |
||||||
|
printValue(out, mean, 1000000000.0, " ", "s"); |
||||||
|
else if(mean >= 1000000.0) |
||||||
|
printValue(out, mean, 1000000.0, " m", "s"); |
||||||
|
else if(mean >= 1000.0) |
||||||
|
printValue(out, mean, 1000.0, " µ", "s"); |
||||||
|
else |
||||||
|
printValue(out, mean, 1.0, " n", "s"); |
||||||
|
} |
||||||
|
|
||||||
|
void printCount(Utility::Debug& out, const Double mean, Double multiplier, const char* const units) { |
||||||
|
if(mean >= multiplier*multiplier*multiplier) |
||||||
|
printValue(out, mean, multiplier*multiplier*multiplier, " G", units); |
||||||
|
else if(mean >= multiplier*multiplier) |
||||||
|
printValue(out, mean, multiplier*multiplier, " M", units); |
||||||
|
else if(mean >= multiplier) |
||||||
|
printValue(out, mean, multiplier, " k", units); |
||||||
|
else |
||||||
|
printValue(out, mean, 1.0, std::strlen(units) ? " " : "", units); |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::printStatisticsInternal(Debug& out) const { |
||||||
|
out << Debug::boldColor(Debug::Color::Default) << "Last" |
||||||
|
<< Debug::boldColor(Debug::Color::Cyan) |
||||||
|
<< Math::min(_measuredFrameCount, _maxFrameCount) |
||||||
|
<< Debug::boldColor(Debug::Color::Default) << "frames:"; |
||||||
|
|
||||||
|
for(const Measurement& measurement: _measurements) { |
||||||
|
out << Debug::newline << " " << Debug::boldColor(Debug::Color::Default) |
||||||
|
<< measurement._name << Debug::nospace << ":" << Debug::resetColor; |
||||||
|
|
||||||
|
/* If this measurement is not available yet, print a placeholder */ |
||||||
|
if(_measuredFrameCount < Math::max(measurement._delay, 1u)) { |
||||||
|
const char* units = nullptr; |
||||||
|
switch(measurement._units) { |
||||||
|
case Units::Count: |
||||||
|
case Units::RatioThousandths: |
||||||
|
units = ""; |
||||||
|
break; |
||||||
|
case Units::Nanoseconds: |
||||||
|
units = "s"; |
||||||
|
break; |
||||||
|
case Units::Bytes: |
||||||
|
units = "B"; |
||||||
|
break; |
||||||
|
case Units::PercentageThousandths: |
||||||
|
units = "%"; |
||||||
|
break; |
||||||
|
} |
||||||
|
CORRADE_INTERNAL_ASSERT(units); |
||||||
|
|
||||||
|
out << Debug::color(Debug::Color::Blue) << "-.--" |
||||||
|
<< Debug::resetColor; |
||||||
|
if(units[0] != '\0') out << units; |
||||||
|
|
||||||
|
/* Otherwise format the value */ |
||||||
|
} else { |
||||||
|
const Double mean = measurementDataInternal(measurement); |
||||||
|
switch(measurement._units) { |
||||||
|
case Units::Nanoseconds: |
||||||
|
printTime(out, mean); |
||||||
|
continue; |
||||||
|
case Units::Bytes: |
||||||
|
printCount(out, mean, 1024.0, "B"); |
||||||
|
continue; |
||||||
|
case Units::Count: |
||||||
|
printCount(out, mean, 1000.0, ""); |
||||||
|
continue; |
||||||
|
case Units::RatioThousandths: |
||||||
|
printCount(out, mean/1000.0, 1000.0, ""); |
||||||
|
continue; |
||||||
|
case Units::PercentageThousandths: |
||||||
|
printValue(out, mean, 1000.0, " ", "%"); |
||||||
|
continue; |
||||||
|
} |
||||||
|
|
||||||
|
CORRADE_INTERNAL_ASSERT_UNREACHABLE(); /* LCOV_EXCL_LINE */ |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
std::string FrameProfiler::statistics() const { |
||||||
|
std::ostringstream out; |
||||||
|
Debug d{&out, Debug::Flag::NoNewlineAtTheEnd|Debug::Flag::DisableColors}; |
||||||
|
printStatisticsInternal(d); |
||||||
|
return out.str(); |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::printStatistics(const std::size_t frequency) const { |
||||||
|
Debug::Flags flags; |
||||||
|
if(!Debug::isTty()) flags |= Debug::Flag::DisableColors; |
||||||
|
printStatistics(Debug{flags}, frequency); |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfiler::printStatistics(Debug& out, const std::size_t frequency) const { |
||||||
|
if(!isEnabled() || _measuredFrameCount % frequency != 0) return; |
||||||
|
|
||||||
|
/* If on a TTY and we printed at least something already, scroll back up to
|
||||||
|
overwrite previous output */ |
||||||
|
if(out.isTty() && _measuredFrameCount > frequency) |
||||||
|
out << Debug::nospace << "\033[" << Debug::nospace |
||||||
|
<< _measurements.size() + 1 << Debug::nospace << "A\033[J" |
||||||
|
<< Debug::nospace; |
||||||
|
|
||||||
|
printStatisticsInternal(out); |
||||||
|
|
||||||
|
/* Unconditionally finish with a newline so the TTY scrollback works
|
||||||
|
correctly */ |
||||||
|
if(out.flags() & Debug::Flag::NoNewlineAtTheEnd) |
||||||
|
out << Debug::newline; |
||||||
|
} |
||||||
|
|
||||||
|
Debug& operator<<(Debug& debug, const FrameProfiler::Units value) { |
||||||
|
debug << "DebugTools::FrameProfiler::Units" << Debug::nospace; |
||||||
|
|
||||||
|
switch(value) { |
||||||
|
/* LCOV_EXCL_START */ |
||||||
|
#define _c(v) case FrameProfiler::Units::v: return debug << "::" #v; |
||||||
|
_c(Nanoseconds) |
||||||
|
_c(Bytes) |
||||||
|
_c(Count) |
||||||
|
_c(RatioThousandths) |
||||||
|
_c(PercentageThousandths) |
||||||
|
#undef _c |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedByte(value)) << Debug::nospace << ")"; |
||||||
|
} |
||||||
|
|
||||||
|
#ifdef MAGNUM_TARGET_GL |
||||||
|
struct GLFrameProfiler::State { |
||||||
|
UnsignedShort cpuDurationIndex = 0xffff, |
||||||
|
gpuDurationIndex = 0xffff, |
||||||
|
frameTimeIndex = 0xffff; |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
UnsignedShort vertexFetchRatioIndex = 0xffff, |
||||||
|
primitiveClipRatioIndex = 0xffff; |
||||||
|
#endif |
||||||
|
UnsignedLong frameTimeStartFrame[2]; |
||||||
|
UnsignedLong cpuDurationStartFrame; |
||||||
|
GL::TimeQuery timeQueries[3]{GL::TimeQuery{NoCreate}, GL::TimeQuery{NoCreate}, GL::TimeQuery{NoCreate}}; |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
GL::PipelineStatisticsQuery verticesSubmittedQueries[3]{GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}}; |
||||||
|
GL::PipelineStatisticsQuery vertexShaderInvocationsQueries[3]{GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}}; |
||||||
|
GL::PipelineStatisticsQuery clippingInputPrimitivesQueries[3]{GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}}; |
||||||
|
GL::PipelineStatisticsQuery clippingOutputPrimitivesQueries[3]{GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}, GL::PipelineStatisticsQuery{NoCreate}}; |
||||||
|
#endif |
||||||
|
}; |
||||||
|
|
||||||
|
GLFrameProfiler::GLFrameProfiler(): _state{Containers::InPlaceInit} {} |
||||||
|
|
||||||
|
GLFrameProfiler::GLFrameProfiler(const Values values, const std::size_t maxFrameCount): GLFrameProfiler{} |
||||||
|
{ |
||||||
|
setup(values, maxFrameCount); |
||||||
|
} |
||||||
|
|
||||||
|
GLFrameProfiler::GLFrameProfiler(GLFrameProfiler&&) noexcept = default; |
||||||
|
|
||||||
|
GLFrameProfiler& GLFrameProfiler::operator=(GLFrameProfiler&&) noexcept = default; |
||||||
|
|
||||||
|
GLFrameProfiler::~GLFrameProfiler() = default; |
||||||
|
|
||||||
|
void GLFrameProfiler::setup(const Values values, const std::size_t maxFrameCount) { |
||||||
|
UnsignedShort index = 0; |
||||||
|
Containers::Array<Measurement> measurements; |
||||||
|
if(values & Value::FrameTime) { |
||||||
|
/* Fucking hell, STL. When I first saw std::chrono back in 2010 I
|
||||||
|
should have flipped the table and learn carpentry instead. BUT NO, |
||||||
|
I'm still suffering this abomination a decade later! */ |
||||||
|
arrayAppend(measurements, Containers::InPlaceInit, |
||||||
|
"Frame time", Units::Nanoseconds, UnsignedInt(Containers::arraySize(_state->frameTimeStartFrame)), |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->frameTimeStartFrame[current] = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); |
||||||
|
}, |
||||||
|
[](void*, UnsignedInt) {}, |
||||||
|
[](void* state, UnsignedInt previous, UnsignedInt current) { |
||||||
|
auto& self = *static_cast<State*>(state); |
||||||
|
return self.frameTimeStartFrame[current] - |
||||||
|
self.frameTimeStartFrame[previous]; |
||||||
|
}, _state.get()); |
||||||
|
_state->frameTimeIndex = index++; |
||||||
|
} |
||||||
|
if(values & Value::CpuDuration) { |
||||||
|
arrayAppend(measurements, Containers::InPlaceInit, |
||||||
|
"CPU duration", Units::Nanoseconds, |
||||||
|
[](void* state) { |
||||||
|
static_cast<State*>(state)->cpuDurationStartFrame = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count(); |
||||||
|
}, |
||||||
|
[](void* state) { |
||||||
|
return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count() - static_cast<State*>(state)->cpuDurationStartFrame; |
||||||
|
}, _state.get()); |
||||||
|
_state->cpuDurationIndex = index++; |
||||||
|
} |
||||||
|
if(values & Value::GpuDuration) { |
||||||
|
for(GL::TimeQuery& q: _state->timeQueries) |
||||||
|
q = GL::TimeQuery{GL::TimeQuery::Target::TimeElapsed}; |
||||||
|
arrayAppend(measurements, Containers::InPlaceInit, |
||||||
|
"GPU duration", Units::Nanoseconds, |
||||||
|
UnsignedInt(Containers::arraySize(_state->timeQueries)), |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->timeQueries[current].begin(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->timeQueries[current].end(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt previous, UnsignedInt) { |
||||||
|
return static_cast<State*>(state)->timeQueries[previous].result<UnsignedLong>(); |
||||||
|
}, _state.get()); |
||||||
|
_state->gpuDurationIndex = index++; |
||||||
|
} |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
if(values & Value::VertexFetchRatio) { |
||||||
|
for(GL::PipelineStatisticsQuery& q: _state->verticesSubmittedQueries) |
||||||
|
q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VerticesSubmitted}; |
||||||
|
for(GL::PipelineStatisticsQuery& q: _state->vertexShaderInvocationsQueries) |
||||||
|
q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::VertexShaderInvocations}; |
||||||
|
arrayAppend(measurements, Containers::InPlaceInit, |
||||||
|
"Vertex fetch ratio", Units::RatioThousandths, |
||||||
|
UnsignedInt(Containers::arraySize(_state->verticesSubmittedQueries)), |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->verticesSubmittedQueries[current].begin(); |
||||||
|
static_cast<State*>(state)->vertexShaderInvocationsQueries[current].begin(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->verticesSubmittedQueries[current].end(); |
||||||
|
static_cast<State*>(state)->vertexShaderInvocationsQueries[current].end(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt previous, UnsignedInt) { |
||||||
|
/* Avoid division by zero if a frame doesn't have any draws */ |
||||||
|
const auto submitted = static_cast<State*>(state)->verticesSubmittedQueries[previous].result<UnsignedLong>(); |
||||||
|
if(!submitted) return UnsignedLong{}; |
||||||
|
|
||||||
|
return static_cast<State*>(state)->vertexShaderInvocationsQueries[previous].result<UnsignedLong>()*1000/submitted; |
||||||
|
}, _state.get()); |
||||||
|
_state->vertexFetchRatioIndex = index++; |
||||||
|
} |
||||||
|
if(values & Value::PrimitiveClipRatio) { |
||||||
|
for(GL::PipelineStatisticsQuery& q: _state->clippingInputPrimitivesQueries) |
||||||
|
q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingInputPrimitives}; |
||||||
|
for(GL::PipelineStatisticsQuery& q: _state->clippingOutputPrimitivesQueries) |
||||||
|
q = GL::PipelineStatisticsQuery{GL::PipelineStatisticsQuery::Target::ClippingOutputPrimitives}; |
||||||
|
arrayAppend(measurements, Containers::InPlaceInit, |
||||||
|
"Primitives clipped", Units::PercentageThousandths, |
||||||
|
UnsignedInt(Containers::arraySize(_state->clippingInputPrimitivesQueries)), |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->clippingInputPrimitivesQueries[current].begin(); |
||||||
|
static_cast<State*>(state)->clippingOutputPrimitivesQueries[current].begin(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt current) { |
||||||
|
static_cast<State*>(state)->clippingInputPrimitivesQueries[current].end(); |
||||||
|
static_cast<State*>(state)->clippingOutputPrimitivesQueries[current].end(); |
||||||
|
}, |
||||||
|
[](void* state, UnsignedInt previous, UnsignedInt) { |
||||||
|
/* Avoid division by zero if a frame doesn't have any draws */ |
||||||
|
const auto input = static_cast<State*>(state)->clippingInputPrimitivesQueries[previous].result<UnsignedLong>(); |
||||||
|
if(!input) return UnsignedLong{}; |
||||||
|
|
||||||
|
return 100000 - static_cast<State*>(state)->clippingOutputPrimitivesQueries[previous].result<UnsignedLong>()*100000/input; |
||||||
|
}, _state.get()); |
||||||
|
_state->primitiveClipRatioIndex = index++; |
||||||
|
} |
||||||
|
#endif |
||||||
|
setup(std::move(measurements), maxFrameCount); |
||||||
|
} |
||||||
|
|
||||||
|
auto GLFrameProfiler::values() const -> Values { |
||||||
|
Values values; |
||||||
|
if(_state->frameTimeIndex != 0xffff) values |= Value::FrameTime; |
||||||
|
if(_state->cpuDurationIndex != 0xffff) values |= Value::CpuDuration; |
||||||
|
if(_state->gpuDurationIndex != 0xffff) values |= Value::GpuDuration; |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
if(_state->vertexFetchRatioIndex != 0xffff) values |= Value::VertexFetchRatio; |
||||||
|
if(_state->primitiveClipRatioIndex != 0xffff) values |= Value::PrimitiveClipRatio; |
||||||
|
#endif |
||||||
|
return values; |
||||||
|
} |
||||||
|
|
||||||
|
bool GLFrameProfiler::isMeasurementAvailable(const Value value) const { |
||||||
|
const UnsignedShort* index = nullptr; |
||||||
|
switch(value) { |
||||||
|
case Value::FrameTime: index = &_state->frameTimeIndex; break; |
||||||
|
case Value::CpuDuration: index = &_state->cpuDurationIndex; break; |
||||||
|
case Value::GpuDuration: index = &_state->gpuDurationIndex; break; |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
case Value::VertexFetchRatio: index = &_state->vertexFetchRatioIndex; break; |
||||||
|
case Value::PrimitiveClipRatio: index = &_state->primitiveClipRatioIndex; break; |
||||||
|
#endif |
||||||
|
} |
||||||
|
CORRADE_INTERNAL_ASSERT(index); |
||||||
|
CORRADE_ASSERT(*index < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::isMeasurementAvailable():" << value << "not enabled", {}); |
||||||
|
return isMeasurementAvailable(*index); |
||||||
|
} |
||||||
|
|
||||||
|
Double GLFrameProfiler::frameTimeMean() const { |
||||||
|
CORRADE_ASSERT(_state->frameTimeIndex < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::frameTimeMean(): not enabled", {}); |
||||||
|
return measurementMean(_state->frameTimeIndex); |
||||||
|
} |
||||||
|
|
||||||
|
Double GLFrameProfiler::cpuDurationMean() const { |
||||||
|
CORRADE_ASSERT(_state->cpuDurationIndex < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::cpuDurationMean(): not enabled", {}); |
||||||
|
return measurementMean(_state->cpuDurationIndex); |
||||||
|
} |
||||||
|
|
||||||
|
Double GLFrameProfiler::gpuDurationMean() const { |
||||||
|
CORRADE_ASSERT(_state->gpuDurationIndex < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::gpuDurationMean(): not enabled", {}); |
||||||
|
return measurementMean(_state->gpuDurationIndex); |
||||||
|
} |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
Double GLFrameProfiler::vertexFetchRatioMean() const { |
||||||
|
CORRADE_ASSERT(_state->vertexFetchRatioIndex < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::vertexFetchRatioMean(): not enabled", {}); |
||||||
|
return measurementMean(_state->vertexFetchRatioIndex); |
||||||
|
} |
||||||
|
|
||||||
|
Double GLFrameProfiler::primitiveClipRatioMean() const { |
||||||
|
CORRADE_ASSERT(_state->primitiveClipRatioIndex < measurementCount(), |
||||||
|
"DebugTools::GLFrameProfiler::primitiveClipRatioMean(): not enabled", {}); |
||||||
|
return measurementMean(_state->primitiveClipRatioIndex); |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
Debug& operator<<(Debug& debug, const GLFrameProfiler::Value value) { |
||||||
|
debug << "DebugTools::GLFrameProfiler::Value" << Debug::nospace; |
||||||
|
|
||||||
|
switch(value) { |
||||||
|
/* LCOV_EXCL_START */ |
||||||
|
#define _c(v) case GLFrameProfiler::Value::v: return debug << "::" #v; |
||||||
|
_c(FrameTime) |
||||||
|
_c(CpuDuration) |
||||||
|
_c(GpuDuration) |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
_c(VertexFetchRatio) |
||||||
|
_c(PrimitiveClipRatio) |
||||||
|
#endif |
||||||
|
#undef _c |
||||||
|
/* LCOV_EXCL_STOP */ |
||||||
|
} |
||||||
|
|
||||||
|
return debug << "(" << Debug::nospace << reinterpret_cast<void*>(UnsignedShort(value)) << Debug::nospace << ")"; |
||||||
|
} |
||||||
|
|
||||||
|
Debug& operator<<(Debug& debug, const GLFrameProfiler::Values value) { |
||||||
|
return Containers::enumSetDebugOutput(debug, value, "DebugTools::GLFrameProfiler::Values{}", { |
||||||
|
GLFrameProfiler::Value::FrameTime, |
||||||
|
GLFrameProfiler::Value::CpuDuration, |
||||||
|
GLFrameProfiler::Value::GpuDuration, |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
GLFrameProfiler::Value::VertexFetchRatio, |
||||||
|
GLFrameProfiler::Value::PrimitiveClipRatio |
||||||
|
#endif |
||||||
|
}); |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
}} |
||||||
@ -0,0 +1,704 @@ |
|||||||
|
#ifndef Magnum_DebugTools_FrameProfiler_h |
||||||
|
#define Magnum_DebugTools_FrameProfiler_h |
||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 |
||||||
|
Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
/** @file
|
||||||
|
* @brief Class @ref Magnum::DebugTools::FrameProfiler, @ref Magnum::DebugTools::GLFrameProfiler |
||||||
|
* @m_since_latest |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <string> |
||||||
|
#include <Corrade/Containers/Array.h> |
||||||
|
#include <Corrade/Containers/Pointer.h> |
||||||
|
|
||||||
|
#include "Magnum/Magnum.h" |
||||||
|
#include "Magnum/DebugTools/visibility.h" |
||||||
|
|
||||||
|
namespace Magnum { namespace DebugTools { |
||||||
|
|
||||||
|
/**
|
||||||
|
@brief Frame profiler |
||||||
|
@m_since_latest |
||||||
|
|
||||||
|
A generic implementation of a frame profiler supporting a moving average over |
||||||
|
a set of frames as well as delayed measurements to avoid stalls when querying |
||||||
|
the results. This class alone doesn't provide any pre-defined measurements, see |
||||||
|
for example @ref GLFrameProfiler that provides common measurements like CPU and |
||||||
|
GPU time. |
||||||
|
|
||||||
|
@experimental |
||||||
|
|
||||||
|
@section DebugTools-FrameProfiler-usage Basic usage |
||||||
|
|
||||||
|
Measurements are performed by calling @ref beginFrame() and @ref endFrame() at |
||||||
|
designated points in the frame: |
||||||
|
|
||||||
|
@snippet MagnumDebugTools.cpp FrameProfiler-usage |
||||||
|
|
||||||
|
In order to have stable profiling results, the application needs to redraw |
||||||
|
constantly. However for applications that otherwise redraw only on change it |
||||||
|
might be wasteful --- to account for this, it's possible to toggle the profiler |
||||||
|
operation using @ref enable() / @ref disable() and then |
||||||
|
@ref Platform::Sdl2Application::redraw() "redraw()" can be called only if |
||||||
|
@ref isEnabled() returns @cpp true @ce. |
||||||
|
|
||||||
|
Data for all measurements is then available through @ref measurementName(), |
||||||
|
@ref measurementUnits() and @ref measurementMean(). For a convenient overview |
||||||
|
of all measured values you can call @ref statistics() and feed its output to a |
||||||
|
UI library or something that can render text. Alternatively, if you don't want |
||||||
|
to bother with text rendering, call @ref printStatistics() to have the output |
||||||
|
periodically printed to the console. If an interactive terminal is detected, |
||||||
|
the output will be colored and refreshing itself in place. Together with the |
||||||
|
on-demand profiling, it could look like this, refreshing the output every 10 |
||||||
|
frames: |
||||||
|
|
||||||
|
@snippet MagnumDebugTools.cpp FrameProfiler-usage-console |
||||||
|
|
||||||
|
And here's a sample output on the terminal --- using a fully configured |
||||||
|
@link GLFrameProfiler @endlink: |
||||||
|
|
||||||
|
@include debugtools-frameprofiler.ansi |
||||||
|
|
||||||
|
@section DebugTools-FrameProfiler-setup Setting up measurements |
||||||
|
|
||||||
|
Unless you're using this class through @ref GLFrameProfiler, measurements |
||||||
|
have to be set up by passing @ref Measurement instances to the @ref setup() |
||||||
|
function or to the constructor, together with specifying count of frames for |
||||||
|
the moving average. A CPU duration measurements using the @ref std::chrono APIs |
||||||
|
over last 50 frames can be done like this: |
||||||
|
|
||||||
|
@snippet MagnumDebugTools.cpp FrameProfiler-setup-immediate |
||||||
|
|
||||||
|
In the above case, the measurement result is available immediately on frame |
||||||
|
end. That's not always the case, and for example GPU queries need a few frames |
||||||
|
delay to avoid stalls from CPU/GPU synchronization. The following snippet sets |
||||||
|
up sample count measurement with a delay, using three separate |
||||||
|
@ref GL::SampleQuery instances that are cycled through each frame and retrieved |
||||||
|
two frames later. The profiler automatically takes care of choosing one of the |
||||||
|
three instances for each measurement via additional `current` / `previous` |
||||||
|
parameters passed to each callback: |
||||||
|
|
||||||
|
@snippet MagnumDebugTools-gl.cpp FrameProfiler-setup-delayed |
||||||
|
|
||||||
|
<b></b> |
||||||
|
|
||||||
|
@m_class{m-block m-warning} |
||||||
|
|
||||||
|
@par Move construction and state pointers in callbacks |
||||||
|
The @ref FrameProfiler class is movable, which could potentially mean that |
||||||
|
state pointers passed to callback functions become dangling. It's not a |
||||||
|
problem in the above snippets because the state is always external to the |
||||||
|
instance, but care has to be taken when passing pointers to subclasses. |
||||||
|
@par |
||||||
|
When setting up measurements from a subclass, it's recommended to always |
||||||
|
pass @cpp this @ce as the state pointer. The base class recognizes it |
||||||
|
during a move and patches the state to point to the new instance instead. |
||||||
|
If you don't or can't use @cpp this @ce as a state pointer, you need to |
||||||
|
either provide a dedicated move constructor and assignment to do the |
||||||
|
required patching or disable moves altogether to avoid accidents. |
||||||
|
*/ |
||||||
|
class MAGNUM_DEBUGTOOLS_EXPORT FrameProfiler { |
||||||
|
public: |
||||||
|
/**
|
||||||
|
* @brief Measurement units |
||||||
|
* |
||||||
|
* @see @ref Measurement |
||||||
|
*/ |
||||||
|
enum class Units: UnsignedByte { |
||||||
|
/**
|
||||||
|
* Nanoseconds, measuring for example elapsed time. Depending on |
||||||
|
* the magnitude, @ref statistics() can show them as microseconds, |
||||||
|
* milliseconds or seconds. |
||||||
|
*/ |
||||||
|
Nanoseconds, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Bytes, measuring for example memory usage, bandwidth. Depending |
||||||
|
* on the magnitude, @ref statistics() can show them as kB, MB, GB |
||||||
|
* (with a multiplier of 1024). |
||||||
|
*/ |
||||||
|
Bytes, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Generic count. For discrete values that don't fit any of the |
||||||
|
* above. Depending on the magnitude, @ref statistics() can show |
||||||
|
* the value as k, M or G (with a multiplier of 1000). |
||||||
|
*/ |
||||||
|
Count, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Ratio expressed in 1/1000s. @ref statistics() divides the value |
||||||
|
* by 1000 and depending on the magnitude it can show it also as k, |
||||||
|
* M or G (with a multiplier of 1000). |
||||||
|
*/ |
||||||
|
RatioThousandths, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Percentage expressed in 1/1000s. @ref statistics() divides the |
||||||
|
* value by 1000 and appends a % sign. |
||||||
|
*/ |
||||||
|
PercentageThousandths |
||||||
|
}; |
||||||
|
|
||||||
|
class Measurement; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Default constructor |
||||||
|
* |
||||||
|
* Call @ref setup() to populate the profiler with measurements. |
||||||
|
*/ |
||||||
|
explicit FrameProfiler() noexcept; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Constructor |
||||||
|
* |
||||||
|
* Equivalent to default-constructing an instance and calling |
||||||
|
* @ref setup() afterwards. |
||||||
|
*/ |
||||||
|
explicit FrameProfiler(Containers::Array<Measurement>&& measurements, std::size_t maxFrameCount) noexcept; |
||||||
|
|
||||||
|
/** @overload */ |
||||||
|
explicit FrameProfiler(std::initializer_list<Measurement> measurements, std::size_t maxFrameCount); |
||||||
|
|
||||||
|
/** @brief Copying is not allowed */ |
||||||
|
FrameProfiler(const FrameProfiler&) = delete; |
||||||
|
|
||||||
|
/** @brief Move constructor */ |
||||||
|
FrameProfiler(FrameProfiler&&) noexcept; |
||||||
|
|
||||||
|
/** @brief Copying is not allowed */ |
||||||
|
FrameProfiler& operator=(const FrameProfiler&) = delete; |
||||||
|
|
||||||
|
/** @brief Move assignment */ |
||||||
|
FrameProfiler& operator=(FrameProfiler&&) noexcept; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Setup measurements |
||||||
|
* @param measurements List of measurements |
||||||
|
* @param maxFrameCount Max frame count over which to calculate a |
||||||
|
* moving average. Expected to be at least @cpp 1 @ce. |
||||||
|
* |
||||||
|
* Calling @ref setup() on an already set up profiler will replace |
||||||
|
* existing measurements with @p measurements and reset |
||||||
|
* @ref measuredFrameCount() back to @cpp 0 @ce. |
||||||
|
*/ |
||||||
|
void setup(Containers::Array<Measurement>&& measurements, std::size_t maxFrameCount); |
||||||
|
|
||||||
|
/** @overload */ |
||||||
|
void setup(std::initializer_list<Measurement> measurements, std::size_t maxFrameCount); |
||||||
|
|
||||||
|
/** @brief Whether the profiling is enabled */ |
||||||
|
bool isEnabled() const { return _enabled; } |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Enable the profiler |
||||||
|
* |
||||||
|
* The profiler is enabled implicitly after construction. When this |
||||||
|
* function is called, it discards all measured data, effectively |
||||||
|
* making @ref measuredFrameCount() zero. If you want to reset the |
||||||
|
* profiler to measure different values as well, call @ref setup(). |
||||||
|
*/ |
||||||
|
void enable(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Disable the profiler |
||||||
|
* |
||||||
|
* Disabling the profiler will make @ref beginFrame() and |
||||||
|
* @ref endFrame() a no-op, effectively freezing all reported |
||||||
|
* measurements until the profiler is enabled again. |
||||||
|
*/ |
||||||
|
void disable(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Begin a frame |
||||||
|
* |
||||||
|
* Has to be called at the beginning of a frame and be paired with a |
||||||
|
* corresponding @ref endFrame(). Calls @p begin functions in all |
||||||
|
* @ref Measurement instances passed to @ref setup(). If the profiler |
||||||
|
* is disabled, the function is a no-op. |
||||||
|
* @see @ref isEnabled() |
||||||
|
*/ |
||||||
|
void beginFrame(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief End a frame |
||||||
|
* |
||||||
|
* Has to be called at the end of frame, before buffer swap, and be |
||||||
|
* paired with a corresponding @ref beginFrame(). Calls @p end |
||||||
|
* functions in all @ref Measurement instances passed to @ref setup() |
||||||
|
* and @p query functions on all measurements that are sufficiently |
||||||
|
* delayed, saving their output. If the profiler is disabled, the |
||||||
|
* function is a no-op. |
||||||
|
* @see @ref isEnabled() |
||||||
|
*/ |
||||||
|
void endFrame(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Max count of measured frames |
||||||
|
* |
||||||
|
* How many frames to calculate a moving average from. At the beginning |
||||||
|
* of a measurement when there's not enough frames, the average is |
||||||
|
* calculated only from @ref measuredFrameCount(). Always at least |
||||||
|
* @cpp 1 @ce. |
||||||
|
*/ |
||||||
|
std::size_t maxFrameCount() const { return _maxFrameCount; } |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Count of measured frames |
||||||
|
* |
||||||
|
* Count of times @ref endFrame() was called, but at most |
||||||
|
* @ref maxFrameCount(), after which the profiler calculates a moving |
||||||
|
* average over last @ref maxFrameCount() frames only. Actual data |
||||||
|
* availability depends on @ref measurementDelay(). |
||||||
|
*/ |
||||||
|
std::size_t measuredFrameCount() const { return _measuredFrameCount; } |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measurement count |
||||||
|
* |
||||||
|
* Count of @ref Measurement instances passed to @ref setup(). If |
||||||
|
* @ref setup() was not called yet, returns @cpp 0 @ce. |
||||||
|
*/ |
||||||
|
std::size_t measurementCount() const { return _measurements.size(); } |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measurement name |
||||||
|
* |
||||||
|
* The @p id corresponds to the index of the measurement in the list |
||||||
|
* passed to @ref setup(). Expects that @p id is less than |
||||||
|
* @ref measurementCount(). |
||||||
|
*/ |
||||||
|
std::string measurementName(std::size_t id) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measurement units |
||||||
|
* |
||||||
|
* The @p id corresponds to the index of the measurement in the list |
||||||
|
* passed to @ref setup(). Expects that @p id is less than |
||||||
|
* @ref measurementCount(). |
||||||
|
*/ |
||||||
|
Units measurementUnits(std::size_t id) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measurement delay |
||||||
|
* |
||||||
|
* How many @ref beginFrame() / @ref endFrame() call pairs needs to be |
||||||
|
* performed before a value for given measurement is available. Always |
||||||
|
* at least @cpp 1 @ce. The @p id corresponds to the index of the |
||||||
|
* measurement in the list passed to @ref setup(). Expects that @p id |
||||||
|
* is less than @ref measurementCount(). |
||||||
|
*/ |
||||||
|
UnsignedInt measurementDelay(std::size_t id) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Whether given measurement is available |
||||||
|
* |
||||||
|
* Returns @cpp true @ce if @ref measuredFrameCount() is at least |
||||||
|
* @ref measurementDelay() for given @p id, @cpp false @ce otherwise. |
||||||
|
* The @p id corresponds to the index of the measurement in the list |
||||||
|
* passed to @ref setup(). Expects that @p id is less than |
||||||
|
* @ref measurementCount(). |
||||||
|
*/ |
||||||
|
bool isMeasurementAvailable(std::size_t id) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measurement mean |
||||||
|
* |
||||||
|
* Returns a moving average of @f$ n @f$ previous measurements out of |
||||||
|
* the total @f$ M @f$ values: @f[ |
||||||
|
* \bar{x}_\text{SM} = \dfrac{1}{n} \sum\limits_{i=0}^{n-1} x_{M -i} |
||||||
|
* @f] |
||||||
|
* |
||||||
|
* The @p id corresponds to the index of the measurement in the list |
||||||
|
* passed to @ref setup(). Expects that @p id is less than |
||||||
|
* @ref measurementCount() and that the measurement is available. |
||||||
|
* @see @ref isMeasurementAvailable() |
||||||
|
*/ |
||||||
|
Double measurementMean(std::size_t id) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Overview of all measurements |
||||||
|
* |
||||||
|
* Returns a formatted string with names, means and units of all |
||||||
|
* measurements in the order they were added. If some measurement data |
||||||
|
* is available yet, prints placeholder values for these; if the |
||||||
|
* @see @ref isMeasurementAvailable(), @ref isEnabled() |
||||||
|
*/ |
||||||
|
std::string statistics() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Print an overview of all measurements to a console at given rate |
||||||
|
* |
||||||
|
* Expected to be called every frame. On every `frequency`th frame |
||||||
|
* prints the same information as @ref statistics(), but in addition, |
||||||
|
* if the output is a TTY, it's colored and overwrites itself instead |
||||||
|
* of filling up the terminal history. |
||||||
|
* @see @ref isMeasurementAvailable(), @ref isEnabled() |
||||||
|
* @ref Corrade::Utility::Debug::isTty() |
||||||
|
*/ |
||||||
|
void printStatistics(std::size_t frequency) const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Print an overview of all measurements to given output at given rate |
||||||
|
* |
||||||
|
* Compared to @ref printStatistics(std::size_t) const prints to given |
||||||
|
* @p out (which can be also @ref Corrade::Utility::Warning or |
||||||
|
* @ref Corrade::Utility::Error) and uses it to decide whether the |
||||||
|
* output is a TTY and whether to print colors. |
||||||
|
* @see @ref Corrade::Utility::Debug::isTty(), |
||||||
|
* @ref Corrade::Utility::Debug::Flag::DisableColors |
||||||
|
*/ |
||||||
|
void printStatistics(Debug& out, std::size_t frequency) const; |
||||||
|
|
||||||
|
/** @overload */ |
||||||
|
void printStatistics(Debug&& out, std::size_t frequency) const { |
||||||
|
printStatistics(out, frequency); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
std::size_t delayedCurrentData(UnsignedInt delay) const; |
||||||
|
Double measurementDataInternal(const Measurement& measurement) const; |
||||||
|
void printStatisticsInternal(Debug& out) const; |
||||||
|
|
||||||
|
bool _enabled = true; |
||||||
|
#ifndef CORRADE_NO_ASSERT |
||||||
|
/* Here it shouldn't cause the class to have a different size when
|
||||||
|
asserts get disabled */ |
||||||
|
bool _beginFrameCalled{}; |
||||||
|
#endif |
||||||
|
std::size_t _currentData{}, _maxFrameCount{1}, _measuredFrameCount{}; |
||||||
|
Containers::Array<Measurement> _measurements; |
||||||
|
Containers::Array<UnsignedLong> _data; |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
@brief Measurement |
||||||
|
|
||||||
|
Describes a single measurement passed to @ref FrameProfiler::setup(). See |
||||||
|
@ref DebugTools-FrameProfiler-setup for introduction and examples. |
||||||
|
*/ |
||||||
|
class MAGNUM_DEBUGTOOLS_EXPORT FrameProfiler::Measurement { |
||||||
|
public: |
||||||
|
/**
|
||||||
|
* @brief Construct an immediate measurement |
||||||
|
* @param name Measurement name, used in |
||||||
|
* @ref FrameProfiler::measurementName() and |
||||||
|
* @ref FrameProfiler::statistics() |
||||||
|
* @param units Measurement units, used in |
||||||
|
* @ref FrameProfiler::measurementUnits() and |
||||||
|
* @ref FrameProfiler::statistics() |
||||||
|
* @param begin Function to call at the beginning of a frame |
||||||
|
* @param end Function to call at the end of a frame, returning |
||||||
|
* the measured value |
||||||
|
* @param state State pointer passed to both @p begin and @p end |
||||||
|
* as a first argument |
||||||
|
*/ |
||||||
|
explicit Measurement(const std::string& name, Units units, void(*begin)(void*), UnsignedLong(*end)(void*), void* state); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Construct a delayed measurement |
||||||
|
* @param name Measurement name, used in |
||||||
|
* @ref FrameProfiler::measurementName() and |
||||||
|
* @ref FrameProfiler::statistics() |
||||||
|
* @param units Measurement units, used in |
||||||
|
* @ref FrameProfiler::measurementUnits() and |
||||||
|
* @ref FrameProfiler::statistics() |
||||||
|
* @param delay How many @ref FrameProfiler::endFrame() calls has |
||||||
|
* to happen before a measured value can be retrieved using |
||||||
|
* @p query. Has to be at least @cpp 1 @ce, delay of @cpp 1 @ce is |
||||||
|
* equal in behavior to immediate measurements. |
||||||
|
* @param begin Function to call at the beginning of a frame. |
||||||
|
* Second argument is a `current` index that's guaranteed to be |
||||||
|
* less than @p delay and always different in each consecutive |
||||||
|
* call. |
||||||
|
* @param end Function to call at the end of a frame. |
||||||
|
* Second argument is a `current` index that's guaranteed to be |
||||||
|
* less than @p delay and always different in each consecutive |
||||||
|
* call. |
||||||
|
* @param query Function to call to get the measured value. Called |
||||||
|
* after @p delay frames. First argument is a `previous` index |
||||||
|
* that is the same as the `current` argument passed to a |
||||||
|
* corresponding @p begin / @p end function of the measurement to |
||||||
|
* query the value of. Second argument is a `current` index that |
||||||
|
* corresponds to current frame. |
||||||
|
* @param state State pointer passed to both @p begin and @p end |
||||||
|
* as a first argument |
||||||
|
*/ |
||||||
|
explicit Measurement(const std::string& name, Units units, UnsignedInt delay, void(*begin)(void*, UnsignedInt), void(*end)(void*, UnsignedInt), UnsignedLong(*query)(void*, UnsignedInt, UnsignedInt), void* state); |
||||||
|
|
||||||
|
private: |
||||||
|
friend FrameProfiler; |
||||||
|
|
||||||
|
std::string _name; |
||||||
|
union { |
||||||
|
void(*immediate)(void*); |
||||||
|
void(*delayed)(void*, UnsignedInt); |
||||||
|
} _begin; |
||||||
|
void(*_end)(void*, UnsignedInt); |
||||||
|
union { |
||||||
|
UnsignedLong(*immediate)(void*); |
||||||
|
UnsignedLong(*delayed)(void*, UnsignedInt, UnsignedInt); |
||||||
|
} _query; |
||||||
|
void* _state; |
||||||
|
Units _units; |
||||||
|
/* Set to 0 to distinguish immediate measurements (first
|
||||||
|
constructor), however always used as max(_delay, 1) */ |
||||||
|
UnsignedInt _delay; |
||||||
|
|
||||||
|
UnsignedInt _current{}; |
||||||
|
UnsignedLong _movingSum{}; |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
@debugoperatorclassenum{FrameProfiler,FrameProfiler::Units} |
||||||
|
@m_since_latest |
||||||
|
*/ |
||||||
|
MAGNUM_DEBUGTOOLS_EXPORT Debug& operator<<(Debug& debug, FrameProfiler::Units value); |
||||||
|
|
||||||
|
#ifdef MAGNUM_TARGET_GL |
||||||
|
/**
|
||||||
|
@brief OpenGL frame profiler |
||||||
|
@m_since_latest |
||||||
|
|
||||||
|
A @ref FrameProfiler with OpenGL-specific measurements. Instantiate with a |
||||||
|
desired subset of measured values and then continue the same way as described |
||||||
|
in the @ref DebugTools-FrameProfiler-usage "FrameProfiler usage documentation": |
||||||
|
|
||||||
|
@snippet MagnumDebugTools-gl.cpp GLFrameProfiler-usage |
||||||
|
|
||||||
|
If none if @ref Value::GpuDuration, @ref Value::VertexFetchRatio and |
||||||
|
@ref Value::PrimitiveClipRatio is not enabled, the class can operate without an |
||||||
|
active OpenGL context. |
||||||
|
|
||||||
|
@experimental |
||||||
|
*/ |
||||||
|
class MAGNUM_DEBUGTOOLS_EXPORT GLFrameProfiler: public FrameProfiler { |
||||||
|
public: |
||||||
|
/**
|
||||||
|
* @brief Measured value |
||||||
|
* |
||||||
|
* @see @ref Values, @ref GLFrameProfiler(Values, std::size_t), |
||||||
|
* @ref setup() |
||||||
|
*/ |
||||||
|
enum class Value: UnsignedShort { |
||||||
|
/**
|
||||||
|
* Measure total frame time (i.e., time between consecutive |
||||||
|
* @ref beginFrame() calls). Reported in @ref Units::Nanoseconds |
||||||
|
* with a delay of 2 frames. When converted to seconds, the value |
||||||
|
* is an inverse of FPS. |
||||||
|
*/ |
||||||
|
FrameTime = 1 << 0, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Measure CPU frame duration (i.e., CPU time spent between |
||||||
|
* @ref beginFrame() and @ref endFrame()). Reported in |
||||||
|
* @ref Units::Nanoseconds with a delay of 1 frame. |
||||||
|
*/ |
||||||
|
CpuDuration = 1 << 1, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Measure GPU frame duration (i.e., time between @ref beginFrame() |
||||||
|
* and @ref endFrame()). Reported in @ref Units::Nanoseconds |
||||||
|
* with a delay of 3 frames. This value requires an active OpenGL |
||||||
|
* context. |
||||||
|
* @requires_gl33 Extension @gl_extension{ARB,timer_query} |
||||||
|
* @requires_es_extension Extension @gl_extension{EXT,disjoint_timer_query} |
||||||
|
* @requires_webgl_extension Extension @webgl_extension{EXT,disjoint_timer_query} |
||||||
|
* on WebGL 1, @gl_extension{EXT,disjoint_timer_query_webgl2} |
||||||
|
* on WebGL 2 |
||||||
|
*/ |
||||||
|
GpuDuration = 1 << 2, |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
/**
|
||||||
|
* Ratio of vertex shader invocations to count of vertices |
||||||
|
* submitted. For a non-indexed draw the ratio will be 1, for |
||||||
|
* indexed draws ratio is less than 1. The lower the value is, the |
||||||
|
* better a mesh is optimized for post-transform vertex cache. |
||||||
|
* Reported in @ref Units::RatioThousandths with a delay of 3 |
||||||
|
* frames. This value requires an active OpenGL context. |
||||||
|
* @requires_gl46 Extension @gl_extension{ARB,pipeline_statistics_query} |
||||||
|
*/ |
||||||
|
VertexFetchRatio = 1 << 3, |
||||||
|
|
||||||
|
/**
|
||||||
|
* Ratio of primitives discarded by the clipping stage to count of |
||||||
|
* primitives submitted. The ratio is 0 when all primitives pass |
||||||
|
* the clipping stage and 1 when all are discarded. Can be used to |
||||||
|
* measure efficiency of a frustum culling algorithm. Reported in |
||||||
|
* @ref Units::PercentageThousandths with a delay of 3 frames. This |
||||||
|
* value requires an active OpenGL context. |
||||||
|
* @requires_gl46 Extension @gl_extension{ARB,pipeline_statistics_query} |
||||||
|
*/ |
||||||
|
PrimitiveClipRatio = 1 << 4 |
||||||
|
#endif |
||||||
|
}; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measured values |
||||||
|
* |
||||||
|
* @see @ref GLFrameProfiler(Values, std::size_t), @ref setup() |
||||||
|
*/ |
||||||
|
typedef Containers::EnumSet<Value> Values; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Default constructor |
||||||
|
* |
||||||
|
* Call @ref setup() to populate the profiler with measurements. |
||||||
|
*/ |
||||||
|
explicit GLFrameProfiler(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Constructor |
||||||
|
* |
||||||
|
* Equivalent to default-constructing an instance and calling |
||||||
|
* @ref setup() afterwards. |
||||||
|
*/ |
||||||
|
explicit GLFrameProfiler(Values values, std::size_t maxFrameCount); |
||||||
|
|
||||||
|
/** @brief Copying is not allowed */ |
||||||
|
GLFrameProfiler(const GLFrameProfiler&) = delete; |
||||||
|
|
||||||
|
/** @brief Move constructor */ |
||||||
|
GLFrameProfiler(GLFrameProfiler&&) noexcept; |
||||||
|
|
||||||
|
/** @brief Copying is not allowed */ |
||||||
|
GLFrameProfiler& operator=(const GLFrameProfiler&) = delete; |
||||||
|
|
||||||
|
/** @brief Move assignment */ |
||||||
|
GLFrameProfiler& operator=(GLFrameProfiler&&) noexcept; |
||||||
|
|
||||||
|
~GLFrameProfiler(); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Setup measured values |
||||||
|
* @param values List of measuremed values |
||||||
|
* @param maxFrameCount Max frame count over which to calculate a |
||||||
|
* moving average. Expected to be at least @cpp 1 @ce. |
||||||
|
* |
||||||
|
* Calling @ref setup() on an already set up profiler will replace |
||||||
|
* existing measurements with @p measurements and reset |
||||||
|
* @ref measuredFrameCount() back to @cpp 0 @ce. |
||||||
|
*/ |
||||||
|
void setup(Values values, std::size_t maxFrameCount); |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Measured values |
||||||
|
* |
||||||
|
* Corresponds to the @p values parameter passed to |
||||||
|
* @ref GLFrameProfiler(Values, std::size_t) or @ref setup(). |
||||||
|
*/ |
||||||
|
Values values() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Whether given measurement is available |
||||||
|
* |
||||||
|
* Returns @cpp true @ce if enough frames was captured to calculate |
||||||
|
* given @p value, @cpp false @ce otherwise. Expects that @p value was |
||||||
|
* enabled. |
||||||
|
*/ |
||||||
|
bool isMeasurementAvailable(Value value) const; |
||||||
|
|
||||||
|
using FrameProfiler::isMeasurementAvailable; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Mean frame time in nanoseconds |
||||||
|
* |
||||||
|
* Expects that @ref Value::FrameTime was enabled, and that measurement |
||||||
|
* data is available. See the flag documentation for more information. |
||||||
|
* @see @ref isMeasurementAvailable(), @ref measurementMean() |
||||||
|
*/ |
||||||
|
Double frameTimeMean() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Mean CPU frame duration in nanoseconds |
||||||
|
* |
||||||
|
* Expects that @ref Value::CpuDuration was enabled, and that |
||||||
|
* measurement data is available. See the flag documentation for more |
||||||
|
* information. |
||||||
|
* @see @ref isMeasurementAvailable(), @ref measurementMean() |
||||||
|
*/ |
||||||
|
Double cpuDurationMean() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Mean GPU frame duration in nanoseconds |
||||||
|
* |
||||||
|
* Expects that @ref Value::GpuDuration was enabled, and that |
||||||
|
* measurement data is available. See the flag documentation for more |
||||||
|
* information. |
||||||
|
* @see @ref isMeasurementAvailable(), @ref measurementMean() |
||||||
|
*/ |
||||||
|
Double gpuDurationMean() const; |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
/**
|
||||||
|
* @brief Mean vertex fetch ratio in thousandths |
||||||
|
* |
||||||
|
* Expects that @ref Value::VertexFetchRatio was enabled, and that |
||||||
|
* measurement data is available. See the flag documentation for more |
||||||
|
* information. |
||||||
|
* @requires_gl46 Extension @gl_extension{ARB,pipeline_statistics_query} |
||||||
|
* @see @ref isMeasurementAvailable(), @ref measurementMean() |
||||||
|
*/ |
||||||
|
Double vertexFetchRatioMean() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief Mean primitive clip ratio in percentage thousandths |
||||||
|
* |
||||||
|
* Expects that @ref Value::PrimitiveClipRatio was enabled, and that |
||||||
|
* measurement data is available. See the flag documentation for more |
||||||
|
* information. |
||||||
|
* @requires_gl46 Extension @gl_extension{ARB,pipeline_statistics_query} |
||||||
|
* @see @ref isMeasurementAvailable(), @ref measurementMean() |
||||||
|
*/ |
||||||
|
Double primitiveClipRatioMean() const; |
||||||
|
#endif |
||||||
|
|
||||||
|
private: |
||||||
|
using FrameProfiler::setup; |
||||||
|
|
||||||
|
struct State; |
||||||
|
Containers::Pointer<State> _state; |
||||||
|
}; |
||||||
|
|
||||||
|
CORRADE_ENUMSET_OPERATORS(GLFrameProfiler::Values) |
||||||
|
|
||||||
|
/**
|
||||||
|
@debugoperatorclassenum{GLFrameProfiler,GLFrameProfiler::Value} |
||||||
|
@m_since_latest |
||||||
|
*/ |
||||||
|
MAGNUM_DEBUGTOOLS_EXPORT Debug& operator<<(Debug& debug, GLFrameProfiler::Value value); |
||||||
|
|
||||||
|
/**
|
||||||
|
@debugoperatorclassenum{GLFrameProfiler,GLFrameProfiler::Values} |
||||||
|
@m_since_latest |
||||||
|
*/ |
||||||
|
MAGNUM_DEBUGTOOLS_EXPORT Debug& operator<<(Debug& debug, GLFrameProfiler::Values value); |
||||||
|
#endif |
||||||
|
|
||||||
|
}} |
||||||
|
|
||||||
|
#endif |
||||||
@ -0,0 +1,242 @@ |
|||||||
|
/*
|
||||||
|
This file is part of Magnum. |
||||||
|
|
||||||
|
Copyright © 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 |
||||||
|
Vladimír Vondruš <mosra@centrum.cz> |
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person obtaining a |
||||||
|
copy of this software and associated documentation files (the "Software"), |
||||||
|
to deal in the Software without restriction, including without limitation |
||||||
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
||||||
|
and/or sell copies of the Software, and to permit persons to whom the |
||||||
|
Software is furnished to do so, subject to the following conditions: |
||||||
|
|
||||||
|
The above copyright notice and this permission notice shall be included |
||||||
|
in all copies or substantial portions of the Software. |
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||||
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
||||||
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||||
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
||||||
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
||||||
|
DEALINGS IN THE SOFTWARE. |
||||||
|
*/ |
||||||
|
|
||||||
|
#include <Corrade/TestSuite/Compare/Numeric.h> |
||||||
|
#include <Corrade/Utility/System.h> |
||||||
|
|
||||||
|
#include "Magnum/DebugTools/FrameProfiler.h" |
||||||
|
#include "Magnum/GL/Context.h" |
||||||
|
#include "Magnum/GL/Extensions.h" |
||||||
|
#include "Magnum/GL/Framebuffer.h" |
||||||
|
#include "Magnum/GL/Mesh.h" |
||||||
|
#include "Magnum/GL/OpenGLTester.h" |
||||||
|
#include "Magnum/GL/Renderbuffer.h" |
||||||
|
#include "Magnum/GL/RenderbufferFormat.h" |
||||||
|
#include "Magnum/MeshTools/Compile.h" |
||||||
|
#include "Magnum/Primitives/Cube.h" |
||||||
|
#include "Magnum/Shaders/Flat.h" |
||||||
|
#include "Magnum/Trade/MeshData.h" |
||||||
|
|
||||||
|
namespace Magnum { namespace DebugTools { namespace Test { namespace { |
||||||
|
|
||||||
|
struct FrameProfilerGLTest: GL::OpenGLTester { |
||||||
|
explicit FrameProfilerGLTest(); |
||||||
|
|
||||||
|
void test(); |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
void vertexFetchRatioDivisionByZero(); |
||||||
|
void primitiveClipRatioDivisionByZero(); |
||||||
|
#endif |
||||||
|
}; |
||||||
|
|
||||||
|
struct { |
||||||
|
const char* name; |
||||||
|
GLFrameProfiler::Values values; |
||||||
|
} Data[]{ |
||||||
|
{"gpu duration", GLFrameProfiler::Value::GpuDuration}, |
||||||
|
{"cpu duration + gpu duration", GLFrameProfiler::Value::CpuDuration|GLFrameProfiler::Value::GpuDuration}, |
||||||
|
{"frame time + gpu duration", GLFrameProfiler::Value::FrameTime|GLFrameProfiler::Value::GpuDuration}, |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
{"gpu duration + vertex fetch ratio", GLFrameProfiler::Value::GpuDuration|GLFrameProfiler::Value::VertexFetchRatio}, |
||||||
|
{"vertex fetch ratio + primitive clip ratio", GLFrameProfiler::Value::VertexFetchRatio|GLFrameProfiler::Value::PrimitiveClipRatio} |
||||||
|
#endif |
||||||
|
}; |
||||||
|
|
||||||
|
FrameProfilerGLTest::FrameProfilerGLTest() { |
||||||
|
addInstancedTests({&FrameProfilerGLTest::test}, |
||||||
|
Containers::arraySize(Data)); |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
addTests({&FrameProfilerGLTest::vertexFetchRatioDivisionByZero, |
||||||
|
&FrameProfilerGLTest::primitiveClipRatioDivisionByZero}); |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfilerGLTest::test() { |
||||||
|
auto&& data = Data[testCaseInstanceId()]; |
||||||
|
setTestCaseDescription(data.name); |
||||||
|
|
||||||
|
if(data.values & GLFrameProfiler::Value::GpuDuration) { |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::timer_query>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::ARB::timer_query::string() + std::string(" is not available")); |
||||||
|
#elif defined(MAGNUM_TARGET_WEBGL) && !defined(MAGNUM_TARGET_GLES2) |
||||||
|
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::disjoint_timer_query_webgl2>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query_webgl2::string() + std::string(" is not available")); |
||||||
|
#else |
||||||
|
if(!GL::Context::current().isExtensionSupported<GL::Extensions::EXT::disjoint_timer_query>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::EXT::disjoint_timer_query::string() + std::string(" is not available")); |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
if((data.values & GLFrameProfiler::Value::VertexFetchRatio) && !GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available")); |
||||||
|
#endif |
||||||
|
|
||||||
|
/* Bind some FB to avoid errors on contexts w/o default FB */ |
||||||
|
GL::Renderbuffer color; |
||||||
|
color.setStorage( |
||||||
|
#if !(defined(MAGNUM_TARGET_WEBGL) && defined(MAGNUM_TARGET_GLES2)) |
||||||
|
GL::RenderbufferFormat::RGBA8, |
||||||
|
#else |
||||||
|
GL::RenderbufferFormat::RGBA4, |
||||||
|
#endif |
||||||
|
Vector2i{32}); |
||||||
|
GL::Framebuffer fb{{{}, Vector2i{32}}}; |
||||||
|
fb.attachRenderbuffer(GL::Framebuffer::ColorAttachment{0}, color) |
||||||
|
.bind(); |
||||||
|
|
||||||
|
Shaders::Flat3D shader; |
||||||
|
GL::Mesh mesh = MeshTools::compile(Primitives::cubeSolid()); |
||||||
|
|
||||||
|
GLFrameProfiler profiler{data.values, 4}; |
||||||
|
CORRADE_COMPARE(profiler.maxFrameCount(), 4); |
||||||
|
|
||||||
|
for(auto value: {GLFrameProfiler::Value::CpuDuration, |
||||||
|
GLFrameProfiler::Value::GpuDuration, |
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
GLFrameProfiler::Value::VertexFetchRatio, |
||||||
|
GLFrameProfiler::Value::PrimitiveClipRatio |
||||||
|
#endif |
||||||
|
}) |
||||||
|
if(data.values & value) |
||||||
|
CORRADE_VERIFY(!profiler.isMeasurementAvailable(value)); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
shader.draw(mesh); |
||||||
|
Utility::System::sleep(1); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
shader.draw(mesh); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
Utility::System::sleep(10); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
shader.draw(mesh); |
||||||
|
Utility::System::sleep(1); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
shader.draw(mesh); |
||||||
|
Utility::System::sleep(1); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
MAGNUM_VERIFY_NO_GL_ERROR(); |
||||||
|
|
||||||
|
/* The GPU time should not be a total zero. Can't test upper bound because
|
||||||
|
(especially on overloaded CIs) it all takes a magnitude more than |
||||||
|
expected. */ |
||||||
|
if(data.values & GLFrameProfiler::Value::GpuDuration) { |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::GpuDuration)); |
||||||
|
CORRADE_COMPARE_AS(profiler.gpuDurationMean(), 100, |
||||||
|
TestSuite::Compare::Greater); |
||||||
|
} |
||||||
|
|
||||||
|
/* 3/4 frames took 1 ms, the ideal average is 0.75 ms. Can't test upper
|
||||||
|
bound because (especially on overloaded CIs) it all takes a magnitude |
||||||
|
more than expected. */ |
||||||
|
if(data.values & GLFrameProfiler::Value::CpuDuration) { |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::CpuDuration)); |
||||||
|
CORRADE_COMPARE_AS(profiler.cpuDurationMean(), 0.70*1000*1000, |
||||||
|
TestSuite::Compare::GreaterOrEqual); |
||||||
|
} |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
/* 24 unique vertices in 12 triangles, ideal ratio is 24/36 */ |
||||||
|
if(data.values & GLFrameProfiler::Value::VertexFetchRatio) { |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::VertexFetchRatio)); |
||||||
|
CORRADE_COMPARE_WITH(profiler.vertexFetchRatioMean()/1000, 0.6667, |
||||||
|
TestSuite::Compare::around(0.1)); |
||||||
|
} |
||||||
|
|
||||||
|
/* We use a default transformation, which means the whole cube should be
|
||||||
|
visible, nothing clipped */ |
||||||
|
if(data.values & GLFrameProfiler::Value::PrimitiveClipRatio) { |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::PrimitiveClipRatio)); |
||||||
|
CORRADE_COMPARE(profiler.primitiveClipRatioMean()/1000, 0.0); |
||||||
|
} |
||||||
|
#endif |
||||||
|
} |
||||||
|
|
||||||
|
#ifndef MAGNUM_TARGET_GLES |
||||||
|
void FrameProfilerGLTest::vertexFetchRatioDivisionByZero() { |
||||||
|
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available")); |
||||||
|
|
||||||
|
GLFrameProfiler profiler{GLFrameProfiler::Value::VertexFetchRatio, 4}; |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
MAGNUM_VERIFY_NO_GL_ERROR(); |
||||||
|
|
||||||
|
/* No draws happened, so the ratio should be 0 (and not crashing with a
|
||||||
|
division by zero) */ |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::VertexFetchRatio)); |
||||||
|
CORRADE_COMPARE(profiler.vertexFetchRatioMean(), 0.0); |
||||||
|
} |
||||||
|
|
||||||
|
void FrameProfilerGLTest::primitiveClipRatioDivisionByZero() { |
||||||
|
if(!GL::Context::current().isExtensionSupported<GL::Extensions::ARB::pipeline_statistics_query>()) |
||||||
|
CORRADE_SKIP(GL::Extensions::ARB::pipeline_statistics_query::string() + std::string(" is not available")); |
||||||
|
|
||||||
|
GLFrameProfiler profiler{GLFrameProfiler::Value::PrimitiveClipRatio, 4}; |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
profiler.beginFrame(); |
||||||
|
profiler.endFrame(); |
||||||
|
|
||||||
|
MAGNUM_VERIFY_NO_GL_ERROR(); |
||||||
|
|
||||||
|
/* No draws happened, so the ratio should be 0 (and not crashing with a
|
||||||
|
division by zero) */ |
||||||
|
CORRADE_VERIFY(profiler.isMeasurementAvailable(GLFrameProfiler::Value::PrimitiveClipRatio)); |
||||||
|
CORRADE_COMPARE(profiler.primitiveClipRatioMean(), 0.0); |
||||||
|
} |
||||||
|
#endif |
||||||
|
|
||||||
|
}}}} |
||||||
|
|
||||||
|
CORRADE_TEST_MAIN(Magnum::DebugTools::Test::FrameProfilerGLTest) |
||||||
Loading…
Reference in new issue