SGP - Departement Computerwetenschappen

SGP
Systeem-geïntegreerde Programmatuur
Systeem-geïntegreerde
Programmatuur
Marc Gobin (&Yolande Berbers)
Departement Computerwetenschappen
(200A 03.20)
(Yolande@cs.kuleuven.ac.be)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 1
SGP

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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 2
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 3
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

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 4
SGP
Systeem-geïntegreerde Programmatuur
deel 1:
inleiding tot real-time systemen
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 5
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 6
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 7
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 8
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 9
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, ...
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 10
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)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 11
SGP

soorten real-time systemen
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 12
SGP
soorten real-time systemen

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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 13
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 14
SGP

voorbeelden van RT systemen
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

Yolande Berbers
dit kan best veel rekenwerk vragen
Systeem-geïntegreerde programmatuur
slide 15
example: simple valve control
SGP
interface
input flow
reading
flow
meter
processing
output valve
angle
valve
time
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 16
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 17
SGP
general process control
operators console
process control
computer
chemicals
and
materials
valve
temperature
transducer
stirrer
finished
products
a process control system
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 18
SGP

voorbeelden van RT systemen
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 19
SGP
general manufacturing
operators console
production control
computer
parts
machine
tools
manipulators
conveyor
belts
finished
products
a production control system
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 20
SGP

voorbeelden van RT systemen
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 hoeveelheden
 vaak geografisch verspreid
 administratieve procedures
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 21
SGP communicatie, bevel en controle
command
post
command and
control computer
terminals
temperature, pressure, power and so on
sensors/actuators
a command and control system
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 22
SGP

voorbeelden van RT systemen
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 23
SGP
real time
clock
industrial embedded system
algorithms for
digital control
interface
data
logging
remote
monitoring
data retrieval
and display
display
devices
engineering
system
database
operator’s
console
Yolande Berbers
operator
interface
Systeem-geïntegreerde programmatuur
slide 24
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 25
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)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 26
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)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 27
SGP

karakteristieken van een RTS
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

Yolande Berbers
complex, often based on differential equations
Systeem-geïntegreerde programmatuur
slide 28
SGP

karakteristieken van een RTS
e.g.: controller (possibly analog), based on feedback
 r(t) is desired signal
 u(t) is input vector
 e(t) is error vector
 y(t) is output signal
r(t)
Yolande Berbers

e(t)
controller
(analog)
u(t)
plant
Systeem-geïntegreerde programmatuur
y(t)
slide 29
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
r(t*)
controller
u(t*)
(computer)
y(t*)
digital to
analog
converter
u(t)
sample
and
hold
plant
y(t)
 requirement: ability to manipulate real numbers
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 30
SGP

karakteristieken van een RTS
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 31
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 32
SGP

voorbeeld: ontploffing Ariane 5
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 33
SGP

voorbeeld: ontploffing Ariane 5
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 34
SGP

voorbeeld: ontploffing Ariane 5
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

Yolande Berbers
maar in de simulaties draaide die module niet na lancering
Systeem-geïntegreerde programmatuur
slide 35
SGP

karakteristieken van een RTS
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 36
SGP

karakteristieken van een RTS
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 37
SGP

karakteristieken van een RTS
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)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 38
SGP

karakteristieken van een RTS
typische karakteristieken voor consumentenmarkt
 goedkoop

beperkt geheugen

goedkopere processor
 time-to-market is extreem laag
 laag vermogen gebruik indien draagbaar
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 39
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 40
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 41
economic importance
SGP

importance for Europe
 US have large part of market for ‘packaged software’
(see next slide)
 top 10 software vendors in the world:

Microsoft

Sybase

Oracle

Adobe systems

Computer Ass. Int.

Informix

Novell

American Management Systems

SAP AG

Sterling Software
 Europe can still grow in the market of embedded systems
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 42
SGP
economic importance
Packaged Software : Production Share versus Customer Share 1993
Production share
100% = $ 100 bn
Customer share
1%
Rest of World
Pacific Region
Europe
4%
5%
16%
14%
42%
79%
USA
39%
Source : Gartner Group 1994
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 43
SGP
Systeem-geïntegreerde Programmatuur
deel 2:
Ada en Java voor real-time en
embedded systemen
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 44
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 45
Comments on Ada
in Relation to C++
Center for Computer Systems Engineering
Joint Interoperability & Engineering Organization
Defense Information Systems Agency
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 47
SGP
Category
IBM Weighted Scores for 6
Criterion Categories
Maximum
Score
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
100.00
76.6
59.6
63.3
55.5
47.0
TOTAL
Source: IBM study, 1985
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 48
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!
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 49
SGP





Software Crisis in1976
Proliferation of languages (>450)
Many dialects of standard languages
Low interoperability
High maintenance costs
Low reliability
Result
Yolande Berbers
Ada
Systeem-geïntegreerde programmatuur
slide 50
SGP Current State of Ada Use in DoD
SIGNIFICANT DECREASE IN No. OF 3GLs
500
400
300
200
100
(450+)
(37)
1976
1994
1985
Ada is No. 1 For Weapons
Ada is No. 2 For AISs
Ada
(33.5%)
Other
(6.1%)
COBOL
(59.2%)
C (22%)
Ada
(22%)
C++
3.4%
Yolande Berbers
FORTRAN
(13.2%)
Jovial
(9.3%)
CMS-2
(12.5%
)
Other
(10%)
C (9%)
Systeem-geïntegreerde programmatuur
slide 51
SGP
Ada in Maintenance Arena
Thousands of 1994 Dollars
Average Annual Costs for Software Maintenance
1600
1400
1200
1000
800
600
400
200
0
Ada
Other HOLs
C
270,000 LOC
225,000 LOC
135,000 LOC
150,000 LOC
112,500 LOC
75,000 LOC
350
700 1,050 1,400 1,750 2,100
Function Points
Yolande Berbers
100% productivity
and 50% quality
increase does
not reduce C
to Ada levels
Source: MITRE (Avionics domain)
Systeem-geïntegreerde programmatuur
slide 52
SGP
Common Reasons for NOT Using Ada






Yolande Berbers
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!
Systeem-geïntegreerde programmatuur
slide 53
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 54
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 Possible
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 55
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 56
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 57
SGP
Why C++ for Industry?
Industry and DoD have different focus
DoD





Commercial Sector
buy one
long-term planning precludes
quick reaction
limited market
fixed profits
failures cost lives





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.
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 58
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 59
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 60
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 61
SGP
Summary Ada vs C++
2001
Ada
Single
Vendor
NonStandard
Stovepipes
Closed
System
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 62
SGP

developing embedded SW in Java
overview: technology and architecture
 why Java ?
 Java Virtual Machine Technology
 alternative technologies
 supporting technologies
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 63
SGP

what is so great about Java ?
programming language
 familiar C-like (but improved) syntax
all test conditions must be Boolean
 e.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++

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 64
SGP

what is so great about Java ?
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)

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 65
SGP
what is so great about Java ?
Java
Source
Java
bytecode
libraries
Java compiler
Java Virtual
Machine
Java
bytecode
operating systems
hardware
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 66
SGP

what is so great about Java ?
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 67
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 68
SGP
JVM technology: components
Java Threads
Class libs
C/C++ Tasks
Java Virtual Machine (+ garbage collector)
Native methods
Multitasking OS
Processor and other hardware
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 69
inside a virtual machine
SGP
Java application
Class libs
Dynamic class loader
Bytecode verifier
Native
methods
Execution engine
Garbage
collector
Multitasking OS
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 70
SGP

inside a virtual machine
execution engine
 bytecode interpreter
 just-in-time compilation
 hybrid

Yolande Berbers
Sun’s HotSpot compiler
Systeem-geïntegreerde programmatuur
slide 71
SGP

inside a virtual machine
garbage collector (biggest myth for Java)
 many algorithms, some even hard RT suitable



Yolande Berbers
naive
incremental
real-time (double heap, HW assisted)
 bounded worst-case allocation time
(faster than incremental GC)
 bounded worst-case object access time
 slower average-case allocation time
 slower object access time
Systeem-geïntegreerde programmatuur
slide 72
SGP

inside a virtual machine
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 73
SGP

inside a virtual machine
bytecode verifier
 detects and prevents “illegal” activity
 verification is optional!
 of little value in a closed system
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 74
SGP

inside a virtual machine
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 memoryconscious

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 75
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

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 76
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

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 77
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!
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 78
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)

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 79
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 80
SGP

alternative technologies
traditional JVM:
 too big
 too slow
 too unpredictable

alternatives:
 Ahead-of-time compilers
 Java processors
 JavaCard technology
 Kjava Virtual Machine
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 81
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++)
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 82
SGP

supporting technologies
JVM Debug Interface (JVMDI)
 programming interface for debuggers



Yolande Berbers
Client(JVM) - Server
monitor and control:
 memory
 stack frames
 threads
 local variables
event notification for:
 field access/modification
 breakpoints
Systeem-geïntegreerde programmatuur
slide 83
SGP
Systeem-geïntegreerde Programmatuur
kort overzicht van Ada
(en C en Java):
programming in the small
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 84
SGP
algemene stijl: een blok in Ada
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 85
SGP algemene
algemene
stijl:
stijl:
eeneen
blokblok
in Cin
enCJava
{
<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;
B = temp;
/* toekenningsoperator is = */
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 86
SGP

gegevenstypen
gegevenstypen
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 87
SGP
types
typesin
inCC
{
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 88
SGP
types
typesin
inAda
Ada
type 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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 89
SGP
typestypes
in Adain(vervolg)
Ada
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 90
SGP
types
typesininCC(vervolg)
en Java
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 91
SGP
gestructureerde gegevenstypes in Ada
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 92
SGP gestructureerde
gestructureerde gegevenstypes
gegevenstypes in
in C
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 93
SGP gestructureerde
inin
Java
gestructureerdegegevenstypes
gegevenstypes
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 94
SGP
gestructureerde
gegevenstypes
in Ada
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 95
SGP gestructureerde
gegevenstypes
in C
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;
Yolande Berbers
/* dit is een nieuw type met naam date2_t */
Systeem-geïntegreerde programmatuur
slide 96
SGP gestructureerde
gegevenstypes
in Java
gestructureerde gegevenstypes
in C (vervolg)
class Date
{
int day, month, year;
}
Date birthday = new Date();
birthdate.day = 31;
birthdate.day = 1;
birthdate.day = 2000;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 97
SGP
gestructureerde
gegevenstypes
in Ada
gestructureerde gegevenstypes
in Ada (vervolg)
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 98
SGP gestructureerde
gegevenstypes
in C
gestructureerde gegevenstypes
in C (vervolg)
struct date_T d = (1, 1, 1);
/* kan alleen bij initialisatie statische variabelen */
...
{
d.year = 2000;
...
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 99
SGP dynamische
dynamische gegevenstypes
gegevenstypes ininCC
{
typedef struct node {
int value;
struct node *next;
} node_t;
/* pointer naar een record hier gedefinieerd */
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 */
...
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 100
SGP dynamische
Ada
dynamische gegevenstypes
gegevenstypes ininAda
type Node;
-- definitie zal volgen
type Ac is access Node;
type Node is
record
Value: Integer;
Next: Ac;
end record;
V: Integer;
A1: Ac;
begin
A1 := new Node;
A1.Value := V;
-- dynamische allocatie van geheugen
A1.Next := null;
. . .
end;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 101
SGP dynamische
dynamische
gegevenstypes
in C
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];
next_event++;
/* adres van eerste element van rij */
/* 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) */
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 102
SGP dynamische
dynamische
gegevenstypes
in Java
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) { … }
Yolande Berbers
// vergelijkt adressen en geen inhoud
Systeem-geïntegreerde programmatuur
slide 103
SGP
controle
leegblok
blok
controle structuren:
structuren: leeg
in Ada:
begin
null;
end;
in Java en C:
{
}
/* gewoon niets */
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 104
SGP controle
if-then-else
controle structuren:
structuren: if-then-else
in Ada:
if A /= 0 then
if B/A > 10 then
High := True;
else
High := False;
end if;
end if;
Yolande Berbers
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;
}
}
Systeem-geïntegreerde programmatuur
slide 105
SGP
controle structuren: if-then-else in Ada
controle structuren:
if-then-else in Ada
(vervolg)
if Number < 10 then
Num_Digits := 1;
elseif Number < 100 then
Num_Digits := 2;
elseif Number < 1000 then
Num_Digits := 3;
elseif Number < 10000 then
Num_Digits := 4;
else
Num_Digits := 5;
end if;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 106
SGP
controle
case
controle structuren:
structuren: case
in Ada:
in Java en C:
case Command is
when ‘A’ | ‘a’ => Action1;
when ‘t’
=> Action2;
when ‘e’
=> Action3;
when ‘x’ .. ‘z’
=> Action4;
when others
=> null;
end case;
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;
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 107
SGP
controle
while-lus
controle structuren:
structuren: while-lus
in Ada:
in Java en C:
while <Boolean Expression> loop
<Statements>
end loop;
while (<expression>) {
/* expressie = 0 eindigt lus */
<statement>
}
loop
...
exit when <Boolean Expression>
...
end loop;
Yolande Berbers
while (1) {
...
if (<expression>) break;
...
}
Systeem-geïntegreerde programmatuur
slide 108
SGP
controle structuren: for-lus en oneindige lus
in Ada:
in C:
for I in 0 .. 9 loop
A(I):= I;
end loop;
for (i = 0; i <= 9; i++) {
A[i] = i;
{
loop
<Statements>
end loop;
while (1) {
<statement>
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 109
SGP
parameters bij subprogrammas in
parameters bij subprogramma’s in Ada
Ada
drie modes:
in
out
in out
data wordt doorgegeven aan het subprogramma
data wordt doorgegeven aan het oproepende
programmaonderdeel
data wordt doorgegeven aan het subprogramma,
wordt daar eventueel gewijzigd en wordt dan weer
doorgegeven aan het oproepende programmaonderdeel
procedure Quadratic ( A, B, C : in Float;
R1, R2 : out Float;
Ok
: out Boolean);
bij functies mogen alleen ‘in’ parameters gebruikt worden
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 110
parameters bij
bij subprogrammas
subprogramma’s in
C
SGP parameters
in C
maar 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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 111
bij
subprogramma’s
in
Java
SGP parameters
parameters bij subprogrammas in C
primitieve 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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 112
SGP
procedures
inAda
Ada
procedures in
procedure 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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 113
SGP
procedures
inCC
procedures in
void 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);
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 114
SGP
procedures/functies
procedures in Cin Java
public 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;
}
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 115
SGP
functies
inAda
Ada
functies in
function Minimum (X, Y: in Integer) return Integer is
begin
if X > Y then
return Y;
else
return X;
end if;
end Minimum;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 116
SGP
functies
inCC
functies in
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));
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 117
SGP
Systeem-geïntegreerde Programmatuur
kort overzicht van Ada
(en C en Java):
programming in the large
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 118
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 119
SGP gegevensverberging: package in Ada

specificatie interface: deze entiteiten zijn zichtbaar er buiten
package Queuemod is
function Empty return Boolean;
procedure Insert (E: Element);
-- Element moet zichtbaar zijn
procedure Remove (E: out Element);
end Queuemod;

voorbeeld van oproep:

lichaam : dit is de implementatie, zie volgende slide
Yolande Berbers
Queuemod.Insert (El);
Systeem-geïntegreerde programmatuur
slide 120
SGP gegevensverberging:
gegevensverberging:
package
in Ada
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 121
SGP gegevensverberging: package in Ada

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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 122
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 123
SGP

gegevensverberging in C
header-bestand (.h bestand): dit bestand definieert de
functionele interface van de module
int Empty();
void insertE (element E);
void removeE (element *E);


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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 124
SGP
gegevensverberging
in C
gegevensverberging
in C (vervolg)
#include “queuemod.h”
struct ...
void create()
{ ... }
int empty()
{ ... }
void insertE (element E)
{ ... }
void removeE (element *E)
{ ... }
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 125
SGP
gegevensverberging in C
queuemod.h
int Empty();
void insertE (element E);
void removeE (element *E);
queuemod.c
#include “queuemod.h”
put_in.c
#include “queuemod.h”
take_out.c
#include “queuemod.h”
….
….
….
int empty()
{ ... }
void insertE (element E)
{ ... }
element E1, E2;
insertE(E1);
insertE(E2);
element E3;
if !empty()
removeE(&E3)
….
….
….
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 126
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 127
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 128
SGP
aparte compilatie in C
queuemod.h
int Empty();
void insertE (element E);
void removeE (element *E);
queuemod.c
#include “queuemod.h”
put_in.c
#include “queuemod.h”
take_out.c
#include “queuemod.h”
….
….
….
int empty()
{ ... }
void insertE (element E)
{ ... }
element E1, E2;
insertE(E1);
insertE(E2);
element E3;
if !empty()
removeE(&E3)
….
….
….
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 129
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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 130
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
Yolande Berbers

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)
Systeem-geïntegreerde programmatuur
slide 131
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 specificatieconsistentie en types
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 132
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 133
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)

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 134
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);
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 135
SGP abstracte
abstractegegevenstypes
gegevenstypesin
inAda
Ada
package 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;
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 136
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;
….
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 137
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 138
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
Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 139
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

Yolande Berbers
Systeem-geïntegreerde programmatuur
slide 140