Systeem-ge ï ntegreerde Programmatuur

Systeem-geïntegreerde programmatuur Yolande Berbers

SGP Systeem-geïntegreerde Programmatuur

Systeem-geïntegreerde Programmatuur

Marc Gobin (&Yolande Berbers)

Departement Computerwetenschappen

(200A 03.20)([email protected])

SGP

slide 2Systeem-geïntegreerde programmatuur Yolande Berbers

practische organisatie

Marc Gobin is ziek ik geef enkele weken les

zeker 2, waarschijnlijk 3, misschien meer slides kun je vinden via mijn home-page

http://www.cs.kuleuven.ac.be/~yolande/

lessen over device drivers die geef ik al altijd

practica: zie verder

SGP


overzicht van de cursus

karakteristieken van real-time systemen

Ada en Java voor real-time en embedded systemen

gelijktijdige processen

het invoeren van tijd

interrupts

device drivers

petri-netten

schedulability

temporele logica

SGP


practica

2 practica practicum 1

individueel schrijven van een programma dat gebruik maakt van

gelijktijdige taken begroot op 10 uur

practicum 2 in groepjes van 2 schrijven van pakket voor communicatie tussen 2 pc’s begroot op 20 uur

er wordt een demo van de 2 practica georganiseerd timing is afhankelijk van verloop herstel Marc Gobin



deel 1: inleiding tot real-time systemen

SGP


overview

what is a real-time system ?

what is an embedded system ?

concrete examples

different types of real-time & embedded systems

characteristics of real-time & embedded systems

economic importance

SGP


wat is een real-time systeem?

een computersysteem dat moet reageren op externe stimuli binnen een eindige en wel bepaalde tijd

de correctheid van het systeem niet alleen afhankelijk van het logische resultaat ook van het tijdstip waarop dat resultaat gegeven werd

niet op tijd reageren is even erg als foutief antwoorden

in het Nederlands ware-tijd-systemen

SGP


wat is een ingebed systeem?

een product met processor en software software is onlosmakelijk verbonden met het product

software wordt niet apart verkocht

software biedt vaak belangrijke toegevoegde waarde

product dat een welbepaalde functie vervult

zeer veel voorbeelden in de huidige consumentenmarkt

vaak is ingebed syst. deel van groter industrieel complex computersysteem bewaakt en/of bestuurt externe apparatuur

voorbeelden uit boek komen meestal uit deze hoek

SGP


real-time systeem vs ingebed systeem

een ingebed systeem reageert op externe stimuli

deze reacties moeten vaak in real-time gebeuren

ingebedde systemen en real-time systemen

veel gelijkaardige karakteristieken

in het boek

real-time system == embedded system

SGP


voorbeelden van RT & ES

prime components of global infrastructure the world’s energy supplies (oil, coal, gas, nuclear) depend on

embedded systems planes fly, and ships sail, based on embedded systems pharmaceutical industries use embedded systems to create our

drug supply our food, drink and clean water come primarily from processes

which depend on embedded systems embedded systems are vital in car manufacturing, national and

international defense, railway networks, medical equipment, telecommunications, broadcast media, ...

SGP


soorten real-time systemen

harde real-time - systemen: absolute noodzaak om te reageren binnen een deadline bv een vlucht-controle systeem wanneer de deadlines erg klein zijn en de mogelijke gevolgen

catastrofaal, zijn dit zeer kritische systemen (bv het besturen van bomraketten)

zachte real-time - systemen: deadline is belangrijk, maar het systeem functioneert correct ook als een deadline ‘af en toe’ gemist wordt bv het verzamelen van gegevens bij procescontrole vaak vermindert de waarde van een reactie wanneer deze te

laat komt (maar heeft geen catastrofale gevolgen)

SGP



what happens if a deadline is missed

system fails: hard real-time

value (or utility) of the result decreases: soft real-time

value is of no benefit: firm real-time system

SGP



een computer systeem kan zowel harde als zachte

real-time subsystemen hebben

missen van een deadline vaak: kost-functie geassocieerd met missen van een deadline

aangeven (in %) hoe vaak een deadline mag gemist worden

SGP


voorbeelden van RT systemen

real-time systemen voor proces-controle

real-time systemen in een productieomgeving

real-time systemen voor communicatie, bevel en controle

veralgemening: industrieel ingebed computersystemen

SGP



real-time systeem voor proces-controle

eenvoudig voorbeeld: zorgen voor een gelijke stroming in een

pijpleiding, door controle van een klep

de hoek van de klep moet aangepast worden aan de

veranderingen van de inputstroming

dit moet gebeuren binnen een bepaalde tijd, of anders zal de

apparatuur aan het einde van de pijp overbelast worden

dit kan best veel rekenwerk vragen

SGP


example: simple valve control

flow meter

valve

time

interface

input flow reading

processing

output valve angle

SGP


examples of real-time systems

process control: general characteristics interaction with equipment

use of sensors and actuators

use of transducers: generate an electrical signal proportional to

the physical quantity being read

use of analog to digital (and digital to analog) converters

SGP


general process control

process control computer

stirrervalvetemperature transducer

operators console

chemicals and

materials

finished products

a process control system

SGP



real-time systeem in een productieomgeving automatisering van allerhande handelingen

verlaagt de productiekost verhoogt de productiviteit

integratie van het volledige productieproces, van ontwerp van een product tot fabricatie

gebruik van een variatie van mechanische tuigen (werktuigen, robots, lopende banden),

werking moet gecoördineerd en gecontroleerd worden vaak een groot aantal los-gekoppelde systemen

SGP


general manufacturing

production control computer

conveyor belts

machinetools

manipulators

operators console

partsfinished products

a production control system

SGP



real-time systemen voor communicatie, bevel en controle militaire term, veel toepassingen met zelfde karakteristieken voorbeelden: automatische bediening van medische toestellen,

luchtverkeer controle, vliegtuigreservaties, bankoperaties per terminal

kenmerken: ingewikkelde beslissingsregels verzamelen van informatie

grote hoeveelhedenvaak geografisch verspreid

administratieve procedures

SGP


communicatie, bevel en controle

a command and control system

command and control computer

temperature, pressure, power and so onterminals

sensors/actuators

commandpost

SGP



veralgemening: industrieel ingebed computersystemen directe interface met fysische wereld

sensoren die op regelmatige tijdstippen informatie geven

meestal ook een console

operator krijgt uitgebreide informatie (vaak grafisch)

operator kan manueel ingrijpen

toestandsveranderingen in het systeem worden in een

gegevensbank bijgehouden voor analyse en het nemen van

beslissingen

SGP


industrial embedded system

operator’sconsole

operatorinterface

data retrievaland display

datalogging

algorithms fordigital control interface

remotemonitoring

displaydevices

engineeringsystem

real timeclock

database

SGP


vb van ingebedde systemen wasmachine

één specifieke taak, beperkte functionaliteit weinig flexibel goedkoop, massaproductie

postsorteermachine één specifieke taak, uitgebreide maar overzienbare functionaliteit geen massaproductie

communicatiesysteem in wagen zeer complex goedkoop zware real-time vereisten laag vermogen gebruik moet zeer flexibel zijn, open voor nieuwe toepassingen

SGP


vb van ingebedde systemen

ADSL switching center in centraal punt 20 tot 50 ADSL lijnen op een ATM netwerk zware real-time vereisten zeer hoge snelheid nodig laag vermogen gebruik

MPEG-4 decoder zeer complex zeer hoge snelheid nodig laag vermogen gebruik (bv in draagbare videospelletjes)

SGP


karakteristieken van een RTS

groot en complex niet gewoon proportioneel met het aantal lijnen code

gerelateerd aan de variëteit die in de code voorkomt

verandert continu omdat de omgeving continu verandert

situaties veranderen

noden veranderen

nood aan continu onderhoud

kan variëren van enkele honderden lijnen assembler of C tot 20

miljoen lijnen Ada-code (geschat voor het ruimtestation ISS)

SGP



manipulation of real numbers many RT systems control an engineering activity e.g.: controller based op feedback

controlled entity has a vector of output variables, that change over time

outputs are compared with desired signal difference is used to change input variables

control based on mathematical model of process to be controlled complex, often based on differential equations

SGP


karakteristieken van een RTS e.g.: controller (possibly analog), based on feedback

r(t) is desired signal e(t) is error vector

r(t)controller(analog)

plante(t) u(t) y(t)

u(t) is input vector y(t) is output signal

SGP


karakteristieken van een RTS more realistic figure using a computer, discrete values (with a *), and D/A and A/D converters discipline: control theory

requirement: ability to manipulate real numbers

r(t*) digital toanalog

converterplant

u(t*) u(t)

y(t)

controller(computer)

sampleandhold

y(t*)

SGP



extreem betrouwbaar en veilig meer en meer vitale functies in de samenleving worden

toevertrouwd aan computer systemen

slecht functionerende systemen kunnen catastrofaal zijn

vaak zijn mensenlevens gemoeid

– bv kerncentrales

kan ook extreem kostelijk zijn

voorbeeld van zeer kostelijke faling: Ariane 5, zie volgende slide

SGP


voorbeeld: ontploffing Ariane 5

eerste lancering van Ariane 5 op 4 juni 1996: na 37 sec. boordcomputer denkt dat raket zwaar uit koers is

boordcomputer geeft sterk bijstuurcommando

boordcomputer oordeelt dat dit niet voldoende is, en schakelt

zelfs de hoofdmotor in

raket kantelt, bovendeel scheurt los, zelfvernietigingsdozen

doen het geheel ontploffen

SGP



wat liep er mis het Inertial Reference System (SRI) berekent de houding en de

bewegingen van de raket, op basis van bepaalde metingen deze metingen worden doorgegeven aan de boordcomputer, die

in functie hiervan stuurbeslissingen neemt vóór de lancering berekent een zekere module in het SRI die

houding tov het lanceerplatform na lancering heeft die bepaalde module geen betekenis meer die module werd gestopt ongeveer 40 sec. na lancering

voor Ariane 4, om count-down te kunnen “pauzeren” behouden in Ariane 5: verander geen goedwerkende software in die code staat een conversie van een 64-bit floating point

getal naar een 16-bit integer

SGP



wat liep er mis (vervolg) Ariane 5 stijgt anders op van Ariane 4: traject is verschillend na de lancering gebeurde er een conversiefout: het 64-bit

floating point getal had een onverwachte grote waarde de toepassing crashte, een 2de computer werd ingeschakeld deze 2de computer bevatte dezelfde software, dus crashte ook door de crash werd een diagnose bit-patroon naar de

boordcomputer gestuurd, die dit als gegevens interpreteerde, en besloot dat er drastisch bijgestuurd moest worden, met alle gevolgen van dien

gebruikte programmeertaal: Ada

SGP



hoe had dit kunnen vermeden worden fouten door conversies, evenals andere fouten zoals delingen

door 0, kunnen opgevangen worden in specifieke stukken code

(zie H6)

dit gebeurde niet voor de instructie die crash veroorzaakte

de fout had via simulaties kunnen gevonden worden

maar in de simulaties draaide die module niet na lancering

SGP



verschillende software componenten zijn gelijktijdig actief

de apparaten in de omgeving werken gelijktijdig

deze gelijktijdigheid wordt het best gerealiseerd door

gelijktijdig uitvoerende software componenten

meer en meer real-time systemen zijn gedistribueerde systemen

dit vraagt ondersteuning van programmeertalen en/of systemen

SGP



omgang met ‘tijd’ responstijd is van groot belang

deadlines moeten in alle omstandigheden gehaald worden

worst-case moet gekend zijn

voorspelbaarheid van responstijd is cruciaal

real-time systemen worden altijd over-gedimensioneerd

taal en systeem moeten toelaten om tijd te specifiëren,

deadlines te specifiëren, om te reageren wanneer een deadline

niet gehaald zal worden

SGP



interacties met hardware interface aangesloten hardware: vaak niet de klassieke randapparaten

randapparaten moeten kunnen gestuurd worden,

liefst op een abstracte manier

vereiste voor efficiënte implementatie en

uitvoeringsomgeving de tijdsvereisten kunnen zo streng zijn dat efficiëntie echt

belangrijk wordt (vb DSP)

SGP



typische karakteristieken voor consumentenmarkt goedkoop

beperkt geheugen

goedkopere processor

time-to-market is extreem laag

laag vermogen gebruik indien draagbaar

SGP


karakteristieken van een RTS: overzicht

groot en complex

manipuleren reële getallen

extreem betrouwbaar en veilig

verschillende software componenten zijn gelijktijdig actief

omgang met ‘tijd’

interacties met hardware interface

vereist efficiënte implementatie en uitvoeringsomgeving

SGP


economisch belang

ingebedde systemen: voor elke PC zijn er ongeveer 50 ingebedde systemen PC-markt heeft een plateau bereikt, markt voor ingebedde

systemen kan nog enorm groeien

belang voor Vlaanderen groot deel van software dat in Vlaanderen gemaakt wordt is

voor ingebedde systemen Vlaanderen is derde ‘super-high-tech region’ in Europa

(na Rheinland-Phals en Hessen) volgens Eurostat studie

belang voor Europa VS hebben groot deel van ‘packaged software’ markt Europa heeft en kan nog groeien in markt ingebedde systemen

SGP


economic importance

importance for Europe US have large part of market for ‘packaged software’

(see next slide)

top 10 software vendors in the world: Microsoft

Oracle

Computer Ass. Int.

Novell

SAP AG

Europe can still grow in the market of embedded systems

Sybase

Adobe systems

Informix

American Management Systems

Sterling Software

SGP


economic importance

Europe

USA

Pacific Region

Rest of World

79%

39%

42%

16% 14%

4% 5%

1%

Production share100% = $ 100 bn

Customer share

Packaged Software : Production Share versus Customer Share 1993

Source : Gartner Group 1994



deel 2: Ada en Java voor real-time en

embedded systemen

SGP


de taal Ada

taal ontworpen op aanvraag van DoD

(Department of Defense, US)

naam “Ada” komt van Countess Augusta Ada Lovelace

dochter van dichter Lord Byron (England)

schreef programma’s voor de “Difference Engine” van

Charles Babbage, de eerste computer uit de geschiedenis

was hierdoor de eerste computerprogrammeur

volgende slides: uit presentatie van DOD

Center for Computer Systems EngineeringJoint Interoperability & Engineering Organization

Defense Information Systems Agency

Comments on Ada in Relation to C++

SGP


Why Ada? (Technical Arguments)

In 1976, nothing else existed, so... Ada was designed with:

Software engineering in mind Large, complex projects in mind Standardization/validation in mind Reliability/maintainability in mind

In 1996, still nothing else exists!

Ada Was Designed With Long-term Support for the

Warfighter in Mind

Ada Was Designed With Long-term Support for the

Warfighter in Mind

SGP


IBM Weighted Scores for 6 Criterion Categories

Category MaximumScore

Ada C Pascal JOVIAL FORTRAN

Capability 16.7 16.1 9.6 10.4 7.6 3.9

Efficiency 16.4 8.0 11.8 10.8 11.0 11.1

Availability/Reliability

22.6 21.5 11.6 14.5 15.6 10.3

Maintainability/Extensibility

17.4 14.0 10.2 12.2 6.8 8.3

Lifecycle Cost 11.3 8.2 7.4 7.8 4.9 5.2

Risk 15.6 8.8 8.9 7.6 9.6 8.2

TOTAL 100.00 76.6 59.6 63.3 55.5 47.0

Source: IBM study, 1985

SGP


Do Defects Really Matter?

is 99.9% an acceptable tolerance for defects?

Consider: Drinking water contaminated for 1 hour per month. 16,000 letters lost every day by the US Post Office. 2 accidents per month at O’Hare International Airport. 20,000 prescriptions in error each year. 50 babies dropped on the delivery room floor each hour. 22,000 checks drawn from the wrong account per hour.

OOPS!

SGP


Software Crisis in1976

Proliferation of languages (>450) Many dialects of standard languages Low interoperability High maintenance costs Low reliability

Result Ada

SGP


(450+)

100200

500

300400

1976 1985 1994

(37)

SIGNIFICANT DECREASE IN No. OF 3GLsN

O.

OF 3

GLs

Ada is No. 1 For Weapons Ada is No. 2 For AISs

Ada(33.5%)

Other(6.1%)

Jovial(9.3%)

CMS-2(12.5%

)

C (22%)

FORTRAN(13.2%)

C++3.4%

COBOL(59.2%)

Ada(22%)

Other(10%)

C (9%)

Current State of Ada Use in DoD

SGP


Ada in Maintenance Arena

Average Annual Costs for Software Maintenance

0200400600800

1000120014001600

350 700 1,050 1,400 1,750 2,100Function Points

Th

ou

sa

nd

s o

f 1

99

4 D

oll

ars

Ada

Other HOLs

C

Source: MITRE (Avionics domain)

100% productivityand 50% qualityincrease doesnot reduce Cto Ada levels

270,000 LOC

225,000 LOC

150,000 LOC135,000 LOC

112,500 LOC

75,000 LOC

SGP


Common Reasons for NOT Using Ada

If I ignore it it will go away! It’s too complex. I don’t have time to learn another language. We don’t have a compiler. We need more tools to use Ada. Blah, Blah, Blah!

SGP


Expected Benefits of Ada

Overall Advantage: Increased Quality per Dollar Spent Code Portability People Portability Maintainability Reliability Common Basis for Tools/Methodologies Modularity, Managing Complexity Management Visibility, System View Improved Productivity Increased Reusability

SGP


Why Ada? (Business Arguments) Ada:

Has better support for “ilities” Yields greater productivity Costs less per SLOC Has fewer defects Supported by multiple vendors

Ada represents: A DoD core competency Increased economies of scale An ISO and ANSI standard Freedom from proprietary solutions

Ada Makes Open Systems and Interoperability PossibleAda Makes Open Systems and Interoperability Possible

SGP


Why C++?

Major industry marketing Nothing equivalent for Ada

Object-oriented programming support Did not exist in Ada 83, but does in Ada 95

Builds on popularity of C C was free with UNIX operating systems Students were taught C Easier to move up to C++ than Ada

Tools, bindings, visual environments and support abundantly available (based on origin) Ada was isolated

SGP


Why C++?

Lower startup costs ($, personnel, tools) Ada delivers more and thus costs more when only

development costs are considered

C++ gives programmers more freedom Less discipline is attractive to programmers - dangerous on

large systems

No standard for C++ Ada vendors must meet standard - more difficult and more

expensive

SGP


sell many quick reaction to market

forces large market large profit potential failures cost money

Source: Nyberg, Karl presentation quoting Gensler, “The Defense Industry” and Aharonian, Greg, “Microeconomic Definitions for Ada Summit”, 1994.

Industry and DoD have different focus

DoD Commercial Sector

Why C++ for Industry?

buy one long-term planning precludes

quick reaction limited market fixed profits failures cost lives

SGP


Software Development vs. Software Maintenance

DoD looks at systems from total lifecycle perspective 60-80+% of the lifecycle costs of software occur in

maintenance Arguments based on lower development costs total only

20-40% of the story On most projects, development and maintenance are two

separate contracts Commercial Off-The-Shelf (COTS) software is not always

the correct choice Decisions must be made on lifecycle costs not on

development costs

SGP


When Not to Use Ada

Ada may not be appropriate When some other language has lower lifecycle costs

For some R&D applications where the intent is for concept

development only and the system will not be fielded

For some prototype applications, however the prototype must

not be carried into E&D for subsequent fielding

When a compiler does not exist for the hardware platform

When timing and/or sizing constraints make Ada a technical

infeasibility

SGP


YF-22 Prototype Development

Software for the aircraft (35% of total avionics development cost)

Developed by 8 geographically separated subcontractors Developed using

different Ada compilers different hardware platforms

12 major avionics subsystems 650 Ada modules Millions of SLOC Integrated in 3 days!

Source: Guidelines for Successful Acquisition and Management of Software Intensive Systems, Vol. I, USAF, Feb 1995

SGP


Summary Ada vs C++

2001

Ada is:• Technically superior• Demonstrably lower

in cost through entire lifecycle

• Successfully used today and growing

• Supported by DISA

Ada was explicitly designed to support large systems well into

the next century

Ada was explicitly designed to support large systems well into

the next century

SingleVendor

Non-Standard

ClosedSystem

Stovepipes

AdaAda

SGP


developing embedded SW in Java

overview: technology and architecture why Java ? Java Virtual Machine Technology alternative technologies supporting technologies

SGP


what is so great about Java ?

programming language familiar C-like (but improved) syntax

all test conditions must be Booleane.g. while (x=3) is not allowed

primitive data types have fixed sizes easier to produce bug-free software

array bounds checking automatic garbage collection

built-in exception-handling built-in library for concurrency truly object-oriented simpler to learn than C++

SGP



bytecodes Java bytecode == portable binary format

instruction set for a virtual machine platform portability, without source code source translation is done in advance

faster than a “fully interpreted” solution can be translated into native opcodes:

at each encounter (bytecode interpreter) at first encounter (just-in-time compiler) prior to loading (ahead-of-time compiler)

SGP



Java Source

Java bytecode

libraries

Java bytecode

Java compiler

Java Virtual Machine

hardware

operating systems

SGP



class libraries high level of abstraction standard APIs:

increase application portability reduce programming effort

support for multitasking (see CH 7-9) Thread class and Runnable interface synchronized keyword monitors via wait() and notify()

support for networking

SGP


why use anything else ?

problems with Java no direct access to hardware (see CH 15)

Java has no pointers nor bytecodes to access a physical address but Java can call C ! (Java Native Methods)

size of code: JVM can be huge inefficiencies

bytecode interpretation is slower than C/C++ garbage collection requires processor time interpreter or JIT may not be “optimal” compiler

unpredictability (see CH 13) garbage collector may preempt a running task Just-in-Time compilation slows first access

SGP


JVM technology: components

Processor and other hardware

Multitasking OSNative methods

Java Virtual Machine (+ garbage collector)

Class libs Java Threads C/C++ Tasks

SGP


inside a virtual machine

Garbagecollector

Execution engine

Bytecode verifier

Dynamic class loader

Java application

Class libs

Nativemethods

Multitasking OS

SGP



execution engine bytecode interpreter just-in-time compilation hybrid

Sun’s HotSpot compiler

SGP



garbage collector (biggest myth for Java) many algorithms, some even hard RT suitable

naive incremental real-time (double heap, HW assisted)

bounded worst-case allocation time (faster than incremental GC)

bounded worst-case object access timeslower average-case allocation timeslower object access time

SGP



dynamic Class Loader find and load referenced class read file <package>/<class>.class in the CLASSPATH ZIP files are also traversable, can be placed in ROM, if

necessary verify class file format link: place contents into a JVM data structure prepare and initialize the class

SGP



bytecode verifier detects and prevents “illegal” activity verification is optional! of little value in a closed system

SGP



Java Class Libraries Write Once, Run Anywhere only if the same set of class libraries are available! multiple “standard platforms” (APIs):

Standard Java - the full set, for desktops and workstations PersonalJava - a subset of the above, for smaller devices EmbeddedJava - like the previous, but more memory-

conscious

SGP


Inside a virtual machine

Java Class Libraries upward compatibility is desirable

EmbeddedJava applications also run on any PersonalJava platform

PersonalJava applications also run on any Standard Java platform

SGP


JVM requirements: memory

ROM: JVM + libraries + application JVM: ~500K is typical maximum Class libraries: ~500K for PersonalJava + the application itself

RAM: JVM + heap + thread stacks affected by engine type

JIT compiler requires large storage area, interpreter does not heap size is application-dependent each thread requires its own stack

SGP


JVM requirements: processor

capabilities arithmetic

32-bit integers assumed cheap and fast, 64-bit available 32-bit and 64-bit floating point (IEEE 754) available

processing power need enough to negate interpretation slowdown

address space JVM + all class libraries requires a lot of memory!

SGP


JVM requirements: OS

JVM is not (usually) an OS replacement RTOS or kernel expected underneath

only minimal functionality required thread creation and deletion (see CH 7) priority-based scheduling (see CH 13)

at least 10 priority levels synchronization primitives (e.g., mutexes) (see CH 8) private thread stacks (see CH 7)

SGP


JVM requirements: other SW

JVMs are written in C, therefore: Standard C library Standard math library

dynamic memory allocation malloc() is called internally

Java class libraries java.net - assumes a TCP/IP stack java.awt - requires a graphics API

others? - implementation-specific

SGP


alternative technologies

traditional JVM: too big too slow too unpredictable

alternatives: Ahead-of-time compilers Java processors JavaCard technology Kjava Virtual Machine

SGP


supporting technologies

Java Native Interface (JNI) call legacy code work around Java’s limitations implement higher-performance functionality native methods == C functions (no good integration with C++)

SGP


supporting technologies

JVM Debug Interface (JVMDI) programming interface for debuggers

Client(JVM) - Server monitor and control:

memory threads

event notification for: field access/modificationbreakpoints

stack frames local variables



kort overzicht van Ada(en C en Java):

programming in the small

SGP


declare

<declarative part>

begin

<sequence of statements>

exception

<exception handlers>

end

declare

Temp: Integer := A; -- initiële waarde wordt gegeven aan Temp

begin

A := B; -- := is de toekennings operator

B := Temp;

end -- geen exception deel

algemene stijl: een blok in Ada

SGP


algemene stijl: een blok in Calgemene stijl: een blok in C{

<declarative part>

<sequence of statements>

}

{

int temp = A; /* declaratie en initialisatie */

/* merk op: in C staat de naam van het type eerst */

/* in Ada komt het na de naam van de variabele */

A = B; /* toekenningsoperator is = */

B = temp;

}

algemene stijl: een blok in C en Java

SGP


gegevenstypengegevenstypen

Ada is sterk getypeerd: in toekenningen en expressies

moeten objecten van hetzelfde type zijn (expliciete

conversies zijn mogelijk)

C biedt veel minder type-controle

Java is ook sterk getypeerd

gegevenstypen

SGP


types in Ctypes in C{

typedef enum (xplane, yplane, zplane) dimension;

/* typedef introduceert een naam voor een nieuw type; */

/* de naam is hier dimension; */

/* enum zegt dat het om een enumeratie gaat */

dimension line, force;

line = xplane;

force = line + 1;

/* force is nu yplane */

}

Java biedt geen enumeratie type

types in C

SGP


types in Adatypes in Adatype Dimension is (Xplane,Yplane,Zplane);

type Map is (Xplane,Yplane);

Line, Force : Dimension;

Grid : Map;

begin

Line := Xplane;

Force := Dimension’Succ(Xplane);

Grid := Yplane;

Grid := Line; -- mag niet, verschillende types

end;

types in Ada

SGP


types in Ada (vervolg)types in Ada (vervolg)subtype Surface is Dimension range Xplane .. Yplane;

type New_int is new Integer;

type Projection is new Dimension range Xplane .. Yplane;

D: Dimension;

S: Surface;

P: Projection;

begin

D := S; -- OK

S := D; -- legaal, maar zou kunnen run-time fout genereren

P := D; -- illegaal

P := Projection(D); -- OK, met expliciete conversie

end;

types in Ada

SGP


types in C (vervolg)types in C (vervolg)in C

typedef int newint;

typedef dimension projection;

/* biedt niet dezelfde protectie als in Ada */

in Java

nieuwe types worden gecreëerd via object-oriëntatie, zie H4

types in C en Java

SGP


Max: constant Integer := 10;

type Reading_T is array (0 .. Max-1) of Float;

Size: constant Integer := Max-1;

type Switches_T is array(0 .. Size, 0 .. Size) of Boolean;

Reading: Reading_T;

Switches: Switches_T;

gestructureerde gegevenstypes in Ada

SGP


gestructureerde gegevenstypes in Cgestructureerde gegevenstypes in C

static final int max = 10; // definitie van constante

float reading[] = new float [MAX]; // index is 0 .. max -1

boolean switches[] [] = new boolean[MAX] [MAX];

// merk op: in Java zijn rijen objecten

gestructureerde gegevenstypes in C

SGP


gestructureerde gegevenstypes in Cgestructureerde gegevenstypes in C

#define MAX 10 /* manier om een constante te definiëren

*/

/* zonder typevoordeel */

typedef float reading_t[MAX]; /* index is 0 .. MAX-1 */

typedef short int switches_t[MAX] [MAX];

/* er zijn geen booleans in C */

reading_t reading;

switches_t switches;

gestructureerde gegevenstypes in Java

SGP


gestructureerde gegevenstypes in Ada (vervolg)gestructureerde gegevenstypes in Ada (vervolg)

type Day_T is new Integer range 1 .. 31;

type Month_T is new Integer range 1 .. 12;

type Year_T is new Integer range 1900 .. 2050;

type Date_T is

record

Day : Day_T := 1;

Month : Month_T := 1;

Year: Year_T;

end record;

gestructureerde gegevenstypes in Ada

SGP


gestructureerde gegevenstypes in C (vervolg)gestructureerde gegevenstypes in C (vervolg)

typedef short int day_t;

typedef short int month_t;

typedef short int year_t;

struct date_t {

day_t day;

month_t month;

year_t year; }; /* naam hiervan is ‘struct date_t */

typedef struct {

day_t day;

month_t month;

year_t year; } date2_t; /* dit is een nieuw type met naam date2_t */


SGP



class Date

{

int day, month, year;

}

Date birthday = new Date();

birthdate.day = 31;

birthdate.day = 1;

birthdate.day = 2000;

gestructureerde gegevenstypes in Java

SGP


D: Date_T;

begin

D.Year := 2000;-- D is nu 1/1/2000

D := (3, 1, 1953); -- volledige toekenning

D := (Year => 1974, Day => 4, Month => 7);

-- volledige toekenning met gebruik van veldnamen

...

end;

gestructureerde gegevenstypes in Ada (vervolg)gestructureerde gegevenstypes in Ada (vervolg)gestructureerde gegevenstypes in Ada

SGP



struct date_T d = (1, 1, 1);/* kan alleen bij initialisatie statische variabelen */

...

{

d.year = 2000;

...

}


SGP


dynamische gegevenstypes in Cdynamische gegevenstypes in C

{

typedef struct node {

int value;

struct node *next; /* pointer naar een record hier gedefinieerd */

} node_t;

int V;

node_t *Ptr;

Ptr = malloc (sizeof(node_t)); /* dynamische allocatie van geheugen */

Ptr->value = V;

Ptr->next = 0; /* de null-pointer bestaat niet */...

}

dynamische gegevenstypes in C

SGP


dynamische gegevenstypes in Adadynamische gegevenstypes in Adatype Node; -- definitie zal volgen

type Ac is access Node;

type Node is

recordValue: Integer;

Next: Ac;

end record;

V: Integer;

A1: Ac;

begin

A1 := new Node;-- dynamische allocatie van geheugen

A1.Value := V;

A1.Next := null;. . .

end;

dynamische gegevenstypes in Ada

SGP


dynamische gegevenstypes in C (vervolg)dynamische gegevenstypes in C (vervolg)

typedef date_t events_t[MAX], *next_event_t;

/* events_t is een type voor arrays van Max el. van type date_t

next_event_t is type voor pointers naar el. van type date_t */

events_t history;

next_event_t next_event;

next_event = &history[0]; /* adres van eerste element van rij */

next_event++; /* de pointer gaat nu wijzen naar het */

/* volgende element in de rij */

/* een pointer in C kan naar om het even wat wijzen, probleem van

hangende pointers (dangling pointer) */

dynamische gegevenstypes in C

SGP


dynamische gegevenstypes in C (vervolg)dynamische gegevenstypes in C (vervolg)

elk object in Java is een referentie naar het actuele object met zijn data, voor de rest zijn er geen pointers voorzien in Java

class node

{

int value;

node next;

}

Node Ref1 = new Node();

Node Ref 2= new Node();

if (Ref1 == Ref2) { … } // vergelijkt adressen en geen inhoud

dynamische gegevenstypes in Java

SGP


controle structuren: leeg blokcontrole structuren: leeg blok

in Ada:

begin

null;

end;

in Java en C:

{ /* gewoon niets */

}

controle structuren: leeg blok

SGP


controle structuren: if-then-elsecontrole structuren: if-then-else

in Ada:

if A /= 0 then

if B/A > 10 then

High := True;

else

High := False;

end if;

end if;

in C:

if (A != 0)if (B/A > 10) high = 1;else high = 0;

// in Java mag die ambiguïteit niet

if (A != 0) {if (B/A > 10) {

high = 1;}else {

high = 0;}

}

controle structuren: if-then-else

SGP


controle structuren: if-then-else in Ada (vervolg)

controle structuren: if-then-else in Ada (vervolg)

if Number < 10 then

Num_Digits := 1;

elseif Number < 100 then

Num_Digits := 2;


Num_Digits := 3;


Num_Digits := 4;

else

Num_Digits := 5;

end if;

controle structuren: if-then-else in Ada

SGP


controle structuren: casecontrole structuren: case

in Ada:

case Command is

when ‘A’ | ‘a’ => Action1;

when ‘t’ => Action2;

when ‘e’ => Action3;

when ‘x’ .. ‘z’ => Action4;

when others => null;

end case;

in Java en C:

switch (command) {case ‘A’ :case ‘a’ : action1; break;case ‘t’ : action2; break;case ‘e’ : action3; break;case ‘x’ :case ‘y’ :case ‘z’ : action4; break;default : break;

}

controle structuren: case

SGP


controle structuren: while-luscontrole structuren: while-lus

in Ada:

while <Boolean Expression> loop

<Statements>

end loop;

loop

...

exit when <Boolean Expression>

...

end loop;

in Java en C:

while (<expression>) {/* expressie = 0 eindigt lus */<statement>

}

while (1) {... if (<expression>) break;...

}

controle structuren: while-lus

SGP


in Ada:

for I in 0 .. 9 loop

A(I):= I;

end loop;

loop

<Statements>

end loop;

in C:

for (i = 0; i <= 9; i++) {

A[i] = i;

{

while (1) {

<statement>

}

controle structuren: for-lus en oneindige lus

SGP


parameters bij subprogrammas in Ada

parameters bij subprogrammas in Ada

drie modes:

in data wordt doorgegeven aan het subprogramma

out data wordt doorgegeven aan het oproepende programmaonderdeel

in out data wordt doorgegeven aan het subprogramma,

wordt daar eventueel gewijzigd en wordt dan weerdoorgegeven aan het oproepende programma-onderdeel

procedure Quadratic ( A, B, C : in Float;

R1, R2 : out Float;

Ok : out Boolean);

bij functies mogen alleen ‘in’ parameters gebruikt worden

parameters bij subprogramma’s in Ada

SGP


parameters bij subprogrammas in Cparameters bij subprogrammas in Cmaar 1 parametermechanisme:

by value: data wordt enkel doorgegeven aan het subprogramma

om resultaten te doen terugkeren naar het oproepende programmaonderdeel moeten pointers gebruikt worden

void quadratic ( float A, float B, float C,

float *R1, float *R2, int *OK);

merk op:

- C gebruikt geen sleutelwoord om een subprogramma aan te geven

- een procedure in C is een functie die niets (void) terug geeft

parameters bij subprogramma’s in C

SGP


parameters bij subprogrammas in Cparameters bij subprogrammas in Cprimitieve argumenten worden gekopieerd

variabelen van classe-type

zijn reference variabelen, worden doorgegeven als referentie

argument dat niet mag gewijzigd worden door functie: “final”

public class Roots {

float R1, R2;

}

boolean quadratic ( final float A, final float B, final float C, Roots R);

merk op:

- de boolean vlag is de teruggeefwaarde van de functie

- Roots is een klasse: R1 en R2 kunnen gewijzigd worden

parameters bij subprogramma’s in Java

SGP


procedures in Adaprocedures in Adaprocedure Quadratic (A, B, C : in Float;

R1, R2 : out Float;Ok : out Boolean) is

Z : Float;begin

Z := B*B - 4.0*A*C;if Z < 0.0 or A = 0.0 then

Ok := False;R1 := 0.0; R2 := 0.0;return;

end if;Ok := True;R1 := (-B + Sqrt(Z)) / (2.0*A); R2 := (-B - Sqrt(Z)) / (2.0*A);

end Quadratic;

procedures in Ada

SGP


procedures in Cprocedures in Cvoid quadratic ( float A, float B, float C, float *R1, float *R2, int *OK);{

float Z;Z = B*B - 4.0*A*C;if (Z < 0.0 || A == 0.0) {

*OK = 0;*R1 = 0.0; *R2 = 0.0;return;

}*OK = 1;*R1 = (-B + SQRT(Z)) / (2.0*A); *R2 = (-B - SQRT(Z)) / (2.0*A);

}...quadratic (F1, F2, F3, &Q1, &Q2, &S);

procedures in C

SGP


procedures in Cprocedures in Cpublic class Roots {

float R1, R2;}boolean quadratic ( final float A, final float B, final float C, Roots R); {

float Z;Z = (float) (B*B - 4.0*A*C);if (Z < 0.0 || A == 0.0) {

R.R1 = 0f; R.R2 = 0f; return false;

}R.R1 = (float) (-B + Math.sqrt(Z)) / (2.0*A); R.R2 = (float) (-B - Math.sqrt(Z)) / (2.0*A);

return true;}

procedures/functies in Java

SGP


functies in Adafuncties in Ada

function Minimum (X, Y: in Integer) return Integer is

begin

if X > Y then

return Y;

else

return X;

end if;

end Minimum;

functies in Ada

SGP


functies in Cfuncties in C

int minimum (int X, int Y)

{

if (X > Y) return Y;

else return ;

}

voorbeeld van een macro (en tegelijk ook van mogelijk cryptische schrijfwijze van if-then-else in C):

#define MIN(X, Y) ((X > Y) ? (Y) : (X));

functies in C



kort overzicht van Ada(en C en Java):

programming in the large

SGP


gegevensverberging: package in Ada

package heeft twee delen specificatie interface: dit is zichtbaar er buiten lichaam: dit is de implementatie, is onzichtbaar er buiten

het lichaam bevat een initialisatie-deel

beide moeten in hetzelfde declaratieve deel staan er mag wel iets tussen staan bv spec. pack. A, spec. pack. B, lichaam pack. A, lichaam pack. B op deze manier kunnen A en B elkaar oproepen

routines (en ge-exporteerde variabelen) kunnen bereikt worden via naam_package.naam_routine

implementatie van slechts één instantie van de queue de queue wordt gecreëerd in het initialisatie-deel

SGP



specificatie interface: deze entiteiten zijn zichtbaar er buiten

voorbeeld van oproep: Queuemod.Insert (El);

lichaam : dit is de implementatie, zie volgende slide

package Queuemod is

function Empty return Boolean;

procedure Insert (E: Element); -- Element moet zichtbaar zijn

procedure Remove (E: out Element);

end Queuemod;

SGP


gegevensverberging: package in Ada (vervolg)gegevensverberging: package in Ada (vervolg)

packagebody Queuemod is

type ...

Q: Queue_Ptr_T;

procedure Create is

begin ... end Create;

function Empty return Boolean is

begin ... end Empty;

procedure Insert (E: Element) is

begin ... end Insert;

procedure Remove (E: out Element) is

begin ... end Remove;

begin

Create;

end Queuemod;


SGP



use: om de naamgeving niet te zwaar te maken wanneer veel

elementen uit een package gebruikt worden naam_package.naam_routine wordt naam_routine

declare

use Queuemod;

begin

if not Empty then

Remove (E);

end if;

end;

SGP


gegevensverberging in C

C: geen taalconstructies voor gegevensverberging modules kunnen nagebootst worden door code in

verschillende bestanden te plaatsen per module een ‘header-file’, deze eindigt op ‘.h’ per module een ‘body-file’, deze eindigt op ‘.c’ het header-bestand wordt ingelast in het .c-bestand geen formele relatie tussen deze bestanden, alleen naamconventie

nadelen: geen initialisatie-deel (initialisatie zal ergens expliciet moeten staan) minder testen door de compiler zijn mogelijk bv geen test op volledigheid specificatie tov lichaam en omgekeerd:

het ontbreken van een routine wordt slechts opgemerkt bij het linken

SGP



header-bestand (.h bestand): dit bestand definieert de functionele interface van de module

dit header-bestand moet ingelast worden in elk bestand dat van de module wenst gebruik te maken (via #include-instructie)

implementatie staat in een .c bestand, zie volgende slide

int Empty();

void insertE (element E);

void removeE (element *E);

SGP


gegevensverberging in C (vervolg)gegevensverberging in C (vervolg)

#include “queuemod.h”

struct ...

void create()

{ ... }

int empty()

{ ... }

void insertE (element E)

{ ... }

void removeE (element *E)

{ ... }


SGP



int Empty();



queuemod.h


….int empty(){ ... }void insertE (element E){ ... }

….

queuemod.c


….element E1, E2;insertE(E1);insertE(E2);

….

put_in.c


….element E3;if !empty() removeE(&E3)

….

take_out.c

SGP


tekortkomingen van modules

modules zijn geen eerste-klas-taalelementen

moduletypes kunnen niet gemaakt worden

je kunt geen verschillende instanties van module creëren

je kunt geen pointer naar een module laten wijzen

SGP


aparte compilatie

voordelen van het apart compileren van modules een module kan geschreven en getest worden, onafhankelijk

van de rest eens getest kan de module in een bibliotheek geplaatst worden,

eventueel reeds gecompileerd aparte compilatie ondersteunt projectbeheer voordeel dat niet alles telkens gehercompileerd moet worden

(dat geldt natuurlijk vooral voor ‘programming in the large’)

aparte compilatie ondersteunt bottom-up ontwerp vooral bottom-up ontwerp van specificaties is interessant

SGP


aparte compilatie in C

int Empty();




….int empty(){ ... }void insertE (element E){ ... }

….


….element E1, E2;insertE(E1);insertE(E2);

….


….element E3;if !empty() removeE(&E3)

….

queuemod.h

queuemod.c put_in.c take_out.c

SGP


aparte compilatie in Ada

with-constructie: gebruik van een package uit bibliotheek(een beetje te vergelijken met #include van C)

een with-constructie kan in een andere package staan: zo ontstaat een hiërarchie van modules vb: module Dispatcher maakt gebruik van module Queuemod

package Dispatcher is

... -- nieuwe zichtbare entiteiten

end Dispatcher;

with Queuemod;

package body Dispatcher is

... -- verborgen entiteiten

end Dispatcher;

SGP


aparte compilatie in Ada

voordelen specificatie en lichaam zijn expliciet in de bibliotheek specificatie kan geschreven worden vóór het lichaam

logische consistentie kan reeds door compiler getest worden specificatie kan geschreven worden door project-leiders

specificatie is een deel van ontwerpen uitwerken van specificatie is vaak programming in the small fout in specificatie heeft grotere gevolgen dan fout in lichaam:

alle modules die de specificatie gebruiken moeten eventueel gewijzigd worden

(bij fout in een lichaam moet enkel dit lichaam hercompileerd worden)

SGP


aparte compilatie

Ada aparte compilatie is deel van de taal

bibliotheekomgeving is deel van taal consistentie van specificaties en types gebeurt over

bibliotheekeenheden

C aparte compilatie is geen deel van taal

C-bestand worden apart gecompileerd: object modules object modules worden gelinked bij het linken wordt niet gechecked op specificatie-

consistentie en types

SGP


abstracte gegevenstypes

uitbreiding van idee dat gebruikers van een type niets hoeven te weten van de precieze voorstellingskeuze van dit type (bv lijst, enkel of dubbel gelinkt, circulair of niet, ..)

lost één van de tekortkomingen van modules op ADT (abstract data type) = module dat een type definieert

type bepaalt: objecten en operaties definitie van een type impliceert dat er variabelen van dit type

kunnen gedeclareerd worden een creatie-routine is hier absoluut noodzakelijk

SGP


abstracte gegevenstypes extra moeilijkheid wanneer gecombineerd met aparte compilatie

normaal wensen we dat de interne voorstelling van het type verborgen wordt, zich dus in het lichaam bevindt

module dat gebruik maakt van een ADT moet het volgende kennen: de operaties (= specificatie, de interface) de grootte van het ADT (dit is nodig voor de compilatie van

de gebruikmakende module) mogelijke oplossing: gebruik van een indirectie

altijd een pointer gebruiken naar het ADT: een pointer heeft een vaste grootte (vaak gebruikt in C)

in Ada: interne voorstelling wordt bij specificatie gevoegd als limited private als private (dan zijn ook toekenning en vgl mogelijk)

SGP


abstracte gegevenstypes in C

voorbeeld van gebruik van indirectie in C: als extra parameter wordt hier nu altijd een pointer naar het object gebruikt

int empty(queue_ptr_t Q);

void insertE (queue_ptr_t Q, element E);

void removeE (queue_ptr_t Q, element *E);

SGP


abstracte gegevenstypes in Adaabstracte gegevenstypes in Adapackage Complex_Arithmetic is

type Complex is private;

function ”+” (X, Y: Complex) return Complex;

function ”-” (X, Y: Complex) return Complex;

function Comp (A, B: Float) return Complex;

function Real_Part (X: Complex) return Float;

private

type Complex is

record

Real_Part: Float;

Imag_Part: Float;

end record;

end Complex_Arithmetic;

abstracte gegevenstypes in Ada

SGP


abstracte gegevenstypes in Ada

with Complex_Arithmetic;

use Complex_Arithmetic;

….

C1, C2, C3: Complex;

A, B: float;

….

C2 := Comp(A, B);

C3 := C1 + C2;

if C1 = C2 then …. end if;

….

SGP


object-georiënteerd programmeren

verder uitbreiding van ADT (variabelen van de ADT worden objecten genoemd)

4 extra kenmerken uitbreidbaarheid van type (over-erving) automatische initialisatie van objecten (constructors) automatische destructie van objecten (destructors) soort operatie wordt pas bij uitvoering bepaald (polymorfisme)

probleem bij real-time programma's: polymorfisme maakt het niet mogelijk om via de code te weten welke operatie opgeroepen zal worden: moeilijk om nodige tijd te schatten

ondersteund in Ada en Java

SGP


OOP en Java abstracte klasse

hier kunnen geen objecten van gedeclareerd worden moet via over-erving concreet gemaakt worden

finale klasse hiervan kan men niet over-erven

sleutelwoord extends geeft aan dat een klasse van een andere is afgeleid public class Coordinate { .. } // voor 2-dimensionaal werken public class ThreeDimension extends Coordinate { … } // voor 3-dimensies

nieuwe velden kunnen toegevoegd worden extra operaties kunnen gedefinieerd worden bestaande operaties kunnen ge-herdefinieerd worden, en mogen in hun

definitie gebruik maken van oorspronkelijke operatie

SGP


herbruikbaarheid

herbruikbaarheid is veelbelovend voor softwareproductie, maar niet zo eenvoudig

overerving is een goed middel ander middel: een sjabloon

type is generisch en wordt pas bepaald bij instantiatie uitwerking in Ada en C++

generic modules in Ada template in C++ [interfaces in Java: werkt iets anders]

componenten kunnen geïnstantieerd worden van een sjabloon voorbeeld: een ADT dat een queue van elementen beheert, het

type van de elementen wordt in het sjabloon nog niet bepaald

Systeem-ge ï ntegreerde Programmatuur

Documents

Transcript of Systeem-ge ï ntegreerde Programmatuur