01-Trap and Interrupt are two types of events.

Interrupts are simply sent to the processor by either

software or hardware which sends the CPU into high-priority condition where the current code
executed is suspended and some new instructions will be executed depending on the interruption
type. In other words, it transfers program control from some address to another based on some
event happening.

Traps are special type of interrupt caused by software. Traps alert errors or special events happening
during the execution of a program which need assistance because the program can't handle them
itself.

Basically, trap is triggered by a user program to invoke OS functionality while the interrupt is
triggered by a hardware device to allow the processor to execute the corresponding interrupt
handler routine.

Trap is synchronous and can arrive after the execution of any instruction whereas interrupt is
asynchronous and can occur at the execution of any instruction.

Yes a trap can be generated intentionally by a user program. It can be used to call operating system
routines or for catching arithmetic errors.

2-The greatest challenges in designing mobile operating systems include:

---- Less storage capacity means the operating system must manage memory carefully.

it's system memory is not vast and fast than that of PCs system memory.

it doesn't have large space, ram and processor.

---- The operating system must also manage power consumption carefully.

Mobile operating system must balance the performance with the battery life.

---- Less processing power plus fewer processors on mobile devices mean the operating system must
carefully apportion processors to applications.

----Mobile operating system must have a good support for external peripheral devices like GPS which
is essential for mobile devices.

----Mobile operating system must consider the limited resources since the mobile devices are much
smaller compared with PCs.

----Development Circle

development circle has limited lots of end users from accessing or using most apps some other
operating system has it supports, this is as a result of required excessive programming efforts by the
developers as they tend to develop multiple apps for as many mobile operating systems out there
from the scratch. Most times individuals are forced to change operating systems or developers are
forced to discontinue development.
----Backward compatibilty is a big issue with mobile operating system.These operating systems
always have a monopoly for their brother devices as they barely communicate with other operating
systems.Sometimes a particular OS doesn't support an app for that one need the newer version of
OS but this is not the case of PCs OS.

----No, or limited, multitasking

Multitasking — in the sense of being able to run more than one app at once — is finally starting to
take off on mobile devices. That said, many devices still can’t multitask, and even those that can,
don’t offer the power or flexibility of desktop multitasking.

4-Advanced Local Procedure Call(ALPC) is a message-passing mechanism. A globally visible

connection-port object is published by the server process. When a client wants services from a
subsystem or service, it opens a handle to the server’s connection-port object and sends a
connection request to the port. A channel is created by the server and returns a handle to the client.
This channel consists of a pair of private communication ports: one for client-to-server messages and
the other for server-to-client messages. Communication channels support a callback mechanism, so
the client and server can accept requests when they would normally be expecting a reply. When an
ALPC channel is created, one of three message-passing techniques is chosen -

The first one is suitable for small to medium messages (up to 63 KB). In this case, the port’s message
queue is used as intermediate storage, and the messages are copied from one process to the other.

The second technique is for larger messages. In this case, a shared memory section object is created
for the channel. Messages sent through the port’s message queue contain a pointer and size
information referring to the section object. This avoids the need to copy large messages. Data is
placed by the sender into the shared section, and the receiver views them directly.

In the third technique, it uses APIs that read and write directly into a process’s address space. ALPC
provides functions and synchronization so that a server can access the data in a client. ALPC is
normally used by RPC to achieve higher performance for specific scenarios.

3-

MAC OS X

Functionally, the Mac OS X architecture consists of several layers that are often shown graphically as
in Figure 1.1. The base level of the operating system is its Unix core, which is called Darwin. Moving
"up" through the layers, the next layer is the graphics subsystem, which consists of three parts:
Quartz, OpenGL, and QuickTime. Then comes the application layer, which has four components,
those being Classic, Carbon, Cocoa, and Java. Finally, the top layer is the user interface, which is
called Aqua.

Figure 1.1. You can think of Mac OS X being composed of four layers; the bottom layer provides the
core OS services, whereas each layer toward the top provides services that are "closer" to the user.

graphics/01fig01.gif

The Core OS: Darwin

Mac OS X is built on a Unix core; the Darwin core is based on the Berkeley Software Distribution
(BSD) version of Unix. The heart of the Darwin core is called Mach. This part of the operating system
performs the fundamental tasks, such as data flow into and from the CPU, memory use, and so on.
Mach's major features include the following:

Protected memory? Mach provides a separate memory area in which each application can run. It
ensures that each application remains in its own memory space and so does not affect other
applications. Therefore, if a running application crashes or hangs, other applications aren't affected.
You can safely shut down the hung application and continue working in the others.

In contrast, previous versions of the Mac OS did not have protected memory. When one application
crashed, it usually took down others and often the OS itself, which resulted in your losing unsaved
data in all the applications. Under Mac OS X, only the data in the crashing application is at risk.

Automatic memory management? Mac OS X manages RAM for you; it automatically allocates RAM
to applications that need it. Under Mac OS X, you don't need to think about how RAM is being used;
the OS takes care of it for you (if you have ever struggled to manually allocate RAM under OS 9 and
earlier, you know why not having to do this anymore is a very good thing).

Preemptive multitasking? Under Mac OS X (or, more specifically, Mach), the operating system
controls the processes that the processor is performing to ensure that all applications and system
services have the resources they need and that the processor is used efficiently. This ensures both
stability and maximum performance for both foreground and background processes.
This is in contrast to the cooperative multitasking in previous versions of the Mac OS. Under that
scheme, applications had to fight among themselves for the resources they needed. This resulted in
instability when applications couldn't get the resources they needed and poor performance for
those applications that were not able to "grab" the system resources they needed (this is why some
processes stopped when you moved them to the background).

Advanced virtual memory? The Mach core uses a virtual memory system that is always on. It
manages the virtual memory use efficiently so that virtual memory is used only as necessary to
ensure maximum performance.

Under previous versions of the Mac OS, you had to control how virtual memory was used manually.
Because the virtual memory system was not very efficient, you had to be careful about when you
had it turned on because it would cause the performance of some applications to slow to a crawl,
even if you had plenty of RAM.

NOTE

graphics/ontheweb_icon.gif

Darwin is open source. This means that the code of which Darwin is composed is freely available to
anyone who wants to use it. A programmer can download the Darwin code and modify it. Thus, it is
possible to provide alternative versions of the Darwin core to change and enhance Mac OS X. The
Darwin code and documentation can be found at http://developer.apple.com/darwin/.

Darwin also provides the input/output services for Mac OS X and easily supports three key
characteristics of modern devices: plug-and-play, hot-swapping, and power management.

Darwin, through its Virtual File System (VFS) design, supports several file systems under Mac OS X,
including the following:

Mac OS Extended Format? Also known as Hierarchical File System Plus (HFS+), this is the default file
system under Mac OS X as it has been under the more recent versions of the Mac OS (those since
Mac OS 8). This file system efficiently supports large hard drives by minimizing the smallest size used
to store a single file.
NOTE

graphics/new1_icon.jpg

For version 10.3, Mac OS X also supports the Mac OS Extended Journaled format. This enables the
OS to track changes that are made while they are being made so that the process of recovering from
errors is much more reliable. You will learn more about this later.

Mac OS Standard Format? Known as HFS, this was the standard for Mac OS versions prior to Mac OS
8.

UFS? The standard file system for Unix systems.

UDF? The Universal Disk Format, it's used for DVD volumes.

ISO 9660? A standard for CD-ROMs.

Darwin supports many major network file protocols. It supports Apple File Protocol (AFP) over IP
client, which is the file-sharing protocol for Macs running Mac OS 8 and Mac OS 9. Network File
System (NFS) client, which is the dominant file-sharing protocol on Unix platforms, is also supported.
Mac OS X also provides support for Windows-based network protocols, meaning you can interact
with Windows machines as easily as you can with other Macs.

Mac OS X uses bundles; a bundle is a directory containing a set of files that provide services. A
bundle contains executable files and all the resources associated with those executables; when they
are a file package, a bundle can appear as a single file. The three types of bundles under Mac OS X
are as follows:

Applications? Under Mac OS X, applications are provided in bundles. Frequently, these bundles are
designed as file packages so the user sees only the files with which he needs to work, such as the file
to launch the application. The rest of the application resources might be hidden from the user. This
makes installing such applications simple.
Framework? A framework bundle is similar to an application bundle except that a framework
provides services that are shared across the OS; frameworks are system resources. A framework
contains a dynamic shared library, meaning different areas of the OS as well as applications can
access the services provided by that framework. Frameworks are always available to the applications
and services running in the system. For example, under Mac OS X, QuickTime is a framework;
applications can access QuickTime services by accessing the QuickTime framework. Frameworks are
not provided as file packages, so the user sees the individual files that make up that framework.

Loadable bundle? Loadable bundles are executable code (just like applications) available to other
applications and the system (similar to frameworks) but must be loaded into an application to
provide their services. The two main types of loadable bundles are plug-ins (such as those used in
Web browsers) and palettes (which are used in building application interfaces). Loadable bundles
can also be presented as a package so the user sees and works with only one file.

NOTE

Because of its Unix architecture, you will see many more filename extensions under Mac OS X than
there were under previous versions of the OS. Most of the extensions for files you will deal with
directly are easily understood (for example, .app is used for applications), but others the system uses
are not as intuitive.

The Graphics Subsystem

Mac OS X includes an advanced graphics subsystem, which has three main components: Quartz
Extreme, OpenGL, and QuickTime.

Quartz Extreme is the name of the part of the graphics subsystem that handles 2D graphics. Quartz
provides the interface graphics, fonts, and other 2D elements of the system, as well as on-the-fly
rendering and antialiasing of images. Under Mac OS X, the Portable Document Format (PDF) is native
to the OS. This means you can create PDF versions of any document without using a third-party
application, such as Adobe Acrobat (to get special features in PDF documents, such as navigation
features, you still need to use an application that provides those features). You can quickly create a
PDF version of any document with which you work; that document can be viewed with Acrobat
Reader or Mac OS X's own Preview application. Quartz Extreme also supports TrueType, Type 1, and
OpenType fonts and blends 3D and QuickTime content with the 2D content it provides directly.
NOTE

Antialiasing reduces the pixelated appearance of a graphic to provide smooth edges instead of
jagged ones.

Because of Quartz Extreme, you don't need to install a font-smoothing utility, such as Adobe Type
Manager, to be able to view and use all sizes of PostScript fonts, as you had to do under Mac OS 9
and earlier.

NOTE

graphics/new1_icon.jpg

Under version 10.3, the Preview application has been greatly improved, especially in terms of speed.
The application opens and displays PDF and other documents much more quickly than it did under
previous versions of Mac OS X.

The OpenGL component of the graphics subsystem provides 3D graphics support for 3D applications.
OpenGL is an industry standard that is also used on Windows and Unix systems. Because of this, it is
easier to create 3D applications for the Mac from those that were designed to run on those other
operating systems. The Mac OS X implementation of OpenGL provides many 3D graphics functions,
such as texture mapping, transparency, antialiasing, atmospheric effects, other special effects, and
more.

QuickTime provides support for many types of digital media, such as digital video, and is the primary
enabler of video and audio streaming under Mac OS X. QuickTime enables both viewing applications,
such as the QuickTime Player, and creative applications, such as iMovie, iTunes, and many more.
QuickTime is also an industry standard, and QuickTime files can be used on Windows and other
computer platforms.

The Application Subsystem

Mac OS X provides the Classic environment to enable it to run Classic applications. It also includes
three application development environments: Carbon, Cocoa, and Java 2.

The Classic environment enables Mac OS X to run applications that were written for previous
versions of the OS without modification. This provides access to thousands of existing applications
that will run under Mac OS X. Classic applications run as they do under previous versions of the Mac
OS; in other words, they do not benefit from the advanced features of Mac OS X such as protected
memory (Classic applications can be affected by other Classic applications, and the Classic
environment itself can be affected when a Classic application has problems).

The Carbon environment enables developers to port existing applications to use Carbon application
program interfaces (APIs); the process of porting a Classic application into the Carbon environment is
called Carbonizing it. The Carbon environment offers the benefits of Darwin for Carbonized
applications, such as protected memory and preemptive multitasking. Carbonizing an application is
significantly less work than creating a new application from scratch, which enabled many
applications to be delivered near the release of Mac OS X.

The Cocoa environment offers developers a state-of-the-art, object-oriented application

development environment. Cocoa applications are designed for Mac OS X from the ground up and
take the most advantage of Mac OS X services and benefits. Most of the applications included with
Mac OS X are Cocoa versions; as time passes, more and more Cocoa applications will become
available and will eventually be the dominant type under Mac OS X.

The Java environment enables you to run Java applications, including pure Java applications and Java
applets. Java applications are widely used on the Web because they enable the same set of code to
be executed on various platforms. You can also develop Java applications under Mac OS X.

The User Interface

The Mac OS X user interface, called Aqua, provides Mac OS X's great visual experience as well as the
tools you use to interact with and customize the interface to suit your preferences. From the drop
shadows on open windows to the extensive use of color and texture to the extremely detailed icons,
Aqua provides a user experience that is both pleasant and efficient.
IOS

The iOS is the operating system created by Apple Inc. for mobile devices. The iOS is used in many of
the mobile devices for apple such as iPhone, iPod, iPad etc. The iOS is used a lot and only lags behind
Android in terms of popularity.

The iOS architecture is layered. It contains an intermediate layer between the applications and the
hardware so they do not communicate directly. The lower layers in iOS provide the basic services
and the higher layers provide the user interface and sophisticated graphics.

The layered architecture of iOS is given as follows −

iOS Architecture

Layers in iOS Architecture

The different layers as shown in the above diagram are given as follows −

Core OS
All the iOS technologies are build on the low level features provided by the Core OS layer. These
technologies include Core Bluetooth Framework, External Accessory Framework, Accelerate
Framework, Security Services Framework, Local Authorisation Framework etc.

Core Services

There are many frameworks available in the cure services layer. Details about some of these are
given as follows −

Cloudkit Framework

The data can be moved between the app the iCloud using the Cloudkit Framework.

Core Foundation Framework

This provides the data management and service features for the iOS apps.

Core Data Framework

The data model of the model view controller app is handled using the Core Data Framework.

Address Book Framework

The address book framework provides access to the contacts database of the user.

Core Motion Framework

All the motion based data on the device is accessed using core motion framework.

Healthkit Framework

The health related information of the user can be handled by this new framework.

Core Location Framework

This framework provides the location and heading information to the various apps.
Media

The media layer enables all the graphics, audio and video technology of the system. The different
frameworks are:

UIKit Graphics

This provides support for designing images and animating the view content.

Core Graphics Framework

This provides support for 2-D vector and image based rendering and is the native drawing engine for
iOS apps.

Core Animation

The Core Animation technology optimizes the animation experience of the apps.

Media Player Framework

This framework provides support for playing playlists and enables the user to use their iTunes
library.

AV Kit

This provides various easy to use interfaces for video presentation.

Cocoa Touch

The cocoa touch layer provides the following frameworks −

EventKit Framework

This shows the standard system interfaces using view controllers for viewing and changing calendar
related events.

GameKit Framework
This provides support for users to share their game related data online using Game center.

MapKit Framework

This provides a scrollable map which can be included into the app user interface.

ANDROID

In downloads

An advanced local procedure call (ALPC) is an interprocess

communication facility for high-speed message passing. It is not directly
available through the Windows API; it is an internal mechanism available
only to Windows operating system components. Here are some examples
of where ALPCs are used:

 Windows applications that use remote procedure calls

(RPCs), a documented API, indirectly use ALPCs when they specify
local-RPC, a form of RPC used to communicate between processes
on the same system.

 A few Windows APIs result in sending messages to the

Windows subsystem process.

 Winlogon uses ALPCs to communicate with the local security

authentication server process, LSASS.

 The security reference monitor (an executive ...