implot for fps

Author: awarebayes

Diff for: src/main.cpp

@@ -58,6 +58,7 @@
 
 #include "imgui_impl_glut.h"
 #include "imgui_impl_opengl3.h"
+#include "util/implot.h"
 
 StopWatchInterface *timer = NULL;
 unsigned int width, height;
@@ -321,6 +322,7 @@ void initGL(int argc, char **argv) {
 	ImGui::CreateContext();
 	ImGuiIO &io = ImGui::GetIO();
 	(void) io;
+	ImPlot::CreateContext();
 
 	io.DisplaySize.x = width;
 	io.DisplaySize.y = height;

Diff for: src/render/draw_caller/rasterizer.cu

@@ -102,8 +102,8 @@ void Rasterizer::async_rasterize(DrawCallArgs &args, int model_index, Image imag
 {
 	auto &model_args = args.models[model_index];
 	auto &model = model_args.model;
-	auto n_grid = model.n_faces / 32 + 1;
-	auto n_block = dim3(32);
+	auto n_grid = get_grid_size(model.n_faces);
+	auto n_block = get_block_size(model.n_faces);
 
 	if (model_args.disabled_faces == nullptr) {
 		switch (model.shader) {

Diff for: src/render/logger/logger.cpp

@@ -3,14 +3,30 @@
 //
 #include "logger.h"
 #include "../../scene/scene.h"
+#include "../../util/const.h"
+#include "../../util/implot.h"
 #include <imgui.h>
 #include <imgui_internal.h>
+#include <filesystem>
 
 void RenderInterface::draw_widget() {
+
+
 	if (ImGui::CollapsingHeader("FPS"))
 	{
+		ImGui::SliderInt("Threads per block", &USE_THREADS, 1, 128);
 		ImGui::Text("FPS: %f", fps.back());
 		ImGui::PlotLines("Framerate", &fps[0], fps.size(), 0, nullptr, 0.0f, 100.0f, ImVec2(300, 100));
+
+		if (ImGui::Button("Clear average fps"))
+		{
+			fps.clear();
+		}
+		if (ImGui::Button("Clear average fps per nthreads"))
+		{
+			avg_fps_per_nthreads.clear();
+		}
+		avg_fps_per_nthreads.display("FPS per nthreads");
 	}
 
 	if (ImGui::CollapsingHeader("Culling")) {
@@ -45,6 +61,7 @@ void RenderInterface::log_fps() {
 	if (fps.size() > 100) {
 		fps.erase(fps.begin());
 	}
+	avg_fps_per_nthreads.log(USE_THREADS, ImGui::GetIO().Framerate);
 }
 void RenderInterface::log_before_culling(int n_models) {
 	n_models_before_culling = n_models;
@@ -68,3 +85,55 @@ bool RenderInterface::is_virtual_geometry_enabled() const {
 void RenderInterface::register_vgeometry_manager(VirtualGeometryManager &manager) {
 	threshold_ptr = &manager.get_threshold_mut();
 }
+
+RenderInterface::RenderInterface() {
+	avg_fps_per_nthreads.log_to("logs/avg_fps_per_nthreads.csv");
+}
+
+void AverageLogger::log(float key, float value) {
+	if (sum.find(key) == sum.end()) {
+		sum[key] = 0;
+		count[key] = 0;
+	}
+	sum[key] += value;
+	count[key]++;
+	file << std::to_string(key) + "," + std::to_string(value) + "\n";
+	if (count[key] % 100 == 0) {
+		file << std::flush;
+	}
+}
+
+float AverageLogger::get_average(float key) {
+	return sum[key] / count[key];
+}
+
+void AverageLogger::display(const std::string &title)
+{
+	sorted.clear();
+	for (auto &p : sum) {
+		sorted.push_back({p.first, p.second / count[p.first]});
+	}
+	std::sort(sorted.begin(), sorted.end(), [](const auto &a, const auto &b) {
+		return a.first > b.first;
+	});
+
+	keys.clear();
+	values.clear();
+	for (auto &p : sorted) {
+		keys.push_back(p.first);
+		values.push_back(p.second);
+	}
+
+	if (ImPlot::BeginPlot(title.data())) {
+		ImPlot::SetupAxes("x","f(x)");
+		ImPlot::PlotLine("sin(x)", (float *)keys.data(), values.data(), sorted.size());
+		ImPlot::EndPlot();
+	}
+
+
+}
+void AverageLogger::clear() {
+	sum.clear();
+	count.clear();
+	std::filesystem::resize_file(filename, 0);
+}

Diff for: src/render/logger/logger.h

@@ -6,6 +6,34 @@
 #define COURSE_RENDERER_LOGGER_H
 #include "../virtual_geometry/manager/virtual_geometry_manger.h"
 #include <vector>
+#include <fstream>
+
+class AverageLogger {
+private:
+	std::ofstream file{};
+	std::string filename{};
+	std::map<float, float> sum{};
+	std::map<float, int> count{};
+
+	std::vector<float> keys;
+	std::vector<float> values;
+	std::vector<std::pair<float, float>> sorted;
+public:
+
+	void log_to(const std::string &filename_) {
+		filename = filename_;
+		file.open(filename_);
+	}
+
+	void log(float key, float value);
+
+	float get_average(float key);
+
+	void display(const std::string &title);
+
+	void clear();
+};
+
 
 class RenderInterface {
 protected:
@@ -16,8 +44,10 @@ class RenderInterface {
 	int n_models_before_culling;
 	int n_models_after_culling;
 	int *threshold_ptr = nullptr;
+	AverageLogger avg_fps_per_nthreads{};
 
 public:
+	RenderInterface();
 	bool is_culling_enabled() const;
 	bool is_virtual_geometry_enabled() const;
 	void register_vgeometry_manager(VirtualGeometryManager &manager);

Diff for: src/render/virtual_geometry/analyzer/mesh_analyzer.cu

@@ -58,8 +58,8 @@ void MeshAnalyzer::async_analyze_mesh(const DrawCallArgs &args, const Image &ima
 		return;
 	auto &model_args = *model_args_it;
 	auto &model = model_args.model;
-	auto n_grid = model.n_faces / 32 + 1;
-	auto n_block = dim3(32);
+	auto n_grid = get_grid_size(model.n_faces);
+	auto n_block = get_block_size(model.n_faces);
 
 	if (model.n_faces > capacity) {
 		capacity = model.n_faces;

Diff for: src/render/virtual_geometry/geometry_upsampler/geometry_upsampler.cu

@@ -3,6 +3,7 @@
 //
 
 #include "../../../shader/all.h"
+#include "../../../util/const.h"
 #include "../../misc/image.cuh"
 #include "geometry_upsampler.h"
 
@@ -92,8 +93,8 @@ __global__ void upsample_faces(ModelRef virtual_model, const ModelDrawCallArgs m
 
 void GeometryUpsampler::async_upsample_geometry(const ModelDrawCallArgs &model_args, bool *disabled_faces_for_original, bool *disabled_faces_for_virtual) {
 	auto &model = model_args.model;
-	auto n_grid = model.n_faces / 32 + 1;
-	auto n_block = dim3(32);
+	auto n_grid = get_grid_size(model.n_faces);
+	auto n_block = get_block_size(model.n_faces);
 
 	cudaMemsetAsync(position, 0, sizeof(int), stream);
 	cudaMemsetAsync(disabled_faces_for_virtual, 1, sizeof(bool) * virtual_model.n_faces, stream);

Diff for: src/render/zbuffer/zfiller.cu

@@ -82,8 +82,8 @@ __global__ void set_kernel(ZBuffer buffer, float set_to)
 void ZFiller::async_zbuf(DrawCallArgs &args, int model_index) {
 	auto &model_args = args.models[model_index];
 	auto &model = model_args.model;
-	auto n_grid = model.n_faces / 32 + 1;
-	auto n_block = 32;
+	auto n_grid = get_grid_size(model.n_faces);
+	auto n_block = get_block_size(model.n_faces);
 	switch (model.shader)
 	{
 		case RegisteredShaders::Default:

Diff for: src/util/const.cpp

@@ -0,0 +1,17 @@
+//
+// Created by dev on 10/31/22.
+//
+
+#include "const.h"
+
+int USE_THREADS = 32;
+
+int get_grid_size(int n)
+{
+	return (n  / USE_THREADS) + 1;
+}
+
+int get_block_size(int n)
+{
+	return USE_THREADS;
+}

Diff for: src/util/const.h

@@ -7,7 +7,12 @@
 
 const int MAX_PIXELS_PER_KERNEL = 5000;
 
-const int VIRTUAL_GEOMETRY_VERTICES = 10000;
-const int VIRTUAL_GEOMETRY_FACES = 100000;
+const int VIRTUAL_GEOMETRY_VERTICES = 1000;
+
+extern int USE_THREADS;
+
+int get_grid_size(int n);
+
+int get_block_size(int n);
 
 #endif//COURSE_RENDERER_CONST_H