src/mesa/vbo/vbo_minmax_index.c - platform/external/mesa3d - Git at Google

 /*
  * Mesa 3-D graphics library
  *
  * Copyright 2003 VMware, Inc.
  * Copyright 2009 VMware, Inc.
  * All Rights Reserved.
  * Copyright (C) 2016 Advanced Micro Devices, Inc.
  *
  * 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 NON-INFRINGEMENT. IN NO EVENT SHALL
  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  */

 #include "main/glheader.h"
 #include "main/context.h"
 #include "main/varray.h"
 #include "main/macros.h"
 #include "main/sse_minmax.h"
 #include "x86/common_x86_asm.h"
 #include "util/hash_table.h"


 struct minmax_cache_key {
    GLintptr offset;
    GLuint count;
    GLenum type;
 };


 struct minmax_cache_entry {
    struct minmax_cache_key key;
    GLuint min;
    GLuint max;
 };


 static uint32_t
 vbo_minmax_cache_hash(const struct minmax_cache_key *key)
 {
    return _mesa_hash_data(key, sizeof(*key));
 }


 static bool
 vbo_minmax_cache_key_equal(const struct minmax_cache_key *a,
                            const struct minmax_cache_key *b)
 {
    return (a->offset == b->offset) && (a->count == b->count) && (a->type == b->type);
 }


 static void
 vbo_minmax_cache_delete_entry(struct hash_entry *entry)
 {
    free(entry->data);
 }


 static GLboolean
 vbo_use_minmax_cache(struct gl_buffer_object *bufferObj)
 {
    if (bufferObj->UsageHistory & (USAGE_TEXTURE_BUFFER |
                                   USAGE_ATOMIC_COUNTER_BUFFER |
                                   USAGE_SHADER_STORAGE_BUFFER |
                                   USAGE_TRANSFORM_FEEDBACK_BUFFER |
                                   USAGE_PIXEL_PACK_BUFFER |
                                   USAGE_DISABLE_MINMAX_CACHE))
       return GL_FALSE;

    if ((bufferObj->Mappings[MAP_USER].AccessFlags &
         (GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT)) ==
        (GL_MAP_PERSISTENT_BIT | GL_MAP_WRITE_BIT))
       return GL_FALSE;

    return GL_TRUE;
 }


 void
 vbo_delete_minmax_cache(struct gl_buffer_object *bufferObj)
 {
    _mesa_hash_table_destroy(bufferObj->MinMaxCache, vbo_minmax_cache_delete_entry);
    bufferObj->MinMaxCache = NULL;
 }


 static GLboolean
 vbo_get_minmax_cached(struct gl_buffer_object *bufferObj,
                       GLenum type, GLintptr offset, GLuint count,
                       GLuint *min_index, GLuint *max_index)
 {
    GLboolean found = GL_FALSE;
    struct minmax_cache_key key;
    uint32_t hash;
    struct hash_entry *result;

    if (!bufferObj->MinMaxCache)
       return GL_FALSE;
    if (!vbo_use_minmax_cache(bufferObj))
       return GL_FALSE;

    mtx_lock(&bufferObj->Mutex);

    if (bufferObj->MinMaxCacheDirty) {
       /* Disable the cache permanently for this BO if the number of hits
        * is asymptotically less than the number of misses. This happens when
        * applications use the BO for streaming.
        *
        * However, some initial optimism allows applications that interleave
        * draw calls with glBufferSubData during warmup.
        */
       unsigned optimism = bufferObj->Size;
       if (bufferObj->MinMaxCacheMissIndices > optimism &&
           bufferObj->MinMaxCacheHitIndices < bufferObj->MinMaxCacheMissIndices - optimism) {
          bufferObj->UsageHistory |= USAGE_DISABLE_MINMAX_CACHE;
          vbo_delete_minmax_cache(bufferObj);
          goto out_disable;
       }

       _mesa_hash_table_clear(bufferObj->MinMaxCache, vbo_minmax_cache_delete_entry);
       bufferObj->MinMaxCacheDirty = false;
       goto out_invalidate;
    }

    key.type = type;
    key.offset = offset;
    key.count = count;
    hash = vbo_minmax_cache_hash(&key);
    result = _mesa_hash_table_search_pre_hashed(bufferObj->MinMaxCache, hash, &key);
    if (result) {
       struct minmax_cache_entry *entry = result->data;
       *min_index = entry->min;
       *max_index = entry->max;
       found = GL_TRUE;
    }

 out_invalidate:
    if (found) {
       /* The hit counter saturates so that we don't accidently disable the
        * cache in a long-running program.
        */
       unsigned new_hit_count = bufferObj->MinMaxCacheHitIndices + count;

       if (new_hit_count >= bufferObj->MinMaxCacheHitIndices)
          bufferObj->MinMaxCacheHitIndices = new_hit_count;
       else
          bufferObj->MinMaxCacheHitIndices = ~(unsigned)0;
    } else {
       bufferObj->MinMaxCacheMissIndices += count;
    }

 out_disable:
    mtx_unlock(&bufferObj->Mutex);
    return found;
 }


 static void
 vbo_minmax_cache_store(struct gl_context *ctx,
                        struct gl_buffer_object *bufferObj,
                        GLenum type, GLintptr offset, GLuint count,
                        GLuint min, GLuint max)
 {
    struct minmax_cache_entry *entry;
    struct hash_entry *table_entry;
    uint32_t hash;

    if (!vbo_use_minmax_cache(bufferObj))
       return;

    mtx_lock(&bufferObj->Mutex);

    if (!bufferObj->MinMaxCache) {
       bufferObj->MinMaxCache =
          _mesa_hash_table_create(NULL,
                                  (uint32_t (*)(const void *))vbo_minmax_cache_hash,
                                  (bool (*)(const void *, const void *))vbo_minmax_cache_key_equal);
       if (!bufferObj->MinMaxCache)
          goto out;
    }

    entry = MALLOC_STRUCT(minmax_cache_entry);
    if (!entry)
       goto out;

    entry->key.offset = offset;
    entry->key.count = count;
    entry->key.type = type;
    entry->min = min;
    entry->max = max;
    hash = vbo_minmax_cache_hash(&entry->key);

    table_entry = _mesa_hash_table_search_pre_hashed(bufferObj->MinMaxCache,
                                                     hash, &entry->key);
    if (table_entry) {
       /* It seems like this could happen when two contexts are rendering using
        * the same buffer object from multiple threads.
        */
       _mesa_debug(ctx, "duplicate entry in minmax cache\n");
       free(entry);
       goto out;
    }

    table_entry = _mesa_hash_table_insert_pre_hashed(bufferObj->MinMaxCache,
                                                     hash, &entry->key, entry);
    if (!table_entry)
       free(entry);

 out:
    mtx_unlock(&bufferObj->Mutex);
 }


 /**
  * Compute min and max elements by scanning the index buffer for
  * glDraw[Range]Elements() calls.
  * If primitive restart is enabled, we need to ignore restart
  * indexes when computing min/max.
  */
 static void
 vbo_get_minmax_index(struct gl_context *ctx,
                      const struct _mesa_prim *prim,
                      const struct _mesa_index_buffer *ib,
                      GLuint *min_index, GLuint *max_index,
                      const GLuint count)
 {
    const GLboolean restart = ctx->Array._PrimitiveRestart;
    const GLuint restartIndex = _mesa_primitive_restart_index(ctx, ib->type);
    const int index_size = vbo_sizeof_ib_type(ib->type);
    const char *indices;
    GLuint i;

    indices = (char *) ib->ptr + prim->start * index_size;
    if (_mesa_is_bufferobj(ib->obj)) {
       GLsizeiptr size = MIN2(count * index_size, ib->obj->Size);

       if (vbo_get_minmax_cached(ib->obj, ib->type, (GLintptr) indices, count,
                                 min_index, max_index))
          return;

       indices = ctx->Driver.MapBufferRange(ctx, (GLintptr) indices, size,
                                            GL_MAP_READ_BIT, ib->obj,
                                            MAP_INTERNAL);
    }

    switch (ib->type) {
    case GL_UNSIGNED_INT: {
       const GLuint *ui_indices = (const GLuint *)indices;
       GLuint max_ui = 0;
       GLuint min_ui = ~0U;
       if (restart) {
          for (i = 0; i < count; i++) {
             if (ui_indices[i] != restartIndex) {
                if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
                if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
             }
          }
       }
       else {
 #if defined(USE_SSE41)
          if (cpu_has_sse4_1) {
             _mesa_uint_array_min_max(ui_indices, &min_ui, &max_ui, count);
          }
          else
 #endif
             for (i = 0; i < count; i++) {
                if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
                if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
             }
       }
       *min_index = min_ui;
       *max_index = max_ui;
       break;
    }
    case GL_UNSIGNED_SHORT: {
       const GLushort *us_indices = (const GLushort *)indices;
       GLuint max_us = 0;
       GLuint min_us = ~0U;
       if (restart) {
          for (i = 0; i < count; i++) {
             if (us_indices[i] != restartIndex) {
                if (us_indices[i] > max_us) max_us = us_indices[i];
                if (us_indices[i] < min_us) min_us = us_indices[i];
             }
          }
       }
       else {
          for (i = 0; i < count; i++) {
             if (us_indices[i] > max_us) max_us = us_indices[i];
             if (us_indices[i] < min_us) min_us = us_indices[i];
          }
       }
       *min_index = min_us;
       *max_index = max_us;
       break;
    }
    case GL_UNSIGNED_BYTE: {
       const GLubyte *ub_indices = (const GLubyte *)indices;
       GLuint max_ub = 0;
       GLuint min_ub = ~0U;
       if (restart) {
          for (i = 0; i < count; i++) {
             if (ub_indices[i] != restartIndex) {
                if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
                if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
             }
          }
       }
       else {
          for (i = 0; i < count; i++) {
             if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
             if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
          }
       }
       *min_index = min_ub;
       *max_index = max_ub;
       break;
    }
    default:
       unreachable("not reached");
    }

    if (_mesa_is_bufferobj(ib->obj)) {
       vbo_minmax_cache_store(ctx, ib->obj, ib->type, prim->start, count,
                              *min_index, *max_index);
       ctx->Driver.UnmapBuffer(ctx, ib->obj, MAP_INTERNAL);
    }
 }

 /**
  * Compute min and max elements for nr_prims
  */
 void
 vbo_get_minmax_indices(struct gl_context *ctx,
                        const struct _mesa_prim *prims,
                        const struct _mesa_index_buffer *ib,
                        GLuint *min_index,
                        GLuint *max_index,
                        GLuint nr_prims)
 {
    GLuint tmp_min, tmp_max;
    GLuint i;
    GLuint count;

    *min_index = ~0;
    *max_index = 0;

    for (i = 0; i < nr_prims; i++) {
       const struct _mesa_prim *start_prim;

       start_prim = &prims[i];
       count = start_prim->count;
       /* Do combination if possible to reduce map/unmap count */
       while ((i + 1 < nr_prims) &&
              (prims[i].start + prims[i].count == prims[i+1].start)) {
          count += prims[i+1].count;
          i++;
       }
       vbo_get_minmax_index(ctx, start_prim, ib, &tmp_min, &tmp_max, count);
       *min_index = MIN2(*min_index, tmp_min);
       *max_index = MAX2(*max_index, tmp_max);
    }
 }
	/*
	* Mesa 3-D graphics library
	*
	* Copyright 2003 VMware, Inc.
	* Copyright 2009 VMware, Inc.
	* All Rights Reserved.
	* Copyright (C) 2016 Advanced Micro Devices, Inc.
	*
	* 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 NON-INFRINGEMENT. IN NO EVENT SHALL
	* THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
	* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
	* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
	* USE OR OTHER DEALINGS IN THE SOFTWARE.
	*/

	#include "main/glheader.h"
	#include "main/context.h"
	#include "main/varray.h"
	#include "main/macros.h"
	#include "main/sse_minmax.h"
	#include "x86/common_x86_asm.h"
	#include "util/hash_table.h"


	struct minmax_cache_key {
	GLintptr offset;
	GLuint count;
	GLenum type;
	};


	struct minmax_cache_entry {
	struct minmax_cache_key key;
	GLuint min;
	GLuint max;
	};


	static uint32_t
	vbo_minmax_cache_hash(const struct minmax_cache_key *key)
	{
	return _mesa_hash_data(key, sizeof(*key));
	}


	static bool
	vbo_minmax_cache_key_equal(const struct minmax_cache_key *a,
	const struct minmax_cache_key *b)
	{
	return (a->offset == b->offset) && (a->count == b->count) && (a->type == b->type);
	}


	static void
	vbo_minmax_cache_delete_entry(struct hash_entry *entry)
	{
	free(entry->data);
	}


	static GLboolean
	vbo_use_minmax_cache(struct gl_buffer_object *bufferObj)
	{
	if (bufferObj->UsageHistory & (USAGE_TEXTURE_BUFFER \|
	USAGE_ATOMIC_COUNTER_BUFFER \|
	USAGE_SHADER_STORAGE_BUFFER \|
	USAGE_TRANSFORM_FEEDBACK_BUFFER \|
	USAGE_PIXEL_PACK_BUFFER \|
	USAGE_DISABLE_MINMAX_CACHE))
	return GL_FALSE;

	if ((bufferObj->Mappings[MAP_USER].AccessFlags &
	(GL_MAP_PERSISTENT_BIT \| GL_MAP_WRITE_BIT)) ==
	(GL_MAP_PERSISTENT_BIT \| GL_MAP_WRITE_BIT))
	return GL_FALSE;

	return GL_TRUE;
	}


	void
	vbo_delete_minmax_cache(struct gl_buffer_object *bufferObj)
	{
	_mesa_hash_table_destroy(bufferObj->MinMaxCache, vbo_minmax_cache_delete_entry);
	bufferObj->MinMaxCache = NULL;
	}


	static GLboolean
	vbo_get_minmax_cached(struct gl_buffer_object *bufferObj,
	GLenum type, GLintptr offset, GLuint count,
	GLuint min_index, GLuint max_index)
	{
	GLboolean found = GL_FALSE;
	struct minmax_cache_key key;
	uint32_t hash;
	struct hash_entry *result;

	if (!bufferObj->MinMaxCache)
	return GL_FALSE;
	if (!vbo_use_minmax_cache(bufferObj))
	return GL_FALSE;

	mtx_lock(&bufferObj->Mutex);

	if (bufferObj->MinMaxCacheDirty) {
	/* Disable the cache permanently for this BO if the number of hits
	* is asymptotically less than the number of misses. This happens when
	* applications use the BO for streaming.
	*
	* However, some initial optimism allows applications that interleave
	* draw calls with glBufferSubData during warmup.
	*/
	unsigned optimism = bufferObj->Size;
	if (bufferObj->MinMaxCacheMissIndices > optimism &&
	bufferObj->MinMaxCacheHitIndices < bufferObj->MinMaxCacheMissIndices - optimism) {
	bufferObj->UsageHistory \|= USAGE_DISABLE_MINMAX_CACHE;
	vbo_delete_minmax_cache(bufferObj);
	goto out_disable;
	}

	_mesa_hash_table_clear(bufferObj->MinMaxCache, vbo_minmax_cache_delete_entry);
	bufferObj->MinMaxCacheDirty = false;
	goto out_invalidate;
	}

	key.type = type;
	key.offset = offset;
	key.count = count;
	hash = vbo_minmax_cache_hash(&key);
	result = _mesa_hash_table_search_pre_hashed(bufferObj->MinMaxCache, hash, &key);
	if (result) {
	struct minmax_cache_entry *entry = result->data;
	*min_index = entry->min;
	*max_index = entry->max;
	found = GL_TRUE;
	}

	out_invalidate:
	if (found) {
	/* The hit counter saturates so that we don't accidently disable the
	* cache in a long-running program.
	*/
	unsigned new_hit_count = bufferObj->MinMaxCacheHitIndices + count;

	if (new_hit_count >= bufferObj->MinMaxCacheHitIndices)
	bufferObj->MinMaxCacheHitIndices = new_hit_count;
	else
	bufferObj->MinMaxCacheHitIndices = ~(unsigned)0;
	} else {
	bufferObj->MinMaxCacheMissIndices += count;
	}

	out_disable:
	mtx_unlock(&bufferObj->Mutex);
	return found;
	}


	static void
	vbo_minmax_cache_store(struct gl_context *ctx,
	struct gl_buffer_object *bufferObj,
	GLenum type, GLintptr offset, GLuint count,
	GLuint min, GLuint max)
	{
	struct minmax_cache_entry *entry;
	struct hash_entry *table_entry;
	uint32_t hash;

	if (!vbo_use_minmax_cache(bufferObj))
	return;

	mtx_lock(&bufferObj->Mutex);

	if (!bufferObj->MinMaxCache) {
	bufferObj->MinMaxCache =
	_mesa_hash_table_create(NULL,
	(uint32_t ()(const void ))vbo_minmax_cache_hash,
	(bool ()(const void , const void *))vbo_minmax_cache_key_equal);
	if (!bufferObj->MinMaxCache)
	goto out;
	}

	entry = MALLOC_STRUCT(minmax_cache_entry);
	if (!entry)
	goto out;

	entry->key.offset = offset;
	entry->key.count = count;
	entry->key.type = type;
	entry->min = min;
	entry->max = max;
	hash = vbo_minmax_cache_hash(&entry->key);

	table_entry = _mesa_hash_table_search_pre_hashed(bufferObj->MinMaxCache,
	hash, &entry->key);
	if (table_entry) {
	/* It seems like this could happen when two contexts are rendering using
	* the same buffer object from multiple threads.
	*/
	_mesa_debug(ctx, "duplicate entry in minmax cache\n");
	free(entry);
	goto out;
	}

	table_entry = _mesa_hash_table_insert_pre_hashed(bufferObj->MinMaxCache,
	hash, &entry->key, entry);
	if (!table_entry)
	free(entry);

	out:
	mtx_unlock(&bufferObj->Mutex);
	}


	/**
	* Compute min and max elements by scanning the index buffer for
	* glDraw[Range]Elements() calls.
	* If primitive restart is enabled, we need to ignore restart
	* indexes when computing min/max.
	*/
	static void
	vbo_get_minmax_index(struct gl_context *ctx,
	const struct _mesa_prim *prim,
	const struct _mesa_index_buffer *ib,
	GLuint min_index, GLuint max_index,
	const GLuint count)
	{
	const GLboolean restart = ctx->Array._PrimitiveRestart;
	const GLuint restartIndex = _mesa_primitive_restart_index(ctx, ib->type);
	const int index_size = vbo_sizeof_ib_type(ib->type);
	const char *indices;
	GLuint i;

	indices = (char ) ib->ptr + prim->start index_size;
	if (_mesa_is_bufferobj(ib->obj)) {
	GLsizeiptr size = MIN2(count * index_size, ib->obj->Size);

	if (vbo_get_minmax_cached(ib->obj, ib->type, (GLintptr) indices, count,
	min_index, max_index))
	return;

	indices = ctx->Driver.MapBufferRange(ctx, (GLintptr) indices, size,
	GL_MAP_READ_BIT, ib->obj,
	MAP_INTERNAL);
	}

	switch (ib->type) {
	case GL_UNSIGNED_INT: {
	const GLuint ui_indices = (const GLuint )indices;
	GLuint max_ui = 0;
	GLuint min_ui = ~0U;
	if (restart) {
	for (i = 0; i < count; i++) {
	if (ui_indices[i] != restartIndex) {
	if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
	if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
	}
	}
	}
	else {
	#if defined(USE_SSE41)
	if (cpu_has_sse4_1) {
	_mesa_uint_array_min_max(ui_indices, &min_ui, &max_ui, count);
	}
	else
	#endif
	for (i = 0; i < count; i++) {
	if (ui_indices[i] > max_ui) max_ui = ui_indices[i];
	if (ui_indices[i] < min_ui) min_ui = ui_indices[i];
	}
	}
	*min_index = min_ui;
	*max_index = max_ui;
	break;
	}
	case GL_UNSIGNED_SHORT: {
	const GLushort us_indices = (const GLushort )indices;
	GLuint max_us = 0;
	GLuint min_us = ~0U;
	if (restart) {
	for (i = 0; i < count; i++) {
	if (us_indices[i] != restartIndex) {
	if (us_indices[i] > max_us) max_us = us_indices[i];
	if (us_indices[i] < min_us) min_us = us_indices[i];
	}
	}
	}
	else {
	for (i = 0; i < count; i++) {
	if (us_indices[i] > max_us) max_us = us_indices[i];
	if (us_indices[i] < min_us) min_us = us_indices[i];
	}
	}
	*min_index = min_us;
	*max_index = max_us;
	break;
	}
	case GL_UNSIGNED_BYTE: {
	const GLubyte ub_indices = (const GLubyte )indices;
	GLuint max_ub = 0;
	GLuint min_ub = ~0U;
	if (restart) {
	for (i = 0; i < count; i++) {
	if (ub_indices[i] != restartIndex) {
	if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
	if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
	}
	}
	}
	else {
	for (i = 0; i < count; i++) {
	if (ub_indices[i] > max_ub) max_ub = ub_indices[i];
	if (ub_indices[i] < min_ub) min_ub = ub_indices[i];
	}
	}
	*min_index = min_ub;
	*max_index = max_ub;
	break;
	}
	default:
	unreachable("not reached");
	}

	if (_mesa_is_bufferobj(ib->obj)) {
	vbo_minmax_cache_store(ctx, ib->obj, ib->type, prim->start, count,
	min_index, max_index);
	ctx->Driver.UnmapBuffer(ctx, ib->obj, MAP_INTERNAL);
	}
	}

	/**
	* Compute min and max elements for nr_prims
	*/
	void
	vbo_get_minmax_indices(struct gl_context *ctx,
	const struct _mesa_prim *prims,
	const struct _mesa_index_buffer *ib,
	GLuint *min_index,
	GLuint *max_index,
	GLuint nr_prims)
	{
	GLuint tmp_min, tmp_max;
	GLuint i;
	GLuint count;

	*min_index = ~0;
	*max_index = 0;

	for (i = 0; i < nr_prims; i++) {
	const struct _mesa_prim *start_prim;

	start_prim = &prims[i];
	count = start_prim->count;
	/* Do combination if possible to reduce map/unmap count */
	while ((i + 1 < nr_prims) &&
	(prims[i].start + prims[i].count == prims[i+1].start)) {
	count += prims[i+1].count;
	i++;
	}
	vbo_get_minmax_index(ctx, start_prim, ib, &tmp_min, &tmp_max, count);
	min_index = MIN2(min_index, tmp_min);
	max_index = MAX2(max_index, tmp_max);
	}
	}