File: systrace_parser.html

package info (click to toggle)
android-platform-frameworks-base 1%3A14~beta1-3
  • links: PTS, VCS
  • area: main
  • in suites: forky, sid, trixie
  • size: 326,092 kB
  • sloc: java: 2,032,373; xml: 343,016; cpp: 304,181; python: 3,683; ansic: 2,090; sh: 1,871; makefile: 117; sed: 19
file content (89 lines) | stat: -rw-r--r-- 3,285 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
<!DOCTYPE html>

<script>
'use strict';

const RENDER_THREAD_NAME = "RenderThread";
const UI_THREAD_NAME = "UI Thread";
const DRAW_FRAME_SLICE_TITLE = "DrawFrame";
const BINDER_SLICE_TITLE = "binder transaction";
const RECORD_SLICE_TITLE = "Record View#draw()";
const DEQUEUE_BUFFER_SLICE_TITLE = "dequeueBuffer";

function getTimeInBinder(slice) {
    if (slice.title === BINDER_SLICE_TITLE) {
        return slice.duration;
    }
    let result = 0.0;
    for (let subslice of slice.subSlices) {
        result += getTimeInBinder(subslice);
    }
    return result;
}

function getTimeInDequeueBuffer(slice) {
    if (slice.title === DEQUEUE_BUFFER_SLICE_TITLE) {
        return slice.duration;
    }
    let result = 0.0;
    for (let subslice of slice.subSlices) {
        result += getTimeInDequeueBuffer(subslice);
    }
    return result;
}

tr.mre.FunctionRegistry.register(
    function AvgDrawFrame(result, model) {
        let canonicalUrl = model.canonicalUrl;

        for (let p of model.getAllProcesses()) {
            //calc stats for processes that have UI and render threads and at least 10 frames
            let renderThread = p.findAtMostOneThreadNamed(RENDER_THREAD_NAME);
            let UIThread = p.findAtMostOneThreadNamed(UI_THREAD_NAME);
            if (renderThread && UIThread)
            {
                let numDrawFrames = 0;
                let drawFramesWallDuration = 0.0;
                let binderDuration = 0.0;
                let dequeueBufferDuration = 0.0;

                let numRecordViewDraw = 0;
                let recordViewDrawWallDuration = 0.0;

                renderThread.sliceGroup.slices.forEach(function(slice) {
                    if (slice.title === DRAW_FRAME_SLICE_TITLE) {
                        drawFramesWallDuration += slice.duration;
                        numDrawFrames++;
                        binderDuration += getTimeInBinder(slice);
                        dequeueBufferDuration += getTimeInDequeueBuffer(slice);
                    }
                });
                if (numDrawFrames < 10) continue;
                UIThread.sliceGroup.slices.forEach(function(slice) {
                    if (slice.title === RECORD_SLICE_TITLE) {
                        recordViewDrawWallDuration += slice.duration;
                        numRecordViewDraw++;
                    }
                });

                let avgDrawFrameDuration = undefined;
                if (numDrawFrames > 0) {
                    avgDrawFrameDuration = (drawFramesWallDuration-dequeueBufferDuration)/numDrawFrames;
                }
                let avgRecordViewDrawDuration = undefined;
                if (numRecordViewDraw > 0) {
                    avgRecordViewDrawDuration = recordViewDrawWallDuration/numRecordViewDraw;
                }

                result.addPair('result', {
                    canonicalUrl: canonicalUrl,
                    processName: p.name,
                    avgDrawFrameDuration: Number(avgDrawFrameDuration).toFixed(3),
                    avgRecordViewDrawDuration: Number(avgRecordViewDrawDuration).toFixed(3),
                    avgRecordAndPlay: Number(avgDrawFrameDuration+avgRecordViewDrawDuration).toFixed(3)
                });
            }
        }
    });

</script>