OpenPunk/citra
1
0
Fork 0
mirror of https://github.com/citra-emu/citra.git synced 2024-11-22 12:10:05 +00:00
Code Issues Projects Releases Wiki Activity

Clipper: Avoid dynamic allocations

Browse Source 
The triangle clipper was allocating its temporary input, output and work
buffers using a std::vector. Since this is a hot path, it's desirable to
use stack allocation instead.
This commit is contained in:
Yuri Kunde Schlesner 2014-12-28 00:56:32 -02:00
parent d151d797b1
commit a320d1a5b4
2 changed files with 8 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
externals/boost vendored

@ -1 +1 @@
Subproject commit b060148c08ae87a3a5809c4f48cb26ac667487ab Subproject commit 97052c28acb141dbf3c5e14114af99045344b695

17
src/video_core/clipper.cpp
View File

@ -2,7 +2,7 @@
// Licensed under GPLv2 or any later version // Licensed under GPLv2 or any later version
// Refer to the license.txt file included. // Refer to the license.txt file included.
#include <vector> #include <boost/container/static_vector.hpp>
#include "clipper.h" #include "clipper.h"
#include "pica.h" #include "pica.h"
@ -98,18 +98,15 @@ static void InitScreenCoordinates(OutputVertex& vtx)
} }
void ProcessTriangle(OutputVertex &v0, OutputVertex &v1, OutputVertex &v2) { void ProcessTriangle(OutputVertex &v0, OutputVertex &v1, OutputVertex &v2) {
using boost::container::static_vector;
// TODO (neobrain): // TODO (neobrain):
// The list of output vertices has some fixed maximum size, // The list of output vertices has some fixed maximum size,
// however I haven't taken the time to figure out what it is exactly. // however I haven't taken the time to figure out what it is exactly.
// For now, we hence just assume a maximal size of 1000 vertices. // For now, we hence just assume a maximal size of 256 vertices.
const size_t max_vertices = 1000; static const size_t MAX_VERTICES = 256;
std::vector<OutputVertex> buffer_vertices; static_vector<OutputVertex, MAX_VERTICES> buffer_vertices;
std::vector<OutputVertex*> output_list{ &v0, &v1, &v2 }; static_vector<OutputVertex*, MAX_VERTICES> output_list = { &v0, &v1, &v2 };
// Make sure to reserve space for all vertices.
// Without this, buffer reallocation would invalidate references.
buffer_vertices.reserve(max_vertices);
// Simple implementation of the Sutherland-Hodgman clipping algorithm. // Simple implementation of the Sutherland-Hodgman clipping algorithm.
// TODO: Make this less inefficient (currently lots of useless buffering overhead happens here) // TODO: Make this less inefficient (currently lots of useless buffering overhead happens here)
@ -120,7 +117,7 @@ void ProcessTriangle(OutputVertex &v0, OutputVertex &v1, OutputVertex &v2) {
ClippingEdge(ClippingEdge::POS_Z, float24::FromFloat32(+1.0)), ClippingEdge(ClippingEdge::POS_Z, float24::FromFloat32(+1.0)),
ClippingEdge(ClippingEdge::NEG_Z, float24::FromFloat32(-1.0)) }) { ClippingEdge(ClippingEdge::NEG_Z, float24::FromFloat32(-1.0)) }) {
const std::vector<OutputVertex*> input_list = output_list; const static_vector<OutputVertex*, MAX_VERTICES> input_list = output_list;
output_list.clear(); output_list.clear();
const OutputVertex* reference_vertex = input_list.back(); const OutputVertex* reference_vertex = input_list.back();