Depsgraph: Cleanup and code simplification

This is mainly a maintenance commit which was aimed to make work with
this module more pleasant and solve such issues as:

- Annoyance with looong files, which had craftload in them
- Usage of STL for the data structures we've got in BLI
- Possible symbol conflicts
- Not real clear layout of what is located where

So in this commit the following changes are done:

- STL is prohibited, it's not really predictable on various compilers,
  with our BLI algorithms we can predict things much better.

  There are still few usages of std::vector, but that we'll be
  solving later once we've got similar thing in BLI.

- Simplify foreach loops, avoid using const_iterator all over the place.

- New directory layout, which is hopefully easier to follow.

- Some files were split, some of them will be split soon.

  The idea of this is to split huge functions into own files with
  good documentation and everything.

- Removed stuff which was planned for use in the future but was never
  finished, tested or anything.

  Let's wipe it out for now, and bring back once we really start using
  it, so it'll be more clear if it solves our needs.

- All the internal routines were moved to DEG namespace to separate
  them better from rest of blender.

  Some places now annoyingly using DEG::foo, but that we can olve by
  moving some utility functions inside of the namespace.

While working on this we've found some hotspot in updates flush, so
now playback of blenrig is few percent faster (something like 96fps
with previous master and around 99-100fps after this change).

Not saying it's something final, there is still room for cleanup and
API simplification, but those might happen as a regular development
now without doing any global changes.

1 files changed, 587 insertions, 0 deletions

diff --git a/source/blender/depsgraph/intern/debug/deg_debug_graphviz.cc b/source/blender/depsgraph/intern/debug/deg_debug_graphviz.cc
new file mode 100644
index 00000000000..6e932d37f37
--- /dev/null
+++ b/source/blender/depsgraph/intern/debug/deg_debug_graphviz.cc
@@ -0,0 +1,587 @@
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2014 Blender Foundation.
+ * All rights reserved.
+ *
+ * Original Author: Lukas Toenne
+ * Contributor(s): None Yet
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+/** \file blender/depsgraph/intern/debug/deg_debug_graphviz.cc
+ *  \ingroup depsgraph
+ *
+ * Implementation of tools for debugging the depsgraph
+ */
+
+#include "BLI_utildefines.h"
+#include "BLI_ghash.h"
+
+extern "C" {
+#include "DNA_listBase.h"
+
+#include "DEG_depsgraph.h"
+#include "DEG_depsgraph_debug.h"
+}  /* extern "C" */
+
+#include "intern/depsgraph_intern.h"
+#include "util/deg_util_foreach.h"
+
+/* ****************** */
+/* Graphviz Debugging */
+
+namespace DEG {
+
+#define NL "\r\n"
+
+/* Only one should be enabled, defines whether graphviz nodes
+ * get colored by individual types or classes.
+ */
+#define COLOR_SCHEME_NODE_CLASS 1
+//#define COLOR_SCHEME_NODE_TYPE  2
+
+static const char *deg_debug_graphviz_fontname = "helvetica";
+static float deg_debug_graphviz_graph_label_size = 20.0f;
+static float deg_debug_graphviz_node_label_size = 14.0f;
+static const int deg_debug_max_colors = 12;
+#ifdef COLOR_SCHEME_NODE_TYPE
+static const char *deg_debug_colors[] = {
+    "#a6cee3", "#1f78b4", "#b2df8a",
+    "#33a02c", "#fb9a99", "#e31a1c",
+    "#fdbf6f", "#ff7f00", "#cab2d6",
+    "#6a3d9a", "#ffff99", "#b15928",
+};
+#endif
+static const char *deg_debug_colors_light[] = {
+    "#8dd3c7", "#ffffb3", "#bebada",
+    "#fb8072", "#80b1d3", "#fdb462",
+    "#b3de69", "#fccde5", "#d9d9d9",
+    "#bc80bd", "#ccebc5", "#ffed6f",
+};
+
+#ifdef COLOR_SCHEME_NODE_TYPE
+static const int deg_debug_node_type_color_map[][2] = {
+    {DEPSNODE_TYPE_ROOT,         0},
+    {DEPSNODE_TYPE_TIMESOURCE,   1},
+    {DEPSNODE_TYPE_ID_REF,       2},
+    {DEPSNODE_TYPE_SUBGRAPH,     3},
+
+    /* Outer Types */
+    {DEPSNODE_TYPE_PARAMETERS,   4},
+    {DEPSNODE_TYPE_PROXY,        5},
+    {DEPSNODE_TYPE_ANIMATION,    6},
+    {DEPSNODE_TYPE_TRANSFORM,    7},
+    {DEPSNODE_TYPE_GEOMETRY,     8},
+    {DEPSNODE_TYPE_SEQUENCER,    9},
+    {DEPSNODE_TYPE_SHADING,      10},
+    {-1,                         0}
+};
+#endif
+
+static int deg_debug_node_color_index(const DepsNode *node)
+{
+#ifdef COLOR_SCHEME_NODE_CLASS
+	/* Some special types. */
+	switch (node->type) {
+		case DEPSNODE_TYPE_ID_REF:
+			return 5;
+		case DEPSNODE_TYPE_OPERATION:
+		{
+			OperationDepsNode *op_node = (OperationDepsNode *)node;
+			if (op_node->is_noop())
+				return 8;
+			break;
+		}
+
+		default:
+			break;
+	}
+	/* Do others based on class. */
+	switch (node->tclass) {
+		case DEPSNODE_CLASS_OPERATION:
+			return 4;
+		case DEPSNODE_CLASS_COMPONENT:
+			return 1;
+		default:
+			return 9;
+	}
+#endif
+
+#ifdef COLOR_SCHEME_NODE_TYPE
+	const int (*pair)[2];
+	for (pair = deg_debug_node_type_color_map; (*pair)[0] >= 0; ++pair) {
+		if ((*pair)[0] == node->type) {
+			return (*pair)[1];
+		}
+	}
+	return -1;
+#endif
+}
+
+struct DebugContext {
+	FILE *file;
+	bool show_tags;
+	bool show_eval_priority;
+};
+
+static void deg_debug_fprintf(const DebugContext &ctx, const char *fmt, ...) ATTR_PRINTF_FORMAT(2, 3);
+static void deg_debug_fprintf(const DebugContext &ctx, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	vfprintf(ctx.file, fmt, args);
+	va_end(args);
+}
+
+static void deg_debug_graphviz_legend_color(const DebugContext &ctx,
+                                            const char *name,
+                                            const char *color)
+{
+	deg_debug_fprintf(ctx, "<TR>");
+	deg_debug_fprintf(ctx, "<TD>%s</TD>", name);
+	deg_debug_fprintf(ctx, "<TD BGCOLOR=\"%s\"></TD>", color);
+	deg_debug_fprintf(ctx, "</TR>" NL);
+}
+
+static void deg_debug_graphviz_legend(const DebugContext &ctx)
+{
+	deg_debug_fprintf(ctx, "{" NL);
+	deg_debug_fprintf(ctx, "rank = sink;" NL);
+	deg_debug_fprintf(ctx, "Legend [shape=none, margin=0, label=<" NL);
+	deg_debug_fprintf(ctx, "  <TABLE BORDER=\"0\" CELLBORDER=\"1\" CELLSPACING=\"0\" CELLPADDING=\"4\">" NL);
+	deg_debug_fprintf(ctx, "<TR><TD COLSPAN=\"2\"><B>Legend</B></TD></TR>" NL);
+
+#ifdef COLOR_SCHEME_NODE_CLASS
+	const char **colors = deg_debug_colors_light;
+	deg_debug_graphviz_legend_color(ctx, "Operation", colors[4]);
+	deg_debug_graphviz_legend_color(ctx, "Component", colors[1]);
+	deg_debug_graphviz_legend_color(ctx, "ID Node", colors[5]);
+	deg_debug_graphviz_legend_color(ctx, "NOOP", colors[8]);
+#endif
+
+#ifdef COLOR_SCHEME_NODE_TYPE
+	const int (*pair)[2];
+	for (pair = deg_debug_node_type_color_map; (*pair)[0] >= 0; ++pair) {
+		DepsNodeFactory *nti = DEG_get_node_factory((eDepsNode_Type)(*pair)[0]);
+		deg_debug_graphviz_legend_color(ctx,
+		                                nti->tname().c_str(),
+		                                deg_debug_colors_light[(*pair)[1] % deg_debug_max_colors]);
+	}
+#endif
+
+	deg_debug_fprintf(ctx, "</TABLE>" NL);
+	deg_debug_fprintf(ctx, ">" NL);
+	deg_debug_fprintf(ctx, ",fontname=\"%s\"", deg_debug_graphviz_fontname);
+	deg_debug_fprintf(ctx, "];" NL);
+	deg_debug_fprintf(ctx, "}" NL);
+}
+
+static void deg_debug_graphviz_node_color(const DebugContext &ctx,
+                                          const DepsNode *node)
+{
+	const char *color_default = "black";
+	const char *color_modified = "orangered4";
+	const char *color_update = "dodgerblue3";
+	const char *color = color_default;
+	if (ctx.show_tags) {
+		if (node->tclass == DEPSNODE_CLASS_OPERATION) {
+			OperationDepsNode *op_node = (OperationDepsNode *)node;
+			if (op_node->flag & DEPSOP_FLAG_DIRECTLY_MODIFIED) {
+				color = color_modified;
+			}
+			else if (op_node->flag & DEPSOP_FLAG_NEEDS_UPDATE) {
+				color = color_update;
+			}
+		}
+	}
+	deg_debug_fprintf(ctx, "\"%s\"", color);
+}
+
+static void deg_debug_graphviz_node_penwidth(const DebugContext &ctx,
+                                             const DepsNode *node)
+{
+	float penwidth_default = 1.0f;
+	float penwidth_modified = 4.0f;
+	float penwidth_update = 4.0f;
+	float penwidth = penwidth_default;
+	if (ctx.show_tags) {
+		if (node->tclass == DEPSNODE_CLASS_OPERATION) {
+			OperationDepsNode *op_node = (OperationDepsNode *)node;
+			if (op_node->flag & DEPSOP_FLAG_DIRECTLY_MODIFIED) {
+				penwidth = penwidth_modified;
+			}
+			else if (op_node->flag & DEPSOP_FLAG_NEEDS_UPDATE) {
+				penwidth = penwidth_update;
+			}
+		}
+	}
+	deg_debug_fprintf(ctx, "\"%f\"", penwidth);
+}
+
+static void deg_debug_graphviz_node_fillcolor(const DebugContext &ctx,
+                                              const DepsNode *node)
+{
+	const char *defaultcolor = "gainsboro";
+	int color_index = deg_debug_node_color_index(node);
+	const char *fillcolor = color_index < 0 ? defaultcolor : deg_debug_colors_light[color_index % deg_debug_max_colors];
+	deg_debug_fprintf(ctx, "\"%s\"", fillcolor);
+}
+
+static void deg_debug_graphviz_relation_color(const DebugContext &ctx,
+                                              const DepsRelation *rel)
+{
+	const char *color_default = "black";
+	const char *color_error = "red4";
+	const char *color = color_default;
+	if (rel->flag & DEPSREL_FLAG_CYCLIC) {
+		color = color_error;
+	}
+	deg_debug_fprintf(ctx, "%s", color);
+}
+
+static void deg_debug_graphviz_node_style(const DebugContext &ctx, const DepsNode *node)
+{
+	const char *base_style = "filled"; /* default style */
+	if (ctx.show_tags) {
+		if (node->tclass == DEPSNODE_CLASS_OPERATION) {
+			OperationDepsNode *op_node = (OperationDepsNode *)node;
+			if (op_node->flag & (DEPSOP_FLAG_DIRECTLY_MODIFIED | DEPSOP_FLAG_NEEDS_UPDATE)) {
+				base_style = "striped";
+			}
+		}
+	}
+	switch (node->tclass) {
+		case DEPSNODE_CLASS_GENERIC:
+			deg_debug_fprintf(ctx, "\"%s\"", base_style);
+			break;
+		case DEPSNODE_CLASS_COMPONENT:
+			deg_debug_fprintf(ctx, "\"%s\"", base_style);
+			break;
+		case DEPSNODE_CLASS_OPERATION:
+			deg_debug_fprintf(ctx, "\"%s,rounded\"", base_style);
+			break;
+	}
+}
+
+static void deg_debug_graphviz_node_single(const DebugContext &ctx,
+                                           const DepsNode *node)
+{
+	const char *shape = "box";
+	string name = node->identifier();
+	float priority = -1.0f;
+	if (node->type == DEPSNODE_TYPE_ID_REF) {
+		IDDepsNode *id_node = (IDDepsNode *)node;
+		char buf[256];
+		BLI_snprintf(buf, sizeof(buf), " (Layers: %d)", id_node->layers);
+		name += buf;
+	}
+	if (ctx.show_eval_priority && node->tclass == DEPSNODE_CLASS_OPERATION) {
+		priority = ((OperationDepsNode *)node)->eval_priority;
+	}
+	deg_debug_fprintf(ctx, "// %s\n", name.c_str());
+	deg_debug_fprintf(ctx, "\"node_%p\"", node);
+	deg_debug_fprintf(ctx, "[");
+//	deg_debug_fprintf(ctx, "label=<<B>%s</B>>", name);
+	if (priority >= 0.0f) {
+		deg_debug_fprintf(ctx, "label=<%s<BR/>(<I>%.2f</I>)>",
+		                 name.c_str(),
+		                 priority);
+	}
+	else {
+		deg_debug_fprintf(ctx, "label=<%s>", name.c_str());
+	}
+	deg_debug_fprintf(ctx, ",fontname=\"%s\"", deg_debug_graphviz_fontname);
+	deg_debug_fprintf(ctx, ",fontsize=%f", deg_debug_graphviz_node_label_size);
+	deg_debug_fprintf(ctx, ",shape=%s", shape);
+	deg_debug_fprintf(ctx, ",style="); deg_debug_graphviz_node_style(ctx, node);
+	deg_debug_fprintf(ctx, ",color="); deg_debug_graphviz_node_color(ctx, node);
+	deg_debug_fprintf(ctx, ",fillcolor="); deg_debug_graphviz_node_fillcolor(ctx, node);
+	deg_debug_fprintf(ctx, ",penwidth="); deg_debug_graphviz_node_penwidth(ctx, node);
+	deg_debug_fprintf(ctx, "];" NL);
+	deg_debug_fprintf(ctx, NL);
+}
+
+static void deg_debug_graphviz_node_cluster_begin(const DebugContext &ctx,
+                                                  const DepsNode *node)
+{
+	string name = node->identifier().c_str();
+	if (node->type == DEPSNODE_TYPE_ID_REF) {
+		IDDepsNode *id_node = (IDDepsNode *)node;
+		char buf[256];
+		BLI_snprintf(buf, sizeof(buf), " (Layers: %d)", id_node->layers);
+		name += buf;
+	}
+	deg_debug_fprintf(ctx, "// %s\n", name.c_str());
+	deg_debug_fprintf(ctx, "subgraph \"cluster_%p\" {" NL, node);
+//	deg_debug_fprintf(ctx, "label=<<B>%s</B>>;" NL, name);
+	deg_debug_fprintf(ctx, "label=<%s>;" NL, name.c_str());
+	deg_debug_fprintf(ctx, "fontname=\"%s\";" NL, deg_debug_graphviz_fontname);
+	deg_debug_fprintf(ctx, "fontsize=%f;" NL, deg_debug_graphviz_node_label_size);
+	deg_debug_fprintf(ctx, "margin=\"%d\";" NL, 16);
+	deg_debug_fprintf(ctx, "style="); deg_debug_graphviz_node_style(ctx, node); deg_debug_fprintf(ctx, ";" NL);
+	deg_debug_fprintf(ctx, "color="); deg_debug_graphviz_node_color(ctx, node); deg_debug_fprintf(ctx, ";" NL);
+	deg_debug_fprintf(ctx, "fillcolor="); deg_debug_graphviz_node_fillcolor(ctx, node); deg_debug_fprintf(ctx, ";" NL);
+	deg_debug_fprintf(ctx, "penwidth="); deg_debug_graphviz_node_penwidth(ctx, node); deg_debug_fprintf(ctx, ";" NL);
+	/* dummy node, so we can add edges between clusters */
+	deg_debug_fprintf(ctx, "\"node_%p\"", node);
+	deg_debug_fprintf(ctx, "[");
+	deg_debug_fprintf(ctx, "shape=%s", "point");
+	deg_debug_fprintf(ctx, ",style=%s", "invis");
+	deg_debug_fprintf(ctx, "];" NL);
+	deg_debug_fprintf(ctx, NL);
+}
+
+static void deg_debug_graphviz_node_cluster_end(const DebugContext &ctx)
+{
+	deg_debug_fprintf(ctx, "}" NL);
+	deg_debug_fprintf(ctx, NL);
+}
+
+static void deg_debug_graphviz_graph_nodes(const DebugContext &ctx,
+                                           const Depsgraph *graph);
+static void deg_debug_graphviz_graph_relations(const DebugContext &ctx,
+                                               const Depsgraph *graph);
+
+static void deg_debug_graphviz_node(const DebugContext &ctx,
+                                    const DepsNode *node)
+{
+	switch (node->type) {
+		case DEPSNODE_TYPE_ID_REF:
+		{
+			const IDDepsNode *id_node = (const IDDepsNode *)node;
+			if (BLI_ghash_size(id_node->components) == 0) {
+				deg_debug_graphviz_node_single(ctx, node);
+			}
+			else {
+				deg_debug_graphviz_node_cluster_begin(ctx, node);
+				GHASH_FOREACH_BEGIN(const ComponentDepsNode *, comp, id_node->components)
+				{
+					deg_debug_graphviz_node(ctx, comp);
+				}
+				GHASH_FOREACH_END();
+				deg_debug_graphviz_node_cluster_end(ctx);
+			}
+			break;
+		}
+		case DEPSNODE_TYPE_SUBGRAPH:
+		{
+			SubgraphDepsNode *sub_node = (SubgraphDepsNode *)node;
+			if (sub_node->graph) {
+				deg_debug_graphviz_node_cluster_begin(ctx, node);
+				deg_debug_graphviz_graph_nodes(ctx, sub_node->graph);
+				deg_debug_graphviz_node_cluster_end(ctx);
+			}
+			else {
+				deg_debug_graphviz_node_single(ctx, node);
+			}
+			break;
+		}
+		case DEPSNODE_TYPE_PARAMETERS:
+		case DEPSNODE_TYPE_ANIMATION:
+		case DEPSNODE_TYPE_TRANSFORM:
+		case DEPSNODE_TYPE_PROXY:
+		case DEPSNODE_TYPE_GEOMETRY:
+		case DEPSNODE_TYPE_SEQUENCER:
+		case DEPSNODE_TYPE_EVAL_POSE:
+		case DEPSNODE_TYPE_BONE:
+		case DEPSNODE_TYPE_SHADING:
+		case DEPSNODE_TYPE_EVAL_PARTICLES:
+		{
+			ComponentDepsNode *comp_node = (ComponentDepsNode *)node;
+			if (!comp_node->operations.empty()) {
+				foreach (DepsNode *op_node, comp_node->operations) {
+					deg_debug_graphviz_node(ctx, op_node);
+				}
+				deg_debug_graphviz_node_cluster_end(ctx);
+			}
+			else {
+				deg_debug_graphviz_node_single(ctx, node);
+			}
+			break;
+		}
+		default:
+			deg_debug_graphviz_node_single(ctx, node);
+			break;
+	}
+}
+
+static bool deg_debug_graphviz_is_cluster(const DepsNode *node)
+{
+	switch (node->type) {
+		case DEPSNODE_TYPE_ID_REF:
+		{
+			const IDDepsNode *id_node = (const IDDepsNode *)node;
+			return BLI_ghash_size(id_node->components) > 0;
+		}
+		case DEPSNODE_TYPE_SUBGRAPH:
+		{
+			SubgraphDepsNode *sub_node = (SubgraphDepsNode *)node;
+			return sub_node->graph != NULL;
+		}
+		case DEPSNODE_TYPE_PARAMETERS:
+		case DEPSNODE_TYPE_ANIMATION:
+		case DEPSNODE_TYPE_TRANSFORM:
+		case DEPSNODE_TYPE_PROXY:
+		case DEPSNODE_TYPE_GEOMETRY:
+		case DEPSNODE_TYPE_SEQUENCER:
+		case DEPSNODE_TYPE_EVAL_POSE:
+		case DEPSNODE_TYPE_BONE:
+		{
+			ComponentDepsNode *comp_node = (ComponentDepsNode *)node;
+			return !comp_node->operations.empty();
+		}
+		default:
+			return false;
+	}
+}
+
+static bool deg_debug_graphviz_is_owner(const DepsNode *node,
+                                        const DepsNode *other)
+{
+	switch (node->tclass) {
+		case DEPSNODE_CLASS_COMPONENT:
+		{
+			ComponentDepsNode *comp_node = (ComponentDepsNode *)node;
+			if (comp_node->owner == other)
+				return true;
+			break;
+		}
+		case DEPSNODE_CLASS_OPERATION:
+		{
+			OperationDepsNode *op_node = (OperationDepsNode *)node;
+			if (op_node->owner == other)
+				return true;
+			else if (op_node->owner->owner == other)
+				return true;
+			break;
+		}
+		default: break;
+	}
+	return false;
+}
+
+static void deg_debug_graphviz_node_relations(const DebugContext &ctx,
+                                              const DepsNode *node)
+{
+	foreach (DepsRelation *rel, node->inlinks) {
+		float penwidth = 2.0f;
+
+		const DepsNode *tail = rel->to; /* same as node */
+		const DepsNode *head = rel->from;
+		deg_debug_fprintf(ctx, "// %s -> %s\n",
+		                 head->identifier().c_str(),
+		                 tail->identifier().c_str());
+		deg_debug_fprintf(ctx, "\"node_%p\"", head);
+		deg_debug_fprintf(ctx, " -> ");
+		deg_debug_fprintf(ctx, "\"node_%p\"", tail);
+
+		deg_debug_fprintf(ctx, "[");
+		/* Note: without label an id seem necessary to avoid bugs in graphviz/dot */
+		deg_debug_fprintf(ctx, "id=\"%s\"", rel->name);
+		deg_debug_fprintf(ctx, ",color="); deg_debug_graphviz_relation_color(ctx, rel);
+		deg_debug_fprintf(ctx, ",penwidth=\"%f\"", penwidth);
+		/* NOTE: edge from node to own cluster is not possible and gives graphviz
+		 * warning, avoid this here by just linking directly to the invisible
+		 * placeholder node
+		 */
+		if (deg_debug_graphviz_is_cluster(tail) && !deg_debug_graphviz_is_owner(head, tail)) {
+			deg_debug_fprintf(ctx, ",ltail=\"cluster_%p\"", tail);
+		}
+		if (deg_debug_graphviz_is_cluster(head) && !deg_debug_graphviz_is_owner(tail, head)) {
+			deg_debug_fprintf(ctx, ",lhead=\"cluster_%p\"", head);
+		}
+		deg_debug_fprintf(ctx, "];" NL);
+		deg_debug_fprintf(ctx, NL);
+	}
+}
+
+static void deg_debug_graphviz_graph_nodes(const DebugContext &ctx,
+                                           const Depsgraph *graph)
+{
+	if (graph->root_node) {
+		deg_debug_graphviz_node(ctx, graph->root_node);
+	}
+	GHASH_FOREACH_BEGIN (DepsNode *, node, graph->id_hash)
+	{
+		deg_debug_graphviz_node(ctx, node);
+	}
+	GHASH_FOREACH_END();
+	TimeSourceDepsNode *time_source = graph->find_time_source(NULL);
+	if (time_source != NULL) {
+		deg_debug_graphviz_node(ctx, time_source);
+	}
+}
+
+static void deg_debug_graphviz_graph_relations(const DebugContext &ctx,
+                                               const Depsgraph *graph)
+{
+	GHASH_FOREACH_BEGIN(IDDepsNode *, id_node, graph->id_hash)
+	{
+		GHASH_FOREACH_BEGIN(ComponentDepsNode *, comp_node, id_node->components)
+		{
+			foreach (OperationDepsNode *op_node, comp_node->operations) {
+				deg_debug_graphviz_node_relations(ctx, op_node);
+			}
+		}
+		GHASH_FOREACH_END();
+	}
+	GHASH_FOREACH_END();
+
+	TimeSourceDepsNode *time_source = graph->find_time_source(NULL);
+	if (time_source != NULL) {
+		deg_debug_graphviz_node_relations(ctx, time_source);
+	}
+}
+
+}  // namespace DEG
+
+void DEG_debug_graphviz(const Depsgraph *graph, FILE *f, const char *label, bool show_eval)
+{
+	if (!graph) {
+		return;
+	}
+
+	const DEG::Depsgraph *deg_graph = reinterpret_cast<const DEG::Depsgraph *>(graph);
+
+	DEG::DebugContext ctx;
+	ctx.file = f;
+	ctx.show_tags = show_eval;
+	ctx.show_eval_priority = show_eval;
+
+	DEG::deg_debug_fprintf(ctx, "digraph depgraph {" NL);
+	DEG::deg_debug_fprintf(ctx, "rankdir=LR;" NL);
+	DEG::deg_debug_fprintf(ctx, "graph [");
+	DEG::deg_debug_fprintf(ctx, "compound=true");
+	DEG::deg_debug_fprintf(ctx, ",labelloc=\"t\"");
+	DEG::deg_debug_fprintf(ctx, ",fontsize=%f", DEG::deg_debug_graphviz_graph_label_size);
+	DEG::deg_debug_fprintf(ctx, ",fontname=\"%s\"", DEG::deg_debug_graphviz_fontname);
+	DEG::deg_debug_fprintf(ctx, ",label=\"%s\"", label);
+	DEG::deg_debug_fprintf(ctx, ",splines=ortho");
+	DEG::deg_debug_fprintf(ctx, ",overlap=scalexy"); // XXX: only when using neato
+	DEG::deg_debug_fprintf(ctx, "];" NL);
+
+	DEG::deg_debug_graphviz_graph_nodes(ctx, deg_graph);
+	DEG::deg_debug_graphviz_graph_relations(ctx, deg_graph);
+
+	DEG::deg_debug_graphviz_legend(ctx);
+
+	DEG::deg_debug_fprintf(ctx, "}" NL);
+}
+
+#undef NL