[llvm-mca] Initial implementation of output serialization using JSON

[wolfgangp]

Summary

This is a first cut at creating JSON output for MCA views.

Generate JSON by using --json on the command line. llvm-mca generates either its readable output as before or JSON. At the moment they cannot be both generated with just one run.

4 views are implemented:

• Summary
• InstructionInfo
• Timeline
• ResourcePressure

There is a major and minor version included as key/value pairs in the output. The views appear in alphabetical order.

The test case is rather rigid. It checks for every single line emitted. It can possibly be shortened, but I don't know what a compromise would be. There is also a need to check that regular output and JSON output match from a data point of view. This would involve creating a tool that would check the 2 different outputs for deviations.

Let me know what you think.

[lebedev.ri]

I don't like the test.
Can it simply be autogenerated, without omitting details?

llvm/test/tools/llvm-mca/JSON/X86/views.s

7

Maybe decrease/hardcode iteration/cycle count.
I don't think you need that long of a simulation here.

llvm/tools/llvm-mca/PipelinePrinter.cpp

29–30

I'd just inline them, less potential for dubious allocations.

llvm/tools/llvm-mca/Views/BottleneckAnalysis.h

335

Are you sure these have to be std::string. I'd think they can be StringLiteral, or StringRef.

llvm/tools/llvm-mca/Views/InstructionInfoView.cpp

131

getValueOr("None") ?

llvm/tools/llvm-mca/llvm-mca.cpp

99

I think there was some docs for the tool, it would be good to document this there, and possibly in releasenotes

[andreadb]

Thanks Wolfgang for working on this.

I suggest a few changes to the JSON ouput:

1. Have a single (top level) JSON object for the assembly code sequence (see example below):

"InstructionSequence": [
  "addl\t%eax, %eax",
  "addl\t%ebx, %ebx",
  "addl\t%ecx, %ecx",
  "addl\t%edx, %edx"
]

2. Have Views reference code strings by simply using indices to the "InstructionSequence". This is to avoid to have to unnecessarily print the same instruction over and over (since different views may need to reference specific instructions).

Example (based on the code snippet from your test):

Before:

{
  "Instruction": "addl\t%ecx, %ecx",
  "Latency": 1,
  "NumMicroOpcodes": 1,
  "RThroughput": "0.5",
  <...>
}

After:

{
  "Instruction": 1
  "Latency": 1,
  "Latency": 1,
  "NumMicroOpcodes": 1,
  "RThroughput": "0.5",
}

3. Have a top level object describing the simulated cpu. That object would need two fields:
   • A cpu name (in your test, it would report "haswell").
   • An array of processor resource units (strings).

The principle is the same as for the code sequence: if a View needs to reference a processor resource unit, then just use an index to that array.

4. (optional) Change the ResourcePressureView object by splitting the array into multiple arrays (i.e. one per each instruction in the code sequence).

Point 4. is optional, but only if point 3 is implemented. Without point 3. there is no correspondence between the resource cycles and the (names of) consumed resources.
You can still infer the number of resources by dividing the number of elements in the array by the number of instructions in the code sequence.
Splitting that single array into a sequence of arrays would give a bit more structure and make (at least in my opinion) the entire output a bit more readable.

More in general: I suggest to remove the version number from the JSON format. We can add it in future if we need to.

About the test: I agree with Roman. We want to check both the structure and the numbers. So an autogenerated test that doesn't omit details is much much better.
Also (as Roman already suggested), please limit the number of iterations to 1. Otherwise your json output would be really too big (especially if you print the timeline!).

-Andrea

P.s.: in a future patch, we need a way to print out warnings (generated by mca during a simulation) as part of the json output.

[wolfgangp]

In D86644#2239673, @lebedev.ri wrote:

Can it simply be autogenerated, without omitting details?

It would have to be auto-generated based on the readable output, then, using some sort of (python) script that creates the structure independently, or did you have something else in mind?

[andreadb]

In D86644#2240251, @wolfgangp wrote:

In D86644#2239673, @lebedev.ri wrote:

Can it simply be autogenerated, without omitting details?

It would have to be auto-generated based on the readable output, then, using some sort of (python) script that creates the structure independently, or did you have something else in mind?

You should be able to use update_mca_test_checks.py to autogenerate the CHECK lines.

[andreadb]

Hey Wolfgang,
are you still looking at this patch? Do you have any updates?

[wolfgangp]

In D86644#2333464, @andreadb wrote:

Hey Wolfgang,
are you still looking at this patch? Do you have any updates?

Yeah, sorry, I got roped into other things. I haven't forgotten about it and am planning to return to it, but right now I don't have the cycles. Anyone who wants to grab it and run with it feel free.

[wolfgangp]

Apologies for the long delay, I'm finally ready to resume work on this feature. The update does the following:

• The test case is auto-generated with a cycle count of 1, so is much smaller than before.
• The instruction strings and the resource names are emitted in top level objects, where the views refer to the individual items by index. To emit the top level JSON object for the instruction strings I Introduced a special class with a singleton object whose only purpose is to do just that.
• added some brief documentation for the --json option. Let me know if more is needed.
• Addressed other miscellaneous review comments.

[wolfgangp]

llvm/tools/llvm-mca/llvm-mca.cpp

99

Added some brief documentation, need more perhaps?

[RKSimon]

llvm/tools/llvm-mca/Views/InstructionInfoView.cpp

143

const auto &I ?

[andreadb]

llvm/test/tools/llvm-mca/JSON/X86/views.s

86–104

There are multiple problems here:

An instruction rarely consumes more than maybe three or four processor resource units during an entrie simulation. So, array ResourcePressureInfo is going to be very sparse (subtargets may declare more than 10 units).
In practice, 'Numerator' is going to be zero most of the times for most entries.

It is not clear how to reconstruct the resource pressure view from this json output.
In this example, there are 10 processor resource units. However, the number of actual resources declared in JSON array Resources is more than 10 (i.e. it contains names for both units and groups). The ResourcePressureView only cares about resource units.

When processing the content of the json file, this forces the user to skip resource groups, and assume that units always come first within array Resources. While this may be true now, we don't want to strongly rely on an implementation detail.

Another (minor) issue is that "Denominator" is currently set to 1. However, to compute the actual pressure value the user needs to do the following math:
( Numerator / Denominator) / Executions .

This approach requires that we look elsewhere for the execution number (which is 100 in this example). Personally, I think it is more user friendly if we just do the math and stick a double in there (rather than having "Numerator" and "Denominator").

So, I suggest the following two changes:

1. Only report entries where Numerator is different than zero.
2. Each entry must also provide an instruction index and a resource index.
3. Report the actual pressure value as a double (up to two digits after the dot), instead of field Numerator and Denominator.

Soomething like this:

{
  "InstructionIndex": 0,
  "ResourceIndex" : 2,
  "Pressure": 1.00
}

[andreadb]

The json output is better now.
However there are things about the implementation that must be fixed/changed (see my comments below).

llvm/tools/llvm-mca/Views/View.cpp

23–32

Please move this to a separate .cpp file.

33–43

This should not be a static member of View.
See my previous comment.

45–46

There is already a mechanism for adding views. We shouldn't add things globally this way. See my other comments about addView.

llvm/tools/llvm-mca/Views/View.h

47–49

This should not be a static member of View. Please move this logic into a separate View class.

What we want is 'just yet-another-view' that prints out static information about the target CPU. That printing logic should be moved into a separate class; an instance of that class would then be added to the PipelinePrinter like any other view.

48–70

Please move this to a separate View header file.

63

This should be a virtual destructor

69

This is unnecessary.
See my comment in llvm-mca.cpp. We should just rely on addView to subscribe new views, rather than doing this.

llvm/tools/llvm-mca/llvm-mca.cpp

576–579

You should be able to just call addView like we do for any other view in this file.

Something like:

Printer.addView(
          std::make_unique<mca::InstructionViewJSONHandler>(*STI, *IP, Insts));

577–578

I think that we should only keep a single API and avoid introducing method printJSON().

Regardless of whether the user requested a JSON report or not, the user should still be able to use the same API (i.e. just call printReport(TOF->os()))

You could add extra state to the PipelinePrinter (something like an OutputKind enum which, at the moment, is either default or json).

Also, we shouldn't be passing the MCInst array, MCPU, and STI back to printJSON.
The printer should be minimalistic and fully delegate to views the task of printing out stuff.

[wolfgangp]

This change is trying to use a more streamlined interface based on Andrea's feedback. I removed the printJSON method from the PipelinePrinter and the singleton object that was used to list the instructions.
Instead, each implemented view now has a <ViewName>JSON derived class that overrides the printView method. When JSON output is requested, objects of these class types are added as views. This leaves the PipelinePrinter largely unchanged.

There is a separate "InstructionView" which lists the instructions and CPU resources. Other views refer to the instructions and resources by index.

The ResourcePRessureView now lists all the non-zero resource usages, referring to the instructions and resources by index.
One thing I was not sure about: The last row of the ResourceUsage matrix has the totals for all iterations. Right now it's just printed as if it belonged to instruction N (with N being the number of instructions). I don't know if we want to do something different.

[andreadb]

I really like this JSON format. Thanks a lot!

The internal design however should be improved/simplified a bit (see my commet below).
This patch is almost ready to go; I plan to accept it once my comment below is addressed.

As a side note: shouldn't we add a line in the release notes about this new feature?
I don't actually remember the process for updating the release notes. When I firstly added llvm-mca, I remember I had to drop a line in a .rst file somewhere.
I think that this change is important enough to be advertised in the release notes (iirc there should be a section specifically for llvm tools). I don't know if the process has changed over the past few years though. Maybe @lebedev.ri and @RKSimon know more about it?

Thanks,
Andrea

llvm/tools/llvm-mca/PipelinePrinter.cpp

16–24

In my previous comment I was suggesting to add the concept of "view output kind". A new enum type visible to all views (something like this):

enum class ViewOutputKind
{
  RAW,
  JSON
};

The PipelinePrinter could store that information as an internal field.
It could be done at construction time (or, if you really want, you could also add a new API like this setOutputKind(enum ViewOutputKind VOK);

The printReport API would still be unchanged. What would change though is the
signature of printView, which would look like this:

void PipelinePrinter::printReport(llvm::raw_ostream &OS) const {
  for (const auto &V : Views)
    V->printView(OutputKind, OS);
}

The main advantage of this approach is that you don't need to derive new views just for printing a JSON report. It also avoids the visibility change "issue" (from private to protected) to expose the internal state of a base view class to the derived classes.

Method printView for most classes might look like this:

void printView(llvm::View::FileOutputKind OK, llvm::raw_ostream &OS) const override
{
  switch (OK)
 {
 default:
 case OK_RAW:
   printViewRaw(llvm::raw_ostream &OS);  /* a new private member of InstructionInfoView */
 case OK_JSON:
   printViewJSon(llvm::raw_ostream &OS);  /* a new private member of InstructionInfoView */
 }
}

printViewRaw and printViewJSon would be private members of a view.

That way, you don't need separate classes just for the purpose of printing the report in a different format. The logic that prints json files would be fully contained in the printViewJSon.

This might also simplify a bit how the PipelinePrinter is populated (though I am not 100% sure about this).

[wolfgangp]

Based on Andrea's request to use an OutputKind rather than overriding the printView method in a separate class for JSON output

1. Introduced an output kind into the View class, which is stored in the PipelinePrinter based on the command line settings. PipelinePrinter passes the output kind to the views' PrintView method(), which dispatches either to the regular printView() or to printViewJSON().
2. Removed the <View>JSON classes and instead added a printViewJSON virtual method which is shared by most views.
3. the toJSON() methods have been moved back to the view classes.

I changed a couple of minor things from Andrea's proposal: 1) I used the name READABLE instead of RAW (the existing output is well formatted, so I felt the name RAW was not quite catching its essence. 2) I overloaded the old PrintView() instead of using a different name.

I didn't address the release note question yet, but I will look into what's needed here.

[RKSimon]

llvm/docs/CommandGuide/llvm-mca.rst

213

Please can you add a mention in "llvm-project\llvm\docs\ReleaseNotes.rst" in the "Changes to the LLVM tools" section.

[andreadb]

I can see that InstructionView has been moved outside of View.h into its own file, but I cannot see that new file anywhere in this diff.

I think that this diff is missing View/InstructionView.{h,cpp}, and llvm/Support/JSON.h.

Could you please upload your full patch?

Some minor comments below.

llvm/tools/llvm-mca/PipelinePrinter.cpp

16

Is it necessary to include this file here?
Also, I cannot see that file in the diff. Could you please upload a full diff (assuming that this is not a phab user error... :) ).

My point is that there is nothing specific about this file which is dependent on any definitions other than those from View.h.

Also, some views might end up implicitly including it anyway.
I noticed that most views tend to include InstructionView.h (which unfortunately I am unable to see in this diff). Maybe you could move this include in there?

llvm/tools/llvm-mca/Views/ResourcePressureView.h

74

Is protected really necessary here? It seems to me that it should be private.

llvm/tools/llvm-mca/Views/TimelineView.h

127

Why protected?
Please correct me if I am wrong, but I don't think it needs to be protected and it can stay private.

[andreadb]

llvm/tools/llvm-mca/PipelinePrinter.cpp

16

Nevermind. Forget about my second sentence.
JSON.h already exists and obviously it is not modified by this patch.
Apologies for the confusion.

The question about whether it should be included here is still valid though.
That being said, it is not an issue, so it is up to you whether to move that include elsewhere or not.

[wolfgangp]

Sorry about the missing files. Some hiccup while generating the diff.

Addressed the latest comments ('protected' was a leftover from the previous iteration, removed an unncessary include directive and added a mention in the release notes).

[andreadb]

LGTM.

Thanks!

[RKSimon]

@lebedev.ri Any more comments? You are currently blocking the patch. Cheers.

[GMNGeoffrey]

FYI I'm seeing clang diagnostic errors, I think from this commit:

Views/InstructionView.h:37:8: error: 'printView' overrides a member function but is not marked 'override' [-Werror,-Winconsistent-missing-override]

void printView(llvm::raw_ostream &) const {}
     ^

Views/View.h:37:16: note: overridden virtual function is here

virtual void printView(llvm::raw_ostream &OS) const = 0;
             ^

In file included from llvm-project/llvm/tools/llvm-mca/Views/BottleneckAnalysis.cpp:15:
In file included from llvm-mca-headers/Views/BottleneckAnalysis.h:83:
Views/InstructionView.h:46:13: error: 'getNameAsString' overrides a member function but is not marked 'override' [-Werror,-Winconsistent-missing-override]

StringRef getNameAsString() const { return "Instructions and CPU resources"; }
          ^

Views/View.h:44:21: note: overridden virtual function is here

virtual StringRef getNameAsString() const = 0;

[wolfgangp]

In D86644#2513898, @GMNGeoffrey wrote:

FYI I'm seeing clang diagnostic errors, I think from this commit:

Should be fixed now.

[GMNGeoffrey]

In D86644#2513914, @wolfgangp wrote:

In D86644#2513898, @GMNGeoffrey wrote:

FYI I'm seeing clang diagnostic errors, I think from this commit:

Should be fixed now.

I'm still seeing some. Looks like your fix didn't get all of them:

Views/InstructionInfoView.h:81:15: error: 'toJSON' overrides a member function but is not marked 'override' [-Werror,-Winconsistent-missing-override]

json::Value toJSON() const;
            ^

Views/InstructionView.h:58:15: note: overridden virtual function is here

json::Value toJSON() const override;

[wolfgangp]

In D86644#2514125, @GMNGeoffrey wrote:

In D86644#2513914, @wolfgangp wrote:

In D86644#2513898, @GMNGeoffrey wrote:

FYI I'm seeing clang diagnostic errors, I think from this commit:

Should be fixed now.

I'm still seeing some. Looks like your fix didn't get all of them:

Sorry about that. Should be all of them now.

[GMNGeoffrey]

In D86644#2514142, @wolfgangp wrote:

In D86644#2514125, @GMNGeoffrey wrote:

In D86644#2513914, @wolfgangp wrote:

In D86644#2513898, @GMNGeoffrey wrote:

FYI I'm seeing clang diagnostic errors, I think from this commit:

Should be fixed now.

I'm still seeing some. Looks like your fix didn't get all of them:

Sorry about that. Should be all of them now.

Thanks! Looks good on my end now :-) Really wish some premerge checks ran with these on... :-/

llvm/docs/CommandGuide/llvm-mca.rst

.. option:: -instruction-tables
   instruction in sequence.
 
 .. option:: -bottleneck-analysis
 
   Print information about bottlenecks that affect the throughput. This analysis
   can be expensive, and it is disabled by default.  Bottlenecks are highlighted
   in the summary view.
 
+.. option:: -json
+
+  Print the requested views in JSON format. The instructions and the processor
+  resources are printed as members of special top level JSON objects.  The
+  individual views refer to them by index.
+
 
 EXIT STATUS
 -----------
 
 :program:`llvm-mca` returns 0 on success. Otherwise, an error message is printed
 to standard error, and the tool returns 1.
 
 USING MARKERS TO ANALYZE SPECIFIC CODE BLOCKS

llvm/docs/ReleaseNotes.rst

 
 Changes to the LLVM tools
 ---------------------------------
 
 * llvm-readobj and llvm-readelf behavior has changed to report an error when
   executed with no input files instead of reading an input from stdin.
   Reading from stdin can still be achieved by specifying `-` as an input file.
 
+* llvm-mca supports serialization of the timeline and summary views.
+  The `--json` command line option prints a JSON representation of
+  these views to stdout.
+
 Changes to LLDB
 ---------------------------------
 
 Changes to Sanitizers
 ---------------------
 
 The integer sanitizer `-fsanitize=integer` now has a new sanitizer:
 `-fsanitize=unsigned-shift-base`. It's not undefined behavior for an unsigned

llvm/test/tools/llvm-mca/JSON/X86/views.s

+# NOTE: Assertions have been autogenerated by utils/update_mca_test_checks.py
+# Verify that we create proper JSON for the MCA views TimelineView, ResourcePressureview,
+# InstructionInfoView and SummaryView.
+
+# RUN: llvm-mca -mcpu=haswell --json --timeline-max-iterations=1 --timeline < %s | FileCheck %s
+
+add %eax, %eax
+add %ebx, %ebx
+add %ecx, %ecx
+add %edx, %edx
+
+# CHECK:      {
+# CHECK-NEXT:   "Instructions": [
+# CHECK-NEXT:     "addl\t%eax, %eax",
+# CHECK-NEXT:     "addl\t%ebx, %ebx",
+# CHECK-NEXT:     "addl\t%ecx, %ecx",
+# CHECK-NEXT:     "addl\t%edx, %edx"
+# CHECK-NEXT:   ],
+# CHECK-NEXT:   "Resources": {
+# CHECK-NEXT:     "CPUName": "haswell",
+# CHECK-NEXT:     "Resources": [
+# CHECK-NEXT:       "HWDivider",
+# CHECK-NEXT:       "HWFPDivider",
+# CHECK-NEXT:       "HWPort0",
+# CHECK-NEXT:       "HWPort1",
+# CHECK-NEXT:       "HWPort2",
+# CHECK-NEXT:       "HWPort3",
+# CHECK-NEXT:       "HWPort4",
+# CHECK-NEXT:       "HWPort5",
+# CHECK-NEXT:       "HWPort6",
+# CHECK-NEXT:       "HWPort7"
+# CHECK-NEXT:     ]
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+# CHECK-NEXT: {
+# CHECK-NEXT:   "SummaryView": {
+# CHECK-NEXT:     "BlockRThroughput": 1,
+# CHECK-NEXT:     "DispatchWidth": 4,
+# CHECK-NEXT:     "IPC": 3.883495145631068,
+# CHECK-NEXT:     "Instructions": 400,
+# CHECK-NEXT:     "Iterations": 100,
+# CHECK-NEXT:     "TotalCycles": 103,
+# CHECK-NEXT:     "TotaluOps": 400,
+# CHECK-NEXT:     "uOpsPerCycle": 3.883495145631068
+# CHECK-NEXT:   }
+# CHECK-NEXT: }
+# CHECK-NEXT: [
+# CHECK-NEXT:   {
+# CHECK-NEXT:     "Instruction": 0,
+# CHECK-NEXT:     "Latency": 1,
+# CHECK-NEXT:     "NumMicroOpcodes": 1,
+# CHECK-NEXT:     "RThroughput": 0.25,
+# CHECK-NEXT:     "hasUnmodeledSideEffects": false,
+# CHECK-NEXT:     "mayLoad": false,
+# CHECK-NEXT:     "mayStore": false
+# CHECK-NEXT:   },
+# CHECK-NEXT:   {
+# CHECK-NEXT:     "Instruction": 1,
+# CHECK-NEXT:     "Latency": 1,
+# CHECK-NEXT:     "NumMicroOpcodes": 1,
+# CHECK-NEXT:     "RThroughput": 0.25,
+# CHECK-NEXT:     "hasUnmodeledSideEffects": false,
+# CHECK-NEXT:     "mayLoad": false,
+# CHECK-NEXT:     "mayStore": false
+# CHECK-NEXT:   },
+# CHECK-NEXT:   {
+# CHECK-NEXT:     "Instruction": 2,
+# CHECK-NEXT:     "Latency": 1,
+# CHECK-NEXT:     "NumMicroOpcodes": 1,
+# CHECK-NEXT:     "RThroughput": 0.25,
+# CHECK-NEXT:     "hasUnmodeledSideEffects": false,
+# CHECK-NEXT:     "mayLoad": false,
+# CHECK-NEXT:     "mayStore": false
+# CHECK-NEXT:   },
+# CHECK-NEXT:   {
+# CHECK-NEXT:     "Instruction": 3,
+# CHECK-NEXT:     "Latency": 1,
+# CHECK-NEXT:     "NumMicroOpcodes": 1,
+# CHECK-NEXT:     "RThroughput": 0.25,
+# CHECK-NEXT:     "hasUnmodeledSideEffects": false,
+# CHECK-NEXT:     "mayLoad": false,
+# CHECK-NEXT:     "mayStore": false
+# CHECK-NEXT:   }
+# CHECK-NEXT: ]
+# CHECK-NEXT: {
+# CHECK-NEXT:   "ResourcePressureInfo": [
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 0,
+# CHECK-NEXT:       "ResourceIndex": 8,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 1,
+# CHECK-NEXT:       "ResourceIndex": 7,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 2,
+# CHECK-NEXT:       "ResourceIndex": 3,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 3,
+# CHECK-NEXT:       "ResourceIndex": 2,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 4,
+# CHECK-NEXT:       "ResourceIndex": 2,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 4,
+# CHECK-NEXT:       "ResourceIndex": 3,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 4,
+# CHECK-NEXT:       "ResourceIndex": 7,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "InstructionIndex": 4,
+# CHECK-NEXT:       "ResourceIndex": 8,
+# CHECK-NEXT:       "ResourceUsage": 1
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT: }
+# CHECK-NEXT: {
+# CHECK-NEXT:   "TimelineInfo": [
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "CycleDispatched": 0,
+# CHECK-NEXT:       "CycleExecuted": 2,
+# CHECK-NEXT:       "CycleIssued": 1,
+# CHECK-NEXT:       "CycleReady": 0,
+# CHECK-NEXT:       "CycleRetired": 3
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "CycleDispatched": 0,
+# CHECK-NEXT:       "CycleExecuted": 2,
+# CHECK-NEXT:       "CycleIssued": 1,
+# CHECK-NEXT:       "CycleReady": 0,
+# CHECK-NEXT:       "CycleRetired": 3
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "CycleDispatched": 0,
+# CHECK-NEXT:       "CycleExecuted": 2,
+# CHECK-NEXT:       "CycleIssued": 1,
+# CHECK-NEXT:       "CycleReady": 0,
+# CHECK-NEXT:       "CycleRetired": 3
+# CHECK-NEXT:     },
+# CHECK-NEXT:     {
+# CHECK-NEXT:       "CycleDispatched": 0,
+# CHECK-NEXT:       "CycleExecuted": 2,
+# CHECK-NEXT:       "CycleIssued": 1,
+# CHECK-NEXT:       "CycleReady": 0,
+# CHECK-NEXT:       "CycleRetired": 3
+# CHECK-NEXT:     }
+# CHECK-NEXT:   ]
+# CHECK-NEXT: }

llvm/tools/llvm-mca/CMakeLists.txt

 add_llvm_tool(llvm-mca
   llvm-mca.cpp
   CodeRegion.cpp
   CodeRegionGenerator.cpp
   PipelinePrinter.cpp
   Views/BottleneckAnalysis.cpp
   Views/DispatchStatistics.cpp
   Views/InstructionInfoView.cpp
+  Views/InstructionView.cpp
   Views/RegisterFileStatistics.cpp
   Views/ResourcePressureView.cpp
   Views/RetireControlUnitStatistics.cpp
   Views/SchedulerStatistics.cpp
   Views/SummaryView.cpp
   Views/TimelineView.cpp
   Views/View.cpp
   )
 
 set(LLVM_MCA_SOURCE_DIR ${CURRENT_SOURCE_DIR})

llvm/tools/llvm-mca/PipelinePrinter.h

 ///
 /// This class knows how to print out the analysis information collected
 /// during the execution of the code. Internally, it delegates to other
 /// classes the task of printing out timeline information as well as
 /// resource pressure.
 class PipelinePrinter {
   Pipeline &P;
   llvm::SmallVector<std::unique_ptr<View>, 8> Views;
+  View::OutputKind OutputKind;
 
 public:
-  PipelinePrinter(Pipeline &pipeline) : P(pipeline) {}
+  PipelinePrinter(Pipeline &pipeline, View::OutputKind OutputKind)
+      : P(pipeline), OutputKind(OutputKind) {}
 
   void addView(std::unique_ptr<View> V) {
     P.addEventListener(V.get());
     Views.emplace_back(std::move(V));
   }
 
   void printReport(llvm::raw_ostream &OS) const;
 };
 } // namespace mca
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_MCA_PIPELINEPRINTER_H

llvm/tools/llvm-mca/PipelinePrinter.cpp

 //===--------------------- PipelinePrinter.cpp ------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the PipelinePrinter interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "PipelinePrinter.h"
 #include "Views/View.h"
 
 namespace llvm {
 namespace mca {
 
 void PipelinePrinter::printReport(llvm::raw_ostream &OS) const {
   for (const auto &V : Views)
-    V->printView(OS);
+    V->printView(OutputKind, OS);
 }
 } // namespace mca.
 } // namespace llvm

llvm/tools/llvm-mca/Views/BottleneckAnalysis.h

 /// set of nodes with no predecessors) to a leaf node is reported as critical
 /// sequence.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_BOTTLENECK_ANALYSIS_H
 #define LLVM_TOOLS_LLVM_MCA_BOTTLENECK_ANALYSIS_H
 
-#include "Views/View.h"
+#include "Views/InstructionView.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/MC/MCSubtargetInfo.h"
-#include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 class PressureTracker {
   const MCSchedModel &SM;
 
   // Resource pressure distribution. There is an element for every processor
BottleneckAnalysis(const MCSubtargetInfo &STI, MCInstPrinter &MCIP,
                      ArrayRef<MCInst> Sequence, unsigned Iterations);
 
   void onCycleEnd() override;
   void onEvent(const HWStallEvent &Event) override { SeenStallCycles = true; }
   void onEvent(const HWPressureEvent &Event) override;
   void onEvent(const HWInstructionEvent &Event) override;
 
   void printView(raw_ostream &OS) const override;
+  StringRef getNameAsString() const override { return "BottleneckAnalysis"; }
+  json::Value toJSON() const override { return "not implemented"; }
 
 #ifndef NDEBUG
   void dump(raw_ostream &OS, MCInstPrinter &MCIP) const { DG.dump(OS, MCIP); }
 #endif
 };
 
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/BottleneckAnalysis.cpp

for (unsigned I = Seq.size(), E = 0; I > E; --I) {
     IID = N.CriticalPredecessor.FromIID;
   }
 }
 
 void BottleneckAnalysis::printInstruction(formatted_raw_ostream &FOS,
                                           const MCInst &MCI,
                                           bool UseDifferentColor) const {
   FOS.PadToColumn(14);
-
   if (UseDifferentColor)
     FOS.changeColor(raw_ostream::CYAN, true, false);
   FOS << printInstructionString(MCI);
   if (UseDifferentColor)
     FOS.resetColor();
 }
 
 void BottleneckAnalysis::printCriticalSequence(raw_ostream &OS) const {

llvm/tools/llvm-mca/Views/DispatchStatistics.h

public:
   void onCycleBegin() override { NumCycles++; }
 
   void onCycleEnd() override { updateHistograms(); }
 
   void printView(llvm::raw_ostream &OS) const override {
     printDispatchStalls(OS);
     printDispatchHistogram(OS);
   }
+  StringRef getNameAsString() const override { return "DispatchStatistics"; }
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/InstructionInfoView.h

 ///  1      3     1.00                      vhaddps %xmm2, %xmm2, %xmm3
 ///  1      3     1.00                      vhaddps %xmm3, %xmm3, %xmm4
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONINFOVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONINFOVIEW_H
 
-#include "Views/View.h"
+#include "Views/InstructionView.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MCA/CodeEmitter.h"
 #include "llvm/Support/raw_ostream.h"
public:
   InstructionInfoView(const llvm::MCSubtargetInfo &ST,
                       const llvm::MCInstrInfo &II, CodeEmitter &C,
                       bool ShouldPrintEncodings, llvm::ArrayRef<llvm::MCInst> S,
                       llvm::MCInstPrinter &IP)
       : InstructionView(ST, IP, S), MCII(II), CE(C),
         PrintEncodings(ShouldPrintEncodings) {}
 
   void printView(llvm::raw_ostream &OS) const override;
+  StringRef getNameAsString() const override { return "InstructionInfoView"; }
+  json::Value toJSON() const;
+  json::Object toJSON(const InstructionInfoViewData &IIVD) const;
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/InstructionInfoView.cpp

 //===--------------------- InstructionInfoView.cpp --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file implements the InstructionInfoView API.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Views/InstructionInfoView.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/JSON.h"
 
 namespace llvm {
 namespace mca {
 
 void InstructionInfoView::printView(raw_ostream &OS) const {
   std::string Buffer;
   raw_string_ostream TempStream(Buffer);
 
void InstructionInfoView::printView(raw_ostream &OS) const {
   if (PrintEncodings) {
     TempStream << "[7]: Encoding Size\n";
     TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    [7]    "
                << "Encodings:                    Instructions:\n";
   } else {
     TempStream << "\n[1]    [2]    [3]    [4]    [5]    [6]    Instructions:\n";
   }
 
-  for (auto I : enumerate(zip(IIVD, Source))) {
+  for (const auto &I : enumerate(zip(IIVD, Source))) {
     const InstructionInfoViewData &IIVDEntry = std::get<0>(I.value());
 
     TempStream << ' ' << IIVDEntry.NumMicroOpcodes << "    ";
     if (IIVDEntry.NumMicroOpcodes < 10)
       TempStream << "  ";
     else if (IIVDEntry.NumMicroOpcodes < 100)
       TempStream << ' ';
     TempStream << IIVDEntry.Latency << "   ";
void InstructionInfoView::printView(raw_ostream &OS) const {
   TempStream.flush();
   OS << Buffer;
 }
 
 void InstructionInfoView::collectData(
     MutableArrayRef<InstructionInfoViewData> IIVD) const {
   const llvm::MCSubtargetInfo &STI = getSubTargetInfo();
   const MCSchedModel &SM = STI.getSchedModel();
-  for (auto I : zip(getSource(), IIVD)) {
+  for (const auto &I : zip(getSource(), IIVD)) {
     const MCInst &Inst = std::get<0>(I);
     InstructionInfoViewData &IIVDEntry = std::get<1>(I);
     const MCInstrDesc &MCDesc = MCII.get(Inst.getOpcode());
 
     // Obtain the scheduling class information from the instruction.
     unsigned SchedClassID = MCDesc.getSchedClass();
     unsigned CPUID = SM.getProcessorID();
 
for (const auto &I : zip(getSource(), IIVD)) {
     IIVDEntry.Latency += MCSchedModel::getForwardingDelayCycles(
         STI.getReadAdvanceEntries(SCDesc));
     IIVDEntry.RThroughput = MCSchedModel::getReciprocalThroughput(STI, SCDesc);
     IIVDEntry.mayLoad = MCDesc.mayLoad();
     IIVDEntry.mayStore = MCDesc.mayStore();
     IIVDEntry.hasUnmodeledSideEffects = MCDesc.hasUnmodeledSideEffects();
   }
 }
+
+// Construct a JSON object from a single InstructionInfoViewData object.
+json::Object
+InstructionInfoView::toJSON(const InstructionInfoViewData &IIVD) const {
+  json::Object JO({{"NumMicroOpcodes", IIVD.NumMicroOpcodes},
+                   {"Latency", IIVD.Latency},
+                   {"mayLoad", IIVD.mayLoad},
+                   {"mayStore", IIVD.mayStore},
+                   {"hasUnmodeledSideEffects", IIVD.hasUnmodeledSideEffects}});
+  JO.try_emplace("RThroughput", IIVD.RThroughput.getValueOr(0.0));
+  return JO;
+}
+
+json::Value InstructionInfoView::toJSON() const {
+  ArrayRef<llvm::MCInst> Source = getSource();
+  if (!Source.size())
+    return json::Value(0);
+
+  IIVDVec IIVD(Source.size());
+  collectData(IIVD);
+
+  json::Array InstInfo;
+  for (const auto I : enumerate(IIVD)) {
+    const InstructionInfoViewData &IIVDEntry = I.value();
+    json::Object JO = toJSON(IIVDEntry);
+    JO.try_emplace("Instruction", (unsigned)I.index());
+    InstInfo.push_back(std::move(JO));
+  }
+  return json::Value(std::move(InstInfo));
+}
 } // namespace mca.
 } // namespace llvm

llvm/tools/llvm-mca/Views/InstructionView.h

+//===----------------------- InstrucionView.h -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines the main interface for Views that examine and reference
+/// a sequence of machine instructions.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
+#define LLVM_TOOLS_LLVM_MCA_INSTRUCTIONVIEW_H
+
+#include "Views/View.h"
+#include "llvm/MC/MCInstPrinter.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/JSON.h"
+
+namespace llvm {
+namespace mca {
+
+// The base class for views that deal with individual machine instructions.
+class InstructionView : public View {
+  const llvm::MCSubtargetInfo &STI;
+  llvm::MCInstPrinter &MCIP;
+  llvm::ArrayRef<llvm::MCInst> Source;
+  StringRef MCPU;
+
+  mutable std::string InstructionString;
+  mutable raw_string_ostream InstrStream;
+
+public:
+  void printView(llvm::raw_ostream &) const {}
+  InstructionView(const llvm::MCSubtargetInfo &STI,
+                  llvm::MCInstPrinter &Printer,
+                  llvm::ArrayRef<llvm::MCInst> S,
+                  StringRef MCPU = StringRef())
+      : STI(STI), MCIP(Printer), Source(S), MCPU(MCPU), InstrStream(InstructionString) {}
+
+  virtual ~InstructionView() = default;
+
+  StringRef getNameAsString() const { return "Instructions and CPU resources"; }
+  // Return a reference to a string representing a given machine instruction.
+  // The result should be used or copied before the next call to
+  // printInstructionString() as it will overwrite the previous result.
+  StringRef printInstructionString(const llvm::MCInst &MCI) const;
+  const llvm::MCSubtargetInfo &getSubTargetInfo() const { return STI; }
+
+  llvm::MCInstPrinter &getInstPrinter() const { return MCIP; }
+  llvm::ArrayRef<llvm::MCInst> getSource() const { return Source; }
+  json::Value toJSON() const override;
+  virtual void printViewJSON(llvm::raw_ostream &OS) override {
+    json::Value JV = toJSON();
+    OS << formatv("{0:2}", JV) << "\n";
+  }
+};
+} // namespace mca
+} // namespace llvm
+
+#endif

llvm/tools/llvm-mca/Views/InstructionView.cpp

+//===----------------------- View.cpp ---------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+///
+/// This file defines the member functions of the class InstructionView.
+///
+//===----------------------------------------------------------------------===//
+
+#include <sstream>
+#include "Views/InstructionView.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCSubtargetInfo.h"
+
+namespace llvm {
+namespace mca {
+
+StringRef InstructionView::printInstructionString(const llvm::MCInst &MCI) const {
+  InstructionString = "";
+  MCIP.printInst(&MCI, 0, "", STI, InstrStream);
+  InstrStream.flush();
+  // Remove any tabs or spaces at the beginning of the instruction.
+  return StringRef(InstructionString).ltrim();
+}
+
+json::Value InstructionView::toJSON() const {
+  json::Object JO;
+  json::Array SourceInfo;
+  for (const auto &MCI : getSource()) {
+    StringRef Instruction = printInstructionString(MCI);
+    SourceInfo.push_back(Instruction.str());
+  }
+  JO.try_emplace("Instructions", std::move(SourceInfo));
+
+  json::Array Resources;
+  const MCSchedModel &SM = STI.getSchedModel();
+  for (unsigned I = 1, E = SM.getNumProcResourceKinds(); I < E; ++I) {
+    const MCProcResourceDesc &ProcResource = *SM.getProcResource(I);
+    unsigned NumUnits = ProcResource.NumUnits;
+    // Skip groups and invalid resources with zero units.
+    if (ProcResource.SubUnitsIdxBegin || !NumUnits)
+      continue;
+    for (unsigned J = 0; J < NumUnits; ++J) {
+      std::stringstream ResNameStream;
+      ResNameStream << ProcResource.Name;
+      if (NumUnits > 1)
+        ResNameStream << "." << J;
+      Resources.push_back(ResNameStream.str());
+    }
+  }
+  JO.try_emplace("Resources", json::Object({{"CPUName", MCPU}, {"Resources", std::move(Resources)}}));
+
+  return JO;
+}
+} // namespace mca
+} // namespace llvm

llvm/tools/llvm-mca/Views/RegisterFileStatistics.h

class RegisterFileStatistics : public View {
   void updateMoveElimInfo(const Instruction &Inst);
 
 public:
   RegisterFileStatistics(const llvm::MCSubtargetInfo &sti);
 
   void onCycleEnd() override;
   void onEvent(const HWInstructionEvent &Event) override;
   void printView(llvm::raw_ostream &OS) const override;
+  StringRef getNameAsString() const override {
+    return "RegisterFileStatistics";
+  }
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/ResourcePressureView.h

 /// per iteration. Consequently, the resource pressure on JFPU0 is of 2cy per
 /// iteration.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_RESOURCEPRESSUREVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_RESOURCEPRESSUREVIEW_H
 
-#include "Views/View.h"
+#include "Views/InstructionView.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/Support/JSON.h"
 
 namespace llvm {
 namespace mca {
 
 /// This class collects resource pressure statistics and it is able to print
 /// out all the collected information as a table to an output stream.
 class ResourcePressureView : public InstructionView {
   unsigned LastInstructionIdx;
 
   // Map to quickly obtain the ResourceUsage column index from a processor
   // resource ID.
   llvm::DenseMap<unsigned, unsigned> Resource2VecIndex;
 
   // Table of resources used by instructions.
   std::vector<ResourceCycles> ResourceUsage;
   unsigned NumResourceUnits;
 
   void printResourcePressurePerIter(llvm::raw_ostream &OS) const;
   void printResourcePressurePerInst(llvm::raw_ostream &OS) const;
 
 public:
   ResourcePressureView(const llvm::MCSubtargetInfo &sti,
                        llvm::MCInstPrinter &Printer,
                        llvm::ArrayRef<llvm::MCInst> S);
 
   void onEvent(const HWInstructionEvent &Event) override;
   void printView(llvm::raw_ostream &OS) const override {
     printResourcePressurePerIter(OS);
     printResourcePressurePerInst(OS);
   }
+  StringRef getNameAsString() const override { return "ResourcePressureView"; }
+  json::Value toJSON() const;
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/ResourcePressureView.cpp

for (const MCInst &MCI : Source) {
     FOS << printInstructionString(MCI) << '\n';
     FOS.flush();
     OS << Buffer;
     Buffer = "";
 
     ++InstrIndex;
   }
 }
+
+json::Value ResourcePressureView::toJSON() const {
+  // We're dumping the instructions and the ResourceUsage array.
+  json::Array ResourcePressureInfo;
+
+  // The ResourceUsage matrix is sparse, so we only consider
+  // non-zero values.
+  ArrayRef<llvm::MCInst> Source = getSource();
+  const unsigned Executions = LastInstructionIdx / Source.size() + 1;
+  for (const auto &R : enumerate(ResourceUsage)) {
+    const ResourceCycles &RU = R.value();
+    if (RU.getNumerator() == 0)
+      continue;
+    unsigned InstructionIndex = R.index() / NumResourceUnits;
+    unsigned ResourceIndex = R.index() % NumResourceUnits;
+    double Usage = RU / Executions;
+    ResourcePressureInfo.push_back(
+        json::Object({{"InstructionIndex", InstructionIndex},
+                      {"ResourceIndex", ResourceIndex},
+                      {"ResourceUsage", Usage}}));
+  }
+
+  json::Object JO({{"ResourcePressureInfo", std::move(ResourcePressureInfo)}});
+  return JO;
+}
 } // namespace mca
 } // namespace llvm

llvm/tools/llvm-mca/Views/RetireControlUnitStatistics.h

class RetireControlUnitStatistics : public View {
   unsigned SumOfUsedEntries;
 
 public:
   RetireControlUnitStatistics(const MCSchedModel &SM);
 
   void onEvent(const HWInstructionEvent &Event) override;
   void onCycleEnd() override;
   void printView(llvm::raw_ostream &OS) const override;
+  StringRef getNameAsString() const override {
+    return "RetireControlUnitStatistics";
+  }
 };
 
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/SchedulerStatistics.h

void onReservedBuffers(const InstRef &IR,
                          llvm::ArrayRef<unsigned> Buffers) override;
 
   // Decreases by one the number of used scheduler queue slots of every
   // buffered resource in the Buffers set.
   void onReleasedBuffers(const InstRef &IR,
                          llvm::ArrayRef<unsigned> Buffers) override;
 
   void printView(llvm::raw_ostream &OS) const override;
+  StringRef getNameAsString() const override { return "SchedulerStatistics"; }
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/SummaryView.h

 
 public:
   SummaryView(const llvm::MCSchedModel &Model, llvm::ArrayRef<llvm::MCInst> S,
               unsigned Width);
 
   void onCycleEnd() override { ++TotalCycles; }
   void onEvent(const HWInstructionEvent &Event) override;
   void printView(llvm::raw_ostream &OS) const override;
+  StringRef getNameAsString() const override { return "SummaryView"; }
+  json::Value toJSON() const override;
 };
-
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/SummaryView.cpp

void SummaryView::collectData(DisplayValues &DV) const {
   DV.TotalCycles = TotalCycles;
   DV.DispatchWidth = DispatchWidth;
   DV.TotalUOps = NumMicroOps * DV.Iterations;
   DV.UOpsPerCycle = (double)DV.TotalUOps / TotalCycles;
   DV.IPC = (double)DV.TotalInstructions / TotalCycles;
   DV.BlockRThroughput = computeBlockRThroughput(SM, DispatchWidth, NumMicroOps,
                                                 ProcResourceUsage);
 }
+
+json::Value SummaryView::toJSON() const {
+  DisplayValues DV;
+  collectData(DV);
+  json::Object JO({{"Iterations", DV.Iterations},
+                   {"Instructions", DV.TotalInstructions},
+                   {"TotalCycles", DV.TotalCycles},
+                   {"TotaluOps", DV.TotalUOps},
+                   {"DispatchWidth", DV.DispatchWidth},
+                   {"uOpsPerCycle", DV.UOpsPerCycle},
+                   {"IPC", DV.IPC},
+                   {"BlockRThroughput", DV.BlockRThroughput}});
+  return JO;
+}
 } // namespace mca.
 } // namespace llvm

llvm/tools/llvm-mca/Views/TimelineView.h

 /// That is expected because instruction 5 cannot transition to the "ready"
 /// state until %xmm4 is written by instruction 4.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_TIMELINEVIEW_H
 #define LLVM_TOOLS_LLVM_MCA_TIMELINEVIEW_H
 
-#include "Views/View.h"
+#include "Views/InstructionView.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 namespace mca {
 
 /// This class listens to instruction state transition events
 /// in order to construct a timeline information.
 ///
 /// For every instruction executed by the Pipeline, this class constructs
 /// a TimelineViewEntry object. TimelineViewEntry objects are then used
 /// to print the timeline information, as well as the "average wait times"
 /// for every instruction in the input assembly sequence.
 class TimelineView : public InstructionView {
   unsigned CurrentCycle;
   unsigned MaxCycle;
   unsigned LastCycle;
 
   struct TimelineViewEntry {
     int CycleDispatched;  // A negative value is an "invalid cycle".
     unsigned CycleReady;
     unsigned CycleIssued;
     unsigned CycleExecuted;
     unsigned CycleRetired;
   };
   std::vector<TimelineViewEntry> Timeline;
 
public:
 
   // print functionalities.
   void printTimeline(llvm::raw_ostream &OS) const;
   void printAverageWaitTimes(llvm::raw_ostream &OS) const;
   void printView(llvm::raw_ostream &OS) const override {
     printTimeline(OS);
     printAverageWaitTimes(OS);
   }
+  StringRef getNameAsString() const override { return "TimelineView"; }
+  json::Value toJSON() const;
 };
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/TimelineView.cpp

for (const MCInst &Inst : Source) {
       printTimelineViewEntry(FOS, Entry, Iteration, SourceIndex);
       FOS << "   " << printInstructionString(Inst) << '\n';
       FOS.flush();
 
       ++IID;
     }
   }
 }
+
+json::Value TimelineView::toJSON() const {
+  json::Array TimelineInfo;
+
+  for (const TimelineViewEntry &TLE : Timeline) {
+    TimelineInfo.push_back(
+        json::Object({{"CycleDispatched", TLE.CycleDispatched},
+                      {"CycleReady", TLE.CycleReady},
+                      {"CycleIssued", TLE.CycleIssued},
+                      {"CycleExecuted", TLE.CycleExecuted},
+                      {"CycleRetired", TLE.CycleRetired}}));
+  }
+  return json::Object({{"TimelineInfo", std::move(TimelineInfo)}});
+}
 } // namespace mca
 } // namespace llvm

llvm/tools/llvm-mca/Views/View.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_MCA_VIEW_H
 #define LLVM_TOOLS_LLVM_MCA_VIEW_H
 
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MCA/HWEventListener.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Support/JSON.h"
 
 namespace llvm {
 namespace mca {
 
 class View : public HWEventListener {
 public:
+  enum OutputKind { OK_READABLE, OK_JSON };
+
+  void printView(OutputKind OutputKind, llvm::raw_ostream &OS) {
+    if (OutputKind == OK_JSON)
+      printViewJSON(OS);
+    else
+      printView(OS);
+  }
+
   virtual void printView(llvm::raw_ostream &OS) const = 0;
+  virtual void printViewJSON(llvm::raw_ostream &OS) {
+    json::Object JO;
+    JO.try_emplace(getNameAsString().str(), toJSON());
+    OS << formatv("{0:2}", json::Value(std::move(JO))) << "\n";
+  }
   virtual ~View() = default;
+  virtual StringRef getNameAsString() const = 0;
+  virtual json::Value toJSON() const { return "not implemented"; }
   void anchor() override;
 };
-
-// The base class for views that deal with individual machine instructions.
-class InstructionView : public View {
-  const llvm::MCSubtargetInfo &STI;
-  llvm::MCInstPrinter &MCIP;
-  llvm::ArrayRef<llvm::MCInst> Source;
-
-  mutable std::string InstructionString;
-  mutable raw_string_ostream InstrStream;
-
-protected:
-  InstructionView(const llvm::MCSubtargetInfo &STI,
-                  llvm::MCInstPrinter &Printer,
-                  llvm::ArrayRef<llvm::MCInst> S)
-      : STI(STI), MCIP(Printer), Source(S), InstrStream(InstructionString) {}
-
-  virtual ~InstructionView() = default;
-
-  // Return a reference to a string representing a given machine instruction.
-  // The result should be used or copied before the next call to
-  // printInstructionString() as it will overwrite the previous result.
-  StringRef printInstructionString(const llvm::MCInst &MCI) const;
-  
-  const llvm::MCSubtargetInfo &getSubTargetInfo() const { return STI; }
-  llvm::MCInstPrinter &getInstPrinter() const { return MCIP; }
-  llvm::ArrayRef<llvm::MCInst> getSource() const { return Source; }
-};
 } // namespace mca
 } // namespace llvm
 
 #endif

llvm/tools/llvm-mca/Views/View.cpp

 //===----------------------- View.cpp ---------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
 ///
 /// This file defines the virtual anchor method in View.h to pin the vtable.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "Views/View.h"
+#include "llvm/MC/MCInst.h"
+#include "llvm/MC/MCSubtargetInfo.h"
 
 namespace llvm {
 namespace mca {
 
 void View::anchor() {}
 
-StringRef InstructionView::printInstructionString(const llvm::MCInst &MCI) const {
-    InstructionString = "";
-    MCIP.printInst(&MCI, 0, "", STI, InstrStream);
-    InstrStream.flush();
-    // Remove any tabs or spaces at the beginning of the instruction.
-    return StringRef(InstructionString).ltrim();
-  }
 } // namespace mca
 } // namespace llvm

llvm/tools/llvm-mca/llvm-mca.cpp

MCPU("mcpu",
          cl::desc("Target a specific cpu type (-mcpu=help for details)"),
          cl::value_desc("cpu-name"), cl::cat(ToolOptions), cl::init("native"));
 
 static cl::opt<std::string>
     MATTR("mattr",
           cl::desc("Additional target features."),
           cl::cat(ToolOptions));
 
+static cl::opt<bool>
+    PrintJson("json",
+          cl::desc("Print the output in json format"),
+          cl::cat(ToolOptions), cl::init(false));
+
 static cl::opt<int>
     OutputAsmVariant("output-asm-variant",
                      cl::desc("Syntax variant to use for output printing"),
                      cl::cat(ToolOptions), cl::init(-1));
 
 static cl::opt<bool>
     PrintImmHex("print-imm-hex", cl::cat(ToolOptions), cl::init(false),
                 cl::desc("Prefer hex format when printing immediate values"));
for (const std::unique_ptr<mca::CodeRegion> &Region : Regions) {
 
     mca::SourceMgr S(LoweredSequence, PrintInstructionTables ? 1 : Iterations);
 
     if (PrintInstructionTables) {
       //  Create a pipeline, stages, and a printer.
       auto P = std::make_unique<mca::Pipeline>();
       P->appendStage(std::make_unique<mca::EntryStage>(S));
       P->appendStage(std::make_unique<mca::InstructionTables>(SM));
-      mca::PipelinePrinter Printer(*P);
+      mca::PipelinePrinter Printer(*P, mca::View::OK_READABLE);
 
       // Create the views for this pipeline, execute, and emit a report.
       if (PrintInstructionInfoView) {
         Printer.addView(std::make_unique<mca::InstructionInfoView>(
             *STI, *MCII, CE, ShowEncoding, Insts, *IP));
       }
       Printer.addView(
           std::make_unique<mca::ResourcePressureView>(*STI, *IP, Insts));
 
       if (!runPipeline(*P))
         return 1;
 
       Printer.printReport(TOF->os());
       continue;
     }
 
     // Create a basic pipeline simulating an out-of-order backend.
     auto P = MCA.createDefaultPipeline(PO, S);
-    mca::PipelinePrinter Printer(*P);
+    mca::PipelinePrinter Printer(*P, PrintJson ? mca::View::OK_JSON
+                                               : mca::View::OK_READABLE);
+
+    // When we output JSON, we add a view that contains the instructions
+    // and CPU resource information.
+    if (PrintJson)
+      Printer.addView(
+          std::make_unique<mca::InstructionView>(*STI, *IP, Insts, MCPU));
 
     if (PrintSummaryView)
       Printer.addView(
           std::make_unique<mca::SummaryView>(SM, Insts, DispatchWidth));
 
     if (EnableBottleneckAnalysis) {
       Printer.addView(std::make_unique<mca::BottleneckAnalysis>(
           *STI, *IP, Insts, S.getNumIterations()));
if (PrintTimelineView) {
           TimelineMaxIterations ? TimelineMaxIterations : 10;
       Printer.addView(std::make_unique<mca::TimelineView>(
           *STI, *IP, Insts, std::min(TimelineIterations, S.getNumIterations()),
           TimelineMaxCycles));
     }
 
     if (!runPipeline(*P))
       return 1;
 
     Printer.printReport(TOF->os());
 
     // Clear the InstrBuilder internal state in preparation for another round.
     IB.clear();
   }
 
   TOF->keep();
   return 0;
 }