tracing/tracing/extras/importer/fuchsia_importer.html - catapult - Git at Google

 <!DOCTYPE html>
 <!--
 Copyright 2017 The Chromium Authors. All rights reserved.
 Use of this source code is governed by a BSD-style license that can be
 found in the LICENSE file.
 -->

 <link rel="import" href="/tracing/base/trace_stream.html">
 <link rel="import" href="/tracing/importer/importer.html">
 <link rel="import" href="/tracing/model/model.html">

 <script>
 'use strict';

 tr.exportTo('tr.e.importer.fuchsia', function() {
   const IMPORT_PRIORITY = 0;
   const IDLE_THREAD_THRESHOLD = 6444000000;

   // Zircon thread state constants from:
   // https://fuchsia.googlesource.com/zircon/+/master/docs/syscalls/object_get_info.md
   const ZX_THREAD_STATE_NEW = 0;
   const ZX_THREAD_STATE_RUNNING = 1;
   const ZX_THREAD_STATE_SUSPENDED = 2;
   const ZX_THREAD_STATE_BLOCKED = 3;
   const ZX_THREAD_STATE_DYING = 4;
   const ZX_THREAD_STATE_DEAD = 5;

   class FuchsiaImporter extends tr.importer.Importer {
     constructor(model, eventData) {
       super(model, eventData);
       this.importPriority = IMPORT_PRIORITY;
       this.model_ = model;
       this.events_ = eventData.events;
       this.parsers_ = [];
       this.threadInfo_ = new Map();
       this.processNames_ = new Map();
       this.threadStates_ = new Map();
     }

     static canImport(eventData) {
       if (eventData instanceof tr.b.TraceStream) {
         if (eventData.isBinary) return false;
         eventData = eventData.header;
       }

       if (eventData instanceof Object && eventData.type === 'fuchsia') {
         return true;
       }

       return false;
     }

     get importerName() {
       return 'FuchsiaImporter';
     }

     get model() {
       return this.model_;
     }

     importClockSyncMarkers() {
     }

     finalizeImport() {
     }

     isIdleThread(prio, tid) {
       if (prio === undefined) {
         // If the "prio" field is not available (if we were, for example,
         // using an old trace), then fall back to the legacy heuristic of
         // assuming that large numbered threads are idle ones.
         return tid > IDLE_THREAD_THRESHOLD;
       }
       // A thread is idle iff its priority is set to 0.
       return prio === 0;
     }

     recordThreadState_(tid, timestamp, state, prio) {
       if (this.isIdleThread(prio, tid)) {
         return;
       }
       const states =
         this.threadStates_.has(tid) ? this.threadStates_.get(tid) : [];
       states.push({'ts': timestamp, state});
       this.threadStates_.set(tid, states);
     }

     // Context switch events take the form:
     // {
     //     "ph": "k",
     //     "ts": 151981130.88743783,
     //     "cpu": 1,
     //     "out": {
     //       "pid": 25977,
     //       "tid": 28909,
     //       "state": 3,
     //       "prio": 20
     //     },
     //     "in": {
     //       "pid": 0,
     //       "tid": 6444931392,
     //       "prio": 0
     //     }
     //   },
     processContextSwitchEvent_(event) {
       let tid = event.in.tid;
       let threadName = tid.toString();
       let procName = '';
       const prio = event.in.prio;

       if (this.threadInfo_.has(tid)) {
         const threadInfo = this.threadInfo_.get(tid);
         threadName = threadInfo.name;
         const pid = threadInfo.pid;
         if (this.processNames_.has(pid)) {
           procName = this.processNames_.get(pid) + ':';
         }
       }

       const name = procName + threadName;

       if (this.isIdleThread(prio, tid)) {
         tid = undefined; // Fake kernel idle task
       }

       const cpu = this.model_.kernel.getOrCreateCpu(event.cpu);
       const timestamp = tr.b.Unit.timestampFromUs(event.ts);
       cpu.switchActiveThread(timestamp, {}, tid, name, tid);

       const SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
       this.recordThreadState_(tid, timestamp, SCHEDULING_STATE.RUNNING, prio);

       let outState = SCHEDULING_STATE.UNKNOWN;

       switch (event.out.state) {
         case ZX_THREAD_STATE_NEW:
           outState = SCHEDULING_STATE.RUNNABLE;
           break;

         case ZX_THREAD_STATE_RUNNING:
           outState = SCHEDULING_STATE.RUNNABLE;
           break;

         case ZX_THREAD_STATE_BLOCKED:
           outState = SCHEDULING_STATE.SLEEPING;
           break;

         case ZX_THREAD_STATE_SUSPENDED:
           outState = SCHEDULING_STATE.STOPPED;
           break;

         case ZX_THREAD_STATE_DEAD:
           outState = SCHEDULING_STATE.TASK_DEAD;
           break;
       }
       this.recordThreadState_(event.out.tid, timestamp, outState,
           event.out.prio);
     }

     processProcessInfoEvent_(event) {
       const process = this.model_.getOrCreateProcess(event.pid);
       process.name = event.name;
       this.processNames_.set(event.pid, event.name);

       if ('sort_index' in event) {
         process.sortIndex = event.sort_index;
       }
     }

     processThreadInfoEvent_(event) {
       const thread = this.model_.getOrCreateProcess(event.pid).
           getOrCreateThread(event.tid);
       thread.name = event.name;
       this.threadInfo_.set(event.tid, {'name': event.name, 'pid': event.pid});

       if ('sort_index' in event) {
         const thread = this.model_.getOrCreateProcess(event.pid).
             getOrCreateThread(event.tid);
         thread.sortIndex = event.sort_index;
       }
     }

     processEvent_(event) {
       switch (event.ph) {
         case 'k':
           this.processContextSwitchEvent_(event);
           break;
         case 'p':
           this.processProcessInfoEvent_(event);
           break;
         case 't':
           this.processThreadInfoEvent_(event);
           break;
       }
     }

     postProcessStates_() {
       for (const [tid, states] of this.threadStates_) {
         if (!this.threadInfo_.has(tid)) {
           continue;
         }
         const pid = this.threadInfo_.get(tid).pid;
         const thread = this.model_.getOrCreateProcess(
             pid).getOrCreateThread(tid);
         const slices = [];
         for (let i = 0; i < states.length - 1; i++) {
           slices.push(new tr.model.ThreadTimeSlice(
               thread, states[i].state, '',
               states[i].ts, {}, states[i + 1].ts - states[i].ts));
         }

         thread.timeSlices = slices;
       }
     }

     /**
      * Imports the data in this.events_ into model_.
      */
     importEvents() {
       for (const event of this.events_) {
         this.processEvent_(event);
       }
       this.postProcessStates_();
     }
   }

   tr.importer.Importer.register(FuchsiaImporter);

   return {
     FuchsiaImporter,
     IMPORT_PRIORITY,
   };
 });
 </script>
	<!DOCTYPE html>
	<!--
	Copyright 2017 The Chromium Authors. All rights reserved.
	Use of this source code is governed by a BSD-style license that can be
	found in the LICENSE file.
	-->

	<link rel="import" href="/tracing/base/trace_stream.html">
	<link rel="import" href="/tracing/importer/importer.html">
	<link rel="import" href="/tracing/model/model.html">

	<script>
	'use strict';

	tr.exportTo('tr.e.importer.fuchsia', function() {
	const IMPORT_PRIORITY = 0;
	const IDLE_THREAD_THRESHOLD = 6444000000;

	// Zircon thread state constants from:
	// https://fuchsia.googlesource.com/zircon/+/master/docs/syscalls/object_get_info.md
	const ZX_THREAD_STATE_NEW = 0;
	const ZX_THREAD_STATE_RUNNING = 1;
	const ZX_THREAD_STATE_SUSPENDED = 2;
	const ZX_THREAD_STATE_BLOCKED = 3;
	const ZX_THREAD_STATE_DYING = 4;
	const ZX_THREAD_STATE_DEAD = 5;

	class FuchsiaImporter extends tr.importer.Importer {
	constructor(model, eventData) {
	super(model, eventData);
	this.importPriority = IMPORT_PRIORITY;
	this.model_ = model;
	this.events_ = eventData.events;
	this.parsers_ = [];
	this.threadInfo_ = new Map();
	this.processNames_ = new Map();
	this.threadStates_ = new Map();
	}

	static canImport(eventData) {
	if (eventData instanceof tr.b.TraceStream) {
	if (eventData.isBinary) return false;
	eventData = eventData.header;
	}

	if (eventData instanceof Object && eventData.type === 'fuchsia') {
	return true;
	}

	return false;
	}

	get importerName() {
	return 'FuchsiaImporter';
	}

	get model() {
	return this.model_;
	}

	importClockSyncMarkers() {
	}

	finalizeImport() {
	}

	isIdleThread(prio, tid) {
	if (prio === undefined) {
	// If the "prio" field is not available (if we were, for example,
	// using an old trace), then fall back to the legacy heuristic of
	// assuming that large numbered threads are idle ones.
	return tid > IDLE_THREAD_THRESHOLD;
	}
	// A thread is idle iff its priority is set to 0.
	return prio === 0;
	}

	recordThreadState_(tid, timestamp, state, prio) {
	if (this.isIdleThread(prio, tid)) {
	return;
	}
	const states =
	this.threadStates_.has(tid) ? this.threadStates_.get(tid) : [];
	states.push({'ts': timestamp, state});
	this.threadStates_.set(tid, states);
	}

	// Context switch events take the form:
	// {
	// "ph": "k",
	// "ts": 151981130.88743783,
	// "cpu": 1,
	// "out": {
	// "pid": 25977,
	// "tid": 28909,
	// "state": 3,
	// "prio": 20
	// },
	// "in": {
	// "pid": 0,
	// "tid": 6444931392,
	// "prio": 0
	// }
	// },
	processContextSwitchEvent_(event) {
	let tid = event.in.tid;
	let threadName = tid.toString();
	let procName = '';
	const prio = event.in.prio;

	if (this.threadInfo_.has(tid)) {
	const threadInfo = this.threadInfo_.get(tid);
	threadName = threadInfo.name;
	const pid = threadInfo.pid;
	if (this.processNames_.has(pid)) {
	procName = this.processNames_.get(pid) + ':';
	}
	}

	const name = procName + threadName;

	if (this.isIdleThread(prio, tid)) {
	tid = undefined; // Fake kernel idle task
	}

	const cpu = this.model_.kernel.getOrCreateCpu(event.cpu);
	const timestamp = tr.b.Unit.timestampFromUs(event.ts);
	cpu.switchActiveThread(timestamp, {}, tid, name, tid);

	const SCHEDULING_STATE = tr.model.SCHEDULING_STATE;
	this.recordThreadState_(tid, timestamp, SCHEDULING_STATE.RUNNING, prio);

	let outState = SCHEDULING_STATE.UNKNOWN;

	switch (event.out.state) {
	case ZX_THREAD_STATE_NEW:
	outState = SCHEDULING_STATE.RUNNABLE;
	break;

	case ZX_THREAD_STATE_RUNNING:
	outState = SCHEDULING_STATE.RUNNABLE;
	break;

	case ZX_THREAD_STATE_BLOCKED:
	outState = SCHEDULING_STATE.SLEEPING;
	break;

	case ZX_THREAD_STATE_SUSPENDED:
	outState = SCHEDULING_STATE.STOPPED;
	break;

	case ZX_THREAD_STATE_DEAD:
	outState = SCHEDULING_STATE.TASK_DEAD;
	break;
	}
	this.recordThreadState_(event.out.tid, timestamp, outState,
	event.out.prio);
	}

	processProcessInfoEvent_(event) {
	const process = this.model_.getOrCreateProcess(event.pid);
	process.name = event.name;
	this.processNames_.set(event.pid, event.name);

	if ('sort_index' in event) {
	process.sortIndex = event.sort_index;
	}
	}

	processThreadInfoEvent_(event) {
	const thread = this.model_.getOrCreateProcess(event.pid).
	getOrCreateThread(event.tid);
	thread.name = event.name;
	this.threadInfo_.set(event.tid, {'name': event.name, 'pid': event.pid});

	if ('sort_index' in event) {
	const thread = this.model_.getOrCreateProcess(event.pid).
	getOrCreateThread(event.tid);
	thread.sortIndex = event.sort_index;
	}
	}

	processEvent_(event) {
	switch (event.ph) {
	case 'k':
	this.processContextSwitchEvent_(event);
	break;
	case 'p':
	this.processProcessInfoEvent_(event);
	break;
	case 't':
	this.processThreadInfoEvent_(event);
	break;
	}
	}

	postProcessStates_() {
	for (const [tid, states] of this.threadStates_) {
	if (!this.threadInfo_.has(tid)) {
	continue;
	}
	const pid = this.threadInfo_.get(tid).pid;
	const thread = this.model_.getOrCreateProcess(
	pid).getOrCreateThread(tid);
	const slices = [];
	for (let i = 0; i < states.length - 1; i++) {
	slices.push(new tr.model.ThreadTimeSlice(
	thread, states[i].state, '',
	states[i].ts, {}, states[i + 1].ts - states[i].ts));
	}

	thread.timeSlices = slices;
	}
	}

	/**
	* Imports the data in this.events_ into model_.
	*/
	importEvents() {
	for (const event of this.events_) {
	this.processEvent_(event);
	}
	this.postProcessStates_();
	}
	}

	tr.importer.Importer.register(FuchsiaImporter);

	return {
	FuchsiaImporter,
	IMPORT_PRIORITY,
	};
	});
	</script>