Japan Advanced Institute of Science and Technology

Japan Advanced Institute of Science and Technology

JAIST Repository

https://dspace.jaist.ac.jp/

Title

Author(s)

Citation

Issue Date

Type

Text version

URL

Rights

Description

To oru Terada

Scho ol of Information Science,

Japan Advanced Institute of Science and Technology

February 14, 1997

Keywords: Extensible operating system, Dynamiccodegeneration, Module.

The current requirements of applications for operating systems are very complex.

Thus, it is impossible for any single operating systems to satisfy all requirements of

applications. So, today's researches are directed to the systems whichcan be extensible.

The microkernel architecture is one of the extensible system models. It moves several

servicesfromtraditionalmonolithickernelstouser-levelservers. Itincreasestheexibility

of op erating systems because of its p ortability of servers. In addition, it increases the

safety that applicationsare neverinuenced byservers whichthey doesnot use.

However, operating systems based on the microkernel architecture have a drawback

concerned with their performance. They need much protection domain crossing than

traditional monolithic kernels because of the communications with servers. Several ap-

proaches to improve this drawback are proposed. The approach moving application's

functionalities into the kernel seems to b e eective. In systems using the approach, ap-

plications load the code into the operating system kernel dynamically in order to alter

its b ehavior. This reduces the numb er of contextswitches. In addition, downloadingthe

code can be used to create data paths in the kernel. This removes the need for much

of data copies across the user/kernel boundary. If applications load the code into the

kernel,safetyissuesshouldbetakenintoaccount. Loadingcodes shouldnotexposeother

applications in danger. However, we require much exibility or the better p erformance

so that it isdicult todesign codes with no errors. Application designers which include

downloadingcodemusttakecarenot toincludesome errors,since thereisnomechanism

tocheckcompletelynotonlysyntacticerrorsbutalsosemanticerrorsofkernelextensions.

To design downloading co de with no error, modular designs are exp ected. In addition,

modular softwares are reusable. However, modular softwares have worse performance

than monolithic and specic software. This thesis proposes optimizations improvingthis

drawback of modularprogramming.

One of the causeof the p oor performance inmo dularsoftwares isthat manymo dules

designedindividuallymanipulatesthesamedatasegmentrespectively. Usually,resp ective

Copyright c

1997byTooruTerada

and storing data in each modules are redundant. To reduce this redundancy, this thesis

provides a mechanism and a set of application programming interfaces which integrates

respective data manipulations into pairs of load/store. This optimization is eective if

the same data is manipulatedrepeatedly by manymo dules.

Another causeofpo orperformanceinmodular softwaresarises whenasetofmodules

istriggered the executionbysome outereventssuchas in-kernel events. Inthe middleof

executing,therearesomecasesthatmo dulesconcludefromtheirexecutionstatesthatno

benet is broughtto the application by that execution. Then, they ab ort the execution.

If many modules are executed until they abort, it includes many useless execution. In

another case, even if the execution is b enetable for the application, executing same

judge at many module is redundant. Now, this thesis intro duce the lter into module

programming. Thislterissimilartothepacketlterinnetwork. Eachmo dulespasstheir

lters to the modules b eing executed formerly. Receiving modules collects and executes

their conditional evaluation. This reduces useless or repeated execution. Moreover, if

receiving modules need not execute their conditional evaluation, they are let propagate

lterstomoreformermodules. Thistechniquebringsnotonlycutsunnecessaryexecutions

but also improvement in memory lo cality. Improvement in memory locality can reduce

cach misses.

These optimizations can be implemented with dynamic code generation. Dynamic

codegeneration isthe creation ofexecutable code atruntime. Itis apowerfultechnique,

enabling applications to use runtime information to improve performance by up to an

order of magnitude. Dynamic co de generation is useful for our optimization. Firstly, dy-

namiccodegenerationreduceprocedurecall bycomp osing setofmodulesintoafunction.

Secondly,since itcan decides instructionorder dynamically, itintegratesdatamanipula-

tions in order to reduce load/store between memorys and registers. Finally, it compiles

lterstructures tomachinecodeinordertoreduceexecutioncostsof composed function.

Weimplementedaprototyp esystemincludingtheseoptimizationonReal-Time Mach

kernel. Real-Time Machis a real-time extension of the Mach op erating system. We also

cho oseVCODEsystemwhichhasdevelop edatMITasadynamiccodegeneratingsystem.

The VCODEsystem is a setof Cmacros and support functions thatallowprogrammers

to portably and eciently generate code at runtime. VCODE generates co de in place.

It eliminates the need to build and consume an intermediate representation. VCODE

instructions are translated directly tothe machine instructions that they correspond to.

This allows us to directory construct arbitrary code at runtime, suchas integrated data

manipulation and compiled lter structure.

We show the eectiveness of our proposal by showing some basic experiments. In

addition, weshowthe eectiveness of downloading co de to kernels orservers.