GLuint *n_active)
{
struct brw_context *brw = brw_context(ctx);
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
const struct gen_perf_query_info *query =
- &brw->perf_ctx.perf->queries[query_index];
+ &perf_ctx->perf->queries[query_index];
*name = query->name;
*data_size = query->data_size;
switch (query->kind) {
case GEN_PERF_QUERY_TYPE_OA:
case GEN_PERF_QUERY_TYPE_RAW:
- *n_active = brw->perf_ctx.n_active_oa_queries;
+ *n_active = perf_ctx->n_active_oa_queries;
break;
case GEN_PERF_QUERY_TYPE_PIPELINE:
- *n_active = brw->perf_ctx.n_active_pipeline_stats_queries;
+ *n_active = perf_ctx->n_active_pipeline_stats_queries;
break;
default:
add_to_unaccumulated_query_list(struct brw_context *brw,
struct gen_perf_query_object *obj)
{
- if (brw->perf_ctx.unaccumulated_elements >=
- brw->perf_ctx.unaccumulated_array_size)
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ if (perf_ctx->unaccumulated_elements >=
+ perf_ctx->unaccumulated_array_size)
{
- brw->perf_ctx.unaccumulated_array_size *= 1.5;
- brw->perf_ctx.unaccumulated =
- reralloc(brw, brw->perf_ctx.unaccumulated,
+ perf_ctx->unaccumulated_array_size *= 1.5;
+ perf_ctx->unaccumulated =
+ reralloc(brw, perf_ctx->unaccumulated,
struct gen_perf_query_object *,
- brw->perf_ctx.unaccumulated_array_size);
+ perf_ctx->unaccumulated_array_size);
}
- brw->perf_ctx.unaccumulated[brw->perf_ctx.unaccumulated_elements++] = obj;
+ perf_ctx->unaccumulated[perf_ctx->unaccumulated_elements++] = obj;
}
/**
drop_from_unaccumulated_query_list(struct brw_context *brw,
struct gen_perf_query_object *obj)
{
- for (int i = 0; i < brw->perf_ctx.unaccumulated_elements; i++) {
- if (brw->perf_ctx.unaccumulated[i] == obj) {
- int last_elt = --brw->perf_ctx.unaccumulated_elements;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ for (int i = 0; i < perf_ctx->unaccumulated_elements; i++) {
+ if (perf_ctx->unaccumulated[i] == obj) {
+ int last_elt = --perf_ctx->unaccumulated_elements;
if (i == last_elt)
- brw->perf_ctx.unaccumulated[i] = NULL;
+ perf_ctx->unaccumulated[i] = NULL;
else {
- brw->perf_ctx.unaccumulated[i] =
- brw->perf_ctx.unaccumulated[last_elt];
+ perf_ctx->unaccumulated[i] =
+ perf_ctx->unaccumulated[last_elt];
}
break;
static bool
inc_n_oa_users(struct brw_context *brw)
{
- if (brw->perf_ctx.n_oa_users == 0 &&
- drmIoctl(brw->perf_ctx.oa_stream_fd,
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ if (perf_ctx->n_oa_users == 0 &&
+ drmIoctl(perf_ctx->oa_stream_fd,
I915_PERF_IOCTL_ENABLE, 0) < 0)
{
return false;
}
- ++brw->perf_ctx.n_oa_users;
+ ++perf_ctx->n_oa_users;
return true;
}
* MI_RPC commands at this point since they could stall the CS
* indefinitely once OACONTROL is disabled.
*/
- --brw->perf_ctx.n_oa_users;
- if (brw->perf_ctx.n_oa_users == 0 &&
- drmIoctl(brw->perf_ctx.oa_stream_fd, I915_PERF_IOCTL_DISABLE, 0) < 0)
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ --perf_ctx->n_oa_users;
+ if (perf_ctx->n_oa_users == 0 &&
+ drmIoctl(perf_ctx->oa_stream_fd, I915_PERF_IOCTL_DISABLE, 0) < 0)
{
DBG("WARNING: Error disabling i915 perf stream: %m\n");
}
static void
discard_all_queries(struct brw_context *brw)
{
- while (brw->perf_ctx.unaccumulated_elements) {
- struct gen_perf_query_object *obj = brw->perf_ctx.unaccumulated[0];
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ while (perf_ctx->unaccumulated_elements) {
+ struct gen_perf_query_object *obj = perf_ctx->unaccumulated[0];
obj->oa.results_accumulated = true;
- drop_from_unaccumulated_query_list(brw, brw->perf_ctx.unaccumulated[0]);
+ drop_from_unaccumulated_query_list(brw, perf_ctx->unaccumulated[0]);
dec_n_oa_users(brw);
}
uint32_t start_timestamp,
uint32_t end_timestamp)
{
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
struct exec_node *tail_node =
- exec_list_get_tail(&brw->perf_ctx.sample_buffers);
+ exec_list_get_tail(&perf_ctx->sample_buffers);
struct oa_sample_buf *tail_buf =
exec_node_data(struct oa_sample_buf, tail_node, link);
uint32_t last_timestamp = tail_buf->last_timestamp;
while (1) {
- struct oa_sample_buf *buf = gen_perf_get_free_sample_buf(&brw->perf_ctx);
+ struct oa_sample_buf *buf = gen_perf_get_free_sample_buf(perf_ctx);
uint32_t offset;
int len;
- while ((len = read(brw->perf_ctx.oa_stream_fd, buf->buf,
+ while ((len = read(perf_ctx->oa_stream_fd, buf->buf,
sizeof(buf->buf))) < 0 && errno == EINTR)
;
if (len <= 0) {
- exec_list_push_tail(&brw->perf_ctx.free_sample_buffers, &buf->link);
+ exec_list_push_tail(&perf_ctx->free_sample_buffers, &buf->link);
if (len < 0) {
if (errno == EAGAIN)
}
buf->len = len;
- exec_list_push_tail(&brw->perf_ctx.sample_buffers, &buf->link);
+ exec_list_push_tail(&perf_ctx->sample_buffers, &buf->link);
/* Go through the reports and update the last timestamp. */
offset = 0;
/* See if we have any periodic reports to accumulate too... */
/* N.B. The oa.samples_head was set when the query began and
- * pointed to the tail of the brw->perf_ctx.sample_buffers list at
+ * pointed to the tail of the perf_ctx->sample_buffers list at
* the time the query started. Since the buffer existed before the
* first MI_REPORT_PERF_COUNT command was emitted we therefore know
* that no data in this particular node's buffer can possibly be
return false;
}
- brw->perf_ctx.oa_stream_fd = fd;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ perf_ctx->oa_stream_fd = fd;
- brw->perf_ctx.current_oa_metrics_set_id = metrics_set_id;
- brw->perf_ctx.current_oa_format = report_format;
+ perf_ctx->current_oa_metrics_set_id = metrics_set_id;
+ perf_ctx->current_oa_format = report_format;
return true;
}
close_perf(struct brw_context *brw,
const struct gen_perf_query_info *query)
{
- if (brw->perf_ctx.oa_stream_fd != -1) {
- close(brw->perf_ctx.oa_stream_fd);
- brw->perf_ctx.oa_stream_fd = -1;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ if (perf_ctx->oa_stream_fd != -1) {
+ close(perf_ctx->oa_stream_fd);
+ perf_ctx->oa_stream_fd = -1;
}
if (query->kind == GEN_PERF_QUERY_TYPE_RAW) {
struct gen_perf_query_info *raw_query =
struct brw_perf_query_object *brw_query = brw_perf_query(o);
struct gen_perf_query_object *obj = brw_query->query;
const struct gen_perf_query_info *query = obj->queryinfo;
- struct gen_perf_config *perf_cfg = brw->perf_ctx.perf;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ struct gen_perf_config *perf_cfg = perf_ctx->perf;
/* We can assume the frontend hides mistaken attempts to Begin a
* query object multiple times before its End. Similarly if an
* require a different counter set or format unless we get an opportunity
* to close the stream and open a new one...
*/
- uint64_t metric_id = gen_perf_query_get_metric_id(brw->perf_ctx.perf, query);
+ uint64_t metric_id = gen_perf_query_get_metric_id(perf_ctx->perf, query);
- if (brw->perf_ctx.oa_stream_fd != -1 &&
- brw->perf_ctx.current_oa_metrics_set_id != metric_id) {
+ if (perf_ctx->oa_stream_fd != -1 &&
+ perf_ctx->current_oa_metrics_set_id != metric_id) {
- if (brw->perf_ctx.n_oa_users != 0) {
+ if (perf_ctx->n_oa_users != 0) {
DBG("WARNING: Begin(%d) failed already using perf config=%i/%"PRIu64"\n",
- o->Id, brw->perf_ctx.current_oa_metrics_set_id, metric_id);
+ o->Id, perf_ctx->current_oa_metrics_set_id, metric_id);
return false;
} else
close_perf(brw, query);
}
/* If the OA counters aren't already on, enable them. */
- if (brw->perf_ctx.oa_stream_fd == -1) {
+
+ if (perf_ctx->oa_stream_fd == -1) {
__DRIscreen *screen = brw->screen->driScrnPriv;
const struct gen_device_info *devinfo = &brw->screen->devinfo;
a_counter_in_bits = 40;
uint64_t overflow_period = pow(2, a_counter_in_bits) /
- (brw->perf_ctx.perf->sys_vars.n_eus *
+ (perf_cfg->sys_vars.n_eus *
/* drop 1GHz freq to have units in nanoseconds */
2);
DBG("A counter overflow period: %"PRIu64"ns, %"PRIu64"ms (n_eus=%"PRIu64")\n",
- overflow_period, overflow_period / 1000000ul, brw->perf_ctx.perf->sys_vars.n_eus);
+ overflow_period, overflow_period / 1000000ul, perf_cfg->sys_vars.n_eus);
int period_exponent = 0;
uint64_t prev_sample_period, next_sample_period;
brw->hw_ctx))
return false;
} else {
- assert(brw->perf_ctx.current_oa_metrics_set_id == metric_id &&
- brw->perf_ctx.current_oa_format == query->oa_format);
+ assert(perf_ctx->current_oa_metrics_set_id == metric_id &&
+ perf_ctx->current_oa_format == query->oa_format);
}
if (!inc_n_oa_users(brw)) {
}
if (obj->oa.bo) {
- brw->perf_ctx.perf->vtbl.bo_unreference(obj->oa.bo);
+ perf_cfg->vtbl.bo_unreference(obj->oa.bo);
obj->oa.bo = NULL;
}
brw_bo_unmap(obj->oa.bo);
#endif
- obj->oa.begin_report_id = brw->perf_ctx.next_query_start_report_id;
- brw->perf_ctx.next_query_start_report_id += 2;
+ obj->oa.begin_report_id = perf_ctx->next_query_start_report_id;
+ perf_ctx->next_query_start_report_id += 2;
/* We flush the batchbuffer here to minimize the chances that MI_RPC
* delimiting commands end up in different batchbuffers. If that's the
perf_cfg->vtbl.batchbuffer_flush(brw, __FILE__, __LINE__);
/* Take a starting OA counter snapshot. */
- brw->perf_ctx.perf->vtbl.emit_mi_report_perf_count(brw, obj->oa.bo, 0,
- obj->oa.begin_report_id);
+ perf_cfg->vtbl.emit_mi_report_perf_count(brw, obj->oa.bo, 0,
+ obj->oa.begin_report_id);
perf_cfg->vtbl.capture_frequency_stat_register(brw, obj->oa.bo,
MI_FREQ_START_OFFSET_BYTES);
- ++brw->perf_ctx.n_active_oa_queries;
+ ++perf_ctx->n_active_oa_queries;
/* No already-buffered samples can possibly be associated with this query
* so create a marker within the list of sample buffers enabling us to
* easily ignore earlier samples when processing this query after
* completion.
*/
- assert(!exec_list_is_empty(&brw->perf_ctx.sample_buffers));
- obj->oa.samples_head = exec_list_get_tail(&brw->perf_ctx.sample_buffers);
+ assert(!exec_list_is_empty(&perf_ctx->sample_buffers));
+ obj->oa.samples_head = exec_list_get_tail(&perf_ctx->sample_buffers);
struct oa_sample_buf *buf =
exec_node_data(struct oa_sample_buf, obj->oa.samples_head, link);
/* Take starting snapshots. */
gen_perf_snapshot_statistics_registers(brw, perf_cfg, obj, 0);
- ++brw->perf_ctx.n_active_pipeline_stats_queries;
+ ++perf_ctx->n_active_pipeline_stats_queries;
break;
default:
struct brw_perf_query_object *brw_query = brw_perf_query(o);
struct gen_perf_query_object *obj = brw_query->query;
struct gen_perf_config *perf_cfg = brw->perf_ctx.perf;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
DBG("End(%d)\n", o->Id);
obj->oa.begin_report_id + 1);
}
- --brw->perf_ctx.n_active_oa_queries;
+ --perf_ctx->n_active_oa_queries;
/* NB: even though the query has now ended, it can't be accumulated
* until the end MI_REPORT_PERF_COUNT snapshot has been written
case GEN_PERF_QUERY_TYPE_PIPELINE:
gen_perf_snapshot_statistics_registers(brw, perf_cfg, obj,
STATS_BO_END_OFFSET_BYTES);
- --brw->perf_ctx.n_active_pipeline_stats_queries;
+ --perf_ctx->n_active_pipeline_stats_queries;
break;
default:
brw_new_perf_query_object(struct gl_context *ctx, unsigned query_index)
{
struct brw_context *brw = brw_context(ctx);
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
const struct gen_perf_query_info *queryinfo =
- &brw->perf_ctx.perf->queries[query_index];
+ &perf_ctx->perf->queries[query_index];
struct gen_perf_query_object *obj =
calloc(1, sizeof(struct gen_perf_query_object));
obj->queryinfo = queryinfo;
- brw->perf_ctx.n_query_instances++;
+ perf_ctx->n_query_instances++;
struct brw_perf_query_object *brw_query = calloc(1, sizeof(struct brw_perf_query_object));
if (unlikely(!brw_query))
struct gen_perf_config *perf_cfg = brw->perf_ctx.perf;
struct brw_perf_query_object *brw_query = brw_perf_query(o);
struct gen_perf_query_object *obj = brw_query->query;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
/* We can assume that the frontend waits for a query to complete
* before ever calling into here, so we don't have to worry about
* longer in use, it's a good time to free our cache of sample
* buffers and close any current i915-perf stream.
*/
- if (--brw->perf_ctx.n_query_instances == 0) {
- gen_perf_free_sample_bufs(&brw->perf_ctx);
+ if (--perf_ctx->n_query_instances == 0) {
+ gen_perf_free_sample_bufs(perf_ctx);
close_perf(brw, obj->queryinfo);
}
const struct gen_device_info *devinfo = &brw->screen->devinfo;
__DRIscreen *screen = brw->screen->driScrnPriv;
- struct gen_perf_config *perf_cfg = brw->perf_ctx.perf;
- if (perf_cfg)
- return perf_cfg->n_queries;
+ struct gen_perf_context *perf_ctx = &brw->perf_ctx;
+ if (perf_ctx->perf)
+ return perf_ctx->perf->n_queries;
+
+ perf_ctx->perf = gen_perf_new(brw);
+ struct gen_perf_config *perf_cfg = perf_ctx->perf;
- perf_cfg = gen_perf_new(brw);
- brw->perf_ctx.perf = perf_cfg;
perf_cfg->vtbl.bo_alloc = brw_oa_bo_alloc;
perf_cfg->vtbl.bo_unreference = (bo_unreference_t)brw_bo_unreference;
perf_cfg->vtbl.emit_mi_report_perf_count =
if ((oa_metrics_kernel_support(screen->fd, devinfo)) &&
(gen_perf_load_oa_metrics(perf_cfg, screen->fd, devinfo)))
- gen_perf_query_register_mdapi_oa_query(&brw->screen->devinfo,
- brw->perf_ctx.perf);
+ gen_perf_query_register_mdapi_oa_query(devinfo, perf_cfg);
- brw->perf_ctx.unaccumulated =
+ perf_ctx->unaccumulated =
ralloc_array(brw, struct gen_perf_query_object *, 2);
- brw->perf_ctx.unaccumulated_elements = 0;
- brw->perf_ctx.unaccumulated_array_size = 2;
+ perf_ctx->unaccumulated_elements = 0;
+ perf_ctx->unaccumulated_array_size = 2;
- exec_list_make_empty(&brw->perf_ctx.sample_buffers);
- exec_list_make_empty(&brw->perf_ctx.free_sample_buffers);
+ exec_list_make_empty(&perf_ctx->sample_buffers);
+ exec_list_make_empty(&perf_ctx->free_sample_buffers);
/* It's convenient to guarantee that this linked list of sample
* buffers is never empty so we add an empty head so when we
* in this list.
*/
struct oa_sample_buf *buf = gen_perf_get_free_sample_buf(&brw->perf_ctx);
- exec_list_push_head(&brw->perf_ctx.sample_buffers, &buf->link);
+ exec_list_push_head(&perf_ctx->sample_buffers, &buf->link);
- brw->perf_ctx.oa_stream_fd = -1;
+ perf_ctx->oa_stream_fd = -1;
- brw->perf_ctx.next_query_start_report_id = 1000;
+ perf_ctx->next_query_start_report_id = 1000;
return perf_cfg->n_queries;
}
projects / mesa.git / commitdiff