[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
+      };
       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);

[Jarin, 2017/03/08 16:35:56]

This will not quite work for optimized code because there might be several
optimized code objects for one function (and we do count them together). We
likely want to match on funcId if the code is optimized function.

+
+      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;
 }