[Grammar] 5-8 Compiler Opt Reports.md

chapters/5-Performance-Analysis-Approaches/5-8 Compiler Opt Reports.md

@@ -1,10 +1,8 @@
-
-
 ## Compiler Optimization Reports {#sec:compilerOptReports}
 
 Nowadays, software development relies very much on compilers to do performance optimizations. Compilers play a critical role in speeding up software. The majority of developers leave the job of optimizing code to compilers, interfering only when they see an opportunity to improve something compilers cannot accomplish. Fair to say, this is a good default strategy. But it doesn't work well when you're looking for the best performance possible. What if the compiler failed to perform a critical optimization like vectorizing a loop? How you would know about this? Luckily, all major compilers provide optimization reports which we will discuss now.
 
-Suppose you want to know if a critical loop was unrolled or not. If it was unrolled, what is the unroll factor? There is a hard way to know this: by studying generated assembly instructions. Unfortunately, not all people are comfortable at reading assembly language. This can be especially difficult if the function is big, it calls other functions or has many loops that were also vectorized, or if the compiler created multiple versions of the same loop. Most compilers, including GCC, Clang, Intel compiler, and MSVC[^9] provide optimization reports to check what optimizations were done for a particular piece of code.
+Suppose you want to know if a critical loop was unrolled or not. If it was unrolled, what is the unroll factor? There is a hard way to know this: by studying generated assembly instructions. Unfortunately, not all people are comfortable reading assembly language. This can be especially difficult if the function is big, it calls other functions or has many loops that were also vectorized, or if the compiler created multiple versions of the same loop. Most compilers, including GCC, Clang, Intel compiler, and MSVC[^9] provide optimization reports to check what optimizations were done for a particular piece of code.
 
 Let's take a look at [@lst:optReport], which shows an example of a loop that is not vectorized by `clang 16.0`.
 
@@ -22,7 +20,7 @@ void foo(float* __restrict__ a,
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-To emit an optimization report in clang, you need to use [-Rpass*](https://llvm.org/docs/Vectorizers.html#diagnostics) flags:
+To emit an optimization report in the Clang compiler, you need to use [-Rpass*](https://llvm.org/docs/Vectorizers.html#diagnostics) flags:
 
 ```bash
 $ clang -O3 -Rpass-analysis=.* -Rpass=.* -Rpass-missed=.* a.c -c
@@ -82,11 +80,11 @@ a.cpp:5:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4
   ^
 ```
 
-This was just one example of using optimization reports; we will provide more examples in [@sec:DiscoverVectOpptnt], when giving advice on how to discover vectorization opportunities. Compiler optimization reports can help you find missed optimization opportunities, and understand why those opportunities were missed. In addition, compiler optimization reports are useful for testing a hypothesis. Compilers often decides whether a certain transformation will be beneficial based on their cost model analysis. But compilers don't always make the optimal choice. Once you detect a key missing optimization in the report, you can attempt to rectify it by changing the source code or by providing hints to the compiler in the form of, say, a `#pragma`, an attribute, a compiler built-in, etc. As always, verify your hypothesis by measuring it in a practical environment.
+This was just one example of using optimization reports; we will provide more examples in [@sec:DiscoverVectOpptnt], where we discuss how to discover vectorization opportunities. Compiler optimization reports can help you find missed optimization opportunities, and understand why those opportunities were missed. In addition, compiler optimization reports are useful for testing a hypothesis. Compilers often decide whether a certain transformation will be beneficial based on their cost model analysis. But compilers don't always make the optimal choice. Once you detect a key missing optimization in the report, you can attempt to rectify it by changing the source code or by providing hints to the compiler in the form of, say, a `#pragma`, an attribute, a compiler built-in, etc. As always, verify your hypothesis by measuring it in a practical environment.
 
-Compiler reports can be quite large, and a separate report is generated for each source-code file. Sometimes, finding relevant records in the output file can become a challenge. We should mention that initially these reports were explicitly designed for use by compiler writers to improve optimization passes. Over the years there has been a number of tools that made them more accessible and actionable by application developers. Most notably, [opt-viewer](https://github.com/llvm/llvm-project/tree/main/llvm/tools/opt-viewer)[^7] and [optview2](https://github.com/OfekShilon/optview2).[^8] Also, the [Compiler Explorer](https://godbolt.org/) website has the "Optimization Output" tool for LLVM-based compilers that reports performed transformations when you hover your mouse over the corresponding line of source code. All of these tools help visualizing successful and failed code transformations by LLVM-based compilers.
+Compiler reports can be quite large, and a separate report is generated for each source-code file. Sometimes, finding relevant records in the output file can become a challenge. We should mention that initially these reports were explicitly designed for use by compiler writers to improve optimization passes. Over the years, several tools have been developed to make optimization reports more accessible and actionable by application developers. Most notably, [opt-viewer](https://github.com/llvm/llvm-project/tree/main/llvm/tools/opt-viewer)[^7] and [optview2](https://github.com/OfekShilon/optview2).[^8] Also, the [Compiler Explorer](https://godbolt.org/) website has the "Optimization Output" tool for LLVM-based compilers that reports performed transformations when you hover your mouse over the corresponding line of source code. All of these tools help visualize successful and failed code transformations by LLVM-based compilers.
 
-In Link-Time Optimizations (LTO)[^5] mode, some optimizations are made during linking stage. To emit compiler reports from both compilation and linking stages, you should pass dedicated options to both the compiler and the linker. See the LLVM "Remarks" [guide](https://llvm.org/docs/Remarks.html)[^6] for more information. 
+In the Link-Time Optimization (LTO)[^5] mode, some optimizations are made during the linking stage. To emit compiler reports from both the compilation and linking stages, you should pass dedicated options to both the compiler and the linker. See the LLVM "Remarks" [guide](https://llvm.org/docs/Remarks.html)[^6] for more information. 
 
 A slightly different way of reporting missing optimizations is taken by the Intel® [ISPC](https://ispc.github.io/ispc.html)[^3] compiler (discussed in [@sec:ISPC]). It issues warnings for code constructs that compile to relatively inefficient code. Either way, compiler optimization reports should be one of the key tools in your toolbox. They are a fast way to check what optimizations were done for a particular hotspot and see if some important ones failed. I have found many improvement opportunities thanks to compiler optimization reports.
 
@@ -96,4 +94,4 @@ A slightly different way of reporting missing optimizations is taken by the Inte
 [^6]: LLVM compiler remarks - [https://llvm.org/docs/Remarks.html](https://llvm.org/docs/Remarks.html)
 [^7]: opt-viewer - [https://github.com/llvm/llvm-project/tree/main/llvm/tools/opt-viewer](https://github.com/llvm/llvm-project/tree/main/llvm/tools/opt-viewer)
 [^8]: optview2 - [https://github.com/OfekShilon/optview2](https://github.com/OfekShilon/optview2)
-[^9]: At the time of writing (2024), MSVC provides only vectorization reports.
+[^9]: At the time of writing (2024), MSVC provides only vectorization reports.