[igt-dev] [PATCH i-g-t v6] tools: Add an intel_dbuf_map tool

* [igt-dev] [PATCH i-g-t v6] tools: Add an intel_dbuf_map tool
@ 2020-01-20 12:39 Stanislav Lisovskiy
  2020-01-20 22:51 ` [igt-dev] ✓ Fi.CI.BAT: success for tools: Add an intel_dbuf_map tool (rev5) Patchwork
  2020-01-21  7:14 ` [igt-dev] ✓ Fi.CI.IGT: " Patchwork
  0 siblings, 2 replies; 3+ messages in thread
From: Stanislav Lisovskiy @ 2020-01-20 12:39 UTC (permalink / raw)
  To: igt-dev; +Cc: martin.peres, juha-pekka.heikkila

As in modern platforms more Display buffer
slices/pipes are coming, which have different
pipe affinities and other constraints, so BSpec
contains their connection in form of a Graph.

So we can generate optimal DBuf assignment,
from the graph which we have in BSpec, to avoid
manual calculations prone to human error and
copy-pasting. The generated table is in C form
and can be used in i915 driver rightaway and also
for verification.

v2: Removed unused i, j, made some functions static,
    to make CI checkers a bit happier. Also had to
    change IGT_LIST to IGT_LIST_HEAD and other stuff,
    as functions seem to be renamed in latest master.

v3: Added command line arguments "--graph" and
    "slices_per_pipe" which allow to define and
    get DBuf assignment from graph without recompiling
    the tool, but right away.
    Example usage:
    intel_dbuf_map --graph PIPE_A-DBUF_S1-DBUF_S2-PIPE_B-PIPE_C --slices_per_pipe 2

    Generates output:
    Graph:
    Type PIPE id 0
        (1)->
             Type DBUF_SLICE id 0
                (1)->
                    Type DBUF_SLICE id 1
                        (1)->
                            Type PIPE id 1
                                (1)->
                                    Type PIPE id 2
    Combination with least weight 3(total combinations 1):
    { BIT(PIPE_A), { DBUF_S1_BIT | DBUF_S2_BIT, 0, 0, 0 } },
    Combination with least weight 3(total combinations 1):
    { BIT(PIPE_B), { 0, DBUF_S2_BIT | DBUF_S1_BIT, 0, 0 } },
    Combination with least weight 2(total combinations 2):
    { BIT(PIPE_A) | BIT(PIPE_B), { DBUF_S1_BIT, DBUF_S2_BIT, 0, 0 } },
    Combination with least weight 5(total combinations 1):
    { BIT(PIPE_C), { 0, 0, DBUF_S2_BIT | DBUF_S1_BIT, 0 } },
    Combination with least weight 3(total combinations 2):
    { BIT(PIPE_A) | BIT(PIPE_C), { DBUF_S1_BIT, 0, DBUF_S2_BIT, 0 } },
    Combination with least weight 4(total combinations 2):
    { BIT(PIPE_B) | BIT(PIPE_C), { 0, DBUF_S2_BIT, DBUF_S1_BIT, 0 } },
    Combination with least weight 4(total combinations 6):
    { BIT(PIPE_A) | BIT(PIPE_B) | BIT(PIPE_C), { DBUF_S1_BIT, DBUF_S2_BIT, DBUF_S2_BIT, 0 } },

v4: - Minor refactoring, simplified algorithm, removed redundant list
      usage
    - Fixed title
    - Added debug option
    - Removed unneeded ARRAY_SIZE definition, which already exists
      (Juha-Pekka Heikkilä)

v5: - Switched to named pipe array initialization, to match current
      kernel code.
    - Minor code refactoring.

v6: - Switched to named initializer for dbuf_mask field.

Signed-off-by: Stanislav Lisovskiy <stanislav.lisovskiy@intel.com>
Cc: Ville Syrjälä <ville.syrjala@linux.intel.com>
---
 tools/intel_dbuf_map.c | 885 +++++++++++++++++++++++++++++++++++++++++
 tools/meson.build      |   1 +
 2 files changed, 886 insertions(+)
 create mode 100644 tools/intel_dbuf_map.c

diff --git a/tools/intel_dbuf_map.c b/tools/intel_dbuf_map.c
new file mode 100644
index 00000000..ee4cdbb3
--- /dev/null
+++ b/tools/intel_dbuf_map.c
@@ -0,0 +1,885 @@
+/*
+ * Copyright © 2019 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.
+ *
+ * Authors:
+ *    Stanislav Lisovskiy <stanislav.lisovskiy@intel.com>
+ *
+ */
+
+#include <stdlib.h>
+#include "igt.h"
+
+enum NodeType {
+	DBUF_SLICE,
+	PIPE
+};
+
+const char *node_type_to_str[] = { "DBUF_SLICE", "PIPE" };
+
+#define MAX_CONNECTIONS 10
+#define MAX_NODES 10
+#define MAX_EDGES (MAX_NODES * 2)
+
+struct GraphEdge;
+
+/*
+ * Graph node, which can be DBuf or Pipe
+ */
+struct GraphNode {
+	int id;
+	enum NodeType type;
+	unsigned int use_count;
+	int visited;
+	struct GraphEdge *connections[MAX_CONNECTIONS];
+	int num_connections;
+};
+
+static struct GraphNode *all_nodes[MAX_NODES];
+static struct GraphEdge *all_edges[MAX_EDGES];
+static int num_nodes;
+static int num_edges;
+
+/*
+ * Graph edge, which connects Graph nodes
+ * and has a weight property.
+ */
+struct GraphEdge {
+	unsigned int weight;
+	struct GraphNode *node;
+};
+
+static struct GraphNode *create_graph_node(enum NodeType type, int id)
+{
+	struct GraphNode *node = 0;
+
+	if (num_nodes >= MAX_NODES) {
+		igt_info("Too much nodes %d", num_nodes);
+		return NULL;
+	}
+
+	node = malloc(sizeof(struct GraphNode));
+	node->type = type;
+	node->id = id;
+	node->use_count = 0;
+	node->visited = 0;
+	memset(node->connections, 0,
+			MAX_CONNECTIONS * sizeof(struct GraphEdge *));
+	node->num_connections = 0;
+
+	all_nodes[num_nodes] = node;
+	num_nodes++;
+
+	return node;
+}
+
+static struct GraphEdge *create_graph_edge(int weight, struct GraphNode *node)
+{
+	struct GraphEdge *edge = 0;
+
+	if (num_edges >= MAX_EDGES) {
+		igt_info("Too much edges %d", num_edges);
+		return NULL;
+	}
+
+	edge = malloc(sizeof(struct GraphEdge));
+
+	edge->node = node;
+	edge->weight = weight;
+
+	all_edges[num_edges] = edge;
+	num_edges++;
+
+	return edge;
+}
+
+static void connect_nodes(struct GraphNode *node1, struct GraphNode *node2, int weight)
+{
+	struct GraphEdge *edge1;
+	struct GraphEdge *edge2;
+
+	if (node1->num_connections >= MAX_CONNECTIONS) {
+		igt_info("Node %d has too much connections\n", node1->id);
+		return;
+	}
+
+	if (node2->num_connections >= MAX_CONNECTIONS) {
+		igt_info("Node %d has too much connections\n", node2->id);
+		return;
+	}
+
+	edge1 = create_graph_edge(weight, node1);
+	edge2 = create_graph_edge(weight, node2);
+
+	node1->connections[node1->num_connections] = edge2;
+	node1->num_connections++;
+	node2->connections[node2->num_connections] = edge1;
+	node2->num_connections++;
+}
+
+static void reset_node(struct GraphNode *node)
+{
+	node->use_count = 0;
+	node->visited = 0;
+	memset(node->connections, 0,
+		MAX_CONNECTIONS * sizeof(struct GraphEdge *));
+	node->num_connections = 0;
+}
+
+static void destroy_node(struct GraphNode *node)
+{
+	free(node);
+}
+
+static void destroy_edge(struct GraphEdge *edge)
+{
+	free(edge);
+}
+
+static void destroy_all_edges(void)
+{
+	int i;
+
+	for (i = 0; i < num_edges; i++) {
+		destroy_edge(all_edges[i]);
+	}
+	num_edges = 0;
+}
+
+static void destroy_all_nodes(void)
+{
+	int i;
+
+	for (i = 0; i < num_nodes; i++) {
+		destroy_node(all_nodes[i]);
+	}
+	num_nodes = 0;
+}
+
+static void reset_all_nodes(void)
+{
+	int i;
+
+	destroy_all_edges();
+
+	for (i = 0; i < num_nodes; i++) {
+		reset_node(all_nodes[i]);
+	}
+}
+
+/*
+ * Traverse and try to print graph in a
+ * somewhat graphical form.
+ */
+static void traverse_graph(struct GraphNode *start_node,
+			   int depth)
+{
+	int i, space;
+
+	if (!depth)
+		igt_info("Graph: \n");
+
+	for (space = 0; space < depth * 4; space++)
+		igt_info(" ");
+
+	start_node->visited++;
+	igt_info("Type %s id %d\n", node_type_to_str[start_node->type],
+		 start_node->id);
+	for (i = 0; i < start_node->num_connections; i++) {
+		if (!start_node->connections[i]->node->visited) {
+			for (space = 0; space < (depth + 1) * 4; space++)
+				igt_info(" ");
+			igt_info("(%d)-> \n", start_node->connections[i]->weight);
+			traverse_graph(start_node->connections[i]->node, depth+2);
+			start_node->connections[i]->node->visited--;
+		}
+	}
+}
+
+bool debug = false;
+
+static void print_node_debug(struct GraphNode *node)
+{
+	igt_info("%s node %d visited %d use count %d\n",
+		 node_type_to_str[node->type], node->id,
+		 node->visited,
+		 node->use_count);
+}
+
+/*
+ * This function recursively searches for a free DBuf slice
+ * for correspondent pipe, based on different constraints, like
+ * weight, usage count. This algorithm is "greedy" which means
+ * that it accounts for local optimum only, which means that
+ * total comparison has to be done in the end.
+ * In graph theory this is called breadth-first search.
+ * As this algorithm tries to utilize nearest neighbours first
+ * it allows to skip many unrequired path calculations which
+ * would be needed if we really would build a matrix like:
+ *   Pipe - DBUF
+ *         0    1
+ *   0     1    2
+ *
+ *   1     2    1
+ * Then we would have to go thourgh all N Dbuf * N Pipes * N Pipes!
+ * to check all possible pipe accomodations.
+ * For above matrix the algorithm would immediately return slice 0
+ * for pipe 0 and slice 1 for pipe 1 as nearest neighbours, skipping
+ * unneccessary paths for pipe0 - slice1, pipe1 - slice0.
+ * Anyway for more complex cases, like:
+ *  Pipe - DBUF
+ *         0    1
+ *   0     1    1
+ *
+ *   1     2    1
+ * checking for all possible accomodations is still needed. However
+ * nearest "greedy" approach first still allows to filter out some of
+ * the redundant combinations, which would be seen if full matrix is built.
+ * Instead we save time by just choosing the nearest ones first which
+ * are expected to have lower cost(greedy approach), however then
+ * we will still check all possible accomodations as we would do with
+ * full matrix approach.
+ */
+static struct GraphNode *find_slice_for_pipe(struct GraphNode *start_node,
+					     int acc_weight, int max_use_count,
+					     unsigned int *total_weight,
+					     int depth,
+					     int *skip)
+{
+	int i;
+	struct GraphNode *node = NULL;
+
+	if (debug) {
+		igt_info("Entering node(resursion depth %d skips %d): \n",
+			 depth, *skip);
+		print_node_debug(start_node);
+		igt_info("Accumulated weight %d max use count %d\n",
+			 acc_weight, max_use_count);
+	}
+
+	start_node->visited++;
+
+	/*
+	 * Iterate through neighbouring slices(graph breadth-first search),
+	 * checking if it's use count allows usage and skip if needed,
+	 * skips are needed when we use multiple slices for
+	 * same pipe to prevent algorithm from returning the
+	 * same DBuf.
+	 */
+	for (i = 0; i < start_node->num_connections; i++) {
+		struct GraphEdge *cur_edge = start_node->connections[i];
+
+		if (debug) {
+			igt_info("    Neighbour node: ");
+			print_node_debug(cur_edge->node);
+		}
+
+		if (cur_edge->node->type != DBUF_SLICE)
+			continue;
+
+		if (cur_edge->node->use_count < max_use_count) {
+			if (!(*skip)) {
+				cur_edge->node->use_count++;
+				*total_weight = acc_weight + cur_edge->weight;
+				node = cur_edge->node;
+				goto out;
+			}
+		}
+
+		if (*skip)
+			(*skip)--;
+	}
+
+	/*
+	 * If couldn't find suitable DBuf node from our
+	 * neighbours, have to continue further, checking
+	 * visited flag, to prevent loops.
+	 */
+	for (i = 0; i < start_node->num_connections; i++) {
+		struct GraphEdge *cur_edge = start_node->connections[i];
+
+		if (cur_edge->node->visited)
+			continue;
+
+		node = find_slice_for_pipe(cur_edge->node,
+					   acc_weight + cur_edge->weight,
+					   max_use_count, total_weight,
+					   depth + 1, skip);
+		cur_edge->node->visited--;
+		if (node)
+			goto out;
+	}
+
+out:
+	if (debug)
+		igt_info("Leaving node %d\n", start_node->id);
+
+	/* If we are at recursion depth 0 - release the root node */
+	if (depth == 0)
+		start_node->visited = 0;
+
+	return node;
+}
+
+static int hweight32(int mask)
+{
+	int i;
+	int count = 0;
+
+	for (i = 0; i < 32; i++)
+		if ((1<<i) & mask)
+			count += 1;
+	return count;
+}
+
+#define I915_MAX_PIPES 4
+#define I915_MAX_SLICES_PER_PIPE 4
+#define I915_MAX_SLICES (I915_MAX_PIPES * I915_MAX_SLICES_PER_PIPE)
+
+const char *pipe_names[] = { "PIPE_A", "PIPE_B", "PIPE_C", "PIPE_D" };
+const char *slice_names[] = { "DBUF_S1", "DBUF_S2", "DBUF_S3", "DBUF_S4" };
+
+static int factorial(int n)
+{
+	if (n <= 1)
+		return 1;
+	return n * factorial(n - 1);
+}
+
+static void do_swap(struct GraphNode **pipe_nodes, int m, int n)
+{
+	*((unsigned long *)pipe_nodes + m) ^= *((unsigned long *)pipe_nodes + n);
+	*((unsigned long *)pipe_nodes + n) ^= *((unsigned long *)pipe_nodes + m);
+	*((unsigned long *)pipe_nodes + m) ^= *((unsigned long *)pipe_nodes + n);
+}
+
+struct PipeNodesCombination {
+	unsigned int total_weight;
+	struct GraphNode *pipe_nodes[I915_MAX_PIPES];
+	struct GraphNode *slices[I915_MAX_SLICES];
+};
+
+struct IterateContext {
+	struct PipeNodesCombination min_comb;
+	int max_use_count;
+	int num_pipes;
+	int num_slices;
+	int slices_per_pipe;
+	int max_combinations;
+};
+
+struct PipeDBuf {
+	struct GraphNode *pipe;
+	struct GraphNode *dbuf[I915_MAX_SLICES_PER_PIPE];
+};
+
+static void print_pipe_nodes(struct GraphNode **pipe_nodes)
+{
+	int i;
+	for (i = 0; i < I915_MAX_PIPES; i++) {
+		if (!pipe_nodes[i])
+			igt_info("(null)");
+		else
+			igt_info("%d", pipe_nodes[i]->id);
+		if ( i < (I915_MAX_PIPES - 1))
+			igt_info(" ,");
+	}
+	igt_info("\n");
+}
+
+
+static void compare_weight(struct IterateContext *ctx,
+			   struct PipeNodesCombination *comb)
+{
+	unsigned int weight;
+	int j = 0;
+	int pipe = 0;
+	int skip = 0;
+	int slice_num = 0;
+
+	comb->total_weight = 0;
+
+	if (debug) {
+		igt_info("Combination: ");
+		print_pipe_nodes(comb->pipe_nodes);
+	}
+
+	/*
+	 * Get a free DBuf slice for each pipe, then
+	 * calculate total weight, which will be
+	 * then compared to minimal weight to find
+	 * combination with total minimal weight.
+	 */
+	while (pipe < I915_MAX_PIPES) {
+		if (comb->pipe_nodes[pipe]) {
+			comb->slices[j] =
+			    find_slice_for_pipe(comb->pipe_nodes[pipe],
+						0, ctx->max_use_count,
+						&weight, 0, &skip);
+			if (comb->slices[j]) {
+				if (debug)
+					igt_info("Found DBuf slice %d for pipe %d\n",
+						 comb->slices[j]->id,
+						 comb->pipe_nodes[pipe]->id);
+				if (slice_num < ctx->slices_per_pipe)
+					skip++;
+				comb->total_weight += weight;
+			} else
+				break;
+			slice_num++;
+
+			if (slice_num >= ctx->slices_per_pipe) {
+				slice_num = 0;
+				pipe++;
+				skip = 0;
+			}
+			j++;
+		} else {
+			pipe++;
+			j += ctx->slices_per_pipe;
+			skip = 0;
+		}
+	}
+
+	if (debug)
+		igt_info("Total weight %d\n", comb->total_weight);
+
+	for (j = 0; j < I915_MAX_SLICES; j++) {
+		if (comb->slices[j])
+			comb->slices[j]->use_count = 0;
+	}
+
+	if (ctx->min_comb.total_weight > comb->total_weight) {
+		memcpy(&ctx->min_comb, comb,
+		       sizeof(struct PipeNodesCombination));
+	}
+}
+
+/*
+ * Generate all possible combinations for elements in
+ * pipe array(total is calculated as n!).
+ */
+static void iterate_all_combinations(struct IterateContext *ctx,
+				     struct GraphNode **pipe_nodes,
+				     int start, int step,
+				     void (*func)(struct IterateContext *ctx,
+				     struct PipeNodesCombination *comb))
+{
+	int i, j;
+	struct GraphNode *nodes[I915_MAX_PIPES];
+	struct PipeNodesCombination comb;
+
+	memcpy(comb.pipe_nodes, pipe_nodes,
+	       I915_MAX_PIPES * sizeof(struct GraphNode *));
+	memset(comb.slices, 0,
+	       I915_MAX_SLICES * sizeof(struct GraphNode *));
+
+	if (func)
+		(*func)(ctx, &comb);
+
+	if ((step == 0) || (ctx->num_pipes == 1))
+		return;
+
+	for (j = step; j > 0; j--) {
+		for (i = start; i < I915_MAX_PIPES - j; i++) {
+			if (!pipe_nodes[i] || !pipe_nodes[i + j])
+				continue;
+			memcpy(nodes, pipe_nodes,
+			       I915_MAX_PIPES * sizeof(struct GraphNode *));
+			do_swap(nodes, i, i + j);
+			iterate_all_combinations(ctx, nodes, i + 1,
+						 step - 1, func);
+		}
+	}
+}
+
+/*
+ * This function calculates and prints optimal
+ * weight-based DBuf assignment for active pipes.
+ */
+static int
+print_dbuf_mask_for_pipes(int active_pipes,
+			  struct GraphNode **pipe_nodes,
+			  int num_slices)
+{
+	int i;
+	int num_pipes = hweight32(active_pipes), pipes_count;
+	int max_use_count = num_slices < num_pipes ? 2 : 1;
+	int pipe = 0;
+	int slices_per_pipe = max(num_slices / num_pipes, 1);
+	struct IterateContext ctx;
+	struct PipeDBuf pipe_dbuf[I915_MAX_PIPES];
+
+	memcpy(ctx.min_comb.pipe_nodes, pipe_nodes,
+	       sizeof(struct GraphNode *) * I915_MAX_PIPES);
+	memset(ctx.min_comb.slices, 0,
+	       I915_MAX_SLICES * sizeof(struct GraphNode *));
+	ctx.min_comb.total_weight = ~0;
+	ctx.max_use_count = max_use_count;
+	ctx.num_pipes = num_pipes;
+	ctx.num_slices = num_slices;
+	ctx.slices_per_pipe = slices_per_pipe;
+	ctx.max_combinations = factorial(num_pipes);
+
+	iterate_all_combinations(&ctx, pipe_nodes,
+				 0, I915_MAX_PIPES - 1, compare_weight);
+
+	if (debug)
+		igt_info("Combination with least weight %d(total combinations %d):\n",
+		         ctx.min_comb.total_weight, ctx.max_combinations);
+
+	memset(pipe_dbuf, 0, sizeof(struct PipeDBuf) * I915_MAX_PIPES);
+
+	for (i = 0; i < I915_MAX_PIPES; i++) {
+		if (ctx.min_comb.pipe_nodes[i]) {
+			int pipe_index = ctx.min_comb.pipe_nodes[i]->id;
+
+			pipe_dbuf[pipe_index].pipe = ctx.min_comb.pipe_nodes[i];
+			memcpy(&pipe_dbuf[pipe_index].dbuf,
+			       &ctx.min_comb.slices[i * slices_per_pipe],
+			       sizeof(struct GraphNode *) * slices_per_pipe);
+		}
+	}
+
+	igt_info("\t\t{\n");
+	pipe = 0;
+	igt_info("\t\t\t\t.active_pipes = ");
+	for (i = 0; i < I915_MAX_PIPES; i++) {
+		if (pipe_dbuf[i].pipe) {
+			igt_info("BIT(%s)", pipe_names[pipe_dbuf[i].pipe->id]);
+			if (pipe < (num_pipes - 1))
+				igt_info(" | ");
+			pipe++;
+		}
+	}
+	igt_info(",\n\t\t\t\t.dbuf_mask = {\n");
+	num_pipes = 0;
+	for (pipe = 0; pipe < I915_MAX_PIPES; pipe++)
+		if (pipe_dbuf[pipe].pipe)
+			num_pipes++;
+
+	pipes_count = 0;
+	for (pipe = 0; pipe < I915_MAX_PIPES; pipe++) {
+		if (pipe_dbuf[pipe].pipe) {
+			igt_info("\t\t\t\t\t\t[%s] = ", pipe_names[pipe_dbuf[pipe].pipe->id]);
+			for (i = 0; i < slices_per_pipe; i++) {
+				int slice_index_converted;
+				struct GraphNode *next_slice =
+						pipe_dbuf[pipe].dbuf[i+1];
+				bool not_last = i < (slices_per_pipe - 1);
+
+				if (!pipe_dbuf[pipe].dbuf[i])
+					break;
+
+				slice_index_converted =
+					pipe_dbuf[pipe].dbuf[i]->id;
+
+				if (not_last && next_slice) {
+					igt_info("BIT(DBUF_S%d) | ",
+						 slice_index_converted + 1);
+				} else {
+					igt_info("BIT(DBUF_S%d)",
+						 slice_index_converted + 1);
+				}
+				pipes_count++;
+			}
+			if (pipes_count < num_pipes) {
+					igt_info(",\n");
+			}
+			else
+				break;
+		}
+	}
+	igt_info("\n\t\t\t\t}\n\t\t},\n");
+
+	return 0;
+}
+
+static void print_table(struct GraphNode **pipes, int num_pipes,
+			struct GraphNode **slices, int num_slices,
+			int slices_per_pipe)
+{
+	unsigned int i, j;
+	int num_combinations = 1 << num_pipes;
+
+	if (num_pipes > I915_MAX_PIPES) {
+		igt_info("Too many pipes %d\n", num_pipes);
+		return;
+	}
+
+	if (num_slices > I915_MAX_SLICES) {
+		igt_info("Too many slices %d\n", num_slices);
+		return;
+	}
+
+	igt_info("/* Autogenerated with igt/tools/intel_dbuf_map tool: */\n");
+	igt_info("{\n");
+	for (i = 1; i < num_combinations; i++) {
+		struct GraphNode *tmp[I915_MAX_PIPES];
+
+		memcpy(tmp, pipes, I915_MAX_PIPES * sizeof(struct GraphNode *));
+
+		for (j = 0; j < I915_MAX_SLICES; j++) {
+			if (slices[j])
+				slices[j]->use_count = 0;
+		}
+
+		for (j = 0; j < I915_MAX_PIPES; j++) {
+			if (!(i & (1 << j))) {
+				tmp[j] = 0;
+			}
+		}
+
+		if (print_dbuf_mask_for_pipes(i, tmp, num_slices))
+			break;
+	}
+	igt_info("};\n");
+}
+
+enum opt {
+	OPT_UNKNOWN = '?',
+	OPT_END = -1,
+	OPT_GEN,
+	OPT_USAGE,
+	OPT_GRAPH,
+	OPT_DEBUG,
+	OPT_SLICES_PER_PIPE
+};
+
+static void usage(const char *toolname)
+{
+	fprintf(stderr, "usage: %s", toolname);
+	fprintf(stderr, " [--gen=<GEN>]"
+			" [--slices_per_pipe=<number>]"
+			" [--graph=\"PIPE_A-DBUF_S1-PIPE_B-...\"]"
+			" [--debug]"
+			" [--help]\n");
+}
+
+static int pipe_str_to_num(const char *str)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(pipe_names); i++) {
+		if (!strcmp(str, pipe_names[i])) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+static int dbuf_str_to_num(const char *str)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(slice_names); i++) {
+		if (!strcmp(str, slice_names[i])) {
+			return i;
+		}
+	}
+	return -1;
+}
+
+#define MAX_GRAPH_STR 80
+
+static void parse_graph_str(char *graph_str, struct GraphNode **pipes,
+			    struct GraphNode **slices, int *num_slices,
+			    int *num_pipes)
+{
+	char* token = strtok(graph_str, "-");
+	struct GraphNode *cur_node = NULL, *last_node = NULL;
+	int n_pipes = 0, n_slices = 0;
+
+	while (token != NULL) {
+		int index;
+
+		index = pipe_str_to_num(token);
+
+		last_node = cur_node;
+		if (index >= 0) {
+			cur_node = pipes[index];
+			n_pipes++;
+		} else {
+			index = dbuf_str_to_num(token);
+			if (index >= 0) {
+				cur_node = slices[index];
+				n_slices++;
+			}
+		}
+		if (last_node && cur_node)
+			connect_nodes(last_node, cur_node, 1);
+
+		token = strtok(NULL, "-");
+	}
+	*num_slices = n_slices;
+	*num_pipes = n_pipes;
+}
+
+int main(int argc, char **argv)
+{
+	struct GraphNode *pipes[I915_MAX_PIPES];
+	struct GraphNode *slices[I915_MAX_SLICES];
+	struct GraphNode *pipeA, *pipeB, *pipeC, *pipeD;
+	struct GraphNode *slice1, *slice2, *slice3, *slice4;
+	int gen = 12, index;
+	enum opt opt;
+	char *endp;
+	char graph_str[MAX_GRAPH_STR];
+	int slices_per_pipe = I915_MAX_SLICES_PER_PIPE;
+	const char *toolname = argv[0];
+	static struct option options[] = {
+		{ "gen",		required_argument,	NULL,	OPT_GEN },
+		{ "graph",		required_argument,	NULL,	OPT_GRAPH },
+		{ "slices_per_pipe",	required_argument,	NULL,	OPT_SLICES_PER_PIPE },
+		{ "help",		no_argument,		NULL,	OPT_USAGE },
+		{ "debug",		no_argument,		NULL,	OPT_DEBUG },
+		{ 0 }
+	};
+
+	num_edges = 0;
+	num_nodes = 0;
+
+	for (opt = 0; opt != OPT_END; ) {
+		opt = getopt_long(argc, argv, "", options, &index);
+
+		switch (opt) {
+		case OPT_GEN:
+			gen = strtoul(optarg, &endp, 0);
+			break;
+		case OPT_SLICES_PER_PIPE:
+			slices_per_pipe = min(strtoul(optarg, &endp, 0),
+					      I915_MAX_SLICES_PER_PIPE);
+			break;
+		case OPT_DEBUG:
+			debug = true;
+			break;
+		case OPT_GRAPH:
+			strncpy(graph_str, optarg, MAX_GRAPH_STR);
+			graph_str[MAX_GRAPH_STR - 1] = 0;
+			gen = 0;
+		case OPT_END:
+			break;
+		case OPT_USAGE: /* fall-through */
+		case OPT_UNKNOWN:
+			usage(toolname);
+			return EXIT_FAILURE;
+		}
+	}
+	pipeA = create_graph_node(PIPE, 0);
+	pipeB = create_graph_node(PIPE, 1);
+	pipeC = create_graph_node(PIPE, 2);
+	pipeD = create_graph_node(PIPE, 3);
+	slice1 = create_graph_node(DBUF_SLICE, 0);
+	slice2 = create_graph_node(DBUF_SLICE, 1);
+	slice3 = create_graph_node(DBUF_SLICE, 2);
+	slice4 = create_graph_node(DBUF_SLICE, 3);
+
+	memset(pipes, 0, I915_MAX_PIPES * sizeof(struct GraphNode *));
+	memset(slices, 0, I915_MAX_SLICES * sizeof(struct GraphNode *));
+
+	if (!gen) {
+		int num_slices = 0, num_pipes = 0;
+		/*
+		 * Prepare to generate assignments for ICL, which
+		 * has 3 pipes and 2 DBuf slices.
+		 */
+		slices[0] = slice1;
+		slices[1] = slice2;
+		slices[2] = slice3;
+		slices[3] = slice4;
+		pipes[0] = pipeA;
+		pipes[1] = pipeB;
+		pipes[2] = pipeC;
+		pipes[3] = pipeD;
+
+		parse_graph_str(graph_str, pipes, slices, &num_slices,
+				&num_pipes);
+
+		traverse_graph(pipes[0], 0);
+
+		print_table(pipes, num_pipes, slices, num_slices, slices_per_pipe);
+
+	} else if (gen == 11) {
+
+		/*
+		 * Prepare to generate assignments for ICL, which
+		 * has 3 pipes and 2 DBuf slices.
+		 */
+		slices[0] = slice1;
+		slices[1] = slice2;
+		pipes[0] = pipeA;
+		pipes[1] = pipeB;
+		pipes[2] = pipeC;
+
+		/*
+		 * BSpec 12716. Generate DBuf Slices table for ICL,
+		 * Graph(each edge assumed to have weight 1):
+		 * PipeA - DBUF_S1 - PipeB - PipeC - DBUF_S2
+		 */
+		connect_nodes(pipeA, slice1, 1);
+		connect_nodes(slice1, pipeB, 1);
+		connect_nodes(pipeB, pipeC, 1);
+		connect_nodes(pipeC, slice2, 1);
+
+		traverse_graph(pipeA, 0);
+
+		print_table(pipes, 3, slices, 2, 2);
+
+	} else if (gen == 12) {
+
+		/*
+		 * Prepare to generate assignments for TGL, which
+		 * has 4 pipes and 2 DBuf slices.
+		 */
+		slices[0] = slice1;
+		slices[1] = slice2;
+		pipes[0] = pipeA;
+		pipes[1] = pipeB;
+		pipes[2] = pipeC;
+		pipes[3] = pipeD;
+
+		/*
+		 * BSpec 49255. Generate DBuf Slices table for TGL.
+		 * Graph(each edge assumed to have weight 1):
+		 * PipeD - DBUF_S2 - PipeC - PipeA - DBUF_S1 - PipeB
+		 */
+		connect_nodes(pipeD, slice2, 1);
+		connect_nodes(slice2, pipeC, 1);
+		connect_nodes(pipeC, pipeA, 1);
+		connect_nodes(pipeA, slice1, 1);
+		connect_nodes(slice1, pipeB, 1);
+
+		traverse_graph(pipeA, 0);
+
+		print_table(pipes, 4, slices, 2, 2);
+	}
+
+	reset_all_nodes();
+
+	/*
+	 * Further platforms can generate table same way.
+	 */
+
+	destroy_all_nodes();
+
+	return  0;
+}
+
diff --git a/tools/meson.build b/tools/meson.build
index 74822a33..644d1439 100644
--- a/tools/meson.build
+++ b/tools/meson.build
@@ -35,6 +35,7 @@ tools_progs = [
 	'intel_watermark',
 	'intel_gem_info',
 	'intel_gvtg_test',
+	'intel_dbuf_map',
 	'dpcd_reg',
 	'lsgpu',
 ]
-- 
2.24.1.485.gad05a3d8e5

_______________________________________________
igt-dev mailing list
igt-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/igt-dev

^ permalink raw reply related	[flat|nested] 3+ messages in thread