Perfscore dumping/dasm improvements (dotnet#264)

briansull · web-flow · commit cee783468f0e · 2019-11-27T16:21:26.000-08:00
* Perf Score dumping/dasm improvements
 - Show how much each BasicBlock contributes to the overall PerfScore
 - Change the string "perf score" to "PerfScore when reporting in the Disassembly and Dump files

Add PerfScore support for all currently used AVX2. SSE, etc... instructions

* Code Review feedback

* Update the INS_lea throughput and latencies
Added comments for INS_movd and INS_movq and a few others

* Fix x86 break - Use baseRegisterRequiresDisplacement(baseReg)

* Fix the RIP relative block for INS_lea

* Fixed INS_lea special cases: IF_RWR_LABEL and IF_RWR_SRD
diff --git a/src/coreclr/src/jit/codegencommon.cpp b/src/coreclr/src/jit/codegencommon.cpp
@@ -2282,11 +2282,6 @@ void CodeGen::genGenerateCode(void** codePtr, ULONG* nativeSizeOfCode)
     trackedStackPtrsContig = !compiler->opts.compDbgEnC;
 #endif
 
-#ifdef DEBUG
-    /* We're done generating code for this function */
-    compiler->compCodeGenDone = true;
-#endif
-
     compiler->EndPhase(PHASE_GENERATE_CODE);
 
     codeSize =
@@ -2296,6 +2291,13 @@ void CodeGen::genGenerateCode(void** codePtr, ULONG* nativeSizeOfCode)
 
     compiler->EndPhase(PHASE_EMIT_CODE);
 
+#ifdef DEBUG
+    assert(compiler->compCodeGenDone == false);
+
+    /* We're done generating code for this function */
+    compiler->compCodeGenDone = true;
+#endif
+
 #if defined(DEBUG) || defined(LATE_DISASM)
     // Add code size information into the Perf Score
     // All compPerfScore calculations must be performed using doubles
@@ -2307,9 +2309,10 @@ void CodeGen::genGenerateCode(void** codePtr, ULONG* nativeSizeOfCode)
 #ifdef DEBUG
     if (compiler->opts.disAsm || verbose)
     {
-        printf("; Total bytes of code %d, prolog size %d, perf score %.2f, (MethodHash=%08x) for method %s\n", codeSize,
-               prologSize, compiler->info.compPerfScore, compiler->info.compMethodHash(), compiler->info.compFullName);
-        printf("; ============================================================\n");
+        printf("\n; Total bytes of code %d, prolog size %d, PerfScore %.2f, (MethodHash=%08x) for method %s\n",
+               codeSize, prologSize, compiler->info.compPerfScore, compiler->info.compMethodHash(),
+               compiler->info.compFullName);
+        printf("; ============================================================\n\n");
         printf(""); // in our logic this causes a flush
     }
 
diff --git a/src/coreclr/src/jit/emit.cpp b/src/coreclr/src/jit/emit.cpp
@@ -1105,13 +1105,13 @@ float emitter::insEvaluateExecutionCost(instrDesc* id)
     assert(throughput > 0.0);
     assert(latency >= 0.0);
 
-    if ((memAccessKind == PERFSCORE_MEMORY_WRITE) && (latency <= PERFSCORE_LATENCY_WR_GENERAL))
+    if (memAccessKind == PERFSCORE_MEMORY_WRITE)
     {
-        // We assume that we won't read back from memory for any writes
-        // Thus we don't pay latency costs for writes.
-        latency = 0.0;
+        // We assume that we won't read back from memory for the next WR_GENERAL (3) cycles
+        // Thus we normally won't pay latency costs for writes.
+        latency = max(0.0f, latency - PERFSCORE_LATENCY_WR_GENERAL);
     }
-    if (latency >= 1.0)
+    else if (latency >= 1.0) // Otherwise, If we aren't performing a memory write
     {
         // We assume that the processor's speculation will typically eliminate one cycle of latency
         //
@@ -2376,7 +2376,8 @@ void* emitter::emitAddLabel(VARSET_VALARG_TP GCvars, regMaskTP gcrefRegs, regMas
 #if defined(DEBUG) || defined(LATE_DISASM)
     else
     {
-        emitCurIG->igWeight = getCurrentBlockWeight();
+        emitCurIG->igWeight    = getCurrentBlockWeight();
+        emitCurIG->igPerfScore = 0.0;
     }
 #endif
 
@@ -3289,7 +3290,12 @@ void emitter::emitDispIG(insGroup* ig, insGroup* igPrev, bool verbose)
     }
     else
     {
-        printf("offs=%06XH, size=%04XH, bbWeight=%s", ig->igOffs, ig->igSize, refCntWtd2str(ig->igWeight));
+        printf("offs=%06XH, size=%04XH", ig->igOffs, ig->igSize);
+
+        if (emitComp->compCodeGenDone)
+        {
+            printf(", bbWeight=%s PerfScore %.2f", refCntWtd2str(ig->igWeight), ig->igPerfScore);
+        }
 
         if (ig->igFlags & IGF_GC_VARS)
         {
@@ -3415,7 +3421,9 @@ size_t emitter::emitIssue1Instr(insGroup* ig, instrDesc* id, BYTE** dp)
 #if defined(DEBUG) || defined(LATE_DISASM)
     float insExeCost = insEvaluateExecutionCost(id);
     // All compPerfScore calculations must be performed using doubles
-    emitComp->info.compPerfScore += (double)(ig->igWeight / (double)BB_UNITY_WEIGHT) * insExeCost;
+    double insPerfScore = (double)(ig->igWeight / (double)BB_UNITY_WEIGHT) * insExeCost;
+    emitComp->info.compPerfScore += insPerfScore;
+    ig->igPerfScore += insPerfScore;
 #endif // defined(DEBUG) || defined(LATE_DISASM)
 
 // printf("[S=%02u]\n", emitCurStackLvl);
@@ -4841,7 +4849,6 @@ unsigned emitter::emitEndCodeGen(Compiler* comp,
         instrDesc* id = (instrDesc*)ig->igData;
 
 #ifdef DEBUG
-
         /* Print the IG label, but only if it is a branch label */
 
         if (emitComp->opts.disAsm || emitComp->opts.dspEmit || emitComp->verbose)
@@ -4853,17 +4860,9 @@ unsigned emitter::emitEndCodeGen(Compiler* comp,
             }
             else
             {
-                printf("\nG_M%03u_IG%02u:", Compiler::s_compMethodsCount, ig->igNum);
-
-                // Display the block weight, but only when it isn't the standard BB_UNITY_WEIGHT
-                if (ig->igWeight != BB_UNITY_WEIGHT)
-                {
-                    printf("\t\t;; bbWeight=%s", refCntWtd2str(ig->igWeight));
-                }
-                printf("\n");
+                printf("\nG_M%03u_IG%02u:\n", Compiler::s_compMethodsCount, ig->igNum);
             }
         }
-
 #endif // DEBUG
 
         BYTE* bp = cp;
@@ -4952,6 +4951,13 @@ unsigned emitter::emitEndCodeGen(Compiler* comp,
             castto(id, BYTE*) += emitIssue1Instr(ig, id, &cp);
         }
 
+#ifdef DEBUG
+        if (emitComp->opts.disAsm || emitComp->opts.dspEmit || emitComp->verbose)
+        {
+            printf("\t\t\t\t\t\t;; bbWeight=%s PerfScore %.2f", refCntWtd2str(ig->igWeight), ig->igPerfScore);
+        }
+#endif // DEBUG
+
         emitCurIG = nullptr;
 
         assert(ig->igSize >= cp - bp);
@@ -6846,7 +6852,8 @@ insGroup* emitter::emitAllocIG()
 #endif
 
 #if defined(DEBUG) || defined(LATE_DISASM)
-    ig->igWeight = getCurrentBlockWeight();
+    ig->igWeight    = getCurrentBlockWeight();
+    ig->igPerfScore = 0.0;
 #endif
 
 #if EMITTER_STATS
diff --git a/src/coreclr/src/jit/emit.h b/src/coreclr/src/jit/emit.h
@@ -249,7 +249,8 @@ struct insGroup
     insGroup* igSelf; // for consistency checking
 #endif
 #if defined(DEBUG) || defined(LATE_DISASM)
-    BasicBlock::weight_t igWeight; // the block weight used for this insGroup
+    BasicBlock::weight_t igWeight;    // the block weight used for this insGroup
+    double               igPerfScore; // The PerfScore for this insGroup
 #endif
 
     UNATIVE_OFFSET igNum;     // for ordering (and display) purposes
@@ -1235,6 +1236,7 @@ class emitter
 #define PERFSCORE_THROUGHPUT_10C 10.0f // slower - 10 cycles
 #define PERFSCORE_THROUGHPUT_13C 13.0f // slower - 13 cycles
 #define PERFSCORE_THROUGHPUT_25C 25.0f // slower - 25 cycles
+#define PERFSCORE_THROUGHPUT_33C 33.0f // slower - 33 cycles
 #define PERFSCORE_THROUGHPUT_52C 52.0f // slower - 52 cycles
 #define PERFSCORE_THROUGHPUT_57C 57.0f // slower - 57 cycles
 
@@ -1253,6 +1255,8 @@ class emitter
 #define PERFSCORE_LATENCY_6C 6.0f
 #define PERFSCORE_LATENCY_7C 7.0f
 #define PERFSCORE_LATENCY_8C 8.0f
+#define PERFSCORE_LATENCY_9C 9.0f
+#define PERFSCORE_LATENCY_10C 10.0f
 #define PERFSCORE_LATENCY_11C 11.0f
 #define PERFSCORE_LATENCY_12C 12.0f
 #define PERFSCORE_LATENCY_13C 13.0f
@@ -1261,6 +1265,7 @@ class emitter
 #define PERFSCORE_LATENCY_26C 26.0f
 #define PERFSCORE_LATENCY_62C 62.0f
 #define PERFSCORE_LATENCY_69C 69.0f
+#define PERFSCORE_LATENCY_400C 400.0f // Intel microcode issue with these instuctions
 
 #define PERFSCORE_LATENCY_BRANCH_DIRECT 1.0f   // cost of an unconditional branch
 #define PERFSCORE_LATENCY_BRANCH_COND 2.0f     // includes cost of a possible misprediction
diff --git a/src/coreclr/src/jit/emitxarch.cpp b/src/coreclr/src/jit/emitxarch.cpp
