[XRay] A tool for Comparing xray function call graphs

[varno]

Summary

This is a tool for comparing the function graphs produced by the
llvm-xray graph too. It takes the form of a new subcommand of the
llvm-xray tool 'graph-diff'.

This initial version of the patch is very rough, but it is close to
feature complete.

Depends on D29363

[varno]

Rebase to master.

[varno]

• rebase on top of D29363

[varno]

• try that again

[varno]

• respond to comments

[varno]

roll back mistaken commit

[varno]

--rebase

[varno]

try again

[dblaikie]

Few drive by comments

tools/llvm-xray/xray-graph-diff.cc

351 ↗

(On Diff #86565)

missing space between ')' and '{'

351–353 ↗

(On Diff #86565)

Usually skip {} on single line blocks

417–419 ↗

(On Diff #86565)

Unnecessary {} and/or missing space (between ')' and '{')

tools/llvm-xray/xray-graph-diff.h

73 ↗

(On Diff #86565)

missing space between '()' and '{'

75 ↗

(On Diff #86565)

spurious semicolon

tools/llvm-xray/xray-graph.h

52 ↗

(On Diff #86565)

Spurious semicolon

[dberris]

Overall needs formatting changes, please use clang-format using the style defined in the LLVM codebase.

tools/llvm-xray/xray-graph-diff.cc

236–266 ↗

(On Diff #86565)

I would really much prefer that we limit the repetition here for readability's sake. Factor the logic out into a single function, and provide the graphs as inputs?

285–287 ↗

(On Diff #86565)

This deserves a comment I think.

391 ↗

(On Diff #86565)

Maybe give a different name for the diff graph?

tools/llvm-xray/xray-graph-diff.h

10–11 ↗

(On Diff #86565)

Probably needs to be updated.

tools/llvm-xray/xray-graph.h

53 ↗

(On Diff #86565)

Please don't use names that start with _.

62 ↗

(On Diff #86565)

Now that you've defined a default constructor and a non-default constructor, you might as well define (or =default) a copy constructor, a move constructor, a copy+move assignment (probably the unified assignment operator), a swap overload, etc.

Can you say instead why you needed to do this now?

[varno]

• Address reviewer comments

[dberris]

tools/llvm-xray/xray-graph-diff.cc

268 ↗

(On Diff #87363)

s/funtino/function/
s/relitively/relatively/ ?

271 ↗

(On Diff #87363)

Now that you've documented this, it seems like this is a "bounded relative diff" or a means of normalizing distance within the range [-1, 1]. I'd urge you to find a more expressive/intuitive name than "divF".

371–373 ↗

(On Diff #87363)

Am not a fan of this function's naming... consider spelling it out instead, truncateString seems just fine to me.

tools/llvm-xray/xray-graph-diff.h

25 ↗

(On Diff #87363)

Please document this class, how to use it, etc.

26 ↗

(On Diff #87363)

nit: really ought to be constexpr size_t.

33 ↗

(On Diff #87363)

A using statement to bring in this EdgeValueType into scope would really make this more readable.

[varno]

• fix mistake and address comments
• address comments

[varno]

tools/llvm-xray/xray-graph.h

62 ↗

(On Diff #86565)

I was able to remove them by empty list-initializing them where used.

[varno]

• Address reviewer comments
• fix mistake and address comments
• address comments
• rebase

[dberris]

Please address all comments by me and @dblaikie

tools/llvm-xray/xray-graph-diff.cc

222 ↗

(On Diff #87750)

Magic number 2 for a reason? Maybe use the N in GraphDiffRenderer?

261 ↗

(On Diff #87750)

Punctuation mark?

316 ↗

(On Diff #87750)

What would be really helpful here is if you gave E.second a name. Is this an EdgeAttr? If so, if would be much easier to read something like:

auto &EdgeAttr = E.second;
if (EdgeAttr.Parents[0] == nullptr)
  return "green";
if (EdgeAttr.Parents[1] == nullptr)
  return "red";
...
  EdgeAttr.Parents[0].Stats.getDouble(Stat)

327–329 ↗

(On Diff #87750)

I'm not an expert here, but comparing to zero seems a little... odd because these are floating point numbers, but maybe not something important enough to worry about.

tools/llvm-xray/xray-graph-diff.h

51 ↗

(On Diff #87750)

Do you need to fully qualify N here?

[dberris]

tools/llvm-xray/xray-graph-diff.cc

416–418 ↗

(On Diff #87750)

Lose the { and } ?

[varno]

• Address reviewer comments
  • fix mistake and address comments
  • address comments
  • rebase
  • address comments
  • -pedantic
  • rebase

[dberris]

Lots of readability comments, and a couple of functionality questions.

tools/llvm-xray/xray-graph-diff.cc

222–238 ↗

(On Diff #87956)

Looks like this is better merged:

for (auto i = 0; i < N; ++i) {
  const auto &G = G[i].get();
  for (const auto &V : G.vertices())
    ...
  for (const auto &E : G.edges())
    ...

223 ↗

(On Diff #87956)

For readability purposes, I'd suggest you alias G[i].get() to reduce the visual noise.

228–229 ↗

(On Diff #87956)

What is "S" and "E" here? It would really help if you use better names here. It will make more sense if you do something like:

auto &FromVertex = E.first.first;
auto &ToVertex = E.first.second;
auto FromVertexOrErr = G.at(FromVertex);
auto ToVertexOrErr = G.at(ToVertex);
...

236 ↗

(On Diff #87956)

This is really unreadable. What is P?

242 ↗

(On Diff #87956)

This is really opaque -- what does IM stand for? Please pick a more meaningful name. It's also not clear why we're using a monotonic number here.

244 ↗

(On Diff #87956)

I suggest using enum names instead of 0 and 1 here, to aid in readability. Something like:

enum { LEFT = 0, RIGHT = 1 };
auto &VAttr = V.second;
if (VAttr.Parent[LEFT] == nullptr || VAttr.Parent[RIGHT] == nullptr)
  continue;

244–245 ↗

(On Diff #87956)

So let me get this right -- if one of the vertex attribute's parents doesn't have it, then we move on. So we don't indicate that the vertex is only seen in one of the graphs?

282–302 ↗

(On Diff #87956)

All this repetition seems unnecessary. It seems you might be able to do this with a loop:

auto MemPtrs[] = { &TimeStat::Count, &TimeStat::Min, &TimeStat::Median, ... };
for (auto Mem : MemPtrs) {
  auto Diff = maxDiff(MA.*Mem, MB.*Mem);
  MA.*Mem = Diff.first;
  MB.*Mem = Diff.second;
}

324–327 ↗

(On Diff #87956)

What is R and what is MR -- this code looks really hard to read. I can't even begin to explain what this is actually doing (what's EdgeAttr.P[0]->second.S ?).

334 ↗

(On Diff #87956)

What is Manumim? Did you mean Maximum?

342–345 ↗

(On Diff #87956)

Why are these colours hard-coded, when you already have a ColorHelper available?

369–372 ↗

(On Diff #87956)

What is this meant to do? Did you mean to provide stringified labels? Why isn't this just always returning the empty string? Is this supposed to also provide the value of the difference, in relative terms as a string appropriately coloured?

382 ↗

(On Diff #87956)

Looks like you might as well just use formatv here, as it's more confusing to read this as is.

405 ↗

(On Diff #87956)

Why are we truncating the tooltip? It seems it might be better to provide the whole string in the tooltip so in cases where we can keep them (in SVG) then the truncated names show up in the code, and on hover will show more information.

tools/llvm-xray/xray-graph-diff.h

38–44 ↗

(On Diff #87956)

Please use a better identifier than P -- Is this meant to indicate Parent? If so, just use that to make it easier to read. If not, then please use a more descriptive name.

[dberris]

@varno -- are you able to make the changes, or are you alright with me taking over this patch?

[varno]

Yep. This weekend

[varno]

• address reviewer comments
• clang-format

[varno]

tools/llvm-xray/xray-graph-diff.cc

244–245 ↗

(On Diff #87956)

That the Vertex is in only one of the graphs is encoded in the fact that the corresponding pointer is null. So Yeah We do indicate this, i.e. if there is no link the 0th or 1st vertex does not exist in the corresponding graph.

282–302 ↗

(On Diff #87956)

Can't quite do this due to type issues but I have fixed this most of the way there.

342–345 ↗

(On Diff #87956)

These are different colors not on the scale for if the vertex or edge does not exist (as opposed to encoding some difference. They should not come from the ColorHelper but are specified separately.

369–372 ↗

(On Diff #87956)

I am not sure what to do here in labeling edges with differences, so I have a TODO here, If you can tell me what you think I should put there I will change this.

[dberris]

More readability comments. In general all the escaped strings and broken up stream operations don't read well. A better option is using formatv(...) and consolidating those into format strings that are specified as raw string literals would make all the output generation code much more readable.

tools/llvm-xray/xray-graph-diff.cc

226 ↗

(On Diff #90568)

What is V.second? Is this the vertex attribute? Aliasing this will make it much easier to read:

const auto& VAttr = V.second;

242–244 ↗

(On Diff #90568)

Single line body; prefer no {}'s.

253–255 ↗

(On Diff #90568)

As documented, it doesn't say what a "negative" value means -- so for values 1 and 2, it will result in:

(1/2) (0.5) - (2) = -1.5

I presume that the sign implies says the value on the left is larger? Or is that in reverse? It would be better if the comment actually stated this.

Alternatively, if you used a relative computation instead and yielded the percentage difference in one direction, and can use that as a label too. That would look something like:

-(Left - Right / Left)

If Left == 0, then it's +100%. If Right is 0 then it's -100%.

256 ↗

(On Diff #90568)

Reading this now, I think 'difference' is a little misleading a name for what it does. It seems to be a scaled relative difference, because it's not just A - B (as the name "difference" would suggest). So one of: scaledRelativeDiff(...) or ratioDiff(...) would make this less confusing as it says what it means.

281–282 ↗

(On Diff #90568)

Alternative way of spelling this:

std::tie(MA.*Mem, MB.*Mem) = DP;

Or just:

std::tie(MA.*Mem, MB.*Mem) =
    maxDiff(MA.*Mem, MB.*Mem, A.*Mem, B.*Mem);

This might also benefit from better names. Mem isn't the best name, but "Stat" might be more indicative of what it actually is. DoubleMemPtrs looks like it doesn't need to be given a name, the for loop could just have it there. Also, MA and MB don't mean much in terms of names. So rewriting that to be more succinct:

for (auto Stat : {&TimeStat::Min, ...})
  std::tie(StatLeft.*Stat, StatRight.*Stat) =
      maxDiff(StatLeft.*Stat, StatRight.*Stat, NewStatLeft.*Stat, NewStatRight.*Stat);

385 ↗

(On Diff #90568)

Use raw string literals to avoid the problem of having to escape quotes.

385 ↗

(On Diff #90568)

Can 40 not be hard-coded here? Consider a flag to control string length truncation.

412–415 ↗

(On Diff #90568)

This is completely unreadable. Consider using the combination of formatv(...) and raw string literals instead. Also, please use aliases to make things like E.first.first say something a bit more readable. Something like:

const auto &SourceVertex = E.first.first;
const auto &DestinationVertex = E.first.second;

437–481 ↗

(On Diff #90568)

Some of this duplication seems a little unnecessary. How about using control flow to reduce the repetition?

struct GraphData {
  bool KeepGoing;
  bool DeduceSiblings;
  string InstrMapFile;
  string Input;
  GraphRenderer::Factory Factory;
  Trace Trace;
  GraphRenderer Renderer;
  Graph Graph;
};
std::array<GraphData, 2> Graphs {
  { isSpecified(KeepGoing1), ... },
  { isSpecified(KeepGoing2), ...},
};
for (auto &Graph : Graphs) {
  Graph.Factory.KeepGoing = Graph.KeepGoing;
  ...
  auto TraceOrError = loadTraceFile(Graph.Input, true);
  if (!TraceOrError) ...
  Graph.Trace = std::move(*TraceOrError);
  ...
}

342–345 ↗

(On Diff #87956)

I can reverse that question too -- why isn't the choice for what colour to use for when something is missing from one side not in the ColorHelper? It seems weird that these are the only colours hard-coded when I'd expect as a reader/maintainer of this that this information fits really well in the ColorHelper utility.

Something like a categorisation amongst "in both sets", "in set A", "in set B", "in neither". We could just use hard-coded colours to indicate those four states in the ColorHelper, and centralise where all the Colors are defined.

369–372 ↗

(On Diff #87956)

How about providing the relative differences? Something like "+10%" or "-2.3%" in the same colour as the edge/vertex?

tools/llvm-xray/xray-graph.cc

374–402 ↗

(On Diff #90568)

Now that I read this, I'm more convinced of a mapping between the enum and data member pointers.

[dberris]

Hi @varno -- are you still working on this, or should I take this over instead?

[varno]

Am still working on this.

[varno]

• Address Reviewer Comments

[varno]

I have fixed most of the comments, and replied to all of them, Tests incoming soon.

tools/llvm-xray/xray-graph-diff.cc

253–255 ↗

(On Diff #90568)

I have improved the comment. I chose this function because it is symmetrical (that is diff(A,B) = -diff(B,A)) and it behaves similarly to a

Right/Left - 1 which you suggest. behaves well if Right == 0 but not if left == 0. it does not treat the left and right hand sides symmetrically, nor close to it away from 1.

369–372 ↗

(On Diff #87956)

I am not convinced that this is the right statistic to show, or whether this is the right way to go about coloring edges.

[dberris]

tools/llvm-xray/xray-graph-diff.cc

265–266 ↗

(On Diff #92261)

So this is always a positive number?

369–372 ↗

(On Diff #87956)

Why not?

User gave you two traces. We're showing them differences. Using a made-up relative difference as opposed to ((A - B / A) * 100%) seems wrong and not helpful. We want to make sure the magnitude of the difference is what we use to highlight the edge or the vertex. Any other scheme would be trying to be too clever, and be actively harmful because it wouldn't make sense to the user trying to make sense of the data. If you don't provide the relative difference then it's effectively useless -- I as a user wouldn't be able to tell how severe the difference is in relative terms which is the whole point of the diff tool.

What makes the current way better than using the relative difference for the stat chosen?

[varno]

tools/llvm-xray/xray-graph-diff.cc

265–266 ↗

(On Diff #92261)

Sorry, bad comment will fix.

369–372 ↗

(On Diff #87956)

Hi Dean.

I Agree that for the textrual representation that RatioDiff is not the best answer, however for coloring the differences and determining what the largest difference is, this is just fine as both as the graph plotting ratioDiff vs (A-B)/A is monotonic. The properties of the chosen funciton Namely the symmetry allow us to compare the amount of change going positive and negative with each other, which is a useful property.

The reason that this is better is that the order of diff is mostly arbitrary, and so A/B - B;/A behaves like max(A,B)/min(A,B) away from where A and B are similar and properly when A, and B are close to each other then it behaves like (A-B)/A. However even here the behavior is better behaved. Also for choosing colors this is easier. the function (A-B)/ A just treats A, and B too differently to work well for coloring edges (I tried this first at google btw as it was the "obvious" answer).

However as a User in a textual representation I agree that we want to use a different metric, that is why I store both sides of the max and minimum statistics and not just the diff. There I am not sure whether we want to show percentage difference, absolute difference or just both numbers in the change. The decision here also will likely be different for edges and vertices, with edges probably wanting something simple like the percentage change or absolute difference, while the vertices you may want to have both the old and new numbers plus an amount of change.

[varno]

Just doing the math now, (A/B - B/A)*100 is exactly 2x the average of x and y where x and y are defined such that :
A is x% faster than B, and B is x% slower than A. So this is really a reasonable relative difference function even intuitively, being the average of the two difference metrics.

(x = (A/B - 1)*100 and y= -(B/A - 1)*100, so (x+y)/2 = (A/B - B/A)/2)

[varno]

• Change coloring metric, add labels

[dberris]

I've had a quick look, but haven't dug deep into the recent changes yet. Please add tests.

[dberris]

@varno -- are you still working on this?

[varno]

I have been very busy recently but I have next week off. I will be working on it then.

[varno]

• New branch
• address reviewer comments
• clang-format
• Address Reviewer Comments
• Change coloring metric, add labels
• tests

[dberris]

LGTM -- just a couple more nits, but I'll land it first and get the follow-up changes done myself. :)

Thanks for the work @varno!

tools/llvm-xray/xray-graph-diff.cc

310–315 ↗

(On Diff #96079)

Why isn't the caller of this just doing:

llvm::find(Collection, nullptr) != Collection.end()

350 ↗

(On Diff #96079)

Is it just me, or are the squiggly brackets not matched?

tools/llvm-xray/xray-graph.cc

339–341 ↗

(On Diff #96079)

This could be a static constexpr array, so it doesn't have to be initialised every time this function is called.

[varno]

Thanks for letting me finish this.

tools/llvm-xray/xray-graph-diff.cc

350 ↗

(On Diff #96079)

two {{ escape a { in formatv, so yeah, but they have to be

[jroelofs]

llvm/trunk/tools/llvm-xray/xray-graph.h

226

'*' --> '/' copy-pasta?

[sanjoy]

tools/llvm-xray/xray-graph-diff.cc

310–315 ↗

(On Diff #96079)

Armchair comment: we also have llvm::is_contained in STLExtras.h

llvm/trunk/test/tools/llvm-xray/X86/Inputs/graph-diff-A.yaml

+---
+header:
+  version: 1
+  type: 0
+  constant-tsc: true
+  nonstop-tsc: true
+  cycle-frequency: 1
+records:
+  - { type: 0, func-id:  1, cpu: 1, thread: 111, kind: function-enter, tsc: 10000 }
+  - { type: 0, func-id:  1, cpu: 1, thread: 111, kind: function-exit,  tsc: 10010 }
+  - { type: 0, func-id:  2, cpu: 1, thread: 111, kind: function-enter, tsc: 10100 }
+  - { type: 0, func-id:  2, cpu: 1, thread: 111, kind: function-exit,  tsc: 10120 }
+  - { type: 0, func-id:  3, cpu: 1, thread: 111, kind: function-enter, tsc: 10200 }
+  - { type: 0, func-id:  3, cpu: 1, thread: 111, kind: function-exit,  tsc: 10230 }
+  - { type: 0, func-id:  4, cpu: 1, thread: 111, kind: function-enter, tsc: 10300 }
+  - { type: 0, func-id:  4, cpu: 1, thread: 111, kind: function-exit,  tsc: 10340 }
+  - { type: 0, func-id:  5, cpu: 1, thread: 111, kind: function-enter, tsc: 10400 }
+  - { type: 0, func-id:  5, cpu: 1, thread: 111, kind: function-exit,  tsc: 10450 }
+  - { type: 0, func-id:  6, cpu: 1, thread: 111, kind: function-enter, tsc: 10500 }
+  - { type: 0, func-id:  6, cpu: 1, thread: 111, kind: function-exit,  tsc: 10560 }
+  - { type: 0, func-id:  7, cpu: 1, thread: 111, kind: function-enter, tsc: 10600 }
+  - { type: 0, func-id:  7, cpu: 1, thread: 111, kind: function-exit,  tsc: 10670 }
+  - { type: 0, func-id:  8, cpu: 1, thread: 111, kind: function-enter, tsc: 10700 }
+  - { type: 0, func-id:  8, cpu: 1, thread: 111, kind: function-exit,  tsc: 10780 }
+  - { type: 0, func-id:  9, cpu: 1, thread: 111, kind: function-enter, tsc: 10800 }
+  - { type: 0, func-id:  9, cpu: 1, thread: 111, kind: function-exit,  tsc: 10890 }
+  - { type: 0, func-id: 11, cpu: 1, thread: 111, kind: function-enter, tsc: 10900 }
+  - { type: 0, func-id: 11, cpu: 1, thread: 111, kind: function-exit,  tsc: 10910 } 
+---

llvm/trunk/test/tools/llvm-xray/X86/Inputs/graph-diff-B.yaml

+---
+header:
+  version: 1
+  type: 0
+  constant-tsc: true
+  nonstop-tsc: true
+  cycle-frequency: 1
+records:
+  - { type: 0, func-id:  1, cpu: 1, thread: 111, kind: function-enter, tsc: 10000 }
+  - { type: 0, func-id:  1, cpu: 1, thread: 111, kind: function-exit,  tsc: 10090 }
+  - { type: 0, func-id:  2, cpu: 1, thread: 111, kind: function-enter, tsc: 10100 }
+  - { type: 0, func-id:  2, cpu: 1, thread: 111, kind: function-exit,  tsc: 10180 }
+  - { type: 0, func-id:  3, cpu: 1, thread: 111, kind: function-enter, tsc: 10200 }
+  - { type: 0, func-id:  3, cpu: 1, thread: 111, kind: function-exit,  tsc: 10270 }
+  - { type: 0, func-id:  4, cpu: 1, thread: 111, kind: function-enter, tsc: 10300 }
+  - { type: 0, func-id:  4, cpu: 1, thread: 111, kind: function-exit,  tsc: 10360 }
+  - { type: 0, func-id:  5, cpu: 1, thread: 111, kind: function-enter, tsc: 10400 }
+  - { type: 0, func-id:  5, cpu: 1, thread: 111, kind: function-exit,  tsc: 10450 }
+  - { type: 0, func-id:  6, cpu: 1, thread: 111, kind: function-enter, tsc: 10500 }
+  - { type: 0, func-id:  6, cpu: 1, thread: 111, kind: function-exit,  tsc: 10540 }
+  - { type: 0, func-id:  7, cpu: 1, thread: 111, kind: function-enter, tsc: 10600 }
+  - { type: 0, func-id:  7, cpu: 1, thread: 111, kind: function-exit,  tsc: 10630 }
+  - { type: 0, func-id:  8, cpu: 1, thread: 111, kind: function-enter, tsc: 10700 }
+  - { type: 0, func-id:  8, cpu: 1, thread: 111, kind: function-exit,  tsc: 10720 }
+  - { type: 0, func-id:  9, cpu: 1, thread: 111, kind: function-enter, tsc: 10800 }
+  - { type: 0, func-id:  9, cpu: 1, thread: 111, kind: function-exit,  tsc: 10810 }
+  - { type: 0, func-id: 10, cpu: 1, thread: 111, kind: function-enter, tsc: 10900 }
+  - { type: 0, func-id: 10, cpu: 1, thread: 111, kind: function-exit,  tsc: 10910 }
+---
+

llvm/trunk/test/tools/llvm-xray/X86/Inputs/simple-instrmap.yaml

 - { id: 6, address: 0x6, function: 0x6, kind: function-enter, always-instrument: true}
 - { id: 6, address: 0x7, function: 0x6, kind: function-exit, always-instrument: true}
 - { id: 7, address: 0x7, function: 0x7, kind: function-enter, always-instrument: true}
 - { id: 7, address: 0x8, function: 0x7, kind: function-exit, always-instrument: true}
 - { id: 8, address: 0x8, function: 0x8, kind: function-enter, always-instrument: true}
 - { id: 8, address: 0x9, function: 0x8, kind: function-exit, always-instrument: true}
 - { id: 9, address: 0x9, function: 0x9, kind: function-enter, always-instrument: true}
 - { id: 9, address: 0xA, function: 0x9, kind: function-exit, always-instrument: true}
+- { id: 10, address: 0xA, function: 0xA, kind: function-enter, always-instrument: true}
+- { id: 10, address: 0xB, function: 0xA, kind: function-exit, always-instrument: true}
+- { id: 11, address: 0xB, function: 0xB, kind: function-enter, always-instrument: true}
+- { id: 11, address: 0xC, function: 0xB, kind: function-exit, always-instrument: true}
 ...

llvm/trunk/test/tools/llvm-xray/X86/graph-diff-simple.txt

+#RUN: llvm-xray graph-diff -o - -c min -b min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=VCEC
+#RUN: llvm-xray graph-diff -o - -c min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=EC
+#RUN: llvm-xray graph-diff -o - -b min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=VC
+#RUN: llvm-xray graph-diff -o - -e min -v min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=ELVL
+#RUN: llvm-xray graph-diff -o - -e min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=EL
+#RUN: llvm-xray graph-diff -o - -v min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=VL
+#RUN: llvm-xray graph-diff -o - -v min -b min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=VLVC
+#RUN: llvm-xray graph-diff -o - -e min -c min -m %S/Inputs/simple-instrmap.yaml \
+#RUN:  %S/Inputs/graph-diff-A.yaml %S/Inputs/graph-diff-B.yaml \
+#RUN:  | FileCheck %s -check-prefix=ELEC
+
+#VCEC:      digraph xrayDiff {
+#VCEC-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#VCEC-DAG:  F[[N1NO:[0-9]+]] [label="#1" color="#276419"]
+#VCEC-DAG:  F[[N2NO:[0-9]+]] [label="#2" color="#276419"]
+#VCEC-DAG:  F[[N3NO:[0-9]+]] [label="#3" color="#276419"]
+#VCEC-DAG:  F[[N4NO:[0-9]+]] [label="#4" color="#9BCF61"]
+#VCEC-DAG:  F[[N5NO:[0-9]+]] [label="#5" color="#F7F7F7"]
+#VCEC-DAG:  F[[N6NO:[0-9]+]] [label="#6" color="#F5C4E0"]
+#VCEC-DAG:  F[[N7NO:[0-9]+]] [label="#7" color="#E17FB4"]
+#VCEC-DAG:  F[[N8NO:[0-9]+]] [label="#8" color="#CB3088"]
+#VCEC-DAG:  F[[N9NO:[0-9]+]] [label="#9" color="#AD0E69"]
+#VCEC-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#VCEC-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="" color="#276419" labelfontcolor="#276419" penwidth=8.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="" color="#276419" labelfontcolor="#276419" penwidth=3.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="" color="#276419" labelfontcolor="#276419" penwidth=1.33]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="" color="#9BCF61" labelfontcolor="#9BCF61" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="" color="#F7F7F7" labelfontcolor="#F7F7F7" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="" color="#F5C4E0" labelfontcolor="#F5C4E0" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="" color="#E17FB4" labelfontcolor="#E17FB4" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="" color="#CB3088" labelfontcolor="#CB3088" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="" color="#AD0E69" labelfontcolor="#AD0E69" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#VCEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#VCEC-NEXT:}
+
+
+#EC:      digraph xrayDiff {
+#EC-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#EC-DAG:  F[[N1NO:[0-9]+]] [label="#1" color="black"]
+#EC-DAG:  F[[N2NO:[0-9]+]] [label="#2" color="black"]
+#EC-DAG:  F[[N3NO:[0-9]+]] [label="#3" color="black"]
+#EC-DAG:  F[[N4NO:[0-9]+]] [label="#4" color="black"]
+#EC-DAG:  F[[N5NO:[0-9]+]] [label="#5" color="black"]
+#EC-DAG:  F[[N6NO:[0-9]+]] [label="#6" color="black"]
+#EC-DAG:  F[[N7NO:[0-9]+]] [label="#7" color="black"]
+#EC-DAG:  F[[N8NO:[0-9]+]] [label="#8" color="black"]
+#EC-DAG:  F[[N9NO:[0-9]+]] [label="#9" color="black"]
+#EC-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#EC-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="" color="#276419" labelfontcolor="#276419" penwidth=8.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="" color="#276419" labelfontcolor="#276419" penwidth=3.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="" color="#276419" labelfontcolor="#276419" penwidth=1.33]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="" color="#9BCF61" labelfontcolor="#9BCF61" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="" color="#F7F7F7" labelfontcolor="#F7F7F7" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="" color="#F5C4E0" labelfontcolor="#F5C4E0" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="" color="#E17FB4" labelfontcolor="#E17FB4" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="" color="#CB3088" labelfontcolor="#CB3088" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="" color="#AD0E69" labelfontcolor="#AD0E69" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#EC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#EC-NEXT:}
+
+#VC:      digraph xrayDiff {
+#VC-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#VC-DAG:  F[[N1NO:[0-9]+]] [label="#1" color="#276419"]
+#VC-DAG:  F[[N2NO:[0-9]+]] [label="#2" color="#276419"]
+#VC-DAG:  F[[N3NO:[0-9]+]] [label="#3" color="#276419"]
+#VC-DAG:  F[[N4NO:[0-9]+]] [label="#4" color="#9BCF61"]
+#VC-DAG:  F[[N5NO:[0-9]+]] [label="#5" color="#F7F7F7"]
+#VC-DAG:  F[[N6NO:[0-9]+]] [label="#6" color="#F5C4E0"]
+#VC-DAG:  F[[N7NO:[0-9]+]] [label="#7" color="#E17FB4"]
+#VC-DAG:  F[[N8NO:[0-9]+]] [label="#8" color="#CB3088"]
+#VC-DAG:  F[[N9NO:[0-9]+]] [label="#9" color="#AD0E69"]
+#VC-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#VC-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#VC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#VC-NEXT:}
+
+#ELVL:      digraph xrayDiff {
+#ELVL-NEXT: node [shape=record]
+#ELVL-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#ELVL-DAG:  F[[N1NO:[0-9]+]] [label="{#1|800.00%}" color="black"]
+#ELVL-DAG:  F[[N2NO:[0-9]+]] [label="{#2|300.00%}" color="black"]
+#ELVL-DAG:  F[[N3NO:[0-9]+]] [label="{#3|133.33%}" color="black"]
+#ELVL-DAG:  F[[N4NO:[0-9]+]] [label="{#4|50.00%}" color="black"]
+#ELVL-DAG:  F[[N5NO:[0-9]+]] [label="{#5|0.00%}" color="black"]
+#ELVL-DAG:  F[[N6NO:[0-9]+]] [label="{#6|-33.33%}" color="black"]
+#ELVL-DAG:  F[[N7NO:[0-9]+]] [label="{#7|-57.14%}" color="black"]
+#ELVL-DAG:  F[[N8NO:[0-9]+]] [label="{#8|-75.00%}" color="black"]
+#ELVL-DAG:  F[[N9NO:[0-9]+]] [label="{#9|-88.89%}" color="black"]
+#ELVL-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#ELVL-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="800.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="300.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="133.33%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="50.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="0.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="-33.33%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="-57.14%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="-75.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="-88.89%" color="black" labelfontcolor="black" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#ELVL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#ELVL-NEXT:}
+
+#EL:      digraph xrayDiff {
+#EL-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#EL-DAG:  F[[N1NO:[0-9]+]] [label="#1" color="black"]
+#EL-DAG:  F[[N2NO:[0-9]+]] [label="#2" color="black"]
+#EL-DAG:  F[[N3NO:[0-9]+]] [label="#3" color="black"]
+#EL-DAG:  F[[N4NO:[0-9]+]] [label="#4" color="black"]
+#EL-DAG:  F[[N5NO:[0-9]+]] [label="#5" color="black"]
+#EL-DAG:  F[[N6NO:[0-9]+]] [label="#6" color="black"]
+#EL-DAG:  F[[N7NO:[0-9]+]] [label="#7" color="black"]
+#EL-DAG:  F[[N8NO:[0-9]+]] [label="#8" color="black"]
+#EL-DAG:  F[[N9NO:[0-9]+]] [label="#9" color="black"]
+#EL-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#EL-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="800.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="300.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="133.33%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="50.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="0.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="-33.33%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="-57.14%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="-75.00%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="-88.89%" color="black" labelfontcolor="black" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#EL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#EL-NEXT:}
+
+#VL:      digraph xrayDiff {
+#VL-NEXT: node [shape=record]
+#VL-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#VL-DAG:  F[[N1NO:[0-9]+]] [label="{#1|800.00%}" color="black"]
+#VL-DAG:  F[[N2NO:[0-9]+]] [label="{#2|300.00%}" color="black"]
+#VL-DAG:  F[[N3NO:[0-9]+]] [label="{#3|133.33%}" color="black"]
+#VL-DAG:  F[[N4NO:[0-9]+]] [label="{#4|50.00%}" color="black"]
+#VL-DAG:  F[[N5NO:[0-9]+]] [label="{#5|0.00%}" color="black"]
+#VL-DAG:  F[[N6NO:[0-9]+]] [label="{#6|-33.33%}" color="black"]
+#VL-DAG:  F[[N7NO:[0-9]+]] [label="{#7|-57.14%}" color="black"]
+#VL-DAG:  F[[N8NO:[0-9]+]] [label="{#8|-75.00%}" color="black"]
+#VL-DAG:  F[[N9NO:[0-9]+]] [label="{#9|-88.89%}" color="black"]
+#VL-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#VL-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#VL-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#VL-NEXT:}
+
+#VLVC:      digraph xrayDiff {
+#VLVC-NEXT: node [shape=record]
+#VLVC-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#VLVC-DAG:  F[[N1NO:[0-9]+]] [label="{#1|800.00%}" color="#276419"]
+#VLVC-DAG:  F[[N2NO:[0-9]+]] [label="{#2|300.00%}" color="#276419"]
+#VLVC-DAG:  F[[N3NO:[0-9]+]] [label="{#3|133.33%}" color="#276419"]
+#VLVC-DAG:  F[[N4NO:[0-9]+]] [label="{#4|50.00%}" color="#9BCF61"]
+#VLVC-DAG:  F[[N5NO:[0-9]+]] [label="{#5|0.00%}" color="#F7F7F7"]
+#VLVC-DAG:  F[[N6NO:[0-9]+]] [label="{#6|-33.33%}" color="#F5C4E0"]
+#VLVC-DAG:  F[[N7NO:[0-9]+]] [label="{#7|-57.14%}" color="#E17FB4"]
+#VLVC-DAG:  F[[N8NO:[0-9]+]] [label="{#8|-75.00%}" color="#CB3088"]
+#VLVC-DAG:  F[[N9NO:[0-9]+]] [label="{#9|-88.89%}" color="#AD0E69"]
+#VLVC-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#VLVC-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="" color="black" labelfontcolor="black" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#VLVC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#VLVC-NEXT:}
+
+#ELEC:      digraph xrayDiff {
+#ELEC-DAG:  F[[F0NO:[0-9]+]] [label="F0"]
+#ELEC-DAG:  F[[N1NO:[0-9]+]] [label="#1" color="black"]
+#ELEC-DAG:  F[[N2NO:[0-9]+]] [label="#2" color="black"]
+#ELEC-DAG:  F[[N3NO:[0-9]+]] [label="#3" color="black"]
+#ELEC-DAG:  F[[N4NO:[0-9]+]] [label="#4" color="black"]
+#ELEC-DAG:  F[[N5NO:[0-9]+]] [label="#5" color="black"]
+#ELEC-DAG:  F[[N6NO:[0-9]+]] [label="#6" color="black"]
+#ELEC-DAG:  F[[N7NO:[0-9]+]] [label="#7" color="black"]
+#ELEC-DAG:  F[[N8NO:[0-9]+]] [label="#8" color="black"]
+#ELEC-DAG:  F[[N9NO:[0-9]+]] [label="#9" color="black"]
+#ELEC-DAG:  F[[NANO:[0-9]+]] [label="#10" color="#00FF00"]
+#ELEC-DAG:  F[[NBNO:[0-9]+]] [label="#11" color="#FF0000"]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N1NO]] [tooltip="F0 -> #1" label="800.00%" color="#276419" labelfontcolor="#276419" penwidth=8.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N2NO]] [tooltip="F0 -> #2" label="300.00%" color="#276419" labelfontcolor="#276419" penwidth=3.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N3NO]] [tooltip="F0 -> #3" label="133.33%" color="#276419" labelfontcolor="#276419" penwidth=1.33]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N4NO]] [tooltip="F0 -> #4" label="50.00%" color="#9BCF61" labelfontcolor="#9BCF61" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N5NO]] [tooltip="F0 -> #5" label="0.00%" color="#F7F7F7" labelfontcolor="#F7F7F7" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N6NO]] [tooltip="F0 -> #6" label="-33.33%" color="#F5C4E0" labelfontcolor="#F5C4E0" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N7NO]] [tooltip="F0 -> #7" label="-57.14%" color="#E17FB4" labelfontcolor="#E17FB4" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N8NO]] [tooltip="F0 -> #8" label="-75.00%" color="#CB3088" labelfontcolor="#CB3088" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[N9NO]] [tooltip="F0 -> #9" label="-88.89%" color="#AD0E69" labelfontcolor="#AD0E69" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NANO]] [tooltip="F0 -> #10" label="" color="#00FF00" labelfontcolor="#00FF00" penwidth=1.00]
+#ELEC-DAG:  F{{.*}}[[F0NO]] -> F{{.*}}[[NBNO]] [tooltip="F0 -> #11" label="" color="#FF0000" labelfontcolor="#FF0000" penwidth=1.00]
+#ELEC-NEXT:}
+
+

llvm/trunk/tools/llvm-xray/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   DebugInfoDWARF
   Object
   Support
   Symbolize
   XRay)
 
 set(LLVM_XRAY_TOOLS
   func-id-helper.cc
   xray-account.cc
   xray-color-helper.cc
   xray-converter.cc
   xray-extract.cc
   xray-extract.cc
   xray-graph.cc
+  xray-graph-diff.cc
   xray-registry.cc)
 
 add_llvm_tool(llvm-xray llvm-xray.cc ${LLVM_XRAY_TOOLS})

llvm/trunk/tools/llvm-xray/xray-color-helper.h

 /// for (double p= -1; p <= 1 ; p += 0.1){
 ///   cout() << D.getColor(p) << " \n"; // sample the gradient at 0.1 intervals
 /// }
 class ColorHelper {
   double MinIn;
   double MaxIn;
 
   ArrayRef<std::tuple<uint8_t, uint8_t, uint8_t>> ColorMap;
+  ArrayRef<std::tuple<uint8_t, uint8_t, uint8_t>> BoundMap;
 
 public:
   /// Enum of the availible Sequential Color Schemes
   enum class SequentialScheme {
     // Schemes based on the ColorBrewer Color schemes of the same name from
     // http://www.colorbrewer.org/ by Cynthis A Brewer Penn State University.
     Greys,
     OrRd,
public:
 
   ColorHelper(DivergingScheme S);
 
   // Sample the gradient at the input point.
   std::tuple<uint8_t, uint8_t, uint8_t> getColorTuple(double Point) const;
 
   std::string getColorString(double Point) const;
 
+  // Get the Default color, at the moment allways black.
+  std::tuple<uint8_t, uint8_t, uint8_t> getDefaultColorTuple() const {
+    return std::make_tuple(0, 0, 0);
+  }
+
+  std::string getDefaultColorString() const { return "black"; }
+
   // Convert a tuple to a string
   static std::string getColorString(std::tuple<uint8_t, uint8_t, uint8_t> t);
 };
-}
-}
+} // namespace xray
+} // namespace llvm
 #endif

llvm/trunk/tools/llvm-xray/xray-color-helper.cc

 //===-- xray-graph.cc - XRay Function Call Graph Renderer -----------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // A class to get a color from a specified gradient.
 //
 //===----------------------------------------------------------------------===//
 #include <algorithm>
+#include <iostream>
 
 #include "xray-color-helper.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace xray;
 
static const std::tuple<uint8_t, uint8_t, uint8_t> SequentialMaps[][9] = {
      std::make_tuple(127, 0, 0)},
     {// The PuBu color scheme from http://colorbrewer2.org/
      std::make_tuple(255, 247, 251), std::make_tuple(236, 231, 242),
      std::make_tuple(208, 209, 230), std::make_tuple(166, 189, 219),
      std::make_tuple(116, 169, 207), std::make_tuple(54, 144, 192),
      std::make_tuple(5, 112, 176), std::make_tuple(4, 90, 141),
      std::make_tuple(2, 56, 88)}};
 
+// Sequential Maps extend the last colors given out of range inputs.
+static const std::tuple<uint8_t, uint8_t, uint8_t> SequentialBounds[][2] = {
+    {// The Bounds for the greys color scheme
+     std::make_tuple(255, 255, 255), std::make_tuple(0, 0, 0)},
+    {// The Bounds for the OrRd color Scheme
+     std::make_tuple(255, 247, 236), std::make_tuple(127, 0, 0)},
+    {// The Bounds for the PuBu color Scheme
+     std::make_tuple(255, 247, 251), std::make_tuple(2, 56, 88)}};
+
 ColorHelper::ColorHelper(ColorHelper::SequentialScheme S)
-    : MinIn(0.0), MaxIn(1.0), ColorMap(SequentialMaps[static_cast<int>(S)]) {}
+    : MinIn(0.0), MaxIn(1.0), ColorMap(SequentialMaps[static_cast<int>(S)]),
+      BoundMap(SequentialBounds[static_cast<int>(S)]) {}
 
 // Diverging ColorMaps, which are used to represent information
 // representing differenes, or a range that goes from negative to positive.
 // These take an input in the range [-1,1].
 
 static const std::tuple<uint8_t, uint8_t, uint8_t> DivergingCoeffs[][11] = {
     {// The PiYG color scheme from http://colorbrewer2.org/
      std::make_tuple(142, 1, 82), std::make_tuple(197, 27, 125),
      std::make_tuple(222, 119, 174), std::make_tuple(241, 182, 218),
      std::make_tuple(253, 224, 239), std::make_tuple(247, 247, 247),
      std::make_tuple(230, 245, 208), std::make_tuple(184, 225, 134),
      std::make_tuple(127, 188, 65), std::make_tuple(77, 146, 33),
      std::make_tuple(39, 100, 25)}};
 
+// Diverging maps use out of bounds ranges to show missing data. Missing Right
+// Being below min, and missing left being above max.
+static const std::tuple<uint8_t, uint8_t, uint8_t> DivergingBounds[][2] = {
+    {// The PiYG color scheme has green and red for missing right and left
+     // respectively.
+     std::make_tuple(255, 0, 0), std::make_tuple(0, 255, 0)}};
+
 ColorHelper::ColorHelper(ColorHelper::DivergingScheme S)
-    : MinIn(-1.0), MaxIn(1.0), ColorMap(DivergingCoeffs[static_cast<int>(S)]) {}
+    : MinIn(-1.0), MaxIn(1.0), ColorMap(DivergingCoeffs[static_cast<int>(S)]),
+      BoundMap(DivergingBounds[static_cast<int>(S)]) {}
 
 // Takes a tuple of uint8_ts representing a color in RGB and converts them to
 // HSV represented by a tuple of doubles
 static std::tuple<double, double, double>
 convertToHSV(const std::tuple<uint8_t, uint8_t, uint8_t> &Color) {
   double Scaled[3] = {std::get<0>(Color) / 255.0, std::get<1>(Color) / 255.0,
                       std::get<2>(Color) / 255.0};
   int Min = 0;
   int Max = 0;
   for (int i = 1; i < 3; ++i) {
     if (Scaled[i] < Scaled[Min])
       Min = i;
     if (Scaled[i] > Scaled[Max])
       Max = i;
   }
 
   double C = Scaled[Max] - Scaled[Min];
 
-  double HPrime = (Scaled[(Max + 1) % 3] - Scaled[(Max + 2) % 3]) / C;
+  double HPrime =
+      (C == 0) ? 0 : (Scaled[(Max + 1) % 3] - Scaled[(Max + 2) % 3]) / C;
   HPrime = HPrime + 2.0 * Max;
 
   double H = (HPrime < 0) ? (HPrime + 6.0) * 60
                           : HPrime * 60; // Scale to between 0 and 360
-
   double V = Scaled[Max];
 
   double S = (V == 0.0) ? 0.0 : C / V;
 
   return std::make_tuple(H, S, V);
 }
 
 // Takes a double precision number, clips it between 0 and 1 and then converts
interpolateHSV(const std::tuple<double, double, double> &C0,
   double V = std::get<2>(C0) + T * (std::get<2>(C1) - std::get<2>(C0));
   return std::make_tuple(H, S, V);
 }
 
 // Get the Color as a tuple of uint8_ts
 std::tuple<uint8_t, uint8_t, uint8_t>
 ColorHelper::getColorTuple(double Point) const {
   assert(!ColorMap.empty() && "ColorMap must not be empty!");
+  assert(!BoundMap.empty() && "BoundMap must not be empty!");
+
+  if (Point < MinIn)
+    return BoundMap[0];
+  if (Point > MaxIn)
+    return BoundMap[1];
+
   size_t MaxIndex = ColorMap.size() - 1;
   double IntervalWidth = MaxIn - MinIn;
   double OffsetP = Point - MinIn;
   double SectionWidth = IntervalWidth / static_cast<double>(MaxIndex);
   size_t SectionNo = std::floor(OffsetP / SectionWidth);
   double T = (OffsetP - SectionNo * SectionWidth) / SectionWidth;
 
   auto &RGBColor0 = ColorMap[SectionNo];

llvm/trunk/tools/llvm-xray/xray-graph-diff.h

+//===-- xray-graph-diff.h - XRay Graph Diff Renderer ------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Generate a DOT file to represent the difference between the function call
+// graph of two differnent traces.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef XRAY_GRAPH_DIFF_H
+#define XRAY_GRAPH_DIFF_H
+
+#include "xray-graph.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/XRay/Graph.h"
+
+namespace llvm {
+namespace xray {
+
+// This class creates a graph representing the difference between two
+// xray-graphs And allows you to print it to a dot file, with optional color
+// coding.
+class GraphDiffRenderer {
+  static const int N = 2;
+
+public:
+  using StatType = GraphRenderer::StatType;
+  using TimeStat = GraphRenderer::TimeStat;
+
+  using GREdgeValueType = GraphRenderer::GraphT::EdgeValueType;
+  using GRVertexValueType = GraphRenderer::GraphT::VertexValueType;
+
+  struct EdgeAttribute {
+    std::array<const GREdgeValueType *, N> CorrEdgePtr = {};
+  };
+
+  struct VertexAttribute {
+    std::array<const GRVertexValueType *, N> CorrVertexPtr = {};
+  };
+
+  using GraphT = Graph<VertexAttribute, EdgeAttribute, StringRef>;
+
+  class Factory {
+    std::array<std::reference_wrapper<const GraphRenderer::GraphT>, N> G;
+
+  public:
+    template <typename... Ts> Factory(Ts &... Args) : G{{Args...}} {};
+
+    Expected<GraphDiffRenderer> getGraphDiffRenderer();
+  };
+
+private:
+  GraphT G;
+
+  GraphDiffRenderer() = default;
+
+public:
+  void exportGraphAsDOT(raw_ostream &OS, StatType EdgeLabel = StatType::NONE,
+                        StatType EdgeColor = StatType::NONE,
+                        StatType VertexLabel = StatType::NONE,
+                        StatType VertexColor = StatType::NONE,
+                        int TruncLen = 40);
+
+  const GraphT &getGraph() { return G; };
+};
+} // namespace xray
+} // namespace llvm
+
+#endif

llvm/trunk/tools/llvm-xray/xray-graph-diff.cc

+//===-- xray-graph-diff.cc - XRay Function Call Graph Renderer ------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// Generate a DOT file to represent the function call graph encountered in
+// the trace.
+//
+//===----------------------------------------------------------------------===//
+#include <cassert>
+#include <cmath>
+#include <limits>
+#include <string>
+
+#include "xray-graph-diff.h"
+#include "xray-graph.h"
+#include "xray-registry.h"
+
+#include "xray-color-helper.h"
+#include "llvm/ADT/iterator_range.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/XRay/Trace.h"
+
+using namespace llvm;
+using namespace xray;
+
+static cl::SubCommand GraphDiff("graph-diff",
+                                "Generate diff of function-call graphs");
+static cl::opt<std::string> GraphDiffInput1(cl::Positional,
+                                            cl::desc("<xray log file 1>"),
+                                            cl::Required, cl::sub(GraphDiff));
+static cl::opt<std::string> GraphDiffInput2(cl::Positional,
+                                            cl::desc("<xray log file 2>"),
+                                            cl::Required, cl::sub(GraphDiff));
+
+static cl::opt<bool>
+    GraphDiffKeepGoing("keep-going",
+                       cl::desc("Keep going on errors encountered"),
+                       cl::sub(GraphDiff), cl::init(false));
+static cl::alias GraphDiffKeepGoingA("k", cl::aliasopt(GraphDiffKeepGoing),
+                                     cl::desc("Alias for -keep-going"),
+                                     cl::sub(GraphDiff));
+static cl::opt<bool>
+    GraphDiffKeepGoing1("keep-going-1",
+                        cl::desc("Keep going on errors encountered in trace 1"),
+                        cl::sub(GraphDiff), cl::init(false));
+static cl::alias GraphDiffKeepGoing1A("k1", cl::aliasopt(GraphDiffKeepGoing1),
+                                      cl::desc("Alias for -keep-going-1"),
+                                      cl::sub(GraphDiff));
+static cl::opt<bool>
+    GraphDiffKeepGoing2("keep-going-2",
+                        cl::desc("Keep going on errors encountered in trace 2"),
+                        cl::sub(GraphDiff), cl::init(false));
+static cl::alias GraphDiffKeepGoing2A("k2", cl::aliasopt(GraphDiffKeepGoing2),
+                                      cl::desc("Alias for -keep-going-2"),
+                                      cl::sub(GraphDiff));
+
+static cl::opt<std::string>
+    GraphDiffInstrMap("instr-map",
+                      cl::desc("binary with the instrumentation map, or "
+                               "a separate instrumentation map for graph"),
+                      cl::value_desc("binary with xray_instr_map or yaml"),
+                      cl::sub(GraphDiff), cl::init(""));
+static cl::alias GraphDiffInstrMapA("m", cl::aliasopt(GraphDiffInstrMap),
+                                    cl::desc("Alias for -instr-map"),
+                                    cl::sub(GraphDiff));
+static cl::opt<std::string>
+    GraphDiffInstrMap1("instr-map-1",
+                       cl::desc("binary with the instrumentation map, or "
+                                "a separate instrumentation map for graph 1"),
+                       cl::value_desc("binary with xray_instr_map or yaml"),
+                       cl::sub(GraphDiff), cl::init(""));
+static cl::alias GraphDiffInstrMap1A("m1", cl::aliasopt(GraphDiffInstrMap1),
+                                     cl::desc("Alias for -instr-map-1"),
+                                     cl::sub(GraphDiff));
+static cl::opt<std::string>
+    GraphDiffInstrMap2("instr-map-2",
+                       cl::desc("binary with the instrumentation map, or "
+                                "a separate instrumentation map for graph 2"),
+                       cl::value_desc("binary with xray_instr_map or yaml"),
+                       cl::sub(GraphDiff), cl::init(""));
+static cl::alias GraphDiffInstrMap2A("m2", cl::aliasopt(GraphDiffInstrMap2),
+                                     cl::desc("Alias for -instr-map-2"),
+                                     cl::sub(GraphDiff));
+
+static cl::opt<bool> GraphDiffDeduceSiblingCalls(
+    "deduce-sibling-calls",
+    cl::desc("Deduce sibling calls when unrolling function call stacks"),
+    cl::sub(GraphDiff), cl::init(false));
+static cl::alias
+    GraphDiffDeduceSiblingCallsA("d", cl::aliasopt(GraphDiffDeduceSiblingCalls),
+                                 cl::desc("Alias for -deduce-sibling-calls"),
+                                 cl::sub(GraphDiff));
+static cl::opt<bool> GraphDiffDeduceSiblingCalls1(
+    "deduce-sibling-calls-1",
+    cl::desc("Deduce sibling calls when unrolling function call stacks"),
+    cl::sub(GraphDiff), cl::init(false));
+static cl::alias GraphDiffDeduceSiblingCalls1A(
+    "d1", cl::aliasopt(GraphDiffDeduceSiblingCalls1),
+    cl::desc("Alias for -deduce-sibling-calls-1"), cl::sub(GraphDiff));
+static cl::opt<bool> GraphDiffDeduceSiblingCalls2(
+    "deduce-sibling-calls-2",
+    cl::desc("Deduce sibling calls when unrolling function call stacks"),
+    cl::sub(GraphDiff), cl::init(false));
+static cl::alias GraphDiffDeduceSiblingCalls2A(
+    "d2", cl::aliasopt(GraphDiffDeduceSiblingCalls2),
+    cl::desc("Alias for -deduce-sibling-calls-2"), cl::sub(GraphDiff));
+
+static cl::opt<GraphRenderer::StatType> GraphDiffEdgeLabel(
+    "edge-label", cl::desc("Output graphs with edges labeled with this field"),
+    cl::value_desc("field"), cl::sub(GraphDiff),
+    cl::init(GraphRenderer::StatType::NONE),
+    cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
+                          "Do not label Edges"),
+               clEnumValN(GraphRenderer::StatType::COUNT, "count",
+                          "function call counts"),
+               clEnumValN(GraphRenderer::StatType::MIN, "min",
+                          "minimum function durations"),
+               clEnumValN(GraphRenderer::StatType::MED, "med",
+                          "median function durations"),
+               clEnumValN(GraphRenderer::StatType::PCT90, "90p",
+                          "90th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::PCT99, "99p",
+                          "99th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::MAX, "max",
+                          "maximum function durations"),
+               clEnumValN(GraphRenderer::StatType::SUM, "sum",
+                          "sum of call durations")));
+static cl::alias GraphDiffEdgeLabelA("e", cl::aliasopt(GraphDiffEdgeLabel),
+                                     cl::desc("Alias for -edge-label"),
+                                     cl::sub(GraphDiff));
+
+static cl::opt<GraphRenderer::StatType> GraphDiffEdgeColor(
+    "edge-color", cl::desc("Output graphs with edges colored by this field"),
+    cl::value_desc("field"), cl::sub(GraphDiff),
+    cl::init(GraphRenderer::StatType::NONE),
+    cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
+                          "Do not color Edges"),
+               clEnumValN(GraphRenderer::StatType::COUNT, "count",
+                          "function call counts"),
+               clEnumValN(GraphRenderer::StatType::MIN, "min",
+                          "minimum function durations"),
+               clEnumValN(GraphRenderer::StatType::MED, "med",
+                          "median function durations"),
+               clEnumValN(GraphRenderer::StatType::PCT90, "90p",
+                          "90th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::PCT99, "99p",
+                          "99th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::MAX, "max",
+                          "maximum function durations"),
+               clEnumValN(GraphRenderer::StatType::SUM, "sum",
+                          "sum of call durations")));
+static cl::alias GraphDiffEdgeColorA("c", cl::aliasopt(GraphDiffEdgeColor),
+                                     cl::desc("Alias for -edge-color"),
+                                     cl::sub(GraphDiff));
+
+static cl::opt<GraphRenderer::StatType> GraphDiffVertexLabel(
+    "vertex-label",
+    cl::desc("Output graphs with vertices labeled with this field"),
+    cl::value_desc("field"), cl::sub(GraphDiff),
+    cl::init(GraphRenderer::StatType::NONE),
+    cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
+                          "Do not label Vertices"),
+               clEnumValN(GraphRenderer::StatType::COUNT, "count",
+                          "function call counts"),
+               clEnumValN(GraphRenderer::StatType::MIN, "min",
+                          "minimum function durations"),
+               clEnumValN(GraphRenderer::StatType::MED, "med",
+                          "median function durations"),
+               clEnumValN(GraphRenderer::StatType::PCT90, "90p",
+                          "90th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::PCT99, "99p",
+                          "99th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::MAX, "max",
+                          "maximum function durations"),
+               clEnumValN(GraphRenderer::StatType::SUM, "sum",
+                          "sum of call durations")));
+static cl::alias GraphDiffVertexLabelA("v", cl::aliasopt(GraphDiffVertexLabel),
+                                       cl::desc("Alias for -vertex-label"),
+                                       cl::sub(GraphDiff));
+
+static cl::opt<GraphRenderer::StatType> GraphDiffVertexColor(
+    "vertex-color",
+    cl::desc("Output graphs with vertices colored by this field"),
+    cl::value_desc("field"), cl::sub(GraphDiff),
+    cl::init(GraphRenderer::StatType::NONE),
+    cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
+                          "Do not color Vertices"),
+               clEnumValN(GraphRenderer::StatType::COUNT, "count",
+                          "function call counts"),
+               clEnumValN(GraphRenderer::StatType::MIN, "min",
+                          "minimum function durations"),
+               clEnumValN(GraphRenderer::StatType::MED, "med",
+                          "median function durations"),
+               clEnumValN(GraphRenderer::StatType::PCT90, "90p",
+                          "90th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::PCT99, "99p",
+                          "99th percentile durations"),
+               clEnumValN(GraphRenderer::StatType::MAX, "max",
+                          "maximum function durations"),
+               clEnumValN(GraphRenderer::StatType::SUM, "sum",
+                          "sum of call durations")));
+static cl::alias GraphDiffVertexColorA("b", cl::aliasopt(GraphDiffVertexColor),
+                                       cl::desc("Alias for -vertex-color"),
+                                       cl::sub(GraphDiff));
+
+static cl::opt<int> GraphDiffVertexLabelTrunc(
+    "vertex-label-trun", cl::desc("What length to truncate vertex labels to "),
+    cl::sub(GraphDiff), cl::init(40));
+static cl::alias
+    GraphDiffVertexLabelTrunc1("t", cl::aliasopt(GraphDiffVertexLabelTrunc),
+                               cl::desc("Alias for -vertex-label-trun"),
+                               cl::sub(GraphDiff));
+
+static cl::opt<std::string>
+    GraphDiffOutput("output", cl::value_desc("Output file"), cl::init("-"),
+                    cl::desc("output file; use '-' for stdout"),
+                    cl::sub(GraphDiff));
+static cl::alias GraphDiffOutputA("o", cl::aliasopt(GraphDiffOutput),
+                                  cl::desc("Alias for -output"),
+                                  cl::sub(GraphDiff));
+
+Expected<GraphDiffRenderer> GraphDiffRenderer::Factory::getGraphDiffRenderer() {
+  GraphDiffRenderer R;
+
+  for (int i = 0; i < N; ++i) {
+    const auto &G = this->G[i].get();
+    for (const auto &V : G.vertices()) {
+      const auto &VAttr = V.second;
+      R.G[VAttr.SymbolName].CorrVertexPtr[i] = &V;
+    }
+    for (const auto &E : G.edges()) {
+      auto &EdgeTailID = E.first.first;
+      auto &EdgeHeadID = E.first.second;
+      auto EdgeTailAttrOrErr = G.at(EdgeTailID);
+      auto EdgeHeadAttrOrErr = G.at(EdgeHeadID);
+      if (!EdgeTailAttrOrErr)
+        return EdgeTailAttrOrErr.takeError();
+      if (!EdgeHeadAttrOrErr)
+        return EdgeHeadAttrOrErr.takeError();
+      GraphT::EdgeIdentifier ID{EdgeTailAttrOrErr->SymbolName,
+                                EdgeHeadAttrOrErr->SymbolName};
+      R.G[ID].CorrEdgePtr[i] = &E;
+    }
+  }
+
+  return R;
+}
+// Returns the Relative change With respect to LeftStat between LeftStat
+// and RightStat.
+static double statRelDiff(const GraphDiffRenderer::TimeStat &LeftStat,
+                          const GraphDiffRenderer::TimeStat &RightStat,
+                          GraphDiffRenderer::StatType T) {
+  double LeftAttr = LeftStat.getDouble(T);
+  double RightAttr = RightStat.getDouble(T);
+
+  return RightAttr / LeftAttr - 1.0;
+}
+
+static std::string getColor(const GraphDiffRenderer::GraphT::EdgeValueType &E,
+                            const GraphDiffRenderer::GraphT &G, ColorHelper H,
+                            GraphDiffRenderer::StatType T) {
+  auto &EdgeAttr = E.second;
+  if (EdgeAttr.CorrEdgePtr[0] == nullptr)
+    return H.getColorString(2.0); // A number greater than 1.0
+  if (EdgeAttr.CorrEdgePtr[1] == nullptr)
+    return H.getColorString(-2.0); // A number less than -1.0
+
+  if (T == GraphDiffRenderer::StatType::NONE)
+    return H.getDefaultColorString();
+
+  const auto &LeftStat = EdgeAttr.CorrEdgePtr[0]->second.S;
+  const auto &RightStat = EdgeAttr.CorrEdgePtr[1]->second.S;
+
+  double RelDiff = statRelDiff(LeftStat, RightStat, T);
+  double CappedRelDiff = std::min(1.0, std::max(-1.0, RelDiff));
+
+  return H.getColorString(CappedRelDiff);
+}
+
+static std::string getColor(const GraphDiffRenderer::GraphT::VertexValueType &V,
+                            const GraphDiffRenderer::GraphT &G, ColorHelper H,
+                            GraphDiffRenderer::StatType T) {
+  auto &VertexAttr = V.second;
+  if (VertexAttr.CorrVertexPtr[0] == nullptr)
+    return H.getColorString(2.0); // A number greater than 1.0
+  if (VertexAttr.CorrVertexPtr[1] == nullptr)
+    return H.getColorString(-2.0); // A number less than -1.0
+
+  if (T == GraphDiffRenderer::StatType::NONE)
+    return H.getDefaultColorString();
+
+  const auto &LeftStat = VertexAttr.CorrVertexPtr[0]->second.S;
+  const auto &RightStat = VertexAttr.CorrVertexPtr[1]->second.S;
+
+  double RelDiff = statRelDiff(LeftStat, RightStat, T);
+  double CappedRelDiff = std::min(1.0, std::max(-1.0, RelDiff));
+
+  return H.getColorString(CappedRelDiff);
+}
+
+static Twine truncateString(const StringRef &S, size_t n) {
+  return (S.size() > n) ? Twine(S.substr(0, n)) + "..." : Twine(S);
+}
+
+template <typename T> static bool containsNullptr(const T &Collection) {
+  for (const auto &E : Collection)
+    if (E == nullptr)
+      return true;
+  return false;
+}
+
+static std::string getLabel(const GraphDiffRenderer::GraphT::EdgeValueType &E,
+                            GraphDiffRenderer::StatType EL) {
+  auto &EdgeAttr = E.second;
+  switch (EL) {
+  case GraphDiffRenderer::StatType::NONE:
+    return "";
+  default:
+    if (containsNullptr(EdgeAttr.CorrEdgePtr))
+      return "";
+
+    const auto &LeftStat = EdgeAttr.CorrEdgePtr[0]->second.S;
+    const auto &RightStat = EdgeAttr.CorrEdgePtr[1]->second.S;
+
+    double RelDiff = statRelDiff(LeftStat, RightStat, EL);
+    return formatv(R"({0:P})", RelDiff);
+  }
+}
+
+static std::string getLabel(const GraphDiffRenderer::GraphT::VertexValueType &V,
+                            GraphDiffRenderer::StatType VL, int TrunLen) {
+  const auto &VertexId = V.first;
+  const auto &VertexAttr = V.second;
+  switch (VL) {
+  case GraphDiffRenderer::StatType::NONE:
+    return formatv(R"({0})", truncateString(VertexId, TrunLen).str());
+  default:
+    if (containsNullptr(VertexAttr.CorrVertexPtr))
+      return formatv(R"({0})", truncateString(VertexId, TrunLen).str());
+
+    const auto &LeftStat = VertexAttr.CorrVertexPtr[0]->second.S;
+    const auto &RightStat = VertexAttr.CorrVertexPtr[1]->second.S;
+
+    double RelDiff = statRelDiff(LeftStat, RightStat, VL);
+    return formatv(R"({{{0}|{1:P}})", truncateString(VertexId, TrunLen).str(),
+                   RelDiff);
+  }
+}
+
+static double getLineWidth(const GraphDiffRenderer::GraphT::EdgeValueType &E,
+                           GraphDiffRenderer::StatType EL) {
+  auto &EdgeAttr = E.second;
+  switch (EL) {
+  case GraphDiffRenderer::StatType::NONE:
+    return 1.0;
+  default:
+    if (containsNullptr(EdgeAttr.CorrEdgePtr))
+      return 1.0;
+
+    const auto &LeftStat = EdgeAttr.CorrEdgePtr[0]->second.S;
+    const auto &RightStat = EdgeAttr.CorrEdgePtr[1]->second.S;
+
+    double RelDiff = statRelDiff(LeftStat, RightStat, EL);
+    return (RelDiff > 1.0) ? RelDiff : 1.0;
+  }
+}
+
+void GraphDiffRenderer::exportGraphAsDOT(raw_ostream &OS, StatType EdgeLabel,
+                                         StatType EdgeColor,
+                                         StatType VertexLabel,
+                                         StatType VertexColor, int TruncLen) {
+  // Get numbering of vertices for dot output.
+  StringMap<int32_t> VertexNo;
+
+  int i = 0;
+  for (const auto &V : G.vertices()) {
+    VertexNo[V.first] = i++;
+  }
+
+  ColorHelper H(ColorHelper::DivergingScheme::PiYG);
+
+  OS << "digraph xrayDiff {\n";
+
+  if (VertexLabel != StatType::NONE)
+    OS << "node [shape=record]\n";
+
+  for (const auto &E : G.edges()) {
+    const auto &HeadId = E.first.first;
+    const auto &TailId = E.first.second;
+    OS << formatv(R"(F{0} -> F{1} [tooltip="{2} -> {3}" label="{4}" )"
+                  R"(color="{5}" labelfontcolor="{5}" penwidth={6}])"
+                  "\n",
+                  VertexNo[HeadId], VertexNo[TailId],
+                  (HeadId.equals("")) ? static_cast<StringRef>("F0") : HeadId,
+                  TailId, getLabel(E, EdgeLabel), getColor(E, G, H, EdgeColor),
+                  getLineWidth(E, EdgeColor));
+  }
+
+  for (const auto &V : G.vertices()) {
+    const auto &VertexId = V.first;
+    if (VertexId.equals("")) {
+      OS << formatv(R"(F{0} [label="F0"])"
+                    "\n",
+                    VertexNo[VertexId]);
+      continue;
+    }
+    OS << formatv(R"(F{0} [label="{1}" color="{2}"])"
+                  "\n",
+                  VertexNo[VertexId], getLabel(V, VertexLabel, TruncLen),
+                  getColor(V, G, H, VertexColor));
+  }
+
+  OS << "}\n";
+};
+
+template <typename T> static T &ifSpecified(T &A, cl::alias &AA, T &B) {
+  if (A.getPosition() == 0 && AA.getPosition() == 0)
+    return B;
+
+  return A;
+}
+
+static CommandRegistration Unused(&GraphDiff, []() -> Error {
+  std::array<GraphRenderer::Factory, 2> Factories{
+      {{ifSpecified(GraphDiffKeepGoing1, GraphDiffKeepGoing1A,
+                    GraphDiffKeepGoing),
+        ifSpecified(GraphDiffDeduceSiblingCalls1, GraphDiffDeduceSiblingCalls1A,
+                    GraphDiffDeduceSiblingCalls),
+        ifSpecified(GraphDiffInstrMap1, GraphDiffInstrMap1A, GraphDiffInstrMap),
+        Trace()},
+       {ifSpecified(GraphDiffKeepGoing2, GraphDiffKeepGoing2A,
+                    GraphDiffKeepGoing),
+        ifSpecified(GraphDiffDeduceSiblingCalls2, GraphDiffDeduceSiblingCalls2A,
+                    GraphDiffDeduceSiblingCalls),
+        ifSpecified(GraphDiffInstrMap2, GraphDiffInstrMap2A, GraphDiffInstrMap),
+        Trace()}}};
+
+  std::array<std::string, 2> Inputs{{GraphDiffInput1, GraphDiffInput2}};
+
+  std::array<GraphRenderer::GraphT, 2> Graphs;
+
+  for (int i = 0; i < 2; i++) {
+    auto TraceOrErr = loadTraceFile(Inputs[i], true);
+    if (!TraceOrErr)
+      return make_error<StringError>(
+          Twine("Failed Loading Input File '") + Inputs[i] + "'",
+          make_error_code(llvm::errc::invalid_argument));
+    Factories[i].Trace = std::move(*TraceOrErr);
+
+    auto GraphRendererOrErr = Factories[i].getGraphRenderer();
+
+    if (!GraphRendererOrErr)
+      return GraphRendererOrErr.takeError();
+
+    auto GraphRenderer = *GraphRendererOrErr;
+
+    Graphs[i] = GraphRenderer.getGraph();
+  }
+
+  GraphDiffRenderer::Factory DGF(Graphs[0], Graphs[1]);
+
+  auto GDROrErr = DGF.getGraphDiffRenderer();
+  if (!GDROrErr)
+    return GDROrErr.takeError();
+
+  auto &GDR = *GDROrErr;
+
+  std::error_code EC;
+  raw_fd_ostream OS(GraphDiffOutput, EC, sys::fs::OpenFlags::F_Text);
+  if (EC)
+    return make_error<StringError>(
+        Twine("Cannot open file '") + GraphDiffOutput + "' for writing.", EC);
+
+  GDR.exportGraphAsDOT(OS, GraphDiffEdgeLabel, GraphDiffEdgeColor,
+                       GraphDiffVertexLabel, GraphDiffVertexColor,
+                       GraphDiffVertexLabelTrunc);
+
+  return Error::success();
+});

llvm/trunk/tools/llvm-xray/xray-graph.h

 /// Graphs from them and then exporting those graphs for review.
 class GraphRenderer {
 public:
   /// An enum for enumerating the various statistics gathered on latencies
   enum class StatType { NONE, COUNT, MIN, MED, PCT90, PCT99, MAX, SUM };
 
   /// An inner struct for common timing statistics information
   struct TimeStat {
-    uint64_t Count = 0;
-    double Min = 0;
-    double Median = 0;
-    double Pct90 = 0;
-    double Pct99 = 0;
-    double Max = 0;
-    double Sum = 0;
-    std::string getAsString(StatType T) const;
-    double compare(StatType T, const TimeStat &Other) const;
+    int64_t Count;
+    double Min;
+    double Median;
+    double Pct90;
+    double Pct99;
+    double Max;
+    double Sum;
+
+    std::string getString(StatType T) const;
+    double getDouble(StatType T) const;
   };
-  typedef uint64_t TimestampT;
+  using TimestampT = uint64_t;
 
   /// An inner struct for storing edge attributes for our graph. Here the
   /// attributes are mainly function call statistics.
   ///
   /// FIXME: expand to contain more information eg call latencies.
   struct CallStats {
     TimeStat S;
     std::vector<TimestampT> Timings;
   };
 
   /// An Inner Struct for storing vertex attributes, at the moment just
   /// SymbolNames, however in future we could store bulk function statistics.
   ///
   /// FIXME: Store more attributes based on instrumentation map.
   struct FunctionStats {
     std::string SymbolName;
-    TimeStat S;
+    TimeStat S = {};
   };
 
   struct FunctionAttr {
     int32_t FuncId;
     uint64_t TSC;
   };
 
-  typedef SmallVector<FunctionAttr, 4> FunctionStack;
+  using FunctionStack = SmallVector<FunctionAttr, 4>;
 
-  typedef DenseMap<llvm::sys::ProcessInfo::ProcessId, FunctionStack>
-      PerThreadFunctionStackMap;
+  using PerThreadFunctionStackMap =
+      DenseMap<llvm::sys::ProcessInfo::ProcessId, FunctionStack>;
 
   class GraphT : public Graph<FunctionStats, CallStats, int32_t> {
   public:
     TimeStat GraphEdgeMax = {};
     TimeStat GraphVertexMax = {};
   };
 
   GraphT G;
-  typedef typename decltype(G)::VertexIdentifier VertexIdentifier;
-  typedef typename decltype(G)::EdgeIdentifier EdgeIdentifier;
+  using VertexIdentifier = typename decltype(G)::VertexIdentifier;
+  using EdgeIdentifier = decltype(G)::EdgeIdentifier;
 
   /// Use a Map to store the Function stack for each thread whilst building the
   /// graph.
   ///
   /// FIXME: Perhaps we can Build this into LatencyAccountant? or vise versa?
   PerThreadFunctionStackMap PerThreadFunctionStack;
 
   /// Usefull object for getting human readable Symbol Names.
-  const FuncIdConversionHelper &FuncIdHelper;
+  FuncIdConversionHelper FuncIdHelper;
   bool DeduceSiblingCalls = false;
   TimestampT CurrentMaxTSC = 0;
 
   /// A private function to help implement the statistic generation functions;
   template <typename U>
   void getStats(U begin, U end, GraphRenderer::TimeStat &S);
   void updateMaxStats(const TimeStat &S, TimeStat &M);
 
public:
   ///
   /// FIXME: Make this more robust against small irregularities.
   Error accountRecord(const XRayRecord &Record);
 
   const PerThreadFunctionStackMap &getPerThreadFunctionStack() const {
     return PerThreadFunctionStack;
   }
 
+  class Factory {
+  public:
+    bool KeepGoing;
+    bool DeduceSiblingCalls;
+    std::string InstrMap;
+    Trace Trace;
+    Expected<GraphRenderer> getGraphRenderer();
+  };
+
   /// Output the Embedded graph in DOT format on \p OS, labeling the edges by
   /// \p T
-  void exportGraphAsDOT(raw_ostream &OS, const XRayFileHeader &H,
-                        StatType EdgeLabel = StatType::NONE,
+  void exportGraphAsDOT(raw_ostream &OS, StatType EdgeLabel = StatType::NONE,
                         StatType EdgeColor = StatType::NONE,
                         StatType VertexLabel = StatType::NONE,
                         StatType VertexColor = StatType::NONE);
 
   /// Get a reference to the internal graph.
-  const GraphT &getGraph() {
-    calculateEdgeStatistics();
-    calculateVertexStatistics();
-    return G;
-  }
+  const GraphT &getGraph() { return G; }
 };
+
+/// Vector Sum of TimeStats
+inline GraphRenderer::TimeStat operator+(const GraphRenderer::TimeStat &A,
+                                         const GraphRenderer::TimeStat &B) {
+  return {A.Count + B.Count, A.Min + B.Min,     A.Median + B.Median,
+          A.Pct90 + B.Pct90, A.Pct99 + B.Pct99, A.Max + B.Max,
+          A.Sum + B.Sum};
+}
+
+/// Vector Difference of Timestats
+inline GraphRenderer::TimeStat operator-(const GraphRenderer::TimeStat &A,
+                                         const GraphRenderer::TimeStat &B) {
+
+  return {A.Count - B.Count, A.Min - B.Min,     A.Median - B.Median,
+          A.Pct90 - B.Pct90, A.Pct99 - B.Pct99, A.Max - B.Max,
+          A.Sum - B.Sum};
 }
+
+/// Scalar Diference of TimeStat and double
+inline GraphRenderer::TimeStat operator/(const GraphRenderer::TimeStat &A,
+                                         double B) {
+
+  return {static_cast<int64_t>(A.Count / B),
+          A.Min / B,
+          A.Median / B,
+          A.Pct90 / B,
+          A.Pct99 / B,
+          A.Max / B,
+          A.Sum / B};
+}
+
+/// Scalar product of TimeStat and Double
+inline GraphRenderer::TimeStat operator*(const GraphRenderer::TimeStat &A,
+                                         double B) {
+  return {static_cast<int64_t>(A.Count * B),
+          A.Min * B,
+          A.Median * B,
+          A.Pct90 * B,
+          A.Pct99 * B,
+          A.Max * B,
+          A.Sum * B};
+}
+
+/// Scalar product of double TimeStat
+inline GraphRenderer::TimeStat operator*(double A,
+                                         const GraphRenderer::TimeStat &B) {
+  return B * A;
+}
+
+/// Hadamard Product of TimeStats
+inline GraphRenderer::TimeStat operator*(const GraphRenderer::TimeStat &A,
+                                         const GraphRenderer::TimeStat &B) {
+  return {A.Count * B.Count, A.Min * B.Min,     A.Median * B.Median,
+          A.Pct90 * B.Pct90, A.Pct99 * B.Pct99, A.Max * B.Max,
+          A.Sum * B.Sum};
+}
+
+/// Hadamard Division of TimeStats
+inline GraphRenderer::TimeStat operator/(const GraphRenderer::TimeStat &A,
+                                         const GraphRenderer::TimeStat &B) {
+  return {A.Count * B.Count, A.Min * B.Min,     A.Median * B.Median,
+          A.Pct90 * B.Pct90, A.Pct99 * B.Pct99, A.Max * B.Max,
+          A.Sum * B.Sum};
 }
+} // namespace xray
+} // namespace llvm
 
 #endif // XRAY_GRAPH_H

llvm/trunk/tools/llvm-xray/xray-graph.cc

 #include <algorithm>
 #include <cassert>
 #include <cmath>
 #include <system_error>
 #include <utility>
 
 #include "xray-graph.h"
 #include "xray-registry.h"
-#include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/XRay/InstrumentationMap.h"
 #include "llvm/XRay/Trace.h"
 #include "llvm/XRay/YAMLXRayRecord.h"
 
 using namespace llvm;
 using namespace llvm::xray;
static cl::alias GraphEdgeLabel2("e", cl::aliasopt(GraphEdgeLabel),
                                  cl::sub(GraphC));
 
 static cl::opt<GraphRenderer::StatType> GraphVertexLabel(
     "vertex-label",
     cl::desc("Output graphs with vertices labeled with this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
-                          "Do not label Edges"),
+                          "Do not label Vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphVertexLabel2("v", cl::aliasopt(GraphVertexLabel),
                                    cl::desc("Alias for -edge-label"),
                                    cl::sub(GraphC));
 
 static cl::opt<GraphRenderer::StatType> GraphEdgeColorType(
     "color-edges",
     cl::desc("Output graphs with edge colors determined by this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
-                          "Do not label Edges"),
+                          "Do not color Edges"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
                clEnumValN(GraphRenderer::StatType::PCT99, "99p",
                           "99th percentile durations"),
                clEnumValN(GraphRenderer::StatType::MAX, "max",
                           "maximum function durations"),
                clEnumValN(GraphRenderer::StatType::SUM, "sum",
                           "sum of call durations")));
 static cl::alias GraphEdgeColorType2("c", cl::aliasopt(GraphEdgeColorType),
                                      cl::desc("Alias for -color-edges"),
                                      cl::sub(GraphC));
 
 static cl::opt<GraphRenderer::StatType> GraphVertexColorType(
     "color-vertices",
     cl::desc("Output graphs with vertex colors determined by this field"),
     cl::value_desc("field"), cl::sub(GraphC),
     cl::init(GraphRenderer::StatType::NONE),
     cl::values(clEnumValN(GraphRenderer::StatType::NONE, "none",
-                          "Do not label Edges"),
+                          "Do not color vertices"),
                clEnumValN(GraphRenderer::StatType::COUNT, "count",
                           "function call counts"),
                clEnumValN(GraphRenderer::StatType::MIN, "min",
                           "minimum function durations"),
                clEnumValN(GraphRenderer::StatType::MED, "med",
                           "median function durations"),
                clEnumValN(GraphRenderer::StatType::PCT90, "90p",
                           "90th percentile durations"),
Error GraphRenderer::accountRecord(const XRayRecord &Record) {
 
   if (Record.TSC < CurrentMaxTSC)
     return make_error<StringError>("Records not in order",
                                    make_error_code(errc::invalid_argument));
 
   auto &ThreadStack = PerThreadFunctionStack[Record.TId];
   switch (Record.Type) {
   case RecordTypes::ENTER: {
-    if (G.count(Record.FuncId) == 0)
+    if (Record.FuncId != 0 && G.count(Record.FuncId) == 0)
       G[Record.FuncId].SymbolName = FuncIdHelper.SymbolOrNumber(Record.FuncId);
     ThreadStack.push_back({Record.FuncId, Record.TSC});
     break;
   }
   case RecordTypes::EXIT: {
     // FIXME: Refactor this and the account subcommand to reduce code
     // duplication
     if (ThreadStack.size() == 0 || ThreadStack.back().FuncId != Record.FuncId) {
for (auto &V : G.vertices()) {
     }
   }
 }
 
 // A Helper function for normalizeStatistics which normalises a single
 // TimeStat element.
 static void normalizeTimeStat(GraphRenderer::TimeStat &S,
                               double CycleFrequency) {
-  S.Min /= CycleFrequency;
-  S.Median /= CycleFrequency;
-  S.Max /= CycleFrequency;
-  S.Sum /= CycleFrequency;
-  S.Pct90 /= CycleFrequency;
-  S.Pct99 /= CycleFrequency;
+  int64_t OldCount = S.Count;
+  S = S / CycleFrequency;
+  S.Count = OldCount;
 }
 
 // Normalises the statistics in the graph for a given TSC frequency.
 void GraphRenderer::normalizeStatistics(double CycleFrequency) {
   for (auto &E : G.edges()) {
     auto &S = E.second.S;
     normalizeTimeStat(S, CycleFrequency);
   }
   for (auto &V : G.vertices()) {
     auto &S = V.second.S;
     normalizeTimeStat(S, CycleFrequency);
   }
 
   normalizeTimeStat(G.GraphEdgeMax, CycleFrequency);
   normalizeTimeStat(G.GraphVertexMax, CycleFrequency);
 }
 
 // Returns a string containing the value of statistic field T
 std::string
-GraphRenderer::TimeStat::getAsString(GraphRenderer::StatType T) const {
+GraphRenderer::TimeStat::getString(GraphRenderer::StatType T) const {
   std::string St;
   raw_string_ostream S{St};
+  double TimeStat::*DoubleStatPtrs[] = {&TimeStat::Min,   &TimeStat::Median,
+                                        &TimeStat::Pct90, &TimeStat::Pct99,
+                                        &TimeStat::Max,   &TimeStat::Sum};
   switch (T) {
+  case GraphRenderer::StatType::NONE:
+    break;
   case GraphRenderer::StatType::COUNT:
     S << Count;
     break;
-  case GraphRenderer::StatType::MIN:
-    S << Min;
-    break;
-  case GraphRenderer::StatType::MED:
-    S << Median;
-    break;
-  case GraphRenderer::StatType::PCT90:
-    S << Pct90;
-    break;
-  case GraphRenderer::StatType::PCT99:
-    S << Pct99;
-    break;
-  case GraphRenderer::StatType::MAX:
-    S << Max;
-    break;
-  case GraphRenderer::StatType::SUM:
-    S << Sum;
-    break;
-  case GraphRenderer::StatType::NONE:
+  default:
+    S << (*this).*
+             DoubleStatPtrs[static_cast<int>(T) -
+                            static_cast<int>(GraphRenderer::StatType::MIN)];
     break;
   }
   return S.str();
 }
 
 // Returns the quotient between the property T of this and another TimeStat as
 // a double
-double GraphRenderer::TimeStat::compare(StatType T, const TimeStat &O) const {
+double GraphRenderer::TimeStat::getDouble(StatType T) const {
   double retval = 0;
+  double TimeStat::*DoubleStatPtrs[] = {&TimeStat::Min,   &TimeStat::Median,
+                                        &TimeStat::Pct90, &TimeStat::Pct99,
+                                        &TimeStat::Max,   &TimeStat::Sum};
   switch (T) {
-  case GraphRenderer::StatType::COUNT:
-    retval = static_cast<double>(Count) / static_cast<double>(O.Count);
-    break;
-  case GraphRenderer::StatType::MIN:
-    retval = Min / O.Min;
-    break;
-  case GraphRenderer::StatType::MED:
-    retval = Median / O.Median;
-    break;
-  case GraphRenderer::StatType::PCT90:
-    retval = Pct90 / O.Pct90;
-    break;
-  case GraphRenderer::StatType::PCT99:
-    retval = Pct99 / O.Pct99;
-    break;
-  case GraphRenderer::StatType::MAX:
-    retval = Max / O.Max;
-    break;
-  case GraphRenderer::StatType::SUM:
-    retval = Sum / O.Sum;
-    break;
   case GraphRenderer::StatType::NONE:
     retval = 0.0;
     break;
+  case GraphRenderer::StatType::COUNT:
+    retval = static_cast<double>(Count);
+    break;
+  default:
+    retval =
+        (*this).*DoubleStatPtrs[static_cast<int>(T) -
+                                static_cast<int>(GraphRenderer::StatType::MIN)];
+    break;
   }
-  return std::sqrt(
-      retval); // the square root here provides more dynamic contrast for
-               // low runtime edges, giving better separation and
-               // coloring lower down the call stack.
+  return retval;
 }
 
 // Outputs a DOT format version of the Graph embedded in the GraphRenderer
 // object on OS. It does this in the expected way by itterating
 // through all edges then vertices and then outputting them and their
 // annotations.
 //
 // FIXME: output more information, better presented.
-void GraphRenderer::exportGraphAsDOT(raw_ostream &OS, const XRayFileHeader &H,
-                                     StatType ET, StatType EC, StatType VT,
-                                     StatType VC) {
-  G.GraphEdgeMax = {};
-  G.GraphVertexMax = {};
-  calculateEdgeStatistics();
-  calculateVertexStatistics();
-
-  if (H.CycleFrequency)
-    normalizeStatistics(H.CycleFrequency);
-
+void GraphRenderer::exportGraphAsDOT(raw_ostream &OS, StatType ET, StatType EC,
+                                     StatType VT, StatType VC) {
   OS << "digraph xray {\n";
 
   if (VT != StatType::NONE)
     OS << "node [shape=record];\n";
 
   for (const auto &E : G.edges()) {
     const auto &S = E.second.S;
     OS << "F" << E.first.first << " -> "
-       << "F" << E.first.second << " [label=\"" << S.getAsString(ET) << "\"";
+       << "F" << E.first.second << " [label=\"" << S.getString(ET) << "\"";
     if (EC != StatType::NONE)
-      OS << " color=\"" << CHelper.getColorString(S.compare(EC, G.GraphEdgeMax))
+      OS << " color=\""
+         << CHelper.getColorString(
+                std::sqrt(S.getDouble(EC) / G.GraphEdgeMax.getDouble(EC)))
          << "\"";
     OS << "];\n";
   }
 
   for (const auto &V : G.vertices()) {
     const auto &VA = V.second;
     if (V.first == 0)
       continue;
     OS << "F" << V.first << " [label=\"" << (VT != StatType::NONE ? "{" : "")
        << (VA.SymbolName.size() > 40 ? VA.SymbolName.substr(0, 40) + "..."
                                      : VA.SymbolName);
     if (VT != StatType::NONE)
-      OS << "|" << VA.S.getAsString(VT) << "}\"";
+      OS << "|" << VA.S.getString(VT) << "}\"";
     else
       OS << "\"";
     if (VC != StatType::NONE)
-      OS << " color=\"" << CHelper.getColorString(VA.S.compare(VC, G.GraphVertexMax))
+      OS << " color=\""
+         << CHelper.getColorString(
+                std::sqrt(VA.S.getDouble(VC) / G.GraphVertexMax.getDouble(VC)))
          << "\"";
     OS << "];\n";
   }
   OS << "}\n";
 }
 
-// Here we register and implement the llvm-xray graph subcommand.
-// The bulk of this code reads in the options, opens the required files, uses
-// those files to create a context for analysing the xray trace, then there is a
-// short loop which actually analyses the trace, generates the graph and then
-// outputs it as a DOT.
-//
-// FIXME: include additional filtering and annalysis passes to provide more
-// specific useful information.
-static CommandRegistration Unused(&GraphC, []() -> Error {
+Expected<GraphRenderer> GraphRenderer::Factory::getGraphRenderer() {
   InstrumentationMap Map;
   if (!GraphInstrMap.empty()) {
     auto InstrumentationMapOrError = loadInstrumentationMap(GraphInstrMap);
     if (!InstrumentationMapOrError)
       return joinErrors(
           make_error<StringError>(
               Twine("Cannot open instrumentation map '") + GraphInstrMap + "'",
               std::make_error_code(std::errc::invalid_argument)),
           InstrumentationMapOrError.takeError());
     Map = std::move(*InstrumentationMapOrError);
   }
 
   const auto &FunctionAddresses = Map.getFunctionAddresses();
+
   symbolize::LLVMSymbolizer::Options Opts(
       symbolize::FunctionNameKind::LinkageName, true, true, false, "");
   symbolize::LLVMSymbolizer Symbolizer(Opts);
-  llvm::xray::FuncIdConversionHelper FuncIdHelper(GraphInstrMap, Symbolizer,
-                                                  FunctionAddresses);
-  xray::GraphRenderer GR(FuncIdHelper, GraphDeduceSiblingCalls);
-  std::error_code EC;
-  raw_fd_ostream OS(GraphOutput, EC, sys::fs::OpenFlags::F_Text);
-  if (EC)
-    return make_error<StringError>(
-        Twine("Cannot open file '") + GraphOutput + "' for writing.", EC);
-
-  auto TraceOrErr = loadTraceFile(GraphInput, true);
-  if (!TraceOrErr)
-    return joinErrors(
-        make_error<StringError>(Twine("Failed loading input file '") +
-                                    GraphInput + "'",
-                                make_error_code(llvm::errc::invalid_argument)),
-        TraceOrErr.takeError());
-
-  auto &Trace = *TraceOrErr;
   const auto &Header = Trace.getFileHeader();
 
-  // Here we generate the call graph from entries we find in the trace.
+  llvm::xray::FuncIdConversionHelper FuncIdHelper(InstrMap, Symbolizer,
+                                                  FunctionAddresses);
+
+  xray::GraphRenderer GR(FuncIdHelper, DeduceSiblingCalls);
   for (const auto &Record : Trace) {
     auto E = GR.accountRecord(Record);
     if (!E)
       continue;
 
     for (const auto &ThreadStack : GR.getPerThreadFunctionStack()) {
       errs() << "Thread ID: " << ThreadStack.first << "\n";
       auto Level = ThreadStack.second.size();
       for (const auto &Entry : llvm::reverse(ThreadStack.second))
         errs() << "#" << Level-- << "\t"
                << FuncIdHelper.SymbolOrNumber(Entry.FuncId) << '\n';
     }
 
     if (!GraphKeepGoing)
       return joinErrors(make_error<StringError>(
                             "Error encountered generating the call graph.",
                             std::make_error_code(std::errc::invalid_argument)),
                         std::move(E));
 
     handleAllErrors(std::move(E),
                     [&](const ErrorInfoBase &E) { E.log(errs()); });
   }
-  GR.exportGraphAsDOT(OS, Header, GraphEdgeLabel, GraphEdgeColorType,
-                      GraphVertexLabel, GraphVertexColorType);
+
+  GR.G.GraphEdgeMax = {};
+  GR.G.GraphVertexMax = {};
+  GR.calculateEdgeStatistics();
+  GR.calculateVertexStatistics();
+
+  if (Header.CycleFrequency)
+    GR.normalizeStatistics(Header.CycleFrequency);
+
+  return GR;
+}
+
+// Here we register and implement the llvm-xray graph subcommand.
+// The bulk of this code reads in the options, opens the required files, uses
+// those files to create a context for analysing the xray trace, then there is a
+// short loop which actually analyses the trace, generates the graph and then
+// outputs it as a DOT.
+//
+// FIXME: include additional filtering and annalysis passes to provide more
+// specific useful information.
+static CommandRegistration Unused(&GraphC, []() -> Error {
+  GraphRenderer::Factory F;
+
+  F.KeepGoing = GraphKeepGoing;
+  F.DeduceSiblingCalls = GraphDeduceSiblingCalls;
+  F.InstrMap = GraphInstrMap;
+
+  auto TraceOrErr = loadTraceFile(GraphInput, true);
+
+  if (!TraceOrErr)
+    return make_error<StringError>(
+        Twine("Failed loading input file '") + GraphInput + "'",
+        make_error_code(llvm::errc::invalid_argument));
+
+  F.Trace = std::move(*TraceOrErr);
+  auto GROrError = F.getGraphRenderer();
+  if (!GROrError)
+    return GROrError.takeError();
+  auto &GR = *GROrError;
+
+  std::error_code EC;
+  raw_fd_ostream OS(GraphOutput, EC, sys::fs::OpenFlags::F_Text);
+  if (EC)
+    return make_error<StringError>(
+        Twine("Cannot open file '") + GraphOutput + "' for writing.", EC);
+
+  GR.exportGraphAsDOT(OS, GraphEdgeLabel, GraphEdgeColorType, GraphVertexLabel,
+                      GraphVertexColorType);
   return Error::success();
 });