An Operating System (OS) is an interface between a computer user and computer hardware. An operating system is a software which performs all the basic tasks like file management, memory management, process management, handling input and output, and controlling peripheral devices such as disk drives and printers.
Some popular Operating Systems include Linux Operating System, Windows Operating System, VMS, OS/400, AIX, z/OS, etc.
An operating system is a program that acts as an interface between the user and the computer hardware and controls the execution of all kinds of programs.
Following are some of important functions of an operating System.
Control over system performance
Error detecting aids
Coordination between other software and users
Memory management refers to management of Primary Memory or Main Memory. Main memory is a large array of words or bytes where each word or byte has its own address.
Main memory provides a fast storage that can be accessed directly by the CPU. For a program to be executed, it must in the main memory. An Operating System does the following activities for memory management −
Keeps tracks of primary memory, i.e., what part of it are in use by whom, what part are not in use.
In multiprogramming, the OS decides which process will get memory when and how much.
Allocates the memory when a process requests it to do so.
De-allocates the memory when a process no longer needs it or has been terminated.
In multiprogramming environment, the OS decides which process gets the processor when and for how much time. This function is called process scheduling. An Operating System does the following activities for processor management −
Keeps tracks of processor and status of process. The program responsible for this task is known as traffic controller.
Allocates the processor (CPU) to a process.
De-allocates processor when a process is no longer required.
An Operating System manages device communication via their respective drivers. It does the following activities for device management −
Keeps tracks of all devices. Program responsible for this task is known as the I/O controller.
Decides which process gets the device when and for how much time.
Allocates the device in the efficient way.
A file system is normally organized into directories for easy navigation and usage. These directories may contain files and other directions.
An Operating System does the following activities for file management −
Keeps track of information, location, uses, status etc. The collective facilities are often known as file system.
Decides who gets the resources.
Allocates the resources.
De-allocates the resources.
Other Important Activities
Following are some of the important activities that an Operating System performs −
Security − By means of password and similar other techniques, it prevents unauthorized access to programs and data.
Control over system performance − Recording delays between request for a service and response from the system.
Job accounting − Keeping track of time and resources used by various jobs and users.
Error detecting aids − Production of dumps, traces, error messages, and other debugging and error detecting aids.
Coordination between other softwares and users − Coordination and assignment of compilers, interpreters, assemblers and other software to the various users of the computer systems.
Android — Overview
What is Android?
Android is an open source and Linux-based Operating System for mobile devices such as smartphones and tablet computers. Android was developed by the Open Handset Alliance, led by Google, and other companies.
Android offers a unified approach to application development for mobile devices which means developers need only develop for Android, and their applications should be able to run on different devices powered by Android.
The first beta version of the Android Software Development Kit (SDK) was released by Google in 2007 where as the first commercial version, Android 1.0, was released in September 2008.
On June 27, 2012, at the Google I/O conference, Google announced the next Android version, 4.1 Jelly Bean. Jelly Bean is an incremental update, with the primary aim of improving the user interface, both in terms of functionality and performance.
The source code for Android is available under free and open source software licenses. Google publishes most of the code under the Apache License version 2.0 and the rest, Linux kernel changes, under the GNU General Public License version 2.
Why Android ?
Features of Android
Android is a powerful operating system competing with Apple 4GS and supports great features. Few of them are listed below −
Feature & Description
Android OS basic screen provides a beautiful and intuitive user interface.
Android has native support for multi-touch which was initially made available in handsets such as the HTC Hero.
User can jump from one task to another and same time various application can run simultaneously.
Widgets are resizable, so users can expand them to show more content or shrink them to save space.
Supports single direction and bi-directional text.
Google Cloud Messaging (GCM) is a service that lets developers send short message data to their users on Android devices, without needing a proprietary sync solution.
A technology that lets apps discover and pair directly, over a high-bandwidth peer-to-peer connection.
A popular NFC-based technology that lets users instantly share, just by touching two NFC-enabled phones together.
Android applications are usually developed in the Java language using the Android Software Development Kit.
Once developed, Android applications can be packaged easily and sold out either through a store such as Google Play, SlideME, Opera Mobile Store, Mobango, F-droid and the Amazon Appstore.
Android powers hundreds of millions of mobile devices in more than 190 countries around the world. It’s the largest installed base of any mobile platform and growing fast. Every day more than 1 million new Android devices are activated worldwide.
This tutorial has been written with an aim to teach you how to develop and package Android application. We will start from environment setup for Android application programming and then drill down to look into various aspects of Android applications.
Categories of Android applications
There are many android applications in the market. The top categories are −
History of Android
The code names of android ranges from A to N currently, such as Aestro, Blender, Cupcake, Donut, Eclair, Froyo, Gingerbread, Honeycomb, Ice Cream Sandwitch, Jelly Bean, KitKat, Lollipop and Marshmallow. Let’s understand the android history in a sequence.
What is API level?
API Level is an integer value that uniquely identifies the framework API revision offered by a version of the Android platform.
Raptor: Performance Tools for Gaia
On this Page
This article presents Raptor: a CLI tool for measuring performance specifically on Firefox OS. It looks at the strategy behind the tool’s functionality, shows you how to get started with the tool, and moves to some advanced topics such as writing your own tests, visualization, and automation.
While the tooling presented in this article is still functional for performance testing Gaia-based devices, any associated automation and related external web sites are no longer maintained or have been decommissioned; they remain documented here for historial purposes. The documentation for this automation also remains in the event anyone would have use to stand this up on a self-hosted basis.
Raptor aims to overcome many of the pitfalls faced when testing performance with the previous tool, make test-perf :
The test-perf tool relies on Marionette.js to listen for events that each application would emit at key points in their loading lifecycles. This requires an atom script to be injected into every application to bind event listeners for these events. Every time new pseudo-standard events need to be captured, the script has to be modified. This means a lot of maintenance time, on top of the overhead of using Marionette.js itself.
The API for creating performance events is not consistent. In order to make capturing our standard performance events simpler, this is done in test-perf by dispatching a custom event, e.g. window.dispatchEvent(new CustomEvent(‘moz-app-visually-complete’)) . Unfortunately if an application wants to emit its own performance event, it has to use a different API from a performance testing helper script.
Every application has to include a performance testing helper script. While this script is necessary for providing access to the API for emitting performance events, it also has its own associated overhead and maintenance.
The test-perf tool is suited to gathering performance metrics for core Gaia applications, but is difficult to extend to handling much outside of that. Applications like Homescreen, System, or other types of interactions outside of application launch are very difficult to test within the confines of the framework.
Raptor is designed to solve these problems, providing a more efficient and extensible performance testing framework that doesn’t add so many overheads of its own.
This section discusses the strategy undertaken in implementing Raptor’s functionality.
The User Timing API provides web documents with a mechanism for indicating custom performance marks and measures. Using a standardized API lets applications avoid the need to include a helper script for emitting performance events. In fact, User Timing does not rely on events at all.
In order to capture performance entries in a manner that is decoupled from the application to avoid affecting performance, we opted to output performance metadata in a device’s log stream, i.e. adb logcat . Raptor consumes this stream and parses performance entries from the log to gather metrics.
Phases and extensibility
Raptor introduces a concept called «phases», which lays a framework for testing interactions in a generic manner. Currently Raptor supports phases of cold launch, reboot, and B2G restart, with additional phases planned. These work by placing a device in a certain phase before starting performance capturing — make writing actual performance test logic simpler.
Raptor uses the Marionette.js client for familiar device interactions using a high-level API. The same Marionette.js client used for writing integration tests can be used for trigger device actions which contain performance measurements.
Raptor also interacts with devices using the FXOS Device Service. This service exposes a number of interactions via a RESTful interface, such as touch input, reading and writing logs, device restarting, and reading and writing files.
NOTE: While Raptor can be run on emulators, the results should not be relied on for performance comparisons. Desktop computers and their power means that they are not comparable to the performance characteristics of devices and end users, and should not be used for time-based decision making.
You must have a copy of Gaia v2.2+ available on your system, as well as Node.js v4.2+ installed.
Installing the Raptor CLI tool
Raptor has a CLI tool installable from npm. You can install it via:
Once the installation is finished, you can invoke it from the command line via the raptor command:
If you aren’t comfortable with the way npm installs global packages to your /usr or /usr/local directories, you have a couple of different options:
Change npm’s default directory to another directory. Following the steps from npm, you can change where npm installs global packages, possibly by placing them into a special directory in your home folder.
Install Raptor into a local directory and reference it relatively. Example:
Installing the profile
In order to interact with the device in a predictable way, Raptor needs a few profile options and custom settings. The default make command for Raptor optimizes Gaia, disables FTU, enables User Timing to write to logcat, and resets Gaia.
If you already have a profile on your device, at a bare minimum you need the following profile options/settings set in order to use Raptor for performance testing:
PERF_LOGGING=1 , this sets dom.performance.enable_user_timing_logging in the profile to true.
NOFTU=1 , this disables the First-time experience, which is only needed if you are dealing with a freshly-reset Gaia.
SCREEN_TIMEOUT=0 , prevents the device from going to sleep and shutting off the screen.
NO_LOCKSCREEN=1 , removes the lock screen for easy application launching from the homescreen.
Raptor provides a bit of helpful information right through the command line:
The core command to execute is the test command, which also has some helpful information:
This should give us enough information to run our first performance test.
Running a performance test
Running a performance test consists of a few parts:
The raptor CLI command
A test to run, whether a named test or a path to a test
Any relevant test settings
For the most basic test, we can do a cold launch test against an application with a command like this:
During the cold launch test, you’ll see B2G restart; the stated application will then launch once to prime it, and a second time to measure its performance. Looking at the log output above, you can see when each application run starts and stops. When a particular application has completed its testing, you will be given a table of metrics and testing will continue, if applicable. In the metrics table you’ll see statistics for each performance entry captured during the lifespan of the test: mean (average), median, minimum value, maximum value, standard deviation, and 95% Upper Bound.
Note: One fun fact is that the table produced by Raptor is compatible with GitHub-flavored Markdown.
Note: Standard deviation and 95% Upper Bound need a collection of runs before they output statistically-useful data.
All metrics relate to the name of the performance entry. The numbers gathered here are not just aggregations of the values produced by User Timing entries, so it’s important to understand how these numbers are derived.
While Raptor relies on the User Timing API to gather its metrics, it also makes some assumptions about measurements that are different to what’s expected in the context of normal web pages. In a typical web page, a performance marker represents the High-Resolution time from the moment of navigationStart . The User Timing API still captures this data, but Raptor’s calculations also include additional time depending on the type of test running. Let’s compare the creation of a performance marker in the context of a typical web page versus a Firefox OS application being cold launched.
Typical web page
In any web page, Firefox OS application or not, creating a performance marker with the User Timing API is simple:
Now let’s get the value back and inspect its contents:
Note the mark’s startTime and duration . The startTime is nothing more than the high-resolution time elapsed since the time of performance.timing.navigationStart ; in this case a little over 5,000 milliseconds. The duration is 0 because this represents a single point in time, which has no duration. The startTime simply states at what moment the marker was created. Inspecting the output of a performance marker is no different in Firefox OS.
A performance measure on the other hand does include a duration, because it is the delta between two performance markers:
Again, let’s inspect the performance entry:
The duration is populated for performance measures, and in this example it took approximately 4.2 seconds to perform a greeting ; going from hello to goodbye .
The difference comes in the calculations that Raptor will report. Raptor makes an assumption that all markers generated are actually performance measures in reality, with their duration measured as the time between the application being instructed to launch and the marker being generated. For cold launch, the homescreen application ( gaia_grid specifically) creates a special performance marker when an application is launching:
In Raptor, performance markers can be given an @-directive that overrides the context of the marker. If the homescreen instead had invoked performance.mark(‘appLaunch’) , normally we’d assume it is in the application’s context. With an @-directive however we can key the performance marker to be against a different application, in essense creating a performance marker for one application inside another. This would evaluate to something like:
In this case the homescreen is generating a performance marker for the clock application denoting the time of appLaunch . Raptor will then calculate a delta between appLaunch and all performance markers to achieve a more accurate user-perceived time for a marker to be hit. By moving the moment of capture to earlier in the loading process, specifically as close to icon touch as possible, it makes the data between Raptor and camera-based measurements much more comparable.
Choosing a test
Tests are selected by changing the name or file that Raptor executes. For example, to run the device reboot performance test instead of a cold launch test you’d do the following:
While Raptor currently contains a few tests for running cold launch tests, rebooting, and restarting B2G, it is possible to write tests that run custom logic.
We can inspect the contents of the current launch test to glean how we can write new tests.
First comes setting up the test. In setup , pass a function to be executed, which will configure the test. This function will be passed all the current configuration settings. At a minimum, you will need the set the phase of the test, which determines the state the device is in when the test begins. Depending on which phase you select when setting options, you may need to pass additional information. For the launch test example, using the cold phase requires an application to be specified. This can either be set on the command line, or you can hard-code it via the app option to force the test to be specific to a certain app.
Note: If you hard-code the application to be launched, make you specify the origin host completely, e.g. «clock.gaiamobile.org». For entry-point-based apps, specify the app option and the entryPoint option.
Important: Any test harness functions doing asynchronous work should return a Promise so Raptor can properly wait.
The afterEach() function will be called once for each run after the phase has been started. For cold launch, it is after an application in context has been primed, exited, and re-opened, and the application denotes it is ready — i.e. performance.mark(‘fullyLoaded’) . For reboot and B2G restart, the phase will be designated as ready when the System application and the Homescreen application are marked as fully loaded.
The phase argument passed to afterEach() represents the current context instance of the phase test runner; in other words, it is specific to the current test being run. It contains methods and functionality that help you trigger device actions which will have profiled performance code. For example, you can start a Marionette.js session and trigger commands:
The runner can also run a teardown() function when all tests are complete.
The Raptor Phase API has not yet been documented, so currently you’ll need to read the source for all the functionality available to you. It may be faster to seek help from a contributor for help on getting started writing a particular test.
Constantly specifying the parameters for commands which change infrequently can be cumbersome. Fortunately Raptor supports defining command-line parameters through directory-specific .raptorrc files. Raptor will search for .raptorrc files in the current working directory from which a test is being run, and will walk upward until it reaches your home/user directory. This means you can have preset command parameters which differ based on the directory where the test is run from, i.e. different .raptorrc files per directory.
A .raptorrc file can be YAML or JSON, and each top-level key corresponds to a command for which to preset parameters:
Visualization and automation
Raptor has improved tooling available for automation and visualization. The test-perf tool used to use the Datazilla tool for graphing and visualizing results to gain insight into possible regressions and performance pulse of applications. Raptor has moved away from Datazilla however for its visualization capabilities — for maintenance and usability reasons — instead having its own UI at https://raptor.mozilla.org. The Raptor dashboards currently categorize performance metrics in a few key categories per device instance — measures and memory — with more metrics planned in the future.
Raptor’s front-end uses the Grafana visualization tool, and its backing store is InfluxDB, a time series database. Grafana provides Raptor UI users with the ability to carry out custom drill-downs into charts, slice time as desired, view data point revisions, and build custom charts and data queries. The default view of several charts displays the 95% Upper Bound of many metrics, but charts can be user-edited to graph other mathematical functions.
This guide is not meant to be a tutorial on the usage of Grafana and InfluxDB, so to learn more about taking full advantage of the Raptor dashboards read through these important pieces of documentation:
Automation in Production
Raptor’s production automation runs in the QA Jenkins environment. When new TaskCluster builds arrive for the devices we test against, Raptor performs a number of automated tests and reports the metrics to the Raptor dashboards. Each job goes through a number of setup procedures before actually running the performance tests:
Full flash the related TaskCluster build. These are currently based on b2g-inbound.
Install the Raptor CLI tool
Create a Python virtualenv, used for installing reference workloads
Install the Raptor profile with make raptor
Install the light reference workload
Tag the device with testing metadata, e.g. device flame-kk, memory 512, branch master
Inform Treeherder a performance test is in progress
Execute a test, report the metrics to InfluxDB
Report test to Treeherder
Repeat Treeherder reports and test executions if there are more applications to test
Archive test assets and mark the build as a success if all tests completed without error
Raptor’s automation uses the same CLI commands to detect regressions that can be used locally. The workflow for detection is as follows:
For a given context (e.g. Contacts, Video, etc.), query InfluxDB for the previous 14 days using the query command.
Pipe the output from querying to the regression command. This will return a JSON array of regressions.
Pipe the output from regression to the track command. This will creating InfluxDB entries for regressions which were previously unknown and return a JSON array of new regressions.
Pipe the output from track to the bug command. This will file bugs in the proper components in Bugzilla and CC relevant stakeholders. Returns a JSON array of bug numbers created.
When a regression is detected and Raptor files a bug, the goal is to have its resolution follow the sheriffing flow in a manner similar to how the Desktop performance sheriffs regulate. This means that upon filing a bug, there should be a resolution in place within 48-72 hours:
Backout the offending patch
Have a follow-up patch in review
Determine acceptance of the regression
Bugs that do not receive attention within the resolution window are subject to immediate backout.
The Raptor dashboard visualization discussed in the previous section can also be installed and used privately. The installation is a Heroku-deployable environment for easy setup. It is also possible to run the Heroku application locally if you use Linux.
To get started with private visualization, or want to learn more about its innards, see the repository: https://github.com/mozilla-raptor/dashboards.
You will also need an installation of InfluxDB 0.9.3+. You can learn more about installing it at: https://influxdb.com/docs/v0.9/introduction/installation.html. Those who are familiar with Docker can also install InfluxDB from Docker Hub: https://hub.docker.com/r/tutum/influxdb/.
Raptor needs CLI options or environment variables for creating a connection to an InfluxDB database. It would be tedious to specify these continually on the command line, so to simplify this, you can values to a .raptorrc file.
In addition, Raptor’s database schema requires its results to be tagged properly in order to display it in correct categories in its dashboard UI. Failure to have these properties set when running performance tests will cause the data to not be displayed. By default, you need to persist the memory configuration of the device, the device type, and the branch the performance test is based on. For example, if you are performance testing a KitKat-based Flame set to 512MB of memory and your patch is based off of Gaia’s master branch, you will set the following properties via ADB:
Note: If you are having trouble with the values being persisted or not saving at all, restart ADB as root with adb root .
If you were working on a branch that was based off of v2.5 on an Aries with 2 Gigabytes of memory, you would use the following properties:
Important: Currently visualization is highly-dependent on the existence of these persisted properties. They are only necessary when using the local visualization tooling; if you flash your device or otherwise unset these properties, you will need to re-set them in order to visualize performance metrics.
Other than setting up the environment and device tags, Raptor can be run as normal locally. Upon each successful run, Raptor will report its metrics to the database. Once the test is complete, you can open a browser to your private visualization instance and view your own custom performance data.
Adding performance marks dynamically when needed
One issue with Raptor is that since the tests require us to add performance marks into code, the Gaia codebase could quickly become littered with Performance.mark() calls without any meaningful relationship between them, making the code clutted and harder to understand. The best way to deal with this is to collect all the marks into some kind of patching files, and apply them dynamically as required when we want to run specific Raptor tests.
To this end, Greg Weng has created a code transformer tool that will do just what is described above. The tool is currently a work in progress, but you can find more about it (including how to get it running) at this newsgroup entry: Raptor: code transformer + marionette workflow now is almost ready. See also bug 1181069 for implementation specifics.
We will publish more formal instructions once the tool has stabilised.
If you have questions about Raptor, visualization, or performance tooling in general, feel free to ping :Eli or :rwood in the #raptor channel on Mozilla IRC.