[Mesa-dev] [PATCH] Bounding box avx2 intrinsic algorithm for openGL/GLES
Eero Tamminen
eero.t.tamminen at intel.com
Fri Aug 31 16:27:07 UTC 2018
Hi,
On 31.08.2018 08:25, kedar.j.karanje at intel.com wrote:
> From: "J Karanje, Kedar" <kedar.j.karanje at intel.com>
>
> The feature is enabled by default during make however we need to
> add the following to drirc to enable the feature at runtime.
> <option name="enable_bounding_box_culling" value="true"/>
>
> vbo: Main algorithm & code to check for MVP & vertex position location
> Build Files: Flags to enable BBOX Code and check AVX version
> compiler: Code to recognize simple shader
> (gl_position is a simple function of mvp and vertex)
> i965 & util: dri query to check if feature is enabled
>
> vbo: Implements a bounding box algorithm for mesa,we hook into the default
> drawelements and drawrangelements and the MVP & vertex positions location
> and the corresponding program is got,we re-create the frustum planes
> using this data and also create a box around the object and use the 8
> vertices (box vertices) and check if the box is within the frustum or not,
> we drop the draw calls that are completely outside the view frustum and
> go for sub-boxes for objects that are intersecting with the frustum planes.
>
> The current patch has been verified on KBL+Ubuntu 16.04, we noticed
> 8~10% improvements in GFxBench TREX offscreen and ~2% for Manhattan offscreen,
> Platforms where avx2 is not supported shall still see ~6-8% improvement, the
> other KPIs were not impacted.
I've tried this with Egypt and T-Rex on KBL GT3e, and I'm not seeing
a performance difference. What I'm missing / what exactly I should
do to get it enabled, see that it's enabled, and to see the perf
difference?
> Based on empirical data we have set minimum vertex count as 999 and the
> sub-box size as 198, this provides the best results, we have also implemented
> some level of caching for the box co-od and frustum plane co-od.
> we have also optimized some algorithms to use avx2 when a target supports it.
>
> Shader classification code is currently in hir and we have got review comments
> to move the same to NIR.
>
> Signed-off-by: Aravindan Muthukumar <aravindan.muthukumar at intel.com>
> Signed-off-by: Yogesh Marathe <yogesh.marathe at intel.com>
> ---
> Android.common.mk | 19 +
> configure.ac | 34 +-
> src/compiler/glsl/ast_to_hir.cpp | 168 +++-
> src/compiler/glsl/glsl_parser_extras.cpp | 10 +
> src/compiler/glsl/glsl_parser_extras.h | 7 +
> src/compiler/glsl/linker.cpp | 18 +
> src/intel/common/gen_debug.c | 7 +
> src/mesa/Makefile.sources | 11 +
> src/mesa/drivers/dri/i965/brw_context.c | 17 +
> src/mesa/drivers/dri/i965/intel_screen.c | 4 +
> src/mesa/main/bufferobj.c | 19 +
> src/mesa/main/mtypes.h | 51 +
> src/mesa/program/Android.mk | 1 +
> src/mesa/program/program.c | 3 +
> src/mesa/vbo/vbo_bbox.c | 1538 ++++++++++++++++++++++++++++++
> src/mesa/vbo/vbo_bbox.h | 383 ++++++++
> src/mesa/vbo/vbo_bbox_cache.c | 195 ++++
> src/mesa/vbo/vbo_context.c | 11 +-
> src/mesa/vbo/vbo_exec_array.c | 37 +-
> src/util/00-mesa-defaults.conf | 4 +
> src/util/xmlpool/t_options.h | 5 +
> 21 files changed, 2535 insertions(+), 7 deletions(-)
> mode change 100644 => 100755 src/compiler/glsl/ast_to_hir.cpp
> create mode 100644 src/mesa/vbo/vbo_bbox.c
> create mode 100644 src/mesa/vbo/vbo_bbox.h
> create mode 100644 src/mesa/vbo/vbo_bbox_cache.c
>
> diff --git a/Android.common.mk b/Android.common.mk
> index aa1b266..efd6792 100644
> --- a/Android.common.mk
> +++ b/Android.common.mk
> @@ -21,6 +21,8 @@
> # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
> # DEALINGS IN THE SOFTWARE.
>
> +MESA_BBOX_ENABLE=true
> +
> ifeq ($(LOCAL_IS_HOST_MODULE),true)
> LOCAL_CFLAGS += -D_GNU_SOURCE
> endif
> @@ -80,6 +82,10 @@ LOCAL_CFLAGS += \
> -fno-trapping-math \
> -Wno-sign-compare
>
> +ifeq ($(MESA_BBOX_ENABLE),true)
> +LOCAL_CFLAGS += -DMESA_BBOX_OPT
> +endif
> +
> LOCAL_CPPFLAGS += \
> -D__STDC_CONSTANT_MACROS \
> -D__STDC_FORMAT_MACROS \
> @@ -87,6 +93,10 @@ LOCAL_CPPFLAGS += \
> -Wno-error=non-virtual-dtor \
> -Wno-non-virtual-dtor
>
> +ifeq ($(MESA_BBOX_ENABLE),true)
> +LOCAL_CPPFLAGS += -DMESA_BBOX_OPT
> +endif
> +
> # mesa requires at least c99 compiler
> LOCAL_CONLYFLAGS += \
> -std=c99
> @@ -98,6 +108,15 @@ ifeq ($(filter 5 6 7 8 9, $(MESA_ANDROID_MAJOR_VERSION)),)
> LOCAL_CFLAGS += -DHAVE_TIMESPEC_GET
> endif
>
> +ifeq ($(MESA_BBOX_ENABLE),true)
> +#if defined(CONFIG_AS_AVX)
> +LOCAL_CONLYFLAGS += -mavx
> +#elif
> +LOCAL_CONLYFLAGS += -msse4.1
> +#endif
> +endif
> +
> +
> ifeq ($(strip $(MESA_ENABLE_ASM)),true)
> ifeq ($(TARGET_ARCH),x86)
> LOCAL_CFLAGS += \
> diff --git a/configure.ac b/configure.ac
> index 4d9d9e5..dcdbcf3 100644
> --- a/configure.ac
> +++ b/configure.ac
> @@ -278,7 +278,8 @@ _SAVE_LDFLAGS="$LDFLAGS"
> _SAVE_CPPFLAGS="$CPPFLAGS"
>
> dnl Compiler macros
> -DEFINES="-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS"
> +DEFINES="-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -DMESA_BBOX_OPT"
> +dnl DEFINES="-D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS"
> AC_SUBST([DEFINES])
> android=no
> case "$host_os" in
> @@ -295,10 +296,38 @@ esac
>
> AM_CONDITIONAL(HAVE_ANDROID, test "x$android" = xyes)
>
> +
> +dnl Conditional parameters for enabling BBOX file compilation in Makefile
> +dnl bbox=yes
> +dnl MESA_BBOX_ENABLE=true
> +dnl AM_CONDITIONAL([MESA_BBOX_ENABLE], [test x$bbox= xyes])
> +
> dnl
> dnl Check compiler flags
> dnl
> -AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall"])
> +
> +AC_ARG_WITH([swr-archs],
> + [AS_HELP_STRING([--with-swr-archs@<:@=DIRS...@:>@],
> + [comma delimited swr architectures list, e.g.
> + "avx,avx2,sse4.1,sse4.2" @<:@default="sse4.1,sse4.2"@:>@])],
> + [with_swr_archs="$withval"],
> + [with_swr_archs="sse4.1,sse4.2"])
> +
> +swr_archs=`IFS=', '; echo $with_swr_archs`
> +if test "$swr_archs" = "avx"; then
> +AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall -msse4.1 -mavx"])
> +AX_CHECK_COMPILE_FLAG([-Wall], [CXXFLAGS="$CXXFLAGS -Wall -msse4.1 -mavx"])
> +elif test "$swr_archs" = "avx2"; then
> +AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall -msse4.1 -mavx -mavx2"])
> +AX_CHECK_COMPILE_FLAG([-Wall], [CXXFLAGS="$CXXFLAGS -Wall -msse4.1 -mavx -mavx2"])
> +elif test "$swr_archs" = "sse4.1"; then
> +AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall -msse4.1"])
> +AX_CHECK_COMPILE_FLAG([-Wall], [CXXFLAGS="$CXXFLAGS -Wall -msse4.1"])
> +elif test "$swr_archs" = "sse4.2"; then
> +AX_CHECK_COMPILE_FLAG([-Wall], [CFLAGS="$CFLAGS -Wall -msse4.1 -msse4.2"])
> +AX_CHECK_COMPILE_FLAG([-Wall], [CXXFLAGS="$CXXFLAGS -Wall -msse4.1 -msse4.2"])
> +fi
> +
> AX_CHECK_COMPILE_FLAG([-Werror=implicit-function-declaration], [CFLAGS="$CFLAGS -Werror=implicit-function-declaration"])
> AX_CHECK_COMPILE_FLAG([-Werror=missing-prototypes], [CFLAGS="$CFLAGS -Werror=missing-prototypes"])
> AX_CHECK_COMPILE_FLAG([-Wmissing-prototypes], [CFLAGS="$CFLAGS -Wmissing-prototypes"])
> @@ -313,7 +342,6 @@ dnl
> dnl Check C++ compiler flags
> dnl
> AC_LANG_PUSH([C++])
> -AX_CHECK_COMPILE_FLAG([-Wall], [CXXFLAGS="$CXXFLAGS -Wall"])
Why removed?
> AX_CHECK_COMPILE_FLAG([-fno-math-errno], [CXXFLAGS="$CXXFLAGS -fno-math-errno"])
> AX_CHECK_COMPILE_FLAG([-fno-trapping-math], [CXXFLAGS="$CXXFLAGS -fno-trapping-math"])
> AX_CHECK_COMPILE_FLAG([-fvisibility=hidden], [VISIBILITY_CXXFLAGS="-fvisibility=hidden"])
> diff --git a/src/compiler/glsl/ast_to_hir.cpp b/src/compiler/glsl/ast_to_hir.cpp
> old mode 100644
> new mode 100755
> index 5d3f10b..f4e8dea
> --- a/src/compiler/glsl/ast_to_hir.cpp
> +++ b/src/compiler/glsl/ast_to_hir.cpp
> @@ -62,7 +62,6 @@
> #include "builtin_functions.h"
>
> using namespace ir_builder;
> -
> static void
> detect_conflicting_assignments(struct _mesa_glsl_parse_state *state,
> exec_list *instructions);
> @@ -1325,6 +1324,124 @@ ast_expression::set_is_lhs(bool new_value)
> this->subexpressions[0]->set_is_lhs(new_value);
> }
>
> +#ifdef MESA_BBOX_OPT
> +static bool
> +is_simple_shader(exec_list *instructions, ast_expression *simple_ast_root,
> + struct _mesa_glsl_parse_state *state)
> +{
> + ast_expression * subex0 = simple_ast_root->subexpressions[0];
> + ast_expression * subex1 = simple_ast_root->subexpressions[1];
> +
> + char temp_identifier[100];
> +
> + subex0->set_is_lhs(true);
> +
> + if (subex1->oper == ast_mul)
> + {
> + ir_rvalue *rhsParts[3];
> + rhsParts[0] = subex1->subexpressions[0]->hir(instructions, state);
> + rhsParts[1] = subex1->subexpressions[1]->hir(instructions, state);
> +
> + if (rhsParts[0]->type->gl_type == GL_FLOAT_MAT4 &&
> + rhsParts[1]->type->gl_type == GL_FLOAT_VEC4) {
> + foreach_list_typed (ast_node, ast, link,
> + &subex1->subexpressions[1]->expressions) {
> + if (((ast_expression *)ast)->oper != ast_identifier &&
> + (((ast_expression *)ast)->oper != ast_int_constant) &&
> + (((ast_expression *)ast)->oper != ast_float_constant)) {
> + return false;
> + }
> + if (((ast_expression *)ast)->oper == ast_identifier &&
> + ((ast_expression *)ast)->primary_expression.identifier) {
> + strncpy((char *)state->stateVertPosition,
> + ((ast_expression *)ast)->primary_expression.identifier,
> + strlen(((ast_expression *)ast)->primary_expression.identifier));
> + }
> + }
> + }
> + if (subex0->oper == ast_identifier) {
> + if (!strcmp(subex0->primary_expression.identifier,"gl_Position")) {
> + if(subex0 && subex0->primary_expression.identifier) {
> + strncpy((char *)temp_identifier,
> + subex0->primary_expression.identifier,
> + strlen(subex0->primary_expression.identifier));
> + } else {
> + return false;
> + }
> + if(subex1 && subex1->subexpressions[0] &&
> + subex1->subexpressions[0]->primary_expression.identifier) {
> + strncpy((char *)state->stateMVP,
> + subex1->subexpressions[0]->primary_expression.identifier,
> + strlen(subex1->subexpressions[0]->primary_expression.identifier));
> + } else {
> + return false;
> + }
> +
> + return true;
> + } else {
> + if(subex0 && subex0->primary_expression.identifier) {
> + strncpy((char *)temp_identifier,
> + subex0->primary_expression.identifier,
> + strlen(subex0->primary_expression.identifier));
> + } else {
> + return true;
> + }
> +
> + if (subex1->subexpressions[0]->oper == ast_identifier) {
> + if(subex1 && subex1->subexpressions[0] &&
> + subex1->subexpressions[0]->primary_expression.identifier) {
> + strncpy((char *)state->stateMVP,
> + subex1->subexpressions[0]->primary_expression.identifier,
> + strlen(subex1->subexpressions[0]->primary_expression.identifier));
> + } else {
> + return true;
> + }
> + }
> + return false; //Return false to trigger further parsing.
> + }
> + } else {
> + return false;
> + }
> + } else {
> + if (subex0->primary_expression.identifier != NULL)
> + if (!strcmp(subex0->primary_expression.identifier,"gl_Position") &&
> + (strlen(temp_identifier) > 0)) { //gl_position = temp;
> + if (subex1->oper == ast_identifier) {
> + if (!strcmp((char *)temp_identifier,
> + subex1->primary_expression.identifier)) {
> + return true;
> + }
> + } else {
> + return false;
> + }
> + }
> + }
> + return false;
> +}
> +/*
> + * Function to check if LHS of assign is an input variable Eg: in_position
> + */
> +
> +static bool
> +is_attribute(struct _mesa_glsl_parse_state *state)
> +{
> + ir_variable *const var = state->symbols->get_variable(state->stateVertPosition);
> + ir_rvalue *result = NULL;
> + void *ctx = state;
> + if (var != NULL)
> + {
> + result = new(ctx) ir_dereference_variable(var);
> + (void)result;
> + if (var->data.mode == ir_var_shader_in)
> + return true;
> +
> + }
> +
> + return false;
> +
> +}
> +#endif //MESA_BBOX_OPT
> +
> ir_rvalue *
> ast_expression::do_hir(exec_list *instructions,
> struct _mesa_glsl_parse_state *state,
> @@ -1400,6 +1517,55 @@ ast_expression::do_hir(exec_list *instructions,
> unreachable("ast_aggregate: Should never get here.");
>
> case ast_assign: {
> +#ifdef MESA_BBOX_OPT
> + if (state->stage == MESA_SHADER_VERTEX &&
> + !state->state_bbox_simple_shader &&
> + is_simple_shader(instructions,this,state) &&
> + !state->state_shader_analysis_complete)
> + {
> + state->state_bbox_simple_shader = true;
> + }
> +
> + if (state->state_bbox_simple_shader &&
> + !state->state_shader_analysis_complete) {
> + if (!is_attribute(state)) {
> + if ((ir_dereference_variable *)op[0] != NULL &&
> + ((ir_dereference_variable *)op[0])->var->name != NULL &&
> + strlen(state->stateVertPosition) != 0)
> + if (!strcmp(((ir_dereference_variable *)op[0])->var->name,
> + state->stateVertPosition) ) {
> + if (((ir_instruction *)op[0])->ir_type == ir_type_variable ||
> + ((ir_instruction *)op[0])->ir_type ==
> + ir_type_dereference_variable &&
> + (ir_dereference_variable *)op[1] != NULL &&
> + ((ir_dereference_variable *)op[1])->ir_type ==
> + ir_type_dereference_variable) {
> + if ((((ir_instruction *)op[1])->ir_type == ir_type_variable ||
> + ((ir_instruction *)op[1])->ir_type ==
> + ir_type_dereference_variable) &&
> + ((ir_dereference_variable *)op[1])->var->name) {
> + strncpy((char *)state->stateVertPosition,
> + (char *)((ir_dereference_variable *)op[1])->var->name,
> + strlen(((ir_dereference_variable *)op[1])->var->name));
> + state->state_shader_analysis_complete = true;
> + }
> + }
> + else {
> + state->state_bbox_simple_shader = false;
> + state->state_shader_analysis_complete = true;
> + }
> + }
> + else {
> + state->state_bbox_simple_shader = false;
> + state->state_shader_analysis_complete = true;
> +
> + }
> + }
> + else {
> + state->state_shader_analysis_complete = true;
> + }
> + }
> +#endif //MESA_BBOX_OPT
> this->subexpressions[0]->set_is_lhs(true);
> op[0] = this->subexpressions[0]->hir(instructions, state);
> op[1] = this->subexpressions[1]->hir(instructions, state);
> diff --git a/src/compiler/glsl/glsl_parser_extras.cpp b/src/compiler/glsl/glsl_parser_extras.cpp
> index 42ba88f..c540b3a 100644
> --- a/src/compiler/glsl/glsl_parser_extras.cpp
> +++ b/src/compiler/glsl/glsl_parser_extras.cpp
> @@ -2121,6 +2121,16 @@ _mesa_glsl_compile_shader(struct gl_context *ctx, struct gl_shader *shader,
> if (!state->error && !state->translation_unit.is_empty())
> _mesa_ast_to_hir(shader->ir, state);
>
> +#ifdef MESA_BBOX_OPT
> + shader->shader_bbox_simple_shader = state->state_bbox_simple_shader;
> + if (shader->shader_bbox_simple_shader)
> + {
> + strncpy((char *)shader->shaderMVP,state->stateMVP,
> + strlen(state->stateMVP));
> + strncpy((char *)shader->shaderVertPosition,state->stateVertPosition,
> + strlen(state->stateVertPosition));
> + }
> +#endif //MESA_BBOX_OPT
> if (!state->error) {
> validate_ir_tree(shader->ir);
>
> diff --git a/src/compiler/glsl/glsl_parser_extras.h b/src/compiler/glsl/glsl_parser_extras.h
> index da44d37..b951a66 100644
> --- a/src/compiler/glsl/glsl_parser_extras.h
> +++ b/src/compiler/glsl/glsl_parser_extras.h
> @@ -887,6 +887,13 @@ struct _mesa_glsl_parse_state {
> * so we can check totals aren't too large.
> */
> unsigned clip_dist_size, cull_dist_size;
> +
> +#ifdef MESA_BBOX_OPT
> + bool state_shader_analysis_complete;
> + bool state_bbox_simple_shader;
> + char stateMVP[20] = {'\0'};
> + char stateVertPosition[100] = {'\0'};
> +#endif
> };
This causes lot of compiler warnings:
-------------------------------------------
In file included from ../../../src/mesa/main/uniform_query.cpp:37:0:
../../../src/compiler/glsl/glsl_parser_extras.h:901:29: warning:
non-static data member initializers only available with -std=c++11 or
-std=gnu++11
char stateMVP[20] = {'\0'};
^
../../../src/compiler/glsl/glsl_parser_extras.h:902:39: warning:
non-static data member initializers only available with -std=c++11 or
-std=gnu++11
char stateVertPosition[100] = {'\0'};
^
../../../src/compiler/glsl/glsl_parser_extras.h:901:29: warning:
extended initializer lists only available with -std=c++11 or -std=gnu++11
char stateMVP[20] = {'\0'};
^
../../../src/compiler/glsl/glsl_parser_extras.h:902:39: warning:
extended initializer lists only available with -std=c++11 or -std=gnu++11
char stateVertPosition[100] = {'\0'};
-------------------------------------------
(Rest of struct isn't initialized like that, so IMHO those members
shouldn't either.)
> # define YYLLOC_DEFAULT(Current, Rhs, N) \
> diff --git a/src/compiler/glsl/linker.cpp b/src/compiler/glsl/linker.cpp
> index 3ce78fe..210f37f 100644
> --- a/src/compiler/glsl/linker.cpp
> +++ b/src/compiler/glsl/linker.cpp
> @@ -4876,6 +4876,24 @@ link_shaders(struct gl_context *ctx, struct gl_shader_program *prog)
>
> switch (stage) {
> case MESA_SHADER_VERTEX:
> +#ifdef MESA_BBOX_OPT
> + if (shader_list[MESA_SHADER_VERTEX][0] != NULL) {
> + sh->linked_bbox_simple_shader =
> + shader_list[MESA_SHADER_VERTEX][0]->shader_bbox_simple_shader;
> + /*TBD: How do we handle multiple Vertex Shaders
> + * being linked ??
> + * MVP Name copied to get MVP in VBO
> + */
> + strncpy((char *)sh->linkedshaderMVP,
> + shader_list[MESA_SHADER_VERTEX][0]->shaderMVP,
> + strlen(shader_list[MESA_SHADER_VERTEX][0]->shaderMVP));
> + /* Vertex Position attribute name */
> + strncpy((char *)sh->linkedshaderVertPosition,
> + shader_list[MESA_SHADER_VERTEX][0]->shaderVertPosition,
> + strlen(
> + shader_list[MESA_SHADER_VERTEX][0]->shaderVertPosition));
> + }
> +#endif
> validate_vertex_shader_executable(prog, sh, ctx);
> break;
> case MESA_SHADER_TESS_CTRL:
> diff --git a/src/intel/common/gen_debug.c b/src/intel/common/gen_debug.c
> index a978f2f..c677208 100644
> --- a/src/intel/common/gen_debug.c
> +++ b/src/intel/common/gen_debug.c
> @@ -106,6 +106,13 @@ intel_debug_flag_for_shader_stage(gl_shader_stage stage)
> static void
> brw_process_intel_debug_variable_once(void)
> {
> +#if defined(__ANDROID__) || defined(ANDROID)
> + setenv("MESA_GLSL_CACHE_DISABLE","true",1);
> + setenv("MESA_BBOX_MIN_VERTEX_CNT", "999", 1);
> + setenv("MESA_BBOX_OPT_ENABLE", "3", 1);
> + setenv("MESA_OPT_SPLIT_SIZE", "198", 1);
> +#endif
> +
> INTEL_DEBUG = parse_debug_string(getenv("INTEL_DEBUG"), debug_control);
> }
>
> diff --git a/src/mesa/Makefile.sources b/src/mesa/Makefile.sources
> index 0d3c277..8148622 100644
> --- a/src/mesa/Makefile.sources
> +++ b/src/mesa/Makefile.sources
> @@ -1,4 +1,5 @@
> ### Lists of source files, included by Makefiles
> +MESA_BBOX_ENABLE = false
>
> # this is part of MAIN_FILES
> MAIN_ES_FILES = \
> @@ -400,6 +401,7 @@ TNL_FILES = \
> tnl/t_vp_build.c \
> tnl/t_vp_build.h
>
> +
> VBO_FILES = \
> vbo/vbo_attrib.h \
> vbo/vbo_attrib_tmp.h \
> @@ -422,6 +424,15 @@ VBO_FILES = \
> vbo/vbo_save.h \
> vbo/vbo_save_loopback.c
>
> +#ifeq($(MESA_BBOX_ENABLE), true)
> +
> +VBO_FILES += \
> + vbo/vbo_bbox_cache.c \
> + vbo/vbo_bbox.c \
> + vbo/vbo_bbox.h
> +
> +#endif
> +
> STATETRACKER_FILES = \
> state_tracker/st_atifs_to_tgsi.c \
> state_tracker/st_atifs_to_tgsi.h \
> diff --git a/src/mesa/drivers/dri/i965/brw_context.c b/src/mesa/drivers/dri/i965/brw_context.c
> index 6ba64e4..03cf861 100644
> --- a/src/mesa/drivers/dri/i965/brw_context.c
> +++ b/src/mesa/drivers/dri/i965/brw_context.c
> @@ -48,6 +48,10 @@
>
> #include "vbo/vbo.h"
>
> +#ifdef MESA_BBOX_OPT
> +#include "vbo/vbo_bbox.h"
> +#endif
> +
> #include "drivers/common/driverfuncs.h"
> #include "drivers/common/meta.h"
> #include "utils.h"
> @@ -890,6 +894,11 @@ brw_process_driconf_options(struct brw_context *brw)
> ctx->Const.AllowGLSLCrossStageInterpolationMismatch =
> driQueryOptionb(options, "allow_glsl_cross_stage_interpolation_mismatch");
>
> +#ifdef MESA_BBOX_OPT
> + ctx->Const.EnableBoundingBoxCulling =
> + driQueryOptionb(options, "enable_bounding_box_culling");
> +#endif //MESA_BBOX_OPT
> +
> ctx->Const.dri_config_options_sha1 = ralloc_array(brw, unsigned char, 20);
> driComputeOptionsSha1(&brw->screen->optionCache,
> ctx->Const.dri_config_options_sha1);
> @@ -1001,6 +1010,14 @@ brwCreateContext(gl_api api,
>
> brw_process_driconf_options(brw);
>
> +#ifdef MESA_BBOX_OPT
> + if (ctx->Const.EnableBoundingBoxCulling) {
> + MESA_BBOX("EnableBoundingBoxCulling True\n");
> + vbo_bbox_init(ctx);
> + } else
> + MESA_BBOX("EnableBoundingBoxCulling False\n");
> +#endif //MESA_BBOX_OPT
> +
> if (INTEL_DEBUG & DEBUG_PERF)
> brw->perf_debug = true;
>
> diff --git a/src/mesa/drivers/dri/i965/intel_screen.c b/src/mesa/drivers/dri/i965/intel_screen.c
> index eaf5a3b..35c7624 100644
> --- a/src/mesa/drivers/dri/i965/intel_screen.c
> +++ b/src/mesa/drivers/dri/i965/intel_screen.c
> @@ -88,6 +88,10 @@ DRI_CONF_BEGIN
> DRI_CONF_ALLOW_HIGHER_COMPAT_VERSION("false")
> DRI_CONF_FORCE_GLSL_ABS_SQRT("false")
>
> +#ifdef MESA_BBOX_OPT
> + DRI_CONF_ENABLE_BOUNDING_BOX_CULLING("true")
> +#endif
> +
> DRI_CONF_OPT_BEGIN_B(shader_precompile, "true")
> DRI_CONF_DESC(en, "Perform code generation at shader link time.")
> DRI_CONF_OPT_END
> diff --git a/src/mesa/main/bufferobj.c b/src/mesa/main/bufferobj.c
> index 1d1e51b..67a369b 100644
> --- a/src/mesa/main/bufferobj.c
> +++ b/src/mesa/main/bufferobj.c
> @@ -48,6 +48,9 @@
> #include "varray.h"
> #include "util/u_atomic.h"
>
> +#ifdef MESA_BBOX_OPT
> +#include "vbo/vbo_bbox.h"
> +#endif
>
> /* Debug flags */
> /*#define VBO_DEBUG*/
> @@ -2254,6 +2257,10 @@ buffer_sub_data(GLenum target, GLuint buffer, GLintptr offset,
>
> if (no_error || validate_buffer_sub_data(ctx, bufObj, offset, size, func))
> _mesa_buffer_sub_data(ctx, bufObj, offset, size, data);
> +
> +#ifdef MESA_BBOX_OPT
> + vbo_bbox_element_buffer_update(ctx,bufObj,data,offset,size);
> +#endif
> }
>
>
> @@ -2589,9 +2596,17 @@ validate_and_unmap_buffer(struct gl_context *ctx,
> #endif
>
> #ifdef VBO_DEBUG
> +#ifdef MESA_BBOX_OPT
> + if (bufObj->StorageFlags & GL_MAP_WRITE_BIT) {
> +#else
> if (bufObj->AccessFlags & GL_MAP_WRITE_BIT) {
> +#endif
> GLuint i, unchanged = 0;
> +#ifdef MESA_BBOX_OPT
> + GLubyte *b = (GLubyte *) bufObj->Data;
> +#else
> GLubyte *b = (GLubyte *) bufObj->Pointer;
> +#endif
> GLint pos = -1;
> /* check which bytes changed */
> for (i = 0; i < bufObj->Size - 1; i++) {
> @@ -3154,7 +3169,11 @@ map_buffer_range(struct gl_context *ctx, struct gl_buffer_object *bufObj,
> /* Access must be write only */
> if ((access & GL_MAP_WRITE_BIT) && (!(access & ~GL_MAP_WRITE_BIT))) {
> GLuint i;
> +#ifdef MESA_BBOX_OPT
> + GLubyte *b = (GLubyte *) bufObj->Data;
> +#else
> GLubyte *b = (GLubyte *) bufObj->Pointer;
> +#endif
> for (i = 0; i < bufObj->Size; i++)
> b[i] = i & 0xff;
> }
> diff --git a/src/mesa/main/mtypes.h b/src/mesa/main/mtypes.h
> index 9fd577d..c262173 100644
> --- a/src/mesa/main/mtypes.h
> +++ b/src/mesa/main/mtypes.h
> @@ -1359,6 +1359,9 @@ struct gl_buffer_object
> bool MinMaxCacheDirty;
>
> bool HandleAllocated; /**< GL_ARB_bindless_texture */
> +#ifdef MESA_BBOX_OPT
> + int data_change_counter; //TBD: Same as RefCount to check
> +#endif
> };
>
>
> @@ -2535,6 +2538,12 @@ struct gl_linked_shader
> * stores information that is also needed during linking.
> */
> struct gl_shader_spirv_data *spirv_data;
> +
> +#ifdef MESA_BBOX_OPT
> + bool linked_bbox_simple_shader;
> + char linkedshaderMVP[20];
> + char linkedshaderVertPosition[100];
> +#endif
> };
>
>
> @@ -2631,6 +2640,11 @@ struct gl_shader
>
> /* ARB_gl_spirv related data */
> struct gl_shader_spirv_data *spirv_data;
> +#ifdef MESA_BBOX_OPT
> + bool shader_bbox_simple_shader;
> + char shaderMVP[20];
> + char shaderVertPosition[100];
> +#endif
> };
>
>
> @@ -2902,6 +2916,9 @@ struct gl_shader_program_data
> * ARB_gl_spirv extension.
> */
> bool spirv;
> +#ifdef MESA_BBOX_OPT
> + GLuint vbo_bbox_mvp_location;
> +#endif
> };
>
> /**
> @@ -3108,6 +3125,10 @@ struct gl_pipeline_shader_state
>
> /** Pipeline objects */
> struct _mesa_HashTable *Objects;
> +#ifdef MESA_BBOX_OPT
> + /* Bounding box draw optimization control structure */
> + struct mesa_bbox_opt *BboxOpt;
> +#endif
> };
>
> /**
> @@ -4076,6 +4097,12 @@ struct gl_constants
>
> /** GL_ARB_gl_spirv */
> struct spirv_supported_capabilities SpirVCapabilities;
> +
> +#ifdef MESA_BBOX_OPT
> + /** MESA_BBOX_OPT Runtime enable_bounding_box_culling*/
> + bool EnableBoundingBoxCulling;
> +#endif
> +
> };
>
>
> @@ -4720,6 +4747,21 @@ struct gl_semaphore_object
> GLuint Name; /**< hash table ID/name */
> };
>
> +#ifdef MESA_BBOX_OPT
> +/**
> + * Bounding volume classification types
> + */
> +typedef enum
> +{
> + BOUNDING_VOLUME_AABB = 0,
> + BOUNDING_VOLUME_OBB = 1,
> + BOUNDING_VOLUME_SPHERE = 2,
> + BOUNDING_VOLUME_DOP = 3,
> + BOUNDING_VOULME_MIXED = 4,
> + BOUNDING_VOLUME_MAX = 5,
> +} bounding_volume_type;
> +#endif //MESA_BBOX_OPT
> +
> /**
> * Mesa rendering context.
> *
> @@ -5096,6 +5138,15 @@ struct gl_context
> struct hash_table_u64 *ResidentTextureHandles;
> struct hash_table_u64 *ResidentImageHandles;
> /*@}*/
> +
> +#ifdef MESA_BBOX_OPT
> + /**
> + * Bounding volume type
> + *
> + */
> + bounding_volume_type volume_type;
> +#endif //MESA_BBOX_OPT
> +
> };
>
> /**
> diff --git a/src/mesa/program/Android.mk b/src/mesa/program/Android.mk
> index c6470e6..6489d3e 100644
> --- a/src/mesa/program/Android.mk
> +++ b/src/mesa/program/Android.mk
> @@ -75,6 +75,7 @@ $(intermediates)/program/lex.yy.c: $(LOCAL_PATH)/program_lexer.l
> LOCAL_C_INCLUDES := \
> $(MESA_TOP)/src/mapi \
> $(MESA_TOP)/src/mesa \
> + $(MESA_TOP)/src/mesa/vbo \
> $(MESA_TOP)/src/compiler/nir \
> $(MESA_TOP)/src/gallium/auxiliary \
> $(MESA_TOP)/src/gallium/include
> diff --git a/src/mesa/program/program.c b/src/mesa/program/program.c
> index 6ab1bf5..e0b3563 100644
> --- a/src/mesa/program/program.c
> +++ b/src/mesa/program/program.c
> @@ -43,6 +43,9 @@
> #include "util/ralloc.h"
> #include "util/u_atomic.h"
>
> +#ifdef MESA_BBOX_OPT
> +#include "vbo/vbo_bbox.h"
> +#endif
>
> /**
> * A pointer to this dummy program is put into the hash table when
> diff --git a/src/mesa/vbo/vbo_bbox.c b/src/mesa/vbo/vbo_bbox.c
> new file mode 100644
> index 0000000..f1e153d
> --- /dev/null
> +++ b/src/mesa/vbo/vbo_bbox.c
> @@ -0,0 +1,1538 @@
> +/*
> + * Copyright � 2018 Intel Corporation
> + *
> + * 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 (including the next
> + * paragraph) 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.
> + */
> +
> +/**
> + * \brief VBO BBOX module implementation
> + * \author Kedar Karanje
> + */
> +
> +#pragma GCC optimize (0)
> +#include "vbo_bbox.h"
> +#include <fcntl.h>
> +#define BBOX_MAX_FRAMES_TO_DYNAMICALLY_UPDATE (5)
> +#define BBOX_MIN_EFFECTIVE_DRAWS_TO_DYNAMICALLY_UPDATE (5)
> +#define BBOX_MIN_VAL_FOR_EFFECTIVE_DRAWS_COUNTER (-100)
> +#define BBOX_MAX_VAL_FOR_EFFECTIVE_DRAWS_COUNTER (100)
> +#define BBOX_MIN_GPU_HEAD_ROOM_TO_PROCESS_ELEMENT_BUFFER (100)
> +
> +/**
> + * Min part of split draw that we want to drop
> + */
> +#define BBOX_MIN_SPLITTED_DRAW_TO_DROP (1)
> +
> +#ifdef __AVX__
> +static __m256 fullMin;
> +static __m256 fullMax;
> +#else
> +static __m128 fullMin;
> +static __m128 fullMax;
> +#endif
> +
> +/* Segment functions */
> +
> +static inline GLboolean
> +intersect(const struct gl_segment *s_src,const struct gl_segment *s_tar)
> +{
> + return (s_src->Left < s_tar->Right && s_src->Right > s_tar->Left);
> +}
> +
> +
> +static inline GLboolean
> +subsegment(const struct gl_segment *s_src,const struct gl_segment *s_tar)
> +{
> + return (s_src->Left <= s_tar->Left && s_src->Right >= s_tar->Right);
> +}
> +
> +
> +static inline GLboolean
> +superset(const struct gl_segment *s_src,const struct gl_segment *s_tar)
> +{
> + return subsegment(s_tar,s_src);
> +}
> +
> +
> +static void
> +normalize(vbo_bbox_frustum_plane *fr_plane)
> +{
> + GLfloat a,b,c;
> + a = fr_plane->a;
> + b = fr_plane->b;
> + c = fr_plane->c;
> +
> + GLfloat norm = 1.0f/sqrt(a*a + b*b + c*c);
> +
> + fr_plane->a *= norm;
> + fr_plane->b *= norm;
> + fr_plane->c *= norm;
> + fr_plane->d *= norm;
> +};
> +
> +static inline
> +int vbo_bbox_get_delay(struct mesa_bbox_opt *opt)
> +{
> + if (mesa_bbox_env_variables.bbox_enable < MESA_BBOX_ENABLE_FORCE_RECALC) {
> + if (opt->calc_delay > BBOX_CALC_MAX_DELAY) {
> + opt->calc_delay = BBOX_CALC_MIN_DELAY;
> + }
> + return opt->calc_delay++;
> + }
> + else {
> + return 0;
> + }
> +}
> +
> +static inline
> +bool vbo_init_sub_bbox_array(int bbox_count, struct vbo_bbox_cache_data* data)
> +{
> + bool allocate_bbox = true;
> + if(data->sub_bbox_array != NULL) {
> + if(bbox_count == data->sub_bbox_cnt) {
> + allocate_bbox = false;
> + }
> + else {
> + free(data->sub_bbox_array);
> + data->sub_bbox_array = NULL;
> + }
> + }
> + if (allocate_bbox)
> + data->sub_bbox_array = (struct bounding_info*) malloc(
> + bbox_count * sizeof (struct bounding_info));
> +
> + if (!data->sub_bbox_array)
> + return false;
> +
> + data->sub_bbox_cnt = bbox_count;
> + return true;
> +}
> +
> +static inline GLint
> +vbo_bbox_get_mvp(struct gl_context *ctx)
> +{
> + struct gl_linked_shader * linked_shader =
> + ctx->Shader.ActiveProgram->_LinkedShaders[MESA_SHADER_VERTEX];
> +
> + return _mesa_GetUniformLocation(ctx->Shader.ActiveProgram->Name,
> + linked_shader->linkedshaderMVP);
> +}
> +
> +/*
> + * Gets the currently linked shaders flag for simple shader
> + *
> + */
> +static inline int
> +vbo_is_simple_shader(struct gl_context *ctx)
> +{
> + struct gl_linked_shader * linked_shader =
> + ctx->Shader.ActiveProgram->_LinkedShaders[MESA_SHADER_VERTEX];
> +
> + return linked_shader->linked_bbox_simple_shader;
> +}
> +
> +/**
> + * Get current VAO
> + */
> +static inline struct gl_vertex_array_object*
> +vbo_get_current_vao(struct gl_context *const gc)
> +{
> + assert(gc);
> + struct gl_vertex_array_object* vao = gc->Array.VAO;
> + assert(vao);
> +
> + return vao;
> +}
> +
> +/**
> + * Returns the location of the "position" in the attributes of the
> + * currently active program
> + */
> +static inline
> +int vbo_get_simple_vs_position_attr_location(
> + struct gl_context *const gc)
> +{
> + assert(gc);
> + struct gl_linked_shader * linked_shader =
> + gc->Shader.ActiveProgram->_LinkedShaders[MESA_SHADER_VERTEX];
> + GLint vertexPosLocation = _mesa_GetAttribLocation(
> + gc->Shader.ActiveProgram->Name,
> + linked_shader->linkedshaderVertPosition);
> + if (vertexPosLocation >= 0)
> + return vertexPosLocation;
> + else
> + return -1;
> +}
> +
> +/**
> + * Get element-buffer handle of the current VAO
> + */
> +static inline struct gl_buffer_object*
> +vbo_get_current_element_buffer(struct gl_context *const gc)
> +{
> + assert(gc);
> + struct gl_buffer_object* element_buffer =
> + vbo_get_current_vao(gc)->IndexBufferObj;
> + assert(element_buffer);
> + return element_buffer;
> +}
> +
> +/**
> + * Get vertex-binding of position from the current VAO
> + */
> +static inline struct gl_vertex_buffer_binding*
> +vbo_get_current_vertex_buffer_binding_of_position(struct gl_context *const gc)
> +{
> + assert(gc);
> + struct gl_vertex_array_object* vao = vbo_get_current_vao(gc);
> +
> + GLbitfield mask = vao->_Enabled & vao->VertexAttribBufferMask;
> + const struct gl_array_attributes *attrib_array =
> + &vao->VertexAttrib[ffs(mask) - 1];
> + struct gl_vertex_buffer_binding *buffer_binding =
> + &vao->BufferBinding[attrib_array->BufferBindingIndex];
> +
> + return buffer_binding;
> +}
> +
> +/**
> + * Get vertex-buffer handle of the current VAO
> + */
> +static inline struct gl_buffer_object*
> +vbo_get_current_vertex_buffer(struct gl_context *const gc)
> +{
> + assert(gc);
> + struct gl_buffer_object* pVertexBuffer =
> + vbo_get_current_vertex_buffer_binding_of_position(gc)->BufferObj;
> + assert(pVertexBuffer);
> + return pVertexBuffer;
> +}
> +
> +
> +/**
> + * Condition to enter bounding box optimization
> + */
> +static inline bool
> +vbo_bbox_check_supported_draw_call(struct gl_context *const gc,
> + GLenum mode, GLsizei count, GLenum type,
> + const GLvoid *indices, GLint basevertex)
> +{
> +
> + assert(gc);
> + int shader_scenario;
> + struct gl_linked_shader *_LinkedShaders;
> +
> + /* Check if the minimum vertex count is met. */
> + if (count < (GLsizei) mesa_bbox_env_variables.bbox_min_vrtx_count) {
> + /* Count is most common cause to bail out form optimization
> + * so should be first.
> + */
> + MESA_BBOX("Aborting MESA_BBOX :%d: Vertex count too small, minimum count = %d\n",
> + count,mesa_bbox_env_variables.bbox_min_vrtx_count);
> + return false;
> + }
> +
> + if (mode != GL_TRIANGLES) {
> + MESA_BBOX("Aborting MESA_BBOX :%d: Primitive mode is not GL_TRIANGLES, \
> + mode = %d\n", count, mode);
> + return false;
> + }
> +
> + /* Examine current shader */
> + if (!gc->_Shader->ActiveProgram) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: No active GLSL program.\n", count);
> + return false;
> + }
> +
> + /* BASIC Shader scenario is when we have just VS & FS */
> + if (gc->_Shader->CurrentProgram[MESA_SHADER_VERTEX] != NULL &&
> + gc->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT] != NULL &&
> + gc->_Shader->CurrentProgram[MESA_SHADER_TESS_CTRL] == NULL &&
> + gc->_Shader->CurrentProgram[MESA_SHADER_TESS_EVAL] == NULL &&
> + gc->_Shader->CurrentProgram[MESA_SHADER_GEOMETRY] == NULL) {
> + shader_scenario = 0;
> + }
> + else
> + shader_scenario = 1;
> +
> + if (shader_scenario) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: GLSL program must contain only vertex and \
> + fragment shaders, shader scenario = \n", count );
> + return false;
> + }
> +
> + if (!vbo_is_simple_shader(gc)) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: GLSL vertex shader does not have simple \
> + position calculation \n", count);
> + return false;
> + }
> + if (gc->Shader.ActiveProgram->_LinkedShaders[MESA_SHADER_VERTEX]) {
> + _LinkedShaders =
> + gc->Shader.ActiveProgram->_LinkedShaders[MESA_SHADER_VERTEX];
> +
> + MESA_BBOX("MVP:%s, VertPos:%s\n",_LinkedShaders->linkedshaderMVP,
> + _LinkedShaders->linkedshaderVertPosition);
> + }
> +
> + /* Examine element buffer */
> + struct gl_buffer_object* element_buffer = vbo_get_current_element_buffer(gc);
> + if ((!element_buffer) || element_buffer->Name == 0) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: Element buffer name is 0\n", count);
> + return false;
> + }
> +
> + if (!(element_buffer->StorageFlags &
> + (GL_CLIENT_STORAGE_BIT | GL_DYNAMIC_STORAGE_BIT))){
> + MESA_BBOX("Aborting MESA_BBOX:%d: Element buffer not resident: %#x\n", count,
> + element_buffer->StorageFlags);
> + return false;
> + }
> +
> + /* Get VertexPosLocation */
> + int vertexPosLocation = 0;
> + if (gc->Shader.ActiveProgram)
> + vertexPosLocation = vbo_get_simple_vs_position_attr_location(gc);
> + if (vertexPosLocation < 0)
> + {
> + MESA_BBOX("Aborting MESA_BBOX:%d: VertexPosition Location is inValid:\n", count);
> + return false;
> + }
> +
> + struct gl_vertex_array_object* vao = vbo_get_current_vao(gc);
> + int posAttribMapMode =
> + _mesa_vao_attribute_map[vao->_AttributeMapMode][vertexPosLocation];
> +
> + if (((vao->_Enabled >> posAttribMapMode) & 0x1) != 1)
> + {
> + MESA_BBOX("Aborting MESA_BBOX:%d: Vertex data does not come from VBO , GL-API:%d\n", count,gc->API);
> +//#if !defined(__ANDROID__) || !defined(ANDROID)
> +//This is not specific to Android but to the GLES API
> + if (gc->API != API_OPENGLES && gc->API != API_OPENGLES2)
> + return false;
> +//#endif
> + }
> +
> + struct gl_buffer_object* vertexattrib_buffer =
> + vbo_get_current_vertex_buffer(gc);
> + if ((!vertexattrib_buffer) || vertexattrib_buffer->Name == 0) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: Vertex buffer %p name is %d\n", count,
> + vertexattrib_buffer,vertexattrib_buffer->Name);
> +#if !defined(__ANDROID__) || !defined(ANDROID)
> + return false;
> +#endif
> + }
> +
> + if (!(vertexattrib_buffer->StorageFlags &
> + (GL_CLIENT_STORAGE_BIT | GL_DYNAMIC_STORAGE_BIT))){
> + MESA_BBOX("Aborting MESA_BBOX:%d:Vertex buffer not resident %#x \n", count,
> + vertexattrib_buffer->StorageFlags);
> + MESA_BBOX("Aborting MESA_BBOX:VAO AttributeMode is %d\n", vao->_AttributeMapMode);
> +#if !defined(__ANDROID__) || !defined(ANDROID)
> + return false;
> +#endif
> + }
> +
> + /* Examine vertex position attribute configuration */
> + if (vao->VertexAttrib[posAttribMapMode].Enabled) {
> + if (vao->VertexAttrib[posAttribMapMode].Size != 3)
> + {
> + MESA_BBOX("Aborting MESA_BBOX:%d: Vertex attrib size :%d, only 3 supported\n",
> + count, vao->VertexAttrib[VERT_ATTRIB_POS].Size);
> +#if !defined(__ANDROID__) || !defined(ANDROID)
> + return false;
> +#endif
> + }
> + if (vao->VertexAttrib[posAttribMapMode].Type != GL_FLOAT)
> + {
> + MESA_BBOX("Aborting MESA_BBOX:%d: Vertex attrib type is %d, only GL_FLOAT \
> + supported\n", count, vao->VertexAttrib[VERT_ATTRIB_POS].Type);
> + return false;
> + }
> + }
> +
> + if (type != GL_UNSIGNED_SHORT) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: type is %d, only GL_UNSIGNED_SHORT \
> + supported\n", count, type);
> + return false;
> + }
> + if (basevertex != 0) {
> + MESA_BBOX("Aborting MESA_BBOX:%d: basevertex is 0 \n", count);
> + return false;
> + }
> +
> + /* If size ==3 and type == GL_FLOAT, then element stride must be 12. */
> + assert(vao->VertexAttrib[VERT_ATTRIB_POS].StrideB == 12);
> +
> + /* When transform feedback is capturing we cannot do early clipping since
> + * xfb must write unclipped vertices
> + * Note - we could check for IsCapturing() but that would require
> + * more elaborate checking for VBO modifications.
> + */
> + if (gc->TransformFeedback.CurrentObject->Active) {
> + MESA_BBOX("MESA_BBOX:%d: Transform feedback is active, \
> + cannot clip\n", count);
> + return false;
> + }
> + return true;
> +}
> +
> +
> +/**
> + * Check condition to enter bounding box optimization and if draw call
> + * is suitable prepare key describing given geometry.
> + */
> +static inline
> +void vbo_bbox_prepare_key(struct gl_context *const gc, GLenum mode,
> + GLsizei count, GLenum type, GLuint type_size,
> + const GLvoid *indices, GLint basevertex,
> + vbo_bbox_cache_key *key)
> +{
> + assert(gc);
> +
> + /* Examine element buffer */
> + struct gl_buffer_object* element_buffer = vbo_get_current_element_buffer(gc);
> + struct gl_buffer_object* vertexattrib_buffer =
> + vbo_get_current_vertex_buffer(gc);
> + struct gl_vertex_buffer_binding* vbinding =
> + vbo_get_current_vertex_buffer_binding_of_position(gc);
> +
> + memset(key,0,sizeof(vbo_bbox_cache_key));
> +
> + key->mode = mode;
> + key->count = count;
> + key->indices_type = type;
> + key->type_size = type_size;
> + key->indices = (GLint) (uintptr_t) indices;
> + key->basevertex = basevertex;
> +
> + key->element_buf_name = element_buffer->Name;
> + key->vertex_buf_name = vertexattrib_buffer->Name;
> +
> + key->offset = (GLint)vbinding->Offset;
> + key->stride = vbinding->Stride;
> +}
> +
> +
> +/**
> + * Create a bounding box descriptor in a form of 8 correctly
> + * ordered vertex coordinates. The order of coordinates is significant.
> + */
> +static
> +void vbo_bbox_create_bounding_box(float* const minVec3f, float* const maxVec3F,
> + vbo_vec4f* vertices4)
> +{
> + assert(minVec3f);
> + assert(maxVec3F);
> + assert(vertices4);
> +
> + float Xmin = minVec3f[0];
> + float Ymin = minVec3f[1];
> + float Zmin = minVec3f[2];
> + float Wmin = 1.0f;
> +
> + float Xmax = maxVec3F[0];
> + float Ymax = maxVec3F[1];
> + float Zmax = maxVec3F[2];
> + float Wmax = 1.0f;
> +
> + float* v = (float*)vertices4;
> + int i = 0;
> + v[i+0] = Xmin; v[i+1] = Ymin; v[i+2] = Zmin;v[i+3]=Wmin; i+=4;
> + v[i+0] = Xmax; v[i+1] = Ymin; v[i+2] = Zmin;v[i+3]=Wmin; i+=4;
> + v[i+0] = Xmin; v[i+1] = Ymax; v[i+2] = Zmin;v[i+3]=Wmin; i+=4;
> + v[i+0] = Xmax; v[i+1] = Ymax; v[i+2] = Zmin;v[i+3]=Wmin; i+=4;
> +
> + v[i+0] = Xmin; v[i+1] = Ymin; v[i+2] = Zmax;v[i+3]=Wmax; i+=4;
> + v[i+0] = Xmax; v[i+1] = Ymin; v[i+2] = Zmax;v[i+3]=Wmax; i+=4;
> + v[i+0] = Xmin; v[i+1] = Ymax; v[i+2] = Zmax;v[i+3]=Wmax; i+=4;
> + v[i+0] = Xmax; v[i+1] = Ymax; v[i+2] = Zmax;v[i+3]=Wmax; i+=4;
> +}
> +
> +#ifdef __AVX__
> +/* Calculate bbox Subbox Coordinates */
> +static void
> +vbo_bbox_calc_subbox_coordinates(unsigned int vertSubBox,unsigned int vertCount,
> + unsigned int first_idx,unsigned int second_idx,
> + unsigned short* indices,float* vertices,
> + unsigned int stride,
> + struct vbo_bbox_cache_data *data)
> +{
> +
> + /* Retrieving the starting offset of the first and second subbox */
> + unsigned int first = first_idx * vertSubBox;
> + unsigned int second = second_idx * vertSubBox;
> +
> + float tmpVertexBuf[8] = {0.0};
> + float tmp_buf_min[8] = {0.0};
> + float tmp_buf_max[8] = {0.0};
> +
> + __m256 subMin = _mm256_set1_ps(FLT_MAX);
> + __m256 subMax = _mm256_set1_ps(-FLT_MAX);
> +
> + /* Run both the subboxes for vertex count */
> + for(unsigned int iter = 0; iter < vertCount; iter++){
> + /* Calculate the vertex offset of first subbox */
> + unsigned short index1 = indices[first+iter];
> + /* Fetching the vertices for the first subbox */
> + float* vertex1 = (float *)((char *)(vertices) + stride*index1);
> + memcpy(tmpVertexBuf,vertex1, 3 * sizeof(float));
> +
> + /* Calculate the vertex offset of second subbox */
> + unsigned short index2 = indices[second+iter];
> +
> + /* Fetching the vertices for the second subbox */
> + float* vertex2 = (float *)((char *)(vertices) + stride*index2);
> + memcpy(tmpVertexBuf+4,vertex2, 3 * sizeof(float));
> +
> + __m256 tmp = _mm256_loadu_ps(tmpVertexBuf);
> + subMin = _mm256_min_ps(subMin, tmp);
> + subMax = _mm256_max_ps(subMax, tmp);
> + }
> +
> + /* compare full box values */
> + fullMin = _mm256_min_ps(fullMin, subMin);
> + fullMax = _mm256_max_ps(fullMax, subMax);
> +
> + /* store results */
> + _mm256_storeu_ps(tmp_buf_min, subMin);
> + _mm256_storeu_ps(tmp_buf_max, subMax);
> +
> +
> + /* Update the min and max values in sub box coordinates for both
> + * the subboxes
> + */
> + vbo_bbox_create_bounding_box(tmp_buf_min, tmp_buf_max,
> + &(data->sub_bbox_array[first_idx].bounding_volume.vert_vec4[0]));
> + vbo_bbox_create_bounding_box(tmp_buf_min+4, tmp_buf_max+4,
> + &(data->sub_bbox_array[second_idx].bounding_volume.vert_vec4[0]));
> +}
> +#else
> +static void
> +vbo_bbox_calc_subbox_coordinates(
> + unsigned int vertSubBox,
> + unsigned int vertCount,
> + unsigned int idx,
> + unsigned short *indices,
> + float *vertices,
> + unsigned int stride,
> + struct vbo_bbox_cache_data *data)
> +{
> + /* Retrieving the starting offset of the first and second subbox */
> + unsigned int first = idx * vertSubBox;
> +
> + float tmpVertexBuf[4] = {0.0};
> + float tmp_buf_min[4] = {0.0};
> + float tmp_buf_max[4] = {0.0};
> +
> + __m128 subMin = _mm_set1_ps(FLT_MAX);
> + __m128 subMax = _mm_set1_ps(-FLT_MAX);
> +
> + /* Run both the subboxes for vertex count */
> + for(unsigned int iter = 0; iter < vertCount; iter++){
> +
> + /* Calculate the vertex offset of first subbox */
> + unsigned short index = indices[first+iter];
> + /* Fetching the vertices for the first subbox */
> + float* vertex = (float *)((char *)(vertices) + stride*index);
> + memcpy(tmpVertexBuf,vertex, 3 * sizeof(float));
> +
> + __m128 tmp = _mm_loadu_ps(tmpVertexBuf);
> + subMin = _mm_min_ps(subMin, tmp);
> + subMax = _mm_max_ps(subMax, tmp);
> + }
> +
> + /* compare full box values */
> + fullMin = _mm_min_ps(fullMin, subMin);
> + fullMax = _mm_max_ps(fullMax, subMax);
> +
> + /* store results */
> + _mm_storeu_ps(tmp_buf_min, subMin);
> + _mm_storeu_ps(tmp_buf_max, subMax);
> +
> + /* Update the min and max values in sub box coordinates for both
> + * the subboxes
> + */
> + vbo_bbox_create_bounding_box(tmp_buf_min, tmp_buf_max,
> + &(data->sub_bbox_array[idx].bounding_volume.vert_vec4[0]));
> +}
> +#endif
> +
> +/**
> + * Get pointer to VBO data.
> + * Pointer should be suitable for fast data reading, not data change.
> + */
> +static
> +bool vbo_bbox_get_vbo_ptr(struct gl_context* gc, struct gl_buffer_object* vbo,
> + int offset, void** data, int* dataSize)
> +{
> + assert(gc);
> + assert(vbo);
> + GLubyte* vboDataPtr = NULL;
> +
> + if (offset >= vbo->Size) {
> + return false;
> + }
> + vboDataPtr = _mesa_MapNamedBuffer(vbo->Name,GL_WRITE_ONLY_ARB);
> + if (vboDataPtr == NULL) {
> + return false;
> + }
> + *data = vboDataPtr + offset;
> + *dataSize = vbo->Size - offset;
> +
> + return true;
> +}
> +
> +/**
> + * Unlock VBO
> + */
> +static inline
> +void vbo_bbox_release_vbo_ptr(struct gl_context* gc,
> + struct gl_buffer_object* vbo)
> +{
> + assert(gc);
> + assert(vbo);
> + _mesa_UnmapNamedBuffer_no_error(vbo->Name);
> +}
> +
> +/**
> + * Check if given range of indices contains only degenerate triangles.
> + */
> +static
> +bool vbo_bbox_is_degenerate(GLvoid *indices, GLuint count_in)
> +{
> + assert(indices);
> + assert(count_in % 3 == 0);
> +
> + GLuint triangle_count = count_in / 3;
> + GLuint input_idx = 0;
> +
> + GLushort* ptr = (GLushort*)indices;
> + for (GLuint i = 0; i < triangle_count; i++) {
> + GLushort a = ptr[input_idx++];
> + GLushort b = ptr[input_idx++];
> + GLushort c = ptr[input_idx++];
> + if (!(a == b || a == c || b == c)) {
> + return false;
> + }
> + }
> + return true;
> +}
> +
> +
> +/**
> + * Calculate bounding boxes for given geometry.
> + */
> +static
> +bool vbo_bbox_calculate_bounding_boxes_with_indices(struct gl_context *const gc,
> + const vbo_bbox_cache_key *key,
> + struct vbo_bbox_cache_data *data,
> + void* indexData,
> + int indexDataSize)
> +{
> + assert(gc);
> +
> + void* vertex_data = NULL;
> + int vertex_datasize = 0;
> + int vert_per_subBbox = mesa_bbox_env_variables.bbox_split_size;
> + int sub_bbox_cnt = (key->count + vert_per_subBbox -1)/vert_per_subBbox;
> + int *subbox_array;
> + int idx =0;
> + int non_degen_count = 0;
> +
> + assert(sub_bbox_cnt);
> +
> + struct gl_buffer_object* element_buffer = _mesa_lookup_bufferobj(gc,
> + key->element_buf_name);
> +
> + struct gl_buffer_object * vertexattrib_buffer = _mesa_lookup_bufferobj(gc,
> + key->vertex_buf_name);
> +
> + if (element_buffer == NULL || vertexattrib_buffer == NULL) {
> + return false;
> + }
> +
> + if (!vbo_bbox_get_vbo_ptr(gc, vertexattrib_buffer,(int) key->offset,
> + &vertex_data, &vertex_datasize)) {
> + return false;
> + }
> +
> + assert(vertex_data);
> + assert(vertex_datasize > 0);
> + assert(indexData);
> + assert(indexDataSize > 0);
> + assert(key->indices_type == GL_UNSIGNED_SHORT);
> + assert(indexDataSize > key->count * (int)key->type_size);
> +
> + /* Allocate memory for bounding boxes */
> + if (!vbo_init_sub_bbox_array(sub_bbox_cnt,data)) {
> + vbo_bbox_release_vbo_ptr(gc, vertexattrib_buffer);
> + return false;
> + }
> + /* Initialize size of bounding boxes */
> + for (int i = 0; i < sub_bbox_cnt; i++) {
> + data->sub_bbox_array[i].vert_count = (i==sub_bbox_cnt-1)?
> + (key->count - i*vert_per_subBbox):vert_per_subBbox;
> + data->sub_bbox_array[i].start_offset = i*vert_per_subBbox * key->type_size;
> + }
> +
> + subbox_array = malloc(sub_bbox_cnt * sizeof(int));
> +
> + /* Check if all triangles withing bbox are degenerate (i.e triangles with
> + zero area) */
> + for (int i = 0; i < sub_bbox_cnt; i++) {
> + GLubyte* ptr = (GLubyte *)indexData;
> + data->sub_bbox_array[i].is_degenerate =
> + vbo_bbox_is_degenerate((ptr + data->sub_bbox_array[i].start_offset),
> + data->sub_bbox_array[i].vert_count);
> +
> + if(!data->sub_bbox_array[i].is_degenerate)
> + {
> + subbox_array[idx++] = i;
> + non_degen_count++;
> + }
> + }
> +
> + float tmp_buf_min[8] = {0.0};
> + float tmp_buf_max[8] = {0.0};
> +
> +#ifdef __AVX__
> + int odd = non_degen_count % 2;
> + int num_iter = non_degen_count/2;
> + int iter;
> +
> + fullMin = _mm256_set1_ps(FLT_MAX);
> + fullMax = _mm256_set1_ps(-FLT_MAX);
> + idx = 0;
> + for(iter = 0; iter < num_iter;iter++){
> + idx = 2*iter;
> + if(data->sub_bbox_array[subbox_array[idx]].vert_count ==
> + data->sub_bbox_array[subbox_array[idx+1]].vert_count)
> + {
> + /* call the algorithm with the count */
> + vbo_bbox_calc_subbox_coordinates(
> + vert_per_subBbox,
> + data->sub_bbox_array[subbox_array[idx]].vert_count,
> + subbox_array[idx],
> + subbox_array[idx+1],
> + (GLushort*)indexData,
> + (GLfloat*)vertex_data,
> + key->stride,
> + data
> + );
> + }
> + else
> + {
> + /* call the first one separately */
> + vbo_bbox_calc_subbox_coordinates(vert_per_subBbox,
> + data->sub_bbox_array[subbox_array[idx]].vert_count,
> + subbox_array[idx],
> + subbox_array[idx],
> + (GLushort*)indexData,
> + (GLfloat*)vertex_data,
> + key->stride,
> + data);
> +
> + /* call the second one separately */
> + vbo_bbox_calc_subbox_coordinates(vert_per_subBbox,
> + data->sub_bbox_array[subbox_array[idx+1]].vert_count,
> + subbox_array[idx+1],
> + subbox_array[idx+1],
> + (GLushort*)indexData,
> + (GLfloat*)vertex_data,
> + key->stride,
> + data);
> +
> + }
> +
> + }
> +
> + if(odd)
> + {
> + idx = 2*iter;
> + /* call the last one separately */
> + vbo_bbox_calc_subbox_coordinates(vert_per_subBbox,
> + data->sub_bbox_array[subbox_array[idx]].vert_count,
> + subbox_array[idx],
> + subbox_array[idx],
> + (GLushort*)indexData,
> + (GLfloat*)vertex_data,
> + key->stride,
> + data);
> + }
> +
> + /* Finding the minimum from the full box 256 */
> + __m128 firstlane = _mm256_extractf128_ps(fullMin,0);
> + __m128 secondlane = _mm256_extractf128_ps(fullMin,1);
> + firstlane = _mm_min_ps(firstlane,secondlane);
> + _mm_storeu_ps(tmp_buf_min,firstlane);
> +
> + /* Finding the maximum from the full box 256 */
> + firstlane = _mm256_extractf128_ps(fullMax,0);
> + secondlane = _mm256_extractf128_ps(fullMax,1);
> + firstlane = _mm_max_ps(firstlane,secondlane);
> + _mm_storeu_ps(tmp_buf_max,firstlane);
> +
> +#else
> + fullMin = _mm_set1_ps(FLT_MAX);
> + fullMax = _mm_set1_ps(-FLT_MAX);
> +
> + for(unsigned int i=0; i< non_degen_count; i++){
> + //call the algorithm with the count
> + vbo_bbox_calc_subbox_coordinates(vert_per_subBbox,
> + data->sub_bbox_array[subbox_array[i]].vert_count,
> + subbox_array[i],
> + (GLushort*)indexData,
> + (GLfloat*)vertex_data,
> + key->stride,
> + data);
> + }
> + _mm_storeu_ps(tmp_buf_min, fullMin);
> + _mm_storeu_ps(tmp_buf_max, fullMax);
> +#endif
> +
> + /* Set up bounding box as 8 vertices and store in bbox data */
> + vbo_bbox_create_bounding_box(tmp_buf_min, tmp_buf_max,
> + &(data->full_box.bounding_volume.vert_vec4[0]));
> +
> + if(subbox_array)
> + free(subbox_array);
> + vbo_bbox_release_vbo_ptr(gc, vertexattrib_buffer);
> + data->valid = true;
> +
> + return true;
> +}
> +
> +
> +/**
> + * Calculate bounding boxes for given geometry.
> + */
> +static inline
> +bool vbo_bbox_calculate_bounding_boxes(struct gl_context *const gc,
> + const vbo_bbox_cache_key *key,
> + struct vbo_bbox_cache_data* data)
> +{
> + assert(gc);
> + assert(key->indices_type == GL_UNSIGNED_SHORT);
> +
> + void* pIndexData = NULL;
> + int indexDataSize = 0;
> +
> + struct gl_buffer_object* element_buffer = _mesa_lookup_bufferobj(gc,
> + key->element_buf_name);
> + if (element_buffer == NULL) {
> + return false;
> + }
> + if (!vbo_bbox_get_vbo_ptr(gc, element_buffer, (int) key->indices,
> + &pIndexData, &indexDataSize)) {
> + return false;
> + }
> +
> + bool ret = vbo_bbox_calculate_bounding_boxes_with_indices(gc, key, data,
> + pIndexData, indexDataSize);
> +
> + vbo_bbox_release_vbo_ptr(gc, element_buffer);
> +
> + return ret;
> +}
> +
> +
> +/**
> + * Create new bounding box cache entry
> + */
> +static
> +struct vbo_bbox_cache_data* vbo_bbox_create_data(struct gl_context *const gc,
> + const vbo_bbox_cache_key *key)
> +{
> + assert(gc);
> +
> + struct gl_buffer_object* element_buffer = vbo_get_current_element_buffer(gc);
> + struct gl_buffer_object* vertexattrib_buffer =
> + vbo_get_current_vertex_buffer(gc);
> +
> + if ((vertexattrib_buffer == NULL) ||
> + (element_buffer == NULL)){
> + return NULL;
> + }
> +
> + mesa_bbox_opt * BboxOpt = gc->Pipeline.BboxOpt;
> + assert(BboxOpt);
> +
> + struct vbo_bbox_cache_data* data = (struct vbo_bbox_cache_data *) malloc(
> + sizeof (struct vbo_bbox_cache_data));
> + data->full_box.is_degenerate = false;
> +
> + if (data == NULL){
> + return NULL;
> + }
> + /* Initialize the cache data and variables in cache data */
> + data->valid = false;
> + data->need_new_calculation = true;
> + data->init_delaycnt = 0;
> + data->init_delaylimit = 0;
> + data->vertpos_vbo_changecnt = 0;
> + data->indices_vbo_changecnt = 0;
> + data->sub_bbox_cnt = 0;
> + data->sub_bbox_array = NULL;
> + data->drawcnt_bbox_helped = 0;
> + data->last_use_frame = 0;
> + data->vertpos_vbo_changecnt = vertexattrib_buffer->data_change_counter;
> + data->indices_vbo_changecnt = element_buffer->data_change_counter;
> +
> + /* This defines for how many cache hits we wait before actually creating the
> + * data */
> + data->init_delaylimit = vbo_bbox_get_delay(BboxOpt);
> +
> + /* At this point data is not valid yet */
> + _mesa_bbox_cache_insert(gc,gc->Pipeline.BboxOpt->cache,
> + key,sizeof(vbo_bbox_cache_key),data);
> +
> + return data;
> +}
> +
> +
> +/**
> + * Check if contents of the VBO buffers have changed since data entry
> + * was created.
> + */
> +static inline
> +bool vbo_bbox_validate_data(
> + struct gl_context *const gc,
> + const vbo_bbox_cache_key *key,
> + struct vbo_bbox_cache_data* data)
> +{
> + assert(gc);
> +
> + struct gl_buffer_object* element_buffer = _mesa_lookup_bufferobj(gc,
> + key->element_buf_name);
> +
> + struct gl_buffer_object * vertexattrib_buffer = _mesa_lookup_bufferobj(gc,
> + key->vertex_buf_name);
> +
> + if (element_buffer == NULL || vertexattrib_buffer == NULL) {
> + return false;
> + }
> +
> + if ((element_buffer->data_change_counter != data->indices_vbo_changecnt) ||
> + (vertexattrib_buffer->data_change_counter != data->vertpos_vbo_changecnt)
> + ) {
> + return false;
> + }
> + return true;
> +}
> +
> +/**
> + * Retrieve bounding box data from cache.
> + */
> +static inline
> +struct vbo_bbox_cache_data* vbo_bbox_get_bounding_boxes(
> + struct gl_context *const gc,
> + const vbo_bbox_cache_key *key)
> + {
> +
> + assert(gc);
> + mesa_bbox_opt * BboxOpt = gc->Pipeline.BboxOpt;
> + assert(BboxOpt);
> + struct vbo_bbox_cache_data* data = _mesa_search_bbox_cache(BboxOpt->cache,
> + key, sizeof(vbo_bbox_cache_key));
> + if (data) {
> + if (data->need_new_calculation == false)
> + {
> + /* Data is initialized and valid */
> + if (data->valid) {
> + if (vbo_bbox_validate_data(gc, key, data)) {
> + data->mvp_valid = true;
> + return data;
> + }
> + }
> + else {
> + data->valid = false;
> + return NULL;
> + }
> + }
> + }
> + else {
> + /* Data does not exist, create it */
> + data = vbo_bbox_create_data(gc, key);
> + if (data == NULL)
> + {
> + return NULL;
> + }
> + }
> + if ((data->need_new_calculation) &&
> + (data->init_delaycnt++ >= data->init_delaylimit)) {
> + data->valid = false;
> + data->need_new_calculation = false;
> + data->mvp_valid = false;
> +
> + if (!vbo_bbox_validate_data(gc, key, data)) {
> + struct gl_buffer_object * element_buffer =
> + _mesa_lookup_bufferobj(gc,key->element_buf_name);
> +
> + struct gl_buffer_object * vertexattrib_buffer =
> + _mesa_lookup_bufferobj(gc,key->vertex_buf_name);
> +
> + if ((vertexattrib_buffer == NULL) ||
> + (element_buffer == NULL)) {
> + return NULL;
> + }
> + data->vertpos_vbo_changecnt = vertexattrib_buffer->data_change_counter;
> + data->indices_vbo_changecnt = element_buffer->data_change_counter;
> + }
> + if (gc->volume_type == BOUNDING_VOLUME_AABB) {
> + /* Calculate bounding boxes */
> + if (vbo_bbox_calculate_bounding_boxes(gc, key, data)) {
> + return data;
> + }
> + }
> + }
> + return NULL;
> +}
> +
> +/**
> + * This function is called when we updating the element buffer. because the
> + * element-buffer has changed we have to update the relevant bbox data:
> + */
> +void vbo_bbox_element_buffer_update(struct gl_context *const gc,
> + struct gl_buffer_object *buffer,
> + const void* data,
> + int offset,
> + int size)
> +{
> + mesa_bbox_opt * BboxOpt = gc->Pipeline.BboxOpt;
> +
> + if (BboxOpt) {
> + struct gl_segment updateSegment;
> + updateSegment.Left = offset;
> + updateSegment.Right = offset+size;
> +
> + mesa_bbox_cache * buffer_map = BboxOpt->cache;
> + if (buffer_map) {
> + struct vbo_bbox_cache_data *c;
> + GLuint i = 0;
> + for (i = 0; i < buffer_map->size; i++)
> + for (c = buffer_map->items[i]; c != NULL ; c = c->next) {
> + struct vbo_bbox_cache_data * bbox_data = buffer_map->items[i];
> + struct gl_buffer_object *buffObj = _mesa_lookup_bufferobj(gc,
> + bbox_data->key->element_buf_name);
> +
> + if(buffObj != buffer)
> + continue;
> +
> + if (!bbox_data) {
> +
> + assert(bbox_data);
> + return;
> + }
> +
> + bbox_data->indices_vbo_changecnt = buffer->data_change_counter;
> +
> + struct gl_segment element_bufferSegment;
> + element_bufferSegment.Left = bbox_data->key->indices;
> + element_bufferSegment.Right = bbox_data->key->indices +
> + (bbox_data->key->count * bbox_data->key->type_size);
> +
> + if (bbox_data->valid &&
> + intersect(&element_bufferSegment, &updateSegment)) {
> + bbox_data->valid = false;
> + bbox_data->need_new_calculation = true;
> +
> + if (superset(&element_bufferSegment,&updateSegment))
> + {
> + int offset_in_newdata = bbox_data->key->indices - offset;
> + int newsize = size - offset_in_newdata;
> +
> + assert(offset_in_newdata >= 0);
> + assert(newsize > 0);
> +
> + GLchar * start_data = (GLchar *)data + offset_in_newdata;
> +
> + if (vbo_bbox_calculate_bounding_boxes_with_indices(gc,
> + bbox_data->key, bbox_data, start_data, newsize)) {
> + bbox_data->need_new_calculation = false;
> + bbox_data->mvp_valid = false;
> + }
> + }
> + }
> + }
> + }
> + }
> +}
> +
> +/**
> + * Generate 6 clip planes from MVP.
> + */
> +static
> +void vbo_bbox_get_frustum_from_mvp(vbo_bbox_frustum *frustum, GLmatrix* mvpin)
> +{
> +
> + GLfloat in_mat[4][4] = {0};
> + {
> + #define M(row,col) m[col*4+row]
> + in_mat[0][0] = mvpin->M(0,0);
> + in_mat[0][1] = mvpin->M(0,1);
> + in_mat[0][2] = mvpin->M(0,2);
> + in_mat[0][3] = mvpin->M(0,3);
> +
> + in_mat[1][0] = mvpin->M(1,0);
> + in_mat[1][1] = mvpin->M(1,1);
> + in_mat[1][2] = mvpin->M(1,2);
> + in_mat[1][3] = mvpin->M(1,3);
> +
> + in_mat[2][0] = mvpin->M(2,0);
> + in_mat[2][1] = mvpin->M(2,1);
> + in_mat[2][2] = mvpin->M(2,2);
> + in_mat[2][3] = mvpin->M(2,3);
> +
> + in_mat[3][0] = mvpin->M(3,0);
> + in_mat[3][1] = mvpin->M(3,1);
> + in_mat[3][2] = mvpin->M(3,2);
> + in_mat[3][3] = mvpin->M(3,3);
> + #undef M
> + }
> +
> + /* Frustum plane calculation */
> +
> + /* Left plane */
> + frustum->plane[0].a = in_mat[3][0] + in_mat[0][0];
> + frustum->plane[0].b = in_mat[3][1] + in_mat[0][1];
> + frustum->plane[0].c = in_mat[3][2] + in_mat[0][2];
> + frustum->plane[0].d = in_mat[3][3] + in_mat[0][3];
> +
> + /* Right plane */
> + frustum->plane[1].a = in_mat[3][0] - in_mat[0][0];
> + frustum->plane[1].b = in_mat[3][1] - in_mat[0][1];
> + frustum->plane[1].c = in_mat[3][2] - in_mat[0][2];
> + frustum->plane[1].d = in_mat[3][3] - in_mat[0][3];
> +
> + /* Top plane */
> + frustum->plane[2].a = in_mat[3][0] - in_mat[1][0];
> + frustum->plane[2].b = in_mat[3][1] - in_mat[1][1];
> + frustum->plane[2].c = in_mat[3][2] - in_mat[1][2];
> + frustum->plane[2].d = in_mat[3][3] - in_mat[1][3];
> +
> + /* Bottom plane */
> + frustum->plane[3].a = in_mat[3][0] + in_mat[1][0];
> + frustum->plane[3].b = in_mat[3][1] + in_mat[1][1];
> + frustum->plane[3].c = in_mat[3][2] + in_mat[1][2];
> + frustum->plane[3].d = in_mat[3][3] + in_mat[1][3];
> +
> + /* Far plane */
> + frustum->plane[4].a = in_mat[3][0] - in_mat[2][0];
> + frustum->plane[4].b = in_mat[3][1] - in_mat[2][1];
> + frustum->plane[4].c = in_mat[3][2] - in_mat[2][2];
> + frustum->plane[4].d = in_mat[3][3] - in_mat[2][3];
> +
> + /* Near plane */
> + frustum->plane[5].a = in_mat[3][0] + in_mat[2][0];
> + frustum->plane[5].b = in_mat[3][1] + in_mat[2][1];
> + frustum->plane[5].c = in_mat[3][2] + in_mat[2][2];
> + frustum->plane[5].d = in_mat[3][3] + in_mat[2][3];
> +
> + /* Calculate octants */
> + for(int n = 0; n < 6; ++n) {
> + frustum->octant[n] = (frustum->plane[n].a >=0 ? 1 : 0) |
> + (frustum->plane[n].b >=0 ? 2 : 0) |
> + (frustum->plane[n].c >=0 ? 4 : 0);
> + normalize(&(frustum->plane[n]));
> + }
> +}
> +
> +
> +/**
> + * Calculate distance form a point to place
> + *
> + */
> +static inline
> +float vbo_bbox_dist_from_point_to_plane(
> + const vbo_bbox_frustum_plane *plane,
> + const vbo_vec4f *point)
> +{
> + return (plane->a * point->x + plane->b * point->y + plane->c *
> + point->z + plane->d);
> +}
> +
> +
> +/**
> + * Description:
> + * Bounding box clipping algorthm
> + * BBOX_CLIP_INSIDE - bounding box is fully inside frustum
> + * BBOX_CLIP_OUTSIDE - bounding box is fully outside frustum
> + * BBOX_CLIP_INTERSECT - bounding box intersects with frustum
> + */
> +static
> +enum vbo_bbox_clip_result vbo_bbox_fast_clipping_test(bounding_info* bbox,
> + const vbo_bbox_frustum *frustum)
> +{
> + assert(bbox);
> + vbo_vec4f *aabb = bbox->bounding_volume.vert_vec4;
> +
> + enum vbo_bbox_clip_result result = BBOX_CLIP_INSIDE;
> + for (int i = 0; i < 6; ++i)
> + {
> + unsigned char normalOctant = frustum->octant[i];
> +
> + /* Test near and far vertices of AABB according to plane normal.
> + * Plane equation can be normalized to save some divisions.
> + */
> + float farDistance = vbo_bbox_dist_from_point_to_plane(
> + &(frustum->plane[i]),
> + &(aabb[normalOctant]));
> + if (farDistance < 0.0f) {
> + return BBOX_CLIP_OUTSIDE;
> + }
> +
> + float nearDistance = vbo_bbox_dist_from_point_to_plane(
> + &(frustum->plane[i]),
> + &(aabb[normalOctant ^ 7]));
> + if (nearDistance < 0.0f) {
> + result = BBOX_CLIP_INTERSECT;
> + }
> + }
> +
> + return result;
> +}
> +
> +/**
> + * Wrapper for clip algorithm.
> + */
> +static inline
> +enum vbo_bbox_clip_result vbo_bbox_clip(bounding_info* bbox,
> + const vbo_bbox_frustum *frustum)
> +{
> + assert(bbox);
> + if (bbox->is_degenerate) {
> + return BBOX_CLIP_DEGEN;
> + }
> + return vbo_bbox_fast_clipping_test(bbox, frustum);
> +}
> +
> +/**
> + * Bounding box drawelements implementation
> + */
> +void
> +vbo_bbox_drawelements(struct gl_context *ctx, GLenum mode,
> + GLboolean index_bounds_valid, GLuint start, GLuint end,
> + GLsizei count, GLenum type, const GLvoid * indices,
> + GLint basevertex, GLuint numInstances,
> + GLuint baseInstance)
> +{
> + assert(ctx);
> + GLuint type_size;
> + /* BOUNDING VOLUME: Checks would remain same I guess */
> + bool draw_call_supported = vbo_bbox_check_supported_draw_call(ctx,
> + mode,
> + count,
> + type,
> + indices,
> + basevertex);
> + if (!draw_call_supported ||
> + (mesa_bbox_env_variables.bbox_enable < MESA_BBOX_ENABLE_FORCE_CLIPPING)) {
> + MESA_BBOX("Aborting MESA_BBOX : BBOX Is not ENABLED !!! \n");
> + vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start,
> + end, count, type, indices, basevertex, numInstances, baseInstance);
> + return;
> + }
> +
> + type_size = sizeof(GLushort);
> + vbo_bbox_cache_key key;/* Need not initialize key its done in prepare key */
> + vbo_bbox_prepare_key(ctx, mode, count, type, type_size, indices, basevertex,
> + &key);
> + /*BOUNDING VOLUME: Call bounding volume creation based on bounding volume
> + * type */
> +
> + struct vbo_bbox_cache_data* cached_bbox = vbo_bbox_get_bounding_boxes(ctx,
> + &key);
> +
> + if (cached_bbox == NULL) {
> + MESA_BBOX("Aborting MESA_BBOX : New Object not in Cache!!! \n");
> + vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start, end,
> + count, type, indices, basevertex,
> + numInstances, baseInstance);
> + return;
> + }
> +
> + GLint loc = vbo_bbox_get_mvp(ctx);
> + if (loc < 0) {
> + MESA_BBOX("MVP Location Error\n");
> + /* TBD: Free cache here */
> + vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start,
> + end, count, type, indices, basevertex,
> + numInstances, baseInstance);
> + return;
> + }
> +
> + GLfloat *mvp_ptr = (GLfloat *)
> + ctx->_Shader->ActiveProgram->data->UniformStorage[loc].storage;
> + vbo_bbox_frustum frustum;
> + bool recalculate_subbox_clip = false;
> +
> + if(cached_bbox->mvp_valid == false ||
> + memcmp(cached_bbox->mvp, mvp_ptr,16*sizeof(GLfloat))) {
> + memcpy(&(cached_bbox->mvp), mvp_ptr, 16*sizeof(GLfloat));
> + cached_bbox->mvpin.m = cached_bbox->mvp;
> + vbo_bbox_get_frustum_from_mvp(&frustum,&(cached_bbox->mvpin));
> +
> + /* BOUNDING VOLUME: Call specific function to calculate clip results */
> +
> + if (ctx->volume_type == BOUNDING_VOLUME_AABB) {
> + cached_bbox->full_box.clip_result =
> + vbo_bbox_clip(&(cached_bbox->full_box), &frustum);
> + }
> + recalculate_subbox_clip = true;
> + }
> +
> + /* Calculate frustum planes */
> + MESA_BBOX("MESA_BBOX: Full Box ClipResult:%d \n",
> + cached_bbox->full_box.clip_result);
> + switch (cached_bbox->full_box.clip_result) {
> + case BBOX_CLIP_OUTSIDE:
> + /* Geometry outside view frustum, dont draw it */
> + return;
> + case BBOX_CLIP_INSIDE:
> + vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start,
> + end, count, type, indices, basevertex,
> + numInstances, baseInstance);
> + return;
> + /* case BBOX_CLIP_INTERSECT: */
> + default:
> + MESA_BBOX("MESA_BBOX: Vertices INTERSECTING with the frustum, going"
> + " for Sub Bboxes: \n");
> + break;
> + }
> +
> + GLsizei count_to_send = 0;
> + GLsizei count_to_drop = 0;
> + GLvoid* offset_to_send = NULL;
> + bool clipped = false;
> + unsigned potential_clipped = 0;
> +
> + for (int i = 0; i < cached_bbox->sub_bbox_cnt; i++) {
> + int new_count = cached_bbox->sub_bbox_array[i].vert_count;
> +
> + if(recalculate_subbox_clip) {
> + if (ctx->volume_type == BOUNDING_VOLUME_AABB) {
> + cached_bbox->sub_bbox_array[i].clip_result =
> + vbo_bbox_clip(&(cached_bbox->sub_bbox_array[i]), &frustum);
> + }
> + }
> +
> + switch (cached_bbox->sub_bbox_array[i].clip_result)
> + {
> + case BBOX_CLIP_OUTSIDE:
> + count_to_drop += new_count;
> + potential_clipped += new_count;
> +
> + break;
> + case BBOX_CLIP_DEGEN:
> + count_to_drop += new_count;
> + potential_clipped += new_count;
> + break;
> + default:
> + /* Sub bounding box intersects with view, draw/save it
> + * for later draw
> + */
> + if (count_to_send == 0) {
> + /* Starting new batch */
> + count_to_send = new_count;
> + offset_to_send = (char*)indices +
> + cached_bbox->sub_bbox_array[i].start_offset;
> + }
> + else {
> + if (count_to_drop >=
> + (int)(mesa_bbox_env_variables.bbox_split_size *
> + BBOX_MIN_SPLITTED_DRAW_TO_DROP)) {
> +
> + /* Draw accumulated geometry */
> + vbo_validated_drawrangeelements(ctx, mode,
> + index_bounds_valid, start, end, count_to_send, type,
> + offset_to_send, basevertex, numInstances, baseInstance);
> +
> + /* Reset accumulated draws */
> + count_to_send = 0;
> + offset_to_send = (char*)indices +
> + cached_bbox->sub_bbox_array[i].start_offset;
> +
> + clipped = true;
> + }
> + else
> + {
> + count_to_send += count_to_drop;
> + }
> +
> + /* append to current batch of sent primitives */
> + count_to_send += new_count;
> + }
> +
> + count_to_drop = 0;
> + break;
> + }
> + }
> +
> + if (count_to_send > 0)
> + {
> + vbo_validated_drawrangeelements(ctx, mode, index_bounds_valid, start,
> + end, count_to_send, type,
> + offset_to_send, basevertex,
> + numInstances, baseInstance);
> + }
> +
> +
> + clipped |= (count_to_drop >= (int)(mesa_bbox_env_variables.bbox_split_size *
> + BBOX_MIN_SPLITTED_DRAW_TO_DROP));
> +
> + if (clipped)
> + {
> + cached_bbox->drawcnt_bbox_helped =
> + MIN(cached_bbox->drawcnt_bbox_helped + 1,
> + BBOX_MAX_VAL_FOR_EFFECTIVE_DRAWS_COUNTER);
> + }
> + else
> + {
> + if (potential_clipped == 0)
> + {
> + cached_bbox->drawcnt_bbox_helped =
> + MAX(cached_bbox->drawcnt_bbox_helped - 1,
> + BBOX_MIN_VAL_FOR_EFFECTIVE_DRAWS_COUNTER);
> + }
> + }
> +}
> +
> +/**
> + * Initialization for bounding box optimization
> + */
> +void vbo_bbox_init(struct gl_context* const gc)
> +{
> + assert(gc);
> +
> + const char * mesa_bbox_opt = getenv("MESA_BBOX_OPT_ENABLE");
> + if (mesa_bbox_opt !=NULL)
> + mesa_bbox_env_variables.bbox_enable = atoi(mesa_bbox_opt);
> +
> + mesa_bbox_opt = getenv("MESA_OPT_SPLIT_SIZE");
> + if (mesa_bbox_opt !=NULL)
> + mesa_bbox_env_variables.bbox_split_size = atoi(mesa_bbox_opt);
> +
> + mesa_bbox_opt = getenv("MESA_BBOX_MIN_VERTEX_CNT");
> + if (mesa_bbox_opt != NULL)
> + mesa_bbox_env_variables.bbox_min_vrtx_count = atoi(mesa_bbox_opt);
> +
> + if (!gc->Const.EnableBoundingBoxCulling) {
> + mesa_bbox_env_variables.bbox_enable = MESA_BBOX_ENABLE_OFF;
> + mesa_bbox_env_variables.bbox_split_size = 0x7fffffff;
> + mesa_bbox_env_variables.bbox_min_vrtx_count = 0;
> + }
> +
> + mesa_bbox_opt = getenv("MESA_OPT_TRACE_LEVEL");
> + if (mesa_bbox_opt !=NULL)
> + mesa_bbox_env_variables.bbox_trace_level = atoi(mesa_bbox_opt);
> +
> + if (mesa_bbox_env_variables.bbox_enable == MESA_BBOX_ENABLE_AUTO) {
> + /* Android/Linux: enable of Gen7.5, Gen8 and Gen9 */
> + #if (IGFX_GEN == IGFX_GEN9)
> + mesa_bbox_env_variables.bbox_enable = MESA_BBOX_ENABLE_SMART;
> + #else
> + mesa_bbox_env_variables.bbox_enable = MESA_BBOX_ENABLE_OFF;
> + #endif
> + if (mesa_bbox_env_variables.bbox_enable == MESA_BBOX_ENABLE_SMART && 1)
> + {
> + mesa_bbox_env_variables.bbox_enable =
> + MESA_BBOX_ENABLE_FORCE_CLIPPING;
> + }
> + }
> + /* BOUNDING VOLUME: Add initializations based on bounding volume here */
> + switch (gc->volume_type) {
> + case BOUNDING_VOLUME_AABB:
> + if (mesa_bbox_env_variables.bbox_enable) {
> + mesa_bbox_env_variables.bbox_split_size =
> + (mesa_bbox_env_variables.bbox_split_size / 3) * 3;
> + mesa_bbox_env_variables.bbox_min_vrtx_count =
> + (mesa_bbox_env_variables.bbox_min_vrtx_count / 3) * 3;
> +
> + assert(gc->Pipeline.BboxOpt == NULL);
> +
> + gc->Pipeline.BboxOpt = malloc(sizeof(mesa_bbox_opt));
> + if (!gc->Pipeline.BboxOpt) {
> + /* No memory, disable bbox optimization */
> + mesa_bbox_env_variables.bbox_enable =
> + MESA_BBOX_ENABLE_OFF;
> + mesa_bbox_env_variables.bbox_split_size = 0x7fffffff;
> + mesa_bbox_env_variables.bbox_min_vrtx_count = 0;
> + return;
> + }
> + else {
> + gc->Pipeline.BboxOpt->calc_delay = BBOX_CALC_MIN_DELAY;
> + gc->Pipeline.BboxOpt->cache = _mesa_new_bbox_cache();
> +
> + if (!gc->Pipeline.BboxOpt->cache) {
> + free(gc->Pipeline.BboxOpt);
> + MESA_BBOX("MESA_BBOX: Cache creation failed\n");
> + return;
> + }
> + }
> + if (mesa_bbox_env_variables.bbox_trace_level > 0) {
> + MESA_BBOX("\nMESA BBOX OPT config: \
> + bboxOptEnable = %d, bboxOptMinVertexCount = %d,\
> + bboxOptSplitSize = %d\n",
> + mesa_bbox_env_variables.bbox_enable,
> + mesa_bbox_env_variables.bbox_min_vrtx_count,
> + mesa_bbox_env_variables.bbox_split_size);
> + }
> + }
> + /* Initialize some function pointers so that we dont have to
> + * check bounding volume type for every draw call */
> + break;
> + case BOUNDING_VOLUME_OBB:
> + /* Init for OBB bounding volume */
> + break;
> + case BOUNDING_VOLUME_SPHERE:
> + /* Init for SPHERE bounding volume */
> + break;
> + case BOUNDING_VOLUME_DOP:
> + /* Init for DOP bounding volume */
> + break;
> + default:
> + MESA_BBOX("BOUNDING VOLUME TYPE IS INCORRECT\n");
> + break;
> + }
> +}
> +
> +
> +/**
> + * Free resources associated with bounding box optimization.
> + * To be called when context is destroyed
> + */
> +void vbo_bbox_free(struct gl_context* const gc)
> +{
> + assert(gc);
> +
> + if (gc->Pipeline.BboxOpt) {
> +
> + if(gc->Pipeline.BboxOpt->cache)
> + {
> + _mesa_delete_bbox_cache(gc,gc->Pipeline.BboxOpt->cache);
> + gc->Pipeline.BboxOpt->cache = NULL;
> + }
> +
> + if(gc->Pipeline.BboxOpt) {
> + free(gc->Pipeline.BboxOpt);
> + gc->Pipeline.BboxOpt = NULL;
> + }
> + }
> +}
> diff --git a/src/mesa/vbo/vbo_bbox.h b/src/mesa/vbo/vbo_bbox.h
> new file mode 100644
> index 0000000..1dd98f2
> --- /dev/null
> +++ b/src/mesa/vbo/vbo_bbox.h
This header is included to several other files that aren't about BBOX
implementation, but some of the things here lack a common (e.g. bbox)
prefix. Have you considered moving some of these things elsewhere or
adding the prefix?
Is all the debug stuff here still needed?
- Eero
> @@ -0,0 +1,383 @@
> +/*
> + * Copyright � 2018 Intel Corporation
> + *
> + * 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 (including the next
> + * paragraph) 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.
> + */
> +
> +/**
> + * \brief VBO BBOX module implementation
> + * \author Kedar Karanje
> + */
> +
> +#ifndef _VBO_BBOX_H_
> +#define _VBO_BBOX_H_
> +
> +#include <stdio.h>
> +#include "main/arrayobj.h"
> +#include "main/glheader.h"
> +#include "main/context.h"
> +#include "main/state.h"
> +#include "main/varray.h"
> +#include "main/bufferobj.h"
> +#include "main/arrayobj.h"
> +#include "main/enums.h"
> +#include "main/macros.h"
> +#include "main/transformfeedback.h"
> +#include "main/mtypes.h"
> +#include "compiler/glsl/ir_uniform.h"
> +#include "main/shaderapi.h"
> +#include "main/uniforms.h"
> +#include "sys/param.h"
> +#include "program/prog_cache.h"
> +/* For Intrinsic functions */
> +#include <smmintrin.h>
> +#include <tmmintrin.h>
> +#include <mmintrin.h>
> +#include <immintrin.h>
> +
> +#if defined(__ANDROID__) || defined(ANDROID)
> +#include <cutils/log.h>
> +#endif
> +
> +#ifdef __cplusplus
> +extern "C" {
> +#endif
> +
> +#define FRUSTUM_PLANE_COUNT 6
> +#define BBOX_CALC_MIN_DELAY 2
> +#define BBOX_CALC_MAX_DELAY 5
> +
> +#undef LOG_TAG
> +#define LOG_TAG "MESA_BBOX_LOG"
> +
> +/* Default, driver will select mode for given GPU and OS */
> +#define MESA_BBOX_ENABLE_AUTO -1
> +/* Disable BBOX */
> +#define MESA_BBOX_ENABLE_OFF 0
> +/* Enable BBOX, bot clipping */
> +#define MESA_BBOX_ENABLE_SMART 1
> +/* Enable BBOX, clipping will be done regardless of GPU utilization */
> +#define MESA_BBOX_ENABLE_FORCE_CLIPPING 2
> +/* Enable BBOX, force immediate bbox recalculation and clipping */
> +#define MESA_BBOX_ENABLE_FORCE_RECALC 3
> +
> +/**
> + * MESA BBOX PRINTS
> + * Uncomment below line to enable debugging logs
> + */
> +#define MESA_BBOX_DEBUG 0
> +
> +#if defined(__ANDROID__) || defined (ANDROID)
> +
> +#if MESA_BBOX_DEBUG == 2
> +#define MESA_BBOX_PRINT(...) ALOGE(__VA_ARGS__)
> +#define MESA_BBOX(...) ALOGE(__VA_ARGS__)
> +
> +#elif MESA_BBOX_DEBUG == 1
> +#define MESA_BBOX_PRINT(...) ALOGE(__VA_ARGS__)
> +#define MESA_BBOX(...)
> +
> +#else
> +#define MESA_BBOX_PRINT(...)
> +#define MESA_BBOX(...)
> +#endif //MESA_BBOX_DEBUG
> +
> +#else //ANDROID
> +
> +#if MESA_BBOX_DEBUG == 2
> +#define MESA_BBOX_PRINT(...) printf(__VA_ARGS__)
> +#define MESA_BBOX(...) printf(__VA_ARGS__)
> +
> +#elif MESA_BBOX_DEBUG == 1
> +#define MESA_BBOX_PRINT(...) printf(__VA_ARGS__)
> +#define MESA_BBOX(...)
> +
> +#else
> +#define MESA_BBOX_PRINT(...)
> +#define MESA_BBOX(...)
> +#endif //MESA_BBOX_DEBUG
> +
> +#endif //ANDROID
> +
> +/**
> + * MESA Bbox options environment variables
> + */
> +int env_opt_val;
> +const char *env_opt;
> +
> +typedef struct vbo_bbox_env_variable {
> + GLuint bbox_min_vrtx_count;
> + GLuint bbox_enable;
> + GLuint bbox_split_size;
> + GLuint bbox_trace_level;
> +} bbox_env;
> +bbox_env mesa_bbox_env_variables;
> +
> +void
> +vbo_bbox_init(struct gl_context *const gc);
> +
> +void
> +vbo_bbox_free(struct gl_context *const gc);
> +
> +
> +void
> +vbo_bbox_element_buffer_update(struct gl_context *const gc,
> + struct gl_buffer_object *buffer,
> + const void* data,
> + int offset,
> + int size);
> +
> +void
> +vbo_validated_drawrangeelements(struct gl_context *ctx,
> + GLenum mode,
> + GLboolean index_bounds_valid,
> + GLuint start,
> + GLuint end,
> + GLsizei count,
> + GLenum type,
> + const GLvoid * indices,
> + GLint basevertex,
> + GLuint numInstances,
> + GLuint baseInstance);
> +
> +void
> +vbo_bbox_drawelements(struct gl_context *ctx,
> + GLenum mode,
> + GLboolean index_bounds_valid,
> + GLuint start,
> + GLuint end,
> + GLsizei count,
> + GLenum type,
> + const GLvoid * indices,
> + GLint basevertex,
> + GLuint numInstances,
> + GLuint baseInstance);
> +
> +/**
> + * Segment Functions
> + */
> +typedef struct gl_segment
> +{
> + GLint Left;
> + GLint Right;
> +
> +}segment;
> +
> +/**
> + * Clip algorithm result
> + */
> +enum vbo_bbox_clip_result
> +{
> + BBOX_CLIP_OUTSIDE=0,
> + BBOX_CLIP_INTERSECT=1,
> + BBOX_CLIP_INSIDE=2,
> + BBOX_CLIP_DEGEN = 3,
> + BBOX_CLIP_ERROR = 4,
> +};
> +
> +typedef struct gl_matrixRec
> +{
> + GLfloat melem[4][4];
> + GLenum matrixType;
> +} gl_matrix;
> +
> +/**
> + * Structure to describe plane
> + */
> +typedef struct vbo_bbox_frustum_plane
> +{
> + GLfloat a, b, c, d;
> +} vbo_bbox_frustum_plane;
> +
> +
> +/**
> + * Planes and octants with their normals
> + */
> +typedef struct vbo_bbox_frustum
> +{
> + const unsigned char planeCount;
> + struct vbo_bbox_frustum_plane plane[FRUSTUM_PLANE_COUNT];
> + unsigned char octant[FRUSTUM_PLANE_COUNT];
> +} vbo_bbox_frustum;
> +
> +/*
> + * Axis Aligned Bounding Box
> + */
> +typedef union vbo_vec4f {
> + GLfloat data[4];
> + struct {
> + GLfloat x, y, z, w;
> + };
> +} vbo_vec4f;
> +
> +/*
> + * Oriented Bounding Box
> + */
> +typedef struct oriented_bounding_box {
> + GLfloat x,y,z,w;
> +} oriented_box;
> +
> +/*
> + * Spherical Bounding volume
> + */
> +typedef struct spherical_bounding_volume {
> + GLfloat x,y,z,r; // x^2+y^2+z^2 = r^2
> +} spherical_volume;
> +
> +/*
> + * 8-Discrete oriented polytopes
> + */
> +typedef struct dop_bounding_volume {
> + GLfloat x,y,z,r,a,b;//TBD Not sure of the representation for 8-DOP yet!
> +} dop_volume;
> +
> +/*
> + * Bounding volumes for AABB, OBB, SPHERE, DOP etc
> + */
> +typedef union bounding_volume_info {
> + vbo_vec4f vert_vec4[8]; /* Bbox mix man coordinates */
> + oriented_box obb[8];
> + spherical_volume sphere;
> + dop_volume dop[8];
> +} bounding_volume_info;
> +
> +
> +typedef struct vbo_bbox_cache_key
> +{
> + /* From API call */
> + GLenum mode; /* GL_TRAINGLES are only mode supported currently */
> + GLsizei count; /* Number if indices in draw call */
> + GLenum indices_type; /* must be GL_UNSIGNED_SHORT for now */
> + GLuint type_size;
> + GLuint type_sizeShift;
> + GLint indices; /* Offset to index VBO */
> + GLint basevertex; /* Only 0 supported for now. */
> +
> + /* VBO objects names */
> + GLuint element_buf_name;
> + GLuint vertex_buf_name;
> +
> + /* Vertex position attribute configuration */
> + GLint offset;
> + GLint size; /* Size of attribute, must be 3 for now */
> + GLenum vertDataType; /* Must be GL_FLOAT */
> + GLsizei stride; /* Any */
> + GLuint elementStride;
> +} vbo_bbox_cache_key;
> +
> +typedef struct bounding_info
> +{
> + int vert_count; /* Number of vertices this bbox covers */
> + int start_offset; /* Start offset for this bbox */
> + bool is_degenerate; /* Triangle can not be formed */
> + enum vbo_bbox_clip_result clip_result;
> +
> + bounding_volume_info bounding_volume; /* Bbox mix man coordinates */
> +
> +} bounding_info;
> +
> +/**
> + * Cached information about (multiple) bounding boxes
> + */
> +struct vbo_bbox_cache_data
> +{
> + /* Valid data indicator, will be set to false if VBO have been
> + * modified by application
> + */
> + bool valid;
> +
> + /* Indicates if bounding boxes were calculated for this geometry */
> + bool need_new_calculation;
> +
> + /* Controls delay with which bounding boxes are calculated */
> + int init_delaycnt;
> + int init_delaylimit;
> +
> + /* Data change indicator for VBOs */
> + int vertpos_vbo_changecnt;
> + int indices_vbo_changecnt;
> +
> + /* How many bounding boxes are stored for this geometry */
> + int sub_bbox_cnt;
> +
> + /* How many draws call the bbox was effective */
> + int drawcnt_bbox_helped;
> +
> + int last_use_frame;
> +
> + GLuint hash;
> +
> + unsigned keysize;
> +
> + vbo_bbox_cache_key *key;
> +
> + bool mvp_valid;
> + GLmatrix mvpin;
> + GLfloat mvp[16];
> + vbo_bbox_frustum frustum;
> +
> + /* Pointer to array of bboxes */
> + bounding_info* sub_bbox_array;
> +
> + /* Bounding box that covers whole geometry */
> + bounding_info full_box;
> +
> + struct vbo_bbox_cache_data *next;
> +};
> +
> +typedef struct mesa_bbox_cache {
> + struct vbo_bbox_cache_data **items;
> + struct vbo_bbox_cache_data *last;
> + GLuint size, n_items;
> +} mesa_bbox_cache;
> +
> +typedef struct mesa_bbox_opt
> +{
> + mesa_bbox_cache * cache;
> + GLuint calc_delay;
> +} mesa_bbox_opt;
> +
> +/**
> + * VBO BBox Cache functions, replica of program cache functions
> + *
> + */
> +struct mesa_bbox_cache *
> +_mesa_new_bbox_cache(void);
> +
> +void
> +_mesa_delete_bbox_cache(struct gl_context *ctx,
> + struct mesa_bbox_cache *cache);
> +
> +struct vbo_bbox_cache_data *
> +_mesa_search_bbox_cache(struct mesa_bbox_cache *cache,
> + const void *key, GLuint keysize);
> +
> +void
> +_mesa_bbox_cache_insert(struct gl_context *ctx,
> + struct mesa_bbox_cache *cache,
> + const void *key,
> + GLuint keysize,
> + struct vbo_bbox_cache_data *CachedData);
> +
> +#ifdef __cplusplus
> +} // extern "C"
> +#endif
> +
> +#endif //_VBO_BBOX_H_
> diff --git a/src/mesa/vbo/vbo_bbox_cache.c b/src/mesa/vbo/vbo_bbox_cache.c
> new file mode 100644
> index 0000000..09bd1dd
> --- /dev/null
> +++ b/src/mesa/vbo/vbo_bbox_cache.c
> @@ -0,0 +1,195 @@
> +
> +/*
> + * Copyright � 2018 Intel Corporation
> + *
> + * 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 (including the next
> + * paragraph) 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.
> + */
> +
> +/**
> + * \brief VBO BBOX module implementation
> + * \author Kedar Karanje
> + */
> +
> +#include "main/imports.h"
> +#include "main/mtypes.h"
> +#include "vbo/vbo_bbox.h"
> +
> +#define CACHE_SIZE 17
> +
> +/**
> + * Compute hash index from state key.
> + */
> +static GLuint
> +bbox_hash_key(const void *key, GLuint key_size)
> +{
> + const GLuint *ikey = (const GLuint *) key;
> + GLuint hash = 0, i;
> +
> + assert(key_size >= 4);
> +
> + /* Make a slightly better attempt at a hash function:
> + */
> + for (i = 0; i < key_size / sizeof(*ikey); i++)
> + {
> + hash += ikey[i];
> + hash += (hash << 10);
> + hash ^= (hash >> 6);
> + }
> +
> + return hash;
> +}
> +
> +
> +/**
> + * Rebuild/expand the hash table to accommodate more entries
> + */
> +static void
> +bbox_rehash(struct mesa_bbox_cache *cache)
> +{
> + struct vbo_bbox_cache_data **items;
> + struct vbo_bbox_cache_data *c, *next;
> + GLuint size, i;
> +
> + cache->last = NULL;
> +
> + size = cache->size * 3;
> + items = calloc(size, sizeof(*items));
> +
> + for (i = 0; i < cache->size; i++)
> + for (c = cache->items[i]; c; c = next) {
> + next = c->next;
> + c->next = items[c->hash % size];
> + items[c->hash % size] = c;
> + }
> +
> + free(cache->items);
> + cache->items = items;
> + cache->size = size;
> +}
> +
> +
> +static void
> +bbox_clear_cache(struct gl_context *ctx, mesa_bbox_cache *cache)
> +{
> + struct vbo_bbox_cache_data *c, *next;
> + GLuint i;
> +
> + cache->last = NULL;
> +
> + for (i = 0; i < cache->size; i++) {
> + for (c = cache->items[i]; c; c = next) {
> + next = c->next;
> + free(c->key);
> + free(c->sub_bbox_array);
> + free(c);
> + }
> + cache->items[i] = NULL;
> + }
> + cache->n_items = 0;
> +}
> +
> +
> +
> +mesa_bbox_cache *
> +_mesa_new_bbox_cache(void)
> +{
> + mesa_bbox_cache *cache = CALLOC_STRUCT(mesa_bbox_cache);
> + if (cache) {
> + cache->size = CACHE_SIZE;
> + cache->items = calloc(cache->size, sizeof(struct vbo_bbox_cache_data));
> + if (!cache->items) {
> + MESA_BBOX("Func:%s cache-size=%d "
> + "Cannot allocate items freeing cache\n",
> + __func__,cache->size);
> + free(cache);
> + return NULL;
> + }
> + MESA_BBOX("Func:%s cache:%#x cache->size=%d \n",
> + __func__,cache,cache->size);
> + return cache;
> + }
> + else {
> + MESA_BBOX("cache is Null in Func:%s\n",__func__);
> + return cache;
> + }
> +}
> +
> +
> +void
> +_mesa_delete_bbox_cache(struct gl_context *ctx, mesa_bbox_cache *cache)
> +{
> + bbox_clear_cache(ctx, cache);
> + free(cache->items);
> + free(cache);
> +}
> +
> +struct vbo_bbox_cache_data *
> +_mesa_search_bbox_cache(mesa_bbox_cache *cache,
> + const void *key, GLuint keysize)
> +{
> + MESA_BBOX("Func:%s cache:%#x \n",__func__,cache);
> + if (cache->last &&
> + cache->last->key->mode == ((vbo_bbox_cache_key *)key)->mode &&
> + cache->last->key->count == ((vbo_bbox_cache_key *)key)->count &&
> + cache->last->key->indices == ((vbo_bbox_cache_key *)key)->indices) {
> + return cache->last;
> + }
> + else {
> + const GLuint hash = bbox_hash_key(key, keysize);
> + struct vbo_bbox_cache_data *c;
> + MESA_BBOX("cache:%#x,hash:%d,cache->size:%d\n",cache,hash,cache->size);
> + for (c = cache->items[hash % cache->size]; c; c = c->next) {
> + if (c->hash == hash &&
> + c->key->mode == ((vbo_bbox_cache_key *)key)->mode &&
> + c->key->count == ((vbo_bbox_cache_key *)key)->count &&
> + c->key->indices == ((vbo_bbox_cache_key *)key)->indices) {
> + cache->last = c;
> + return c;
> + }
> + }
> + return NULL;
> + }
> +}
> +
> +
> +void
> +_mesa_bbox_cache_insert(struct gl_context *ctx,struct mesa_bbox_cache *cache,
> + const void *key, GLuint keysize,
> + struct vbo_bbox_cache_data *CachedData)
> +{
> + const GLuint hash = bbox_hash_key(key, keysize);
> +
> + CachedData->hash = hash;
> +
> + CachedData->key = calloc(1, keysize);
> + memcpy(CachedData->key, key, keysize);
> + CachedData->keysize = keysize;
> +
> + if (cache->n_items > cache->size * 1.5) {
> + if (cache->size < 1000)
> + bbox_rehash(cache);
> + else
> + bbox_clear_cache(ctx, cache);
> + }
> +
> + cache->n_items++;
> + CachedData->next = cache->items[hash % cache->size];
> + cache->items[hash % cache->size] = CachedData;
> +}
> diff --git a/src/mesa/vbo/vbo_context.c b/src/mesa/vbo/vbo_context.c
> index cf9405d..8c608c2 100644
> --- a/src/mesa/vbo/vbo_context.c
> +++ b/src/mesa/vbo/vbo_context.c
> @@ -36,6 +36,9 @@
> #include "vbo.h"
> #include "vbo_private.h"
>
> +#ifdef MESA_BBOX_OPT
> +#include "vbo_bbox.h"
> +#endif
>
> static GLuint
> check_size(const GLfloat *attr)
> @@ -199,6 +202,10 @@ _vbo_CreateContext(struct gl_context *ctx)
> if (ctx->API == API_OPENGL_COMPAT)
> vbo_save_init(ctx);
>
> +#ifdef MESA_BBOX_OPT //Hard coded to AABB for now
> + ctx->volume_type = BOUNDING_VOLUME_AABB;
> +#endif
> +
> vbo->VAO = _mesa_new_vao(ctx, ~((GLuint)0));
> /* The exec VAO assumes to have all arributes bound to binding 0 */
> for (unsigned i = 0; i < VERT_ATTRIB_MAX; ++i)
> @@ -219,7 +226,9 @@ _vbo_DestroyContext(struct gl_context *ctx)
> _ae_destroy_context(ctx);
> ctx->aelt_context = NULL;
> }
> -
> +#ifdef MESA_BBOX_OPT
> + vbo_bbox_free(ctx);
> +#endif
> if (vbo) {
>
> _mesa_reference_buffer_object(ctx, &vbo->binding.BufferObj, NULL);
> diff --git a/src/mesa/vbo/vbo_exec_array.c b/src/mesa/vbo/vbo_exec_array.c
> index 51c000e..3321a21 100644
> --- a/src/mesa/vbo/vbo_exec_array.c
> +++ b/src/mesa/vbo/vbo_exec_array.c
> @@ -39,6 +39,10 @@
> #include "main/macros.h"
> #include "main/transformfeedback.h"
>
> +#ifdef MESA_BBOX_OPT
> +#include "vbo_bbox.h"
> +#endif
> +
> typedef struct {
> GLuint count;
> GLuint primCount;
> @@ -784,6 +788,16 @@ skip_draw_elements(struct gl_context *ctx, GLsizei count,
> * Do the rendering for a glDrawElements or glDrawRangeElements call after
> * we've validated buffer bounds, etc.
> */
> +#ifdef MESA_BBOX_OPT
> +void
> +vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
> + GLboolean index_bounds_valid,
> + GLuint start, GLuint end,
> + GLsizei count, GLenum type,
> + const GLvoid * indices,
> + GLint basevertex, GLuint numInstances,
> + GLuint baseInstance)
> +#else
> static void
> vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
> GLboolean index_bounds_valid,
> @@ -792,6 +806,7 @@ vbo_validated_drawrangeelements(struct gl_context *ctx, GLenum mode,
> const GLvoid * indices,
> GLint basevertex, GLuint numInstances,
> GLuint baseInstance)
> +#endif
> {
> struct _mesa_index_buffer ib;
> struct _mesa_prim prim;
> @@ -997,6 +1012,11 @@ vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
> _mesa_debug(ctx, "glDrawElements(%s, %u, %s, %p)\n",
> _mesa_enum_to_string(mode), count,
> _mesa_enum_to_string(type), indices);
> +#ifdef MESA_BBOX_OPT
> + MESA_BBOX_PRINT("glDrawElements(%s, %u, %s, %p)\n",
> + _mesa_enum_to_string(mode), count,
> + _mesa_enum_to_string(type), indices);
> +#endif
>
> FLUSH_FOR_DRAW(ctx);
>
> @@ -1011,9 +1031,13 @@ vbo_exec_DrawElements(GLenum mode, GLsizei count, GLenum type,
> if (!_mesa_validate_DrawElements(ctx, mode, count, type, indices))
> return;
> }
> -
> +#ifdef MESA_BBOX_OPT
> + vbo_bbox_drawelements(ctx, mode, GL_FALSE, 0, ~0,
> + count, type, indices, 0, 1, 0);
> +#else
> vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, 0, ~0,
> count, type, indices, 0, 1, 0);
> +#endif
> }
>
>
> @@ -1045,8 +1069,13 @@ vbo_exec_DrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
> return;
> }
>
> +#ifdef MESA_BBOX_OPT
> + vbo_bbox_drawelements(ctx, mode, GL_FALSE, 0, ~0,
> + count, type, indices, basevertex, 1, 0);
> +#else
> vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, 0, ~0,
> count, type, indices, basevertex, 1, 0);
> +#endif
> }
>
>
> @@ -1078,9 +1107,13 @@ vbo_exec_DrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
> indices, numInstances))
> return;
> }
> -
> +#ifdef MESA_BBOX_OPT
> + vbo_bbox_drawelements(ctx, mode, GL_FALSE, 0, ~0,
> + count, type, indices, 0, numInstances, 0);
> +#else
> vbo_validated_drawrangeelements(ctx, mode, GL_FALSE, 0, ~0,
> count, type, indices, 0, numInstances, 0);
> +#endif
> }
>
>
> diff --git a/src/util/00-mesa-defaults.conf b/src/util/00-mesa-defaults.conf
> index ad59efb..15f064b 100644
> --- a/src/util/00-mesa-defaults.conf
> +++ b/src/util/00-mesa-defaults.conf
> @@ -197,6 +197,10 @@ TODO: document the other workarounds.
> <option name="force_glsl_extensions_warn" value="true" />
> </application>
>
> + <application name="GLBenchmark" executable="GLBenchmark">
> + <option name="enable_bounding_box_culling" value="true"/>
> + </application>
> +
> <!-- The GL thread whitelist is below, workarounds are above.
> Keep it that way. -->
>
> diff --git a/src/util/xmlpool/t_options.h b/src/util/xmlpool/t_options.h
> index ecf495a..c3f8928 100644
> --- a/src/util/xmlpool/t_options.h
> +++ b/src/util/xmlpool/t_options.h
> @@ -135,6 +135,11 @@ DRI_CONF_OPT_BEGIN_B(allow_glsl_cross_stage_interpolation_mismatch, def) \
> DRI_CONF_DESC(en,gettext("Allow interpolation qualifier mismatch across shader stages")) \
> DRI_CONF_OPT_END
>
> +#define DRI_CONF_ENABLE_BOUNDING_BOX_CULLING(def) \
> +DRI_CONF_OPT_BEGIN_B(enable_bounding_box_culling, def) \
> + DRI_CONF_DESC(en,gettext("Enable bounding box culling in CPU")) \
> +DRI_CONF_OPT_END
> +
> /**
> * \brief Image quality-related options
> */
>
>
>
> _______________________________________________
> mesa-dev mailing list
> mesa-dev at lists.freedesktop.org
> https://lists.freedesktop.org/mailman/listinfo/mesa-dev
>
More information about the mesa-dev
mailing list