src/gallium/auxiliary/hud/hud_driver_query.c - third_party/mesa - Git at Google

 /**************************************************************************
  *
  * Copyright 2013 Marek Olšák <maraeo@gmail.com>
  * All Rights Reserved.
  *
  * 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, sub license, 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 AUTHORS AND/OR ITS 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.
  *
  **************************************************************************/

 /* This file contains code for reading values from pipe queries
  * for displaying on the HUD. To prevent stalls when reading queries, we
  * keep a list of busy queries in a ring. We read only those queries which
  * are idle.
  */

 #include "hud/hud_private.h"
 #include "pipe/p_screen.h"
 #include "util/os_time.h"
 #include "util/u_math.h"
 #include "util/u_memory.h"
 #include <stdio.h>

 // Must be a power of two
 #define NUM_QUERIES 8

 struct hud_batch_query_context {
    unsigned num_query_types;
    unsigned allocated_query_types;
    unsigned *query_types;

    boolean failed;
    struct pipe_query *query[NUM_QUERIES];
    union pipe_query_result *result[NUM_QUERIES];
    unsigned head, pending, results;
 };

 void
 hud_batch_query_update(struct hud_batch_query_context *bq,
                        struct pipe_context *pipe)
 {
    if (!bq || bq->failed)
       return;

    if (bq->query[bq->head])
       pipe->end_query(pipe, bq->query[bq->head]);

    bq->results = 0;

    while (bq->pending) {
       unsigned idx = (bq->head - bq->pending + 1) % NUM_QUERIES;
       struct pipe_query *query = bq->query[idx];

       if (!bq->result[idx])
          bq->result[idx] = MALLOC(sizeof(bq->result[idx]->batch[0]) *
                                   bq->num_query_types);
       if (!bq->result[idx]) {
          fprintf(stderr, "gallium_hud: out of memory.\n");
          bq->failed = TRUE;
          return;
       }

       if (!pipe->get_query_result(pipe, query, FALSE, bq->result[idx]))
          break;

       ++bq->results;
       --bq->pending;
    }

    bq->head = (bq->head + 1) % NUM_QUERIES;

    if (bq->pending == NUM_QUERIES) {
       fprintf(stderr,
               "gallium_hud: all queries busy after %i frames, dropping data.\n",
               NUM_QUERIES);

       assert(bq->query[bq->head]);

       pipe->destroy_query(pipe, bq->query[bq->head]);
       bq->query[bq->head] = NULL;
    }

    ++bq->pending;

    if (!bq->query[bq->head]) {
       bq->query[bq->head] = pipe->create_batch_query(pipe,
                                                      bq->num_query_types,
                                                      bq->query_types);

       if (!bq->query[bq->head]) {
          fprintf(stderr,
                  "gallium_hud: create_batch_query failed. You may have "
                  "selected too many or incompatible queries.\n");
          bq->failed = TRUE;
          return;
       }
    }
 }

 void
 hud_batch_query_begin(struct hud_batch_query_context *bq,
                       struct pipe_context *pipe)
 {
    if (!bq || bq->failed || !bq->query[bq->head])
       return;

    if (!pipe->begin_query(pipe, bq->query[bq->head])) {
       fprintf(stderr,
               "gallium_hud: could not begin batch query. You may have "
               "selected too many or incompatible queries.\n");
       bq->failed = TRUE;
    }
 }

 static boolean
 batch_query_add(struct hud_batch_query_context **pbq,
                 unsigned query_type, unsigned *result_index)
 {
    struct hud_batch_query_context *bq = *pbq;
    unsigned i;

    if (!bq) {
       bq = CALLOC_STRUCT(hud_batch_query_context);
       if (!bq)
          return false;
       *pbq = bq;
    }

    for (i = 0; i < bq->num_query_types; ++i) {
       if (bq->query_types[i] == query_type) {
          *result_index = i;
          return true;
       }
    }

    if (bq->num_query_types == bq->allocated_query_types) {
       unsigned new_alloc = MAX2(16, bq->allocated_query_types * 2);
       unsigned *new_query_types
          = REALLOC(bq->query_types,
                    bq->allocated_query_types * sizeof(unsigned),
                    new_alloc * sizeof(unsigned));
       if (!new_query_types)
          return false;
       bq->query_types = new_query_types;
       bq->allocated_query_types = new_alloc;
    }

    bq->query_types[bq->num_query_types] = query_type;
    *result_index = bq->num_query_types++;
    return true;
 }

 void
 hud_batch_query_cleanup(struct hud_batch_query_context **pbq,
                         struct pipe_context *pipe)
 {
    struct hud_batch_query_context *bq = *pbq;
    unsigned idx;

    if (!bq)
       return;

    *pbq = NULL;

    if (bq->query[bq->head] && !bq->failed)
       pipe->end_query(pipe, bq->query[bq->head]);

    for (idx = 0; idx < NUM_QUERIES; ++idx) {
       if (bq->query[idx])
          pipe->destroy_query(pipe, bq->query[idx]);
       FREE(bq->result[idx]);
    }

    FREE(bq->query_types);
    FREE(bq);
 }

 struct query_info {
    struct hud_batch_query_context *batch;
    enum pipe_query_type query_type;

    /** index to choose fields in pipe_query_data_pipeline_statistics,
     * for example.
     */
    unsigned result_index;
    enum pipe_driver_query_result_type result_type;
    enum pipe_driver_query_type type;

    /* Ring of queries. If a query is busy, we use another slot. */
    struct pipe_query *query[NUM_QUERIES];
    unsigned head, tail;

    uint64_t last_time;
    uint64_t results_cumulative;
    unsigned num_results;
 };

 static void
 query_new_value_batch(struct query_info *info)
 {
    struct hud_batch_query_context *bq = info->batch;
    unsigned result_index = info->result_index;
    unsigned idx = (bq->head - bq->pending) % NUM_QUERIES;
    unsigned results = bq->results;

    while (results) {
       info->results_cumulative += bq->result[idx]->batch[result_index].u64;
       ++info->num_results;

       --results;
       idx = (idx - 1) % NUM_QUERIES;
    }
 }

 static void
 query_new_value_normal(struct query_info *info, struct pipe_context *pipe)
 {
    if (info->last_time) {
       if (info->query[info->head])
          pipe->end_query(pipe, info->query[info->head]);

       /* read query results */
       while (1) {
          struct pipe_query *query = info->query[info->tail];
          union pipe_query_result result;
          uint64_t *res64 = (uint64_t *)&result;

          if (query && pipe->get_query_result(pipe, query, FALSE, &result)) {
             if (info->type == PIPE_DRIVER_QUERY_TYPE_FLOAT) {
                assert(info->result_index == 0);
                info->results_cumulative += (uint64_t) (result.f * 1000.0f);
             }
             else {
                info->results_cumulative += res64[info->result_index];
             }
             info->num_results++;

             if (info->tail == info->head)
                break;

             info->tail = (info->tail+1) % NUM_QUERIES;
          }
          else {
             /* the oldest query is busy */
             if ((info->head+1) % NUM_QUERIES == info->tail) {
                /* all queries are busy, throw away the last query and create
                 * a new one */
                fprintf(stderr,
                        "gallium_hud: all queries are busy after %i frames, "
                        "can't add another query\n",
                        NUM_QUERIES);
                if (info->query[info->head])
                   pipe->destroy_query(pipe, info->query[info->head]);
                info->query[info->head] =
                      pipe->create_query(pipe, info->query_type, 0);
             }
             else {
                /* the last query is busy, we need to add a new one we can use
                 * for this frame */
                info->head = (info->head+1) % NUM_QUERIES;
                if (!info->query[info->head]) {
                   info->query[info->head] =
                         pipe->create_query(pipe, info->query_type, 0);
                }
             }
             break;
          }
       }
    }
    else {
       /* initialize */
       info->query[info->head] = pipe->create_query(pipe, info->query_type, 0);
    }
 }

 static void
 begin_query(struct hud_graph *gr, struct pipe_context *pipe)
 {
    struct query_info *info = gr->query_data;

    assert(!info->batch);
    if (info->query[info->head])
       pipe->begin_query(pipe, info->query[info->head]);
 }

 static void
 query_new_value(struct hud_graph *gr, struct pipe_context *pipe)
 {
    struct query_info *info = gr->query_data;
    uint64_t now = os_time_get();

    if (info->batch) {
       query_new_value_batch(info);
    } else {
       query_new_value_normal(info, pipe);
    }

    if (!info->last_time) {
       info->last_time = now;
       return;
    }

    if (info->num_results && info->last_time + gr->pane->period <= now) {
       double value;

       switch (info->result_type) {
       default:
       case PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE:
          value = info->results_cumulative / info->num_results;
          break;
       case PIPE_DRIVER_QUERY_RESULT_TYPE_CUMULATIVE:
          value = info->results_cumulative;
          break;
       }

       if (info->type == PIPE_DRIVER_QUERY_TYPE_FLOAT) {
          value /= 1000.0;
       }

       hud_graph_add_value(gr, value);

       info->last_time = now;
       info->results_cumulative = 0;
       info->num_results = 0;
    }
 }

 static void
 free_query_info(void *ptr, struct pipe_context *pipe)
 {
    struct query_info *info = ptr;

    if (!info->batch && info->last_time) {
       int i;

       pipe->end_query(pipe, info->query[info->head]);

       for (i = 0; i < ARRAY_SIZE(info->query); i++) {
          if (info->query[i]) {
             pipe->destroy_query(pipe, info->query[i]);
          }
       }
    }
    FREE(info);
 }


 /**
  * \param result_index  to select fields of pipe_query_data_pipeline_statistics,
  *                      for example.
  */
 void
 hud_pipe_query_install(struct hud_batch_query_context **pbq,
                        struct hud_pane *pane,
                        const char *name,
                        enum pipe_query_type query_type,
                        unsigned result_index,
                        uint64_t max_value, enum pipe_driver_query_type type,
                        enum pipe_driver_query_result_type result_type,
                        unsigned flags)
 {
    struct hud_graph *gr;
    struct query_info *info;

    gr = CALLOC_STRUCT(hud_graph);
    if (!gr)
       return;

    strncpy(gr->name, name, sizeof(gr->name));
    gr->name[sizeof(gr->name) - 1] = '\0';
    gr->query_data = CALLOC_STRUCT(query_info);
    if (!gr->query_data)
       goto fail_gr;

    gr->query_new_value = query_new_value;
    gr->free_query_data = free_query_info;

    info = gr->query_data;
    info->result_type = result_type;
    info->type = type;

    if (flags & PIPE_DRIVER_QUERY_FLAG_BATCH) {
       if (!batch_query_add(pbq, query_type, &info->result_index))
          goto fail_info;
       info->batch = *pbq;
    } else {
       gr->begin_query = begin_query;
       info->query_type = query_type;
       info->result_index = result_index;
    }

    hud_pane_add_graph(pane, gr);
    pane->type = type; /* must be set before updating the max_value */

    if (pane->max_value < max_value)
       hud_pane_set_max_value(pane, max_value);
    return;

 fail_info:
    FREE(info);
 fail_gr:
    FREE(gr);
 }

 boolean
 hud_driver_query_install(struct hud_batch_query_context **pbq,
                          struct hud_pane *pane, struct pipe_screen *screen,
                          const char *name)
 {
    struct pipe_driver_query_info query = { 0 };
    unsigned num_queries, i;
    boolean found = FALSE;

    if (!screen->get_driver_query_info)
       return FALSE;

    num_queries = screen->get_driver_query_info(screen, 0, NULL);

    for (i = 0; i < num_queries; i++) {
       if (screen->get_driver_query_info(screen, i, &query) &&
           strcmp(query.name, name) == 0) {
          found = TRUE;
          break;
       }
    }

    if (!found)
       return FALSE;

    hud_pipe_query_install(pbq, pane, query.name, query.query_type, 0,
                           query.max_value.u64, query.type, query.result_type,
                           query.flags);

    return TRUE;
 }
	/**************************************************************************
	*
	* Copyright 2013 Marek Olšák <maraeo@gmail.com>
	* All Rights Reserved.
	*
	* 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, sub license, 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 AUTHORS AND/OR ITS 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.
	*
	**************************************************************************/

	/* This file contains code for reading values from pipe queries
	* for displaying on the HUD. To prevent stalls when reading queries, we
	* keep a list of busy queries in a ring. We read only those queries which
	* are idle.
	*/

	#include "hud/hud_private.h"
	#include "pipe/p_screen.h"
	#include "util/os_time.h"
	#include "util/u_math.h"
	#include "util/u_memory.h"
	#include <stdio.h>

	// Must be a power of two
	#define NUM_QUERIES 8

	struct hud_batch_query_context {
	unsigned num_query_types;
	unsigned allocated_query_types;
	unsigned *query_types;

	boolean failed;
	struct pipe_query *query[NUM_QUERIES];
	union pipe_query_result *result[NUM_QUERIES];
	unsigned head, pending, results;
	};

	void
	hud_batch_query_update(struct hud_batch_query_context *bq,
	struct pipe_context *pipe)
	{
	if (!bq \|\| bq->failed)
	return;

	if (bq->query[bq->head])
	pipe->end_query(pipe, bq->query[bq->head]);

	bq->results = 0;

	while (bq->pending) {
	unsigned idx = (bq->head - bq->pending + 1) % NUM_QUERIES;
	struct pipe_query *query = bq->query[idx];

	if (!bq->result[idx])
	bq->result[idx] = MALLOC(sizeof(bq->result[idx]->batch[0]) *
	bq->num_query_types);
	if (!bq->result[idx]) {
	fprintf(stderr, "gallium_hud: out of memory.\n");
	bq->failed = TRUE;
	return;
	}

	if (!pipe->get_query_result(pipe, query, FALSE, bq->result[idx]))
	break;

	++bq->results;
	--bq->pending;
	}

	bq->head = (bq->head + 1) % NUM_QUERIES;

	if (bq->pending == NUM_QUERIES) {
	fprintf(stderr,
	"gallium_hud: all queries busy after %i frames, dropping data.\n",
	NUM_QUERIES);

	assert(bq->query[bq->head]);

	pipe->destroy_query(pipe, bq->query[bq->head]);
	bq->query[bq->head] = NULL;
	}

	++bq->pending;

	if (!bq->query[bq->head]) {
	bq->query[bq->head] = pipe->create_batch_query(pipe,
	bq->num_query_types,
	bq->query_types);

	if (!bq->query[bq->head]) {
	fprintf(stderr,
	"gallium_hud: create_batch_query failed. You may have "
	"selected too many or incompatible queries.\n");
	bq->failed = TRUE;
	return;
	}
	}
	}

	void
	hud_batch_query_begin(struct hud_batch_query_context *bq,
	struct pipe_context *pipe)
	{
	if (!bq \|\| bq->failed \|\| !bq->query[bq->head])
	return;

	if (!pipe->begin_query(pipe, bq->query[bq->head])) {
	fprintf(stderr,
	"gallium_hud: could not begin batch query. You may have "
	"selected too many or incompatible queries.\n");
	bq->failed = TRUE;
	}
	}

	static boolean
	batch_query_add(struct hud_batch_query_context **pbq,
	unsigned query_type, unsigned *result_index)
	{
	struct hud_batch_query_context bq = pbq;
	unsigned i;

	if (!bq) {
	bq = CALLOC_STRUCT(hud_batch_query_context);
	if (!bq)
	return false;
	*pbq = bq;
	}

	for (i = 0; i < bq->num_query_types; ++i) {
	if (bq->query_types[i] == query_type) {
	*result_index = i;
	return true;
	}
	}

	if (bq->num_query_types == bq->allocated_query_types) {
	unsigned new_alloc = MAX2(16, bq->allocated_query_types * 2);
	unsigned *new_query_types
	= REALLOC(bq->query_types,
	bq->allocated_query_types * sizeof(unsigned),
	new_alloc * sizeof(unsigned));
	if (!new_query_types)
	return false;
	bq->query_types = new_query_types;
	bq->allocated_query_types = new_alloc;
	}

	bq->query_types[bq->num_query_types] = query_type;
	*result_index = bq->num_query_types++;
	return true;
	}

	void
	hud_batch_query_cleanup(struct hud_batch_query_context **pbq,
	struct pipe_context *pipe)
	{
	struct hud_batch_query_context bq = pbq;
	unsigned idx;

	if (!bq)
	return;

	*pbq = NULL;

	if (bq->query[bq->head] && !bq->failed)
	pipe->end_query(pipe, bq->query[bq->head]);

	for (idx = 0; idx < NUM_QUERIES; ++idx) {
	if (bq->query[idx])
	pipe->destroy_query(pipe, bq->query[idx]);
	FREE(bq->result[idx]);
	}

	FREE(bq->query_types);
	FREE(bq);
	}

	struct query_info {
	struct hud_batch_query_context *batch;
	enum pipe_query_type query_type;

	/** index to choose fields in pipe_query_data_pipeline_statistics,
	* for example.
	*/
	unsigned result_index;
	enum pipe_driver_query_result_type result_type;
	enum pipe_driver_query_type type;

	/* Ring of queries. If a query is busy, we use another slot. */
	struct pipe_query *query[NUM_QUERIES];
	unsigned head, tail;

	uint64_t last_time;
	uint64_t results_cumulative;
	unsigned num_results;
	};

	static void
	query_new_value_batch(struct query_info *info)
	{
	struct hud_batch_query_context *bq = info->batch;
	unsigned result_index = info->result_index;
	unsigned idx = (bq->head - bq->pending) % NUM_QUERIES;
	unsigned results = bq->results;

	while (results) {
	info->results_cumulative += bq->result[idx]->batch[result_index].u64;
	++info->num_results;

	--results;
	idx = (idx - 1) % NUM_QUERIES;
	}
	}

	static void
	query_new_value_normal(struct query_info info, struct pipe_context pipe)
	{
	if (info->last_time) {
	if (info->query[info->head])
	pipe->end_query(pipe, info->query[info->head]);

	/* read query results */
	while (1) {
	struct pipe_query *query = info->query[info->tail];
	union pipe_query_result result;
	uint64_t res64 = (uint64_t )&result;

	if (query && pipe->get_query_result(pipe, query, FALSE, &result)) {
	if (info->type == PIPE_DRIVER_QUERY_TYPE_FLOAT) {
	assert(info->result_index == 0);
	info->results_cumulative += (uint64_t) (result.f * 1000.0f);
	}
	else {
	info->results_cumulative += res64[info->result_index];
	}
	info->num_results++;

	if (info->tail == info->head)
	break;

	info->tail = (info->tail+1) % NUM_QUERIES;
	}
	else {
	/* the oldest query is busy */
	if ((info->head+1) % NUM_QUERIES == info->tail) {
	/* all queries are busy, throw away the last query and create
	* a new one */
	fprintf(stderr,
	"gallium_hud: all queries are busy after %i frames, "
	"can't add another query\n",
	NUM_QUERIES);
	if (info->query[info->head])
	pipe->destroy_query(pipe, info->query[info->head]);
	info->query[info->head] =
	pipe->create_query(pipe, info->query_type, 0);
	}
	else {
	/* the last query is busy, we need to add a new one we can use
	* for this frame */
	info->head = (info->head+1) % NUM_QUERIES;
	if (!info->query[info->head]) {
	info->query[info->head] =
	pipe->create_query(pipe, info->query_type, 0);
	}
	}
	break;
	}
	}
	}
	else {
	/* initialize */
	info->query[info->head] = pipe->create_query(pipe, info->query_type, 0);
	}
	}

	static void
	begin_query(struct hud_graph gr, struct pipe_context pipe)
	{
	struct query_info *info = gr->query_data;

	assert(!info->batch);
	if (info->query[info->head])
	pipe->begin_query(pipe, info->query[info->head]);
	}

	static void
	query_new_value(struct hud_graph gr, struct pipe_context pipe)
	{
	struct query_info *info = gr->query_data;
	uint64_t now = os_time_get();

	if (info->batch) {
	query_new_value_batch(info);
	} else {
	query_new_value_normal(info, pipe);
	}

	if (!info->last_time) {
	info->last_time = now;
	return;
	}

	if (info->num_results && info->last_time + gr->pane->period <= now) {
	double value;

	switch (info->result_type) {
	default:
	case PIPE_DRIVER_QUERY_RESULT_TYPE_AVERAGE:
	value = info->results_cumulative / info->num_results;
	break;
	case PIPE_DRIVER_QUERY_RESULT_TYPE_CUMULATIVE:
	value = info->results_cumulative;
	break;
	}

	if (info->type == PIPE_DRIVER_QUERY_TYPE_FLOAT) {
	value /= 1000.0;
	}

	hud_graph_add_value(gr, value);

	info->last_time = now;
	info->results_cumulative = 0;
	info->num_results = 0;
	}
	}

	static void
	free_query_info(void ptr, struct pipe_context pipe)
	{
	struct query_info *info = ptr;

	if (!info->batch && info->last_time) {
	int i;

	pipe->end_query(pipe, info->query[info->head]);

	for (i = 0; i < ARRAY_SIZE(info->query); i++) {
	if (info->query[i]) {
	pipe->destroy_query(pipe, info->query[i]);
	}
	}
	}
	FREE(info);
	}


	/**
	* \param result_index to select fields of pipe_query_data_pipeline_statistics,
	* for example.
	*/
	void
	hud_pipe_query_install(struct hud_batch_query_context **pbq,
	struct hud_pane *pane,
	const char *name,
	enum pipe_query_type query_type,
	unsigned result_index,
	uint64_t max_value, enum pipe_driver_query_type type,
	enum pipe_driver_query_result_type result_type,
	unsigned flags)
	{
	struct hud_graph *gr;
	struct query_info *info;

	gr = CALLOC_STRUCT(hud_graph);
	if (!gr)
	return;

	strncpy(gr->name, name, sizeof(gr->name));
	gr->name[sizeof(gr->name) - 1] = '\0';
	gr->query_data = CALLOC_STRUCT(query_info);
	if (!gr->query_data)
	goto fail_gr;

	gr->query_new_value = query_new_value;
	gr->free_query_data = free_query_info;

	info = gr->query_data;
	info->result_type = result_type;
	info->type = type;

	if (flags & PIPE_DRIVER_QUERY_FLAG_BATCH) {
	if (!batch_query_add(pbq, query_type, &info->result_index))
	goto fail_info;
	info->batch = *pbq;
	} else {
	gr->begin_query = begin_query;
	info->query_type = query_type;
	info->result_index = result_index;
	}

	hud_pane_add_graph(pane, gr);
	pane->type = type; /* must be set before updating the max_value */

	if (pane->max_value < max_value)
	hud_pane_set_max_value(pane, max_value);
	return;

	fail_info:
	FREE(info);
	fail_gr:
	FREE(gr);
	}

	boolean
	hud_driver_query_install(struct hud_batch_query_context **pbq,
	struct hud_pane pane, struct pipe_screen screen,
	const char *name)
	{
	struct pipe_driver_query_info query = { 0 };
	unsigned num_queries, i;
	boolean found = FALSE;

	if (!screen->get_driver_query_info)
	return FALSE;

	num_queries = screen->get_driver_query_info(screen, 0, NULL);

	for (i = 0; i < num_queries; i++) {
	if (screen->get_driver_query_info(screen, i, &query) &&
	strcmp(query.name, name) == 0) {
	found = TRUE;
	break;
	}
	}

	if (!found)
	return FALSE;

	hud_pipe_query_install(pbq, pane, query.name, query.query_type, 0,
	query.max_value.u64, query.type, query.result_type,
	query.flags);

	return TRUE;
	}