[tools/profview] Add individual function timeline view

tools/profview/profile-utils.js

 // Copyright 2017 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 "use strict"
 
 let codeKinds = [
     "UNKNOWN",
     "CPPCOMP",
     "CPPGC",
@@ skipping 54 matching lines @@
       kind = "CPPGC";
     } else if (vmState === 2) {
       kind = "CPPCOMP";
     } else if (vmState === 4) {
       kind = "CPPEXT";
     }
   }
   return kind;
 }
 
-function createNodeFromStackEntry(code) {
+function createNodeFromStackEntry(code, codeId) {
   let name = code ? code.name : "UNKNOWN";
 
-  return { name, type : resolveCodeKind(code),
+  return { name, codeId, type : resolveCodeKind(code),
            children : [], ownTicks : 0, ticks : 0 };
 }
 
 function childIdFromCode(codeId, code) {
   // For JavaScript function, pretend there is one instance of optimized
   // function and one instance of unoptimized function per SFI.
   // Otherwise, just compute the id from code id.
   let type = resolveCodeKind(code);
   if (type === "JSOPT") {
     return code.func * 4 + 1;
@@ skipping 47 matching lines @@
     // If we are doing top-down call tree, update own ticks.
     if (!ascending) {
       parent.ownTicks++;
     }
   } else {
     console.assert(stackPos >= 0 && stackPos < stack.length);
     // We found a child node.
     let childId = childIdFromCode(codeId, code);
     let child = parent.children[childId];
     if (!child) {
-      child = createNodeFromStackEntry(code);
+      child = createNodeFromStackEntry(code, codeId);
       child.delayedExpansion = { frameList : [], ascending };
       parent.children[childId] = child;
     }
     child.ticks++;
     addFrameToFrameList(child.delayedExpansion.frameList, stackIndex, stackPos);
   }
 }
 
 // This expands a tree node (direct children only).
 function expandTreeNode(file, node, filter) {
@@ skipping 13 matching lines @@
       let stackPos = findNextFrame(file, stack, depth + step, step, filter);
       addOrUpdateChildNode(node, file, stackIndex, stackPos, ascending);
     }
   }
   node.delayedExpansion = null;
 }
 
 function createEmptyNode(name) {
   return {
       name : name,
+      codeId: -1,
       type : "CAT",
       children : [],
       ownTicks : 0,
       ticks : 0
   };
 }
 
 class PlainCallTreeProcessor {
   constructor(filter, isBottomUp) {
     this.filter = filter;
@@ skipping 68 matching lines @@
   }
 }
 
 class FunctionListTree {
   constructor(filter, withCategories) {
     if (withCategories) {
       let { categories, root } = buildCategoryTreeAndLookup();
       this.tree = root;
       this.categories = categories;
     } else {
-      this.tree = { name : "root", children : [], ownTicks : 0, ticks : 0 };
+      this.tree = { name : "root", codeId: -1, children : [], ownTicks : 0, ticks : 0 };

[Jarin, 2017/03/08 14:25:56]

<80 character lines, please (here and below).

[Leszek Swirski, 2017/03/08 14:32:40]

Done.

       this.categories = null;
     }
 
     this.codeVisited = [];
     this.filter = filter;
   }
 
   addStack(file, tickIndex) {
     let stack = file.ticks[tickIndex].s;
     let vmState = file.ticks[tickIndex].vm;
@@ skipping 13 matching lines @@
       }
       let childId = childIdFromCode(codeId, code);
       if (this.categories) {
         let kind = resolveCodeKindAndVmState(code, vmState);
         tree = this.categories[kind];
       } else {
         tree = this.tree;
       }
       child = tree.children[childId];
       if (!child) {
-        child = createNodeFromStackEntry(code);
+        child = createNodeFromStackEntry(code, codeId);
         child.children[0] = createEmptyNode("Top-down tree");
         child.children[0].delayedExpansion =
           { frameList : [], ascending : false };
         child.children[1] = createEmptyNode("Bottom-up tree");
         child.children[1].delayedExpansion =
           { frameList : [], ascending : true };
         tree.children[childId] = child;
       }
       child.ticks++;
       child.children[0].ticks++;
@@ skipping 47 matching lines @@
     let bucket = this.buckets[i];
     bucket.total++;
 
     let codeId = (stack.length > 0) ? stack[0] : -1;
     let code = codeId >= 0 ? file.code[codeId] : undefined;
     let kind = resolveCodeKindAndVmState(code, vmState);
     bucket[kind]++;
   }
 }
 
+class FunctionTimelineProcessor {
+  constructor(functionCodeId, filter) {
+    this.functionCodeId = functionCodeId;
+    this.filter = filter;
+    this.blocks = [];
+    this.currentBlock = null;
+  }
+
+  addStack(file, tickIndex) {
+    let { tm : timestamp, vm : vmState, s : stack } = file.ticks[tickIndex];
+
+    let codeInStack = stack.includes(this.functionCodeId);
+    if (codeInStack) {
+      let topOfStack = -1;
+      for (let i = 0; i < stack.length - 1; i += 2) {
+        let codeId = stack[i];
+        let code = codeId >= 0 ? file.code[codeId] : undefined;
+        let type = code ? code.type : undefined;
+        let kind = code ? code.kind : undefined;
+        if (!this.filter(type, kind)) continue;
+
+        topOfStack = i;
+        break;
+      }
+
+      let codeIsTopOfStack = (topOfStack !== -1 && stack[topOfStack] === this.functionCodeId);
+
+      if (this.currentBlock !== null) {
+        this.currentBlock.end = timestamp;
+
+        if (codeIsTopOfStack === this.currentBlock.topOfStack) {
+          return;
+        }
+      }
+
+      this.currentBlock = { start: timestamp, end: timestamp, topOfStack: codeIsTopOfStack };
+      this.blocks.push(this.currentBlock);
+    } else {
+      this.currentBlock = null;
+    }
+  }
+}
+
 // Generates a tree out of a ticks sequence.
 // {file} is the JSON files with the ticks and code objects.
 // {startTime}, {endTime} is the interval.
 // {tree} is the processor of stacks.
 function generateTree(
     file, startTime, endTime, tree) {
   let ticks = file.ticks;
   let i = 0;
   while (i < ticks.length && ticks[i].tm < startTime) {
     i++;
   }
 
   let tickCount = 0;
   while (i < ticks.length && ticks[i].tm < endTime) {
     tree.addStack(file, i);
     i++;
     tickCount++;
   }
 
   return tickCount;
 }