Slic3r::GUI::FrameProfiler Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/FrameProfiler.hpp>

Collaboration diagram for Slic3r::GUI::FrameProfiler:

Classes
struct	Section
struct	Frame

Public Member Functions
void	begin_frame ()
void	mark (const char *name)
void	end_frame ()
const std::vector< Section > &	sections () const
void	start_averaging ()
bool	is_averaging () const
std::vector< Section >	finish_averaging (bool wait)
void	reset ()

Private Member Functions
void	collect (bool wait)

Private Attributes
std::array< Frame, FRAMES_IN_FLIGHT >	m_frames
Frame *	m_recording { nullptr }
size_t	m_next { 0 }
std::chrono::steady_clock::time_point	m_last_mark
std::vector< Section >	m_sections
bool	m_averaging { false }
std::vector< Section >	m_sums
size_t	m_averaged_frames { 0 }

Static Private Attributes
static constexpr size_t	FRAMES_IN_FLIGHT = 4
static constexpr size_t	MAX_SECTIONS = 32

Detailed Description

---

Class Documentation

Slic3r::GUI::FrameProfiler::Section

struct Slic3r::GUI::FrameProfiler::Section

Class Members
double	cpu_ms { 0.0 }
double	gpu_ms { 0.0 }
const char *	name { nullptr }

Slic3r::GUI::FrameProfiler::Frame

struct Slic3r::GUI::FrameProfiler::Frame

Collaboration diagram for Slic3r::GUI::FrameProfiler::Frame:

Class Members
bool	averaged { false }
size_t	count { 0 }
array< double, MAX_SECTIONS >	cpu_ms {}
array< const char *, MAX_SECTIONS >	names {}
bool	pending { false }
array< unsigned int, 2 *MAX_SECTIONS >	queries {}

Member Function Documentation

begin_frame()

void Slic3r::GUI::FrameProfiler::begin_frame

(

)

{
    m_recording = nullptr;
    // GL 3.3 or ARB_timer_query
    if (glQueryCounter == nullptr)
        return;
 
    collect(false);
    Frame& frame = m_frames[m_next];
    // Every frame in flight still waits for the GPU: skip this one rather than stall.
    if (frame.pending)
        return;
 
    if (frame.queries[0] == 0)
        glsafe(::glGenQueries(GLsizei(frame.queries.size()), frame.queries.data()));
    glsafe(::glQueryCounter(frame.queries[0], GL_TIMESTAMP));
    frame.count = 0;
    frame.averaged = m_averaging;
    m_recording = &frame;
    m_last_mark = std::chrono::steady_clock::now();
}

References Slic3r::GUI::FrameProfiler::Frame::averaged, collect(), Slic3r::GUI::FrameProfiler::Frame::count, GL_TIMESTAMP, glGenQueries, glQueryCounter, glsafe, m_averaging, m_frames, m_last_mark, m_next, m_recording, Slic3r::GUI::FrameProfiler::Frame::pending, and Slic3r::GUI::FrameProfiler::Frame::queries.

Here is the call graph for this function:

collect()

void Slic3r::GUI::FrameProfiler::collect ( bool wait )

private

{
    constexpr double SMOOTHING = 0.1;
 
    // Oldest first: a frame whose results are not in yet holds back the newer ones too.
    for (size_t i = 0; i < FRAMES_IN_FLIGHT; ++i) {
        Frame& frame = m_frames[(m_next + i) % FRAMES_IN_FLIGHT];
        if (!frame.pending)
            continue;
 
        if (!wait) {
            GLint available = 0;
            glsafe(::glGetQueryObjectiv(frame.queries[2 * frame.count - 1], GL_QUERY_RESULT_AVAILABLE, &available));
            if (available == 0)
                break;
        }
 
        std::array<GLuint64, 2 * MAX_SECTIONS> stamps{};
        for (size_t j = 0; j < 2 * frame.count; ++j)
            glsafe(::glGetQueryObjectui64v(frame.queries[j], GL_QUERY_RESULT, &stamps[j]));
        frame.pending = false;
 
        const bool averaged = frame.averaged && m_averaging;
        if (averaged)
            ++m_averaged_frames;
        std::vector<Section> sections;
        sections.reserve(frame.count);
        for (size_t j = 0; j < frame.count; ++j) {
            Section section{ frame.names[j], frame.cpu_ms[j], stamps[2 * j + 1] > stamps[2 * j] ? double(stamps[2 * j + 1] - stamps[2 * j]) * 1e-6 : 0.0 };
            if (averaged) {
                auto sum = std::find_if(m_sums.begin(), m_sums.end(), [&section](const Section& s) { return std::strcmp(s.name, section.name) == 0; });
                if (sum == m_sums.end())
                    m_sums.push_back(section);
                else {
                    sum->cpu_ms += section.cpu_ms;
                    sum->gpu_ms += section.gpu_ms;
                }
            }
            for (const Section& prev : m_sections) {
                if (std::strcmp(prev.name, section.name) == 0) {
                    section.cpu_ms = prev.cpu_ms + SMOOTHING * (section.cpu_ms - prev.cpu_ms);
                    section.gpu_ms = prev.gpu_ms + SMOOTHING * (section.gpu_ms - prev.gpu_ms);
                    break;
                }
            }
            sections.push_back(section);
        }
        m_sections = std::move(sections);
    }
}

References Slic3r::GUI::FrameProfiler::Frame::averaged, Slic3r::GUI::FrameProfiler::Frame::count, Slic3r::GUI::FrameProfiler::Frame::cpu_ms, Slic3r::GUI::FrameProfiler::Section::cpu_ms, FRAMES_IN_FLIGHT, GL_QUERY_RESULT, GL_QUERY_RESULT_AVAILABLE, glGetQueryObjectiv, glGetQueryObjectui64v, glsafe, Slic3r::GUI::FrameProfiler::Section::gpu_ms, m_averaged_frames, m_averaging, m_frames, m_next, m_sections, m_sums, Slic3r::GUI::FrameProfiler::Section::name, Slic3r::GUI::FrameProfiler::Frame::names, Slic3r::GUI::FrameProfiler::Frame::pending, Slic3r::GUI::FrameProfiler::Frame::queries, and sections().

Referenced by begin_frame(), and finish_averaging().

Here is the call graph for this function:

Here is the caller graph for this function:

end_frame()

void Slic3r::GUI::FrameProfiler::end_frame

(

)

{
    if (m_recording == nullptr)
        return;
 
    m_recording->pending = m_recording->count > 0;
    m_recording = nullptr;
    m_next = (m_next + 1) % FRAMES_IN_FLIGHT;
}

References FRAMES_IN_FLIGHT, m_next, and m_recording.

finish_averaging()

std::vector< FrameProfiler::Section > Slic3r::GUI::FrameProfiler::finish_averaging

(

bool

wait

)

{
    if (wait && glQueryCounter != nullptr)
        collect(true);
    std::vector<Section> averages = std::move(m_sums);
    for (Section& section : averages) {
        section.cpu_ms /= double(m_averaged_frames);
        section.gpu_ms /= double(m_averaged_frames);
    }
    m_averaging = false;
    m_sums.clear();
    m_averaged_frames = 0;
    return averages;
}

References collect(), glQueryCounter, m_averaged_frames, m_averaging, and m_sums.

Here is the call graph for this function:

is_averaging()

bool Slic3r::GUI::FrameProfiler::is_averaging ( ) const

inline

{ return m_averaging; }

References m_averaging.

mark()

void Slic3r::GUI::FrameProfiler::mark

(

const char *

name

)

{
    if (m_recording == nullptr || m_recording->count == MAX_SECTIONS)
        return;
 
    Frame& frame = *m_recording;
    const std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
    glsafe(::glQueryCounter(frame.queries[2 * frame.count + 1], GL_TIMESTAMP));
    // Else the GPU time would include the CPU time spent until the driver flushes on its own.
    glsafe(::glFlush());
    // Sent with the next section's commands, so the time the GPU waits for them is not billed to it.
    if (frame.count + 1 < MAX_SECTIONS)
        glsafe(::glQueryCounter(frame.queries[2 * frame.count + 2], GL_TIMESTAMP));
    frame.names[frame.count] = name;
    frame.cpu_ms[frame.count] = std::chrono::duration<double, std::milli>(now - m_last_mark).count();
    ++frame.count;
    m_last_mark = now;
}

References Slic3r::GUI::FrameProfiler::Frame::count, Slic3r::GUI::FrameProfiler::Frame::cpu_ms, GL_TIMESTAMP, glFlush, glQueryCounter, glsafe, m_last_mark, m_recording, MAX_SECTIONS, Slic3r::GUI::FrameProfiler::Frame::names, and Slic3r::GUI::FrameProfiler::Frame::queries.

reset()

void Slic3r::GUI::FrameProfiler::reset

(

)

{
    for (Frame& frame : m_frames) {
        if (frame.queries[0] != 0)
            glsafe(::glDeleteQueries(GLsizei(frame.queries.size()), frame.queries.data()));
        frame = Frame();
    }
    m_recording = nullptr;
    m_sections.clear();
    m_averaging = false;
    m_sums.clear();
    m_averaged_frames = 0;
}

References glDeleteQueries, glsafe, m_averaged_frames, m_averaging, m_frames, m_recording, m_sections, and m_sums.

sections()

const std::vector< Section > & Slic3r::GUI::FrameProfiler::sections ( ) const

inline

{ return m_sections; }

References m_sections.

Referenced by collect().

Here is the caller graph for this function:

start_averaging()

void Slic3r::GUI::FrameProfiler::start_averaging

(

)

{
    m_averaging = true;
    m_sums.clear();
    m_averaged_frames = 0;
}

References m_averaged_frames, m_averaging, and m_sums.

Member Data Documentation

FRAMES_IN_FLIGHT

size_t Slic3r::GUI::FrameProfiler::FRAMES_IN_FLIGHT = 4

staticconstexprprivate

Referenced by collect(), and end_frame().

m_averaged_frames

size_t Slic3r::GUI::FrameProfiler::m_averaged_frames { 0 }

private

{ 0 };

Referenced by collect(), finish_averaging(), reset(), and start_averaging().

m_averaging

bool Slic3r::GUI::FrameProfiler::m_averaging { false }

private

{ false };

Referenced by begin_frame(), collect(), finish_averaging(), is_averaging(), reset(), and start_averaging().

m_frames

std::array<Frame, FRAMES_IN_FLIGHT> Slic3r::GUI::FrameProfiler::m_frames

private

Referenced by begin_frame(), collect(), and reset().

m_last_mark

std::chrono::steady_clock::time_point Slic3r::GUI::FrameProfiler::m_last_mark

private

Referenced by begin_frame(), and mark().

m_next

size_t Slic3r::GUI::FrameProfiler::m_next { 0 }

private

{ 0 };

Referenced by begin_frame(), collect(), and end_frame().

m_recording

Frame* Slic3r::GUI::FrameProfiler::m_recording { nullptr }

private

{ nullptr };

Referenced by begin_frame(), end_frame(), mark(), and reset().

m_sections

std::vector<Section> Slic3r::GUI::FrameProfiler::m_sections

private

Referenced by collect(), reset(), and sections().

m_sums

std::vector<Section> Slic3r::GUI::FrameProfiler::m_sums

private

Referenced by collect(), finish_averaging(), reset(), and start_averaging().

MAX_SECTIONS

size_t Slic3r::GUI::FrameProfiler::MAX_SECTIONS = 32

staticconstexprprivate

Referenced by mark().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/FrameProfiler.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/FrameProfiler.cpp