From a9de20a80404a0fc7b522681c655efbfd98771bd Mon Sep 17 00:00:00 2001 From: "sullivan@chromium.org" Date: Fri, 19 Apr 2013 21:09:46 +0000 Subject: [PATCH] Add trace-info.json which contains information about perf traces. Also update test-info.json to use markdown for links. BUG= Review URL: https://codereview.chromium.org/14172018 git-svn-id: svn://svn.chromium.org/chrome/trunk/src@195284 0039d316-1c4b-4281-b951-d872f2087c98 --- tools/perf/test-info.json | 16 +- tools/perf/trace-info.json | 569 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 577 insertions(+), 8 deletions(-) create mode 100644 tools/perf/trace-info.json diff --git a/tools/perf/test-info.json b/tools/perf/test-info.json index c14cf3811eef..1360d784b5ac 100644 --- a/tools/perf/test-info.json +++ b/tools/perf/test-info.json @@ -154,15 +154,15 @@ ] }, "jsgamebench": { - "description": "Score on Facebook's JSGameBench benchmark.\n\nThe focus is sprite performance a player is likely to see. Scoring is how many sprites are drawn, so large scores are better.\n\nFor each render path, JSGameBench draws as many moving, animating sprites as possible at 30fps against a background with both axis-aligned and rotated sprites. We try both because significant performance differences between the two indicate flaws or oversights in current rendering techniques. More importantly, while animation can be used instead of sprite rotations, it is often an unacceptable trade off that game developers should not be forced to make.\n\nThe final score is the geometric mean of the axis aligned and rotated scores. Geometric mean is used to prevent a high axis aligned score from hiding the poor rotated performance.", + "description": "Score on [Facebook's JSGameBench benchmark](https://github.com/facebook/jsgamebench).\n\nThe focus is sprite performance a player is likely to see. Scoring is how many sprites are drawn, so large scores are better.\n\nFor each render path, JSGameBench draws as many moving, animating sprites as possible at 30fps against a background with both axis-aligned and rotated sprites. We try both because significant performance differences between the two indicate flaws or oversights in current rendering techniques. More importantly, while animation can be used instead of sprite rotations, it is often an unacceptable trade off that game developers should not be forced to make.\n\nThe final score is the geometric mean of the axis aligned and rotated scores. Geometric mean is used to prevent a high axis aligned score from hiding the poor rotated performance.", "code": ["chrome/src/tools/perf/perf_tools/jsgamebench.py"] }, "kraken": { - "description": "Score on mozilla's Kraken JavaScript benchmark ", + "description": "Score on [Mozilla's Kraken JavaScript benchmark](http://krakenbenchmark.mozilla.org/)", "code": ["chrome/src/tools/perf/perf_tools/kraken.py"] }, "mach_ports": { - "description": "This test spawns a new browser and counts the number of open Mach ports in the browser process. It navigates tabs and closes them, repeatedly measuring the number of open ports. This is used to protect against leaking Mach ports, which was the source of .", + "description": "This test spawns a new browser and counts the number of open Mach ports in the browser process. It navigates tabs and closes them, repeatedly measuring the number of open ports. This is used to protect against leaking Mach ports, which was the source of [bug 105513](http://crbug.com/105513).", "code": [ "chrome/src/chrome/test/perf/mach_ports_test.cc" ] @@ -190,19 +190,19 @@ ] }, "octane": { - "description": "Score on the V8 team's Octane benchmark ", + "description": "Score on the [V8 team's Octane benchmark](http://octane-benchmark.googlecode.com/svn/latest/index.html)", "code": ["chrome/src/tools/perf/perf_tools/octane.py"] }, "robohornetpro": { - "description": "Milliseconds to complete the RoboHornetPro demo by Microsoft ", + "description": "Milliseconds to complete the [RoboHornetPro demo by Microsoft](http://ie.microsoft.com/testdrive/performance/robohornetpro/)", "code": ["chrome/src/tools/perf/perf_tools/robohornetpro.py"] }, "scrolling_benchmark": { - "description": "Measures frame rate and a variety of other statistics while scrolling down the top 25 web pages. See .", + "description": "Measures frame rate and a variety of other statistics while scrolling down the top 25 web pages. [Documentation](http://www.chromium.org/developers/design-documents/rendering-benchmarks).", "code": ["chrome/src/tools/perf/perf_tools/scrolling_benchmark.py"] }, "spaceport": { - "description": "Performance on spaceport.io's perfmarks benchmark. This test performs 3 animations (rotate, translate, scale) using a variety of methods (css, webgl, canvas, etc) and reports the number of objects that can be simultaneously animated while still achieving 30FPS. See .", + "description": "Performance on [spaceport.io's perfmarks benchmark](http://spaceport.io/community/perfmarks). This test performs 3 animations (rotate, translate, scale) using a variety of methods (css, webgl, canvas, etc) and reports the number of objects that can be simultaneously animated while still achieving 30FPS.", "code": ["chrome/src/tools/perf/perf_tools/spaceport.py"] }, "startup_test": { @@ -210,7 +210,7 @@ "code": ["chrome/src/chrome/test/perf/startup_test.cc"] }, "sunspider": { - "description": "Performance on the SunSpider JavaScript benchmark ", + "description": "Performance on the [SunSpider JavaScript benchmark](http://www.webkit.org/perf/sunspider/sunspider.html)", "code": ["chrome/src/tools/perf/perf_tools/sunspider.py"] } } diff --git a/tools/perf/trace-info.json b/tools/perf/trace-info.json new file mode 100644 index 000000000000..e2e9fb7f39db --- /dev/null +++ b/tools/perf/trace-info.json @@ -0,0 +1,569 @@ +{ + "_description" : "This file contains info about our performance test traces, used by the perf dashboard (http://chromeperf.appspot.com). Links in test descriptions should be in markdown format. SUITE as the description means the same description as the test suite.", + + "dom": { + "description": "" + }, + "dom_attr": { + "description": "" + }, + "dom_attr_element_expando": { + "description": "" + }, + "dom_attr_element_expando___value": { + "description": "" + }, + "dom_attr_element_property": { + "description": "" + }, + "dom_attr_element_property___value": { + "description": "" + }, + "dom_attr_getAttribute": { + "description": "" + }, + "dom_attr_setAttribute": { + "description": "" + }, + "dom_modify": { + "description": "" + }, + "dom_modify_appendChild": { + "description": "" + }, + "dom_modify_coneNode": { + "description": "" + }, + "dom_modify_createElement": { + "description": "" + }, + "dom_modify_createTextNode": { + "description": "" + }, + "dom_modify_innerHTML": { + "description": "" + }, + "dom_modify_insertBefore": { + "description": "" + }, + "dom_query": { + "description": "" + }, + "dom_query_getElementById": { + "description": "" + }, + "dom_query_getElementById__not_in_document_": { + "description": "" + }, + "dom_query_getElementsByName": { + "description": "" + }, + "dom_query_getElementsByName__not_in_document": { + "description": "" + }, + "dom_query_getElementsByTagName___": { + "description": "" + }, + "dom_query_getElementsByTagName_p_": { + "description": "" + }, + "dom_traverse": { + "description": "" + }, + "dom_traverse_childNodes": { + "description": "" + }, + "dom_traverse_firstChild": { + "description": "" + }, + "dom_traverse_lastChild": { + "description": "" + }, + "dom_traverse_nextSibling": { + "description": "" + }, + "dom_traverse_previousSibling": { + "description": "" + }, + + "jslib": { + "description": "" + }, + "jslib_attr_jquery": { + "description": "" + }, + "jslib_attr_jquery_jQuery___addClass": { + "description": "" + }, + "jslib_attr_jquery_jQuery___attr_class__x100": { + "description": "" + }, + "jslib_attr_jquery_jQuery___attr_class_test_": { + "description": "" + }, + "jslib_attr_jquery_jQuery___hasClassx10": { + "description": "" + }, + "jslib_attr_jquery_jQuery___removeAttribute": { + "description": "" + }, + "jslib_attr_jquery_jQuery___removeClass": { + "description": "" + }, + "jslib_attr_prototype": { + "description": "" + }, + + "gif": { + "description": "Time to decode a 3.1 MB gif image. File found at chrome/test/data/image_decoding/droids.gif" + }, + "png": { + "description": "Time to decode a 4.6 MB png image. File found at chrome/test/data/image_decoding/droids.png" + }, + "jpg": { + "description": "Time to decode a 810 KB jpg image. File found at chrome/test/data/image_decoding/droids.jpg" + }, + "webp": { + "description": "Time to decode a 65 KB webp image. File found at chrome/test/data/image_decoding/droids.webp" + }, + "ImageDecoding_avg": { + "description": "Average decode time of 4 images formats: gif, png, jpg, and webp." + }, + + "score": { + "description": "SUITE" + }, + + "Total": { + "description": "SUITE" + }, + "ai-astar": { + "description": "This benchmark uses the [A* search algorithm](http://en.wikipedia.org/wiki/A*_search_algorithm) to automatically plot an efficient path between two points, in the presence of obstacles. Adapted from code by [Brian Gringstead](http://www.briangrinstead.com/blog/astar-search-algorithm-in-javascript)." + }, + "audio-beat-detection": { + "description": "This benchmark performs [beat detection](http://en.wikipedia.org/wiki/Beat_detection) on an Audio sample using [code](http://beatdetektor.svn.sourceforge.net/viewvc/beatdetektor/trunk/core/js/beatdetektor.js?revision=18&view=markup) from [BeatDetektor](http://www.cubicproductions.com/index.php?option=com_content&view=article&id=67&Itemid=82) and [DSP.js](http://github.com/corbanbrook/dsp.js/)." + }, + "audio-dft": { + "description": "This benchmark performs a [Discrete Fourier Transform](http://en.wikipedia.org/wiki/Discrete_Fourier_transform) on an Audio sample using code from [DSP.js](http://github.com/corbanbrook/dsp.js)." + }, + "audio-fft": { + "description": "This benchmark performs a [Fast Fourier Transform](http://en.wikipedia.org/wiki/Fast_Fourier_transform) on an Audio sample using code from [DSP.js](http://github.com/corbanbrook/dsp.js/)." + }, + "audio-oscillator": { + "description": "This benchmark generates a soundwave using code from [DSP.js](http://github.com/corbanbrook/dsp.js/)." + }, + "imaging-darkroom": { + "description": "This benchmark performs a variety of photo manipulations such as Fill, Brightness, Contrast, Saturation, and Temperature." + }, + "imaging-desaturate": { + "description": "This benchmark [desaturates](http://en.wikipedia.org/wiki/Colorfulness) a photo using code from [Pixastic](http://www.pixastic.com/)." + }, + "imaging-gaussian-blur": { + "description": "This benchmark performs a [Gaussian blur](http://en.wikipedia.org/wiki/Gaussian_blur) on a photo." + }, + "json-parse-financial": { + "description": "This benchmark parses [JSON](http://www.json.org) records." + }, + "json-stringify-tinderbox": { + "description": "This benchmark serializes [Tinderbox](http://tests.themasta.com/tinderboxpushlog/?tree=Firefox) build data to [JSON](http://www.json.org)." + }, + "stanford-crypto-aes": { + "description": "" + }, + "stanford-crypto-ccm": { + "description": "" + }, + "stanford-crypto-pbkdf2": { + "description": "" + }, + "stanford-crypto-sha256-iterative": { + "description": "" + }, + + "Memory_RendererUsed": { + "description": "" + }, + "Memory_BrowserUsed": { + "description": "" + }, + "V8-MemoryExternalFragmentationTotal": { + "description": "" + }, + "V8_MemoryHeapSampleTotalCommitted": { + "description": "" + }, + "V8_MemoryHeapSampleTotalUsed": { + "description": "" + }, + + "CodeLoad": { + "description": "measures how quickly a JavaScript engine can start executing code after loading a large JavaScript program, social widget being a common example. The source for test is derived from open source libraries (Closure, jQuery) (1,530 lines)." + }, + "Crypto": { + "description": "Encryption and decryption benchmark based on code by Tom Wu (1698 lines)." + }, + "DeltaBlue": { + "description": "One-way constraint solver, originally written in Smalltalk by John Maloney and Mario Wolczko (880 lines)." + }, + "EarleyBoyer": { + "description": "Classic Scheme benchmarks, translated to JavaScript by Florian Loitsch's Scheme2Js compiler (4684 lines)." + }, + "Gameboy": { + "description": "Emulate the portable console's architecture and runs a demanding 3D simulation, all in JavaScript (11,097 lines)." + }, + "Mandreel": { + "description": "Runs the 3D Bullet Physics Engine ported from C++ to JavaScript via Mandreel (277,377 lines)." + }, + "NavierStokes": { + "description": "2D NavierStokes equations solver, heavily manipulates double precision arrays. Based on Oliver Hunt's code (387 lines)." + }, + "PdfJS": { + "description": "Mozilla's PDF Reader implemented in JavaScript. It measures decoding and interpretation time (33,056 lines)." + }, + "RayTrace": { + "description": "Ray tracer benchmark based on code by Adam Burmister (904 lines)." + }, + "RegExp": { + "description": "Regular expression benchmark generated by extracting regular expression operations from 50 of the most popular web pages (1761 lines)." + }, + "Richards": { + "description": "OS kernel simulation benchmark, originally written in BCPL by Martin Richards (539 lines)." + }, + "Splay": { + "description": "Data manipulation benchmark that deals with splay trees and exercises the automatic memory management subsystem (394 lines).." + }, + + "t": { + "description": "Average page load time." + }, + "total_byte_b": { + "description": "Total number of bytes of browser process IO" + }, + "total_byte_r": { + "description": "Total number of bytes of renderer process IO" + }, + "total_op_b": { + "description": "Total number of IO operations by browser process" + }, + "total_op_r": { + "description": "Total number of IO operations by renderer process" + }, + "vm_peak_b": { + "description": "The peak Virtual Memory Size (address space allocated) usage achieved by the browser process." + }, + "vm_peak_r": { + "description": "The peak Virtual Memory Size (address space allocated) usage achieved by the renderer process." + }, + "vm_rss_final_b": { + "description": "Resident Set Size (physically resident memory) of browser process" + }, + "vm_rss_final_r": { + "description": "Resident Set Size (physically resident memory) of renderer process" + }, + "vm_ws_final_b": { + "description": "Working Set size of browser process" + }, + "vm_ws_final_r": { + "description": "Working Set size of renderer process" + }, + "vm_size_final_b": { + "description": "Virtual Memory Size (address space allocated) of browser process" + }, + "vm_size_final_r": { + "description": "Virtual Memory Size (address space allocated) of renderer process" + }, + "vm_size_final_t": { + "description": "Virtual Memory Size (address space allocated) of all processes" + }, + "rss_peak_b": { + "description": "The peak Resident Set Size (physically resident memory) usage achieved by the browser process." + }, + "rss_peak_r": { + "description": "The peak Resident Set Size (physically resident memory) usage achieved by the renderer process." + }, + "ws_peak_b": { + "description": "The peak Working Set Size usage achieved by the browser process." + }, + "ws_peak_r": { + "description": "The peak Working Set Size usage achieved by the renderer process." + }, + "commit_charge": { + "description": "System commit charge (commited memory pages)" + }, + "processes": { + "description": "Number of processes used by chrome" + }, + "read_byte_b": { + "description": "Number of IO bytes read by the browser process" + }, + "read_byte_r": { + "description": "Number of IO bytes read by the renderer process" + }, + "read_op_b": { + "description": "Number of IO read operations by the browser process" + }, + "read_op_r": { + "description": "Number of IO read operations by the renderer process" + }, + "write_byte_b": { + "description": "Number of IO bytes written by the browser process" + }, + "write_byte_r": { + "description": "Number of IO bytes written by the renderer process" + }, + "write_op_b": { + "description": "Number of write IO operations by browser process" + }, + "write_op_r": { + "description": "Number of write IO operations by renderer process" + }, + "V8.MemoryExternalFragmentationTotal": { + "description": "Total external memory fragmentation after each GC in percent." + }, + "V8.MemoryExternalFragmentationTotal_.1": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.25": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.5": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.75": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.9": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.95": { + "description": "" + }, + "V8.MemoryExternalFragmentationTotal_.99": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted": { + "description": "The total size of committed memory used by V8 after each GC in KB." + }, + "V8.MemoryHeapSampleTotalCommitted_.1": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.25": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.5": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.75": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.9": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.95": { + "description": "" + }, + "V8.MemoryHeapSampleTotalCommitted_.99": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed": { + "description": "The total size of live memory used by V8 after each GC in KB." + }, + "V8.MemoryHeapSampleTotalUsed_.1": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.25": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.5": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.75": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.9": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.95": { + "description": "" + }, + "V8.MemoryHeapSampleTotalUsed_.99": { + "description": "" + }, + + "avg_surface_fps": { + "description": "Average frames per second as measured by the platform's SurfaceFlinger." + }, + "mean_frame_time": { + "description": "The frame rate, but reported as an interval." + }, + "texture_upload_count": { + "description": "The number of textures uploaded to the GPU." + }, + "total_paint_time": { + "description": "" + }, + "average_commit_time": { + "description": "Time spent pushing the layer tree from the main thread to the compositor thread. Is zero if software rendering." + }, + "average_image_gathering_time": { + "description": "" + }, + "average_num_layers_drawn": { + "description": "Number of layers in the tree at draw time. Is zero in software mode." + }, + "average_num_missing_tiles": { + "description": "" + }, + "dropped_percent": { + "description": "Number of frames that missed vsync. The metric is slightly different in each rendering mode but roughly approximates how janky the page was." + }, + "megapixels_painted_per_second": { + "description": "Time spent painting, normalized by the amount of pixels we painted." + }, + "megapixels_rasterized_per_second": { + "description": "Time spent rasterizing, normalized by the amount of pixels rasterized." + }, + "percent_impl_scrolled": { + "description": "The percent of input events that caused fast scrolling on the impl thread. If you see numbers between 0 and 100, it's probably because the page changed halfway through and became slow scrolling, or vice versa." + }, + "total_deferred_image_decode_count": { + "description": "" + }, + "total_deferred_image_decode_time": { + "description": "" + }, + "total_image_cache_hit_count": { + "description": "" + }, + "total_paint_and_rasterize_time": { + "description": "The sum of rasterize and painting times." + }, + "total_pixels_painted": { + "description": "" + }, + "total_pixels_rasterized": { + "description": "" + }, + "total_rasterize_time": { + "description": "" + }, + "dom_content_loaded_time": { + "description": "" + }, + "load_time": { + "description": "" + }, + "total_texture_upload_time": { + "description": "The time spent in texture upload on the GPU process." + }, + "load_time_by_url": { + "description": "" + }, + + "Score": { + "description": "SUITE" + }, + "canvasDrawImageFullClear": { + "description": "Using a canvas element to render. Bitmaps are blitted to the canvas using the 'drawImage' function and the canvas is fully cleared at the beginning of each frame." + }, + "canvasDrawImageFullClearAlign": { + "description": "Same as canvasDrawImageFullClear except all 'x' and 'y' values are roudned to the nearest integer. This can be more efficient on translate on certain browsers." + }, + "canvasDrawImagePartialClear": { + "description": "Using a canvas element to render. Bitmaps are blitted to the canvas using the 'drawImage' function and pixels drawn in the last frame are cleared to the clear color at the beginning of each frame. This is generally slower on hardware accelerated implementations, but sometimes faster on CPU-based implementations." + }, + "canvasDrawImagePartialClearAlign": { + "description": "Same as canvasDrawImageFullClearAlign but only partially clearing the canvas each frame." + }, + "css2dBackground": { + "description": "Using div elements that have a background image specified using CSS styles. These div elements are translated, scaled, and rotated using CSS-2D transforms." + }, + "css2dImg": { + "description": "Same as css2dBackground, but using img elements instead of div elements." + }, + "css3dBackground": { + "description": "Same as css2dBackground, but using CSS-3D transforms." + }, + "css3dImg": { + "description": "Same as css2dImage but using CSS-3D tranforms." + }, + + "3d-cube": { + "description": "Pure JavaScript computations of the kind you might use to do 3d rendering, but without the rendering. This ends up mostly hitting floating point math and array access." + }, + "3d-morph": { + "description": "Pure JavaScript computations of the kind you might use to do 3d rendering, but without the rendering. This ends up mostly hitting floating point math and array access." + }, + "3d-raytrace": { + "description": "Pure JavaScript computations of the kind you might use to do 3d rendering, but without the rendering. This ends up mostly hitting floating point math and array access." + }, + "access-binary-trees": { + "description": "Array, object property and variable access." + }, + "access-fannkuch": { + "description": "Array, object property and variable access." + }, + "access-nbody": { + "description": "Array, object property and variable access." + }, + "access-nsieve": { + "description": "Array, object property and variable access." + }, + "bitops-3bit-bits-in-byte": { + "description": "Bitwise operations, these can be useful for various things including games, mathematical computations, and various kinds of encoding/decoding. It's also the only kind of math in JavaScript that is done as integer, not floating point." + }, + "bitops-bits-in-byte": { + "description": "Bitwise operations, these can be useful for various things including games, mathematical computations, and various kinds of encoding/decoding. It's also the only kind of math in JavaScript that is done as integer, not floating point." + }, + "bitops-bitwise-and": { + "description": "Bitwise operations, these can be useful for various things including games, mathematical computations, and various kinds of encoding/decoding. It's also the only kind of math in JavaScript that is done as integer, not floating point." + }, + "bitops-nsieve-bits": { + "description": "Bitwise operations, these can be useful for various things including games, mathematical computations, and various kinds of encoding/decoding. It's also the only kind of math in JavaScript that is done as integer, not floating point." + }, + "controlflow-recursive": { + "description": "Control flow constructs (looping, recursion, conditionals). Right now it mostly covers recursion, as the others are pretty well covered by other tests." + }, + "crypto-aes": { + "description": "Real cryptography code, mostly covers bitwise operations and string operations." + }, + "crypto-md5": { + "description": "Real cryptography code, mostly covers bitwise operations and string operations." + }, + "crypto-sha1": { + "description": "Real cryptography code, mostly covers bitwise operations and string operations." + }, + "date-format-tofte": { + "description": "Performance of JavaScript's 'date' objects." + }, + "date-format-xparb": { + "description": "Performance of JavaScript's 'date' objects." + }, + "math-cordic": { + "description": "Various mathematical type computations." + }, + "math-partial-sums": { + "description": "Various mathematical type computations." + }, + "math-spectral-norm": { + "description": "Various mathematical type computations." + }, + "regexp-dna": { + "description": "Regular expressions performance" + }, + "string-base64": { + "description": "String processing, including code to generate a giant 'tagcloud', extracting compressed JS code, etc." + }, + "string-fasta": { + "description": "String processing, including code to generate a giant 'tagcloud', extracting compressed JS code, etc." + }, + "string-tagcloud": { + "description": "String processing, including code to generate a giant 'tagcloud', extracting compressed JS code, etc." + }, + "string-unpack-code": { + "description": "String processing, including code to generate a giant 'tagcloud', extracting compressed JS code, etc." + }, + "string-validate-input": { + "description": "String processing, including code to generate a giant 'tagcloud', extracting compressed JS code, etc." + } +} -- 2.11.4.GIT