Sie sind auf Seite 1von 24

Westflische Wilhelms-Universitt Mnster

Ausarbeitung

FORTRAN
im Rahmen des Seminars Programmiersprachen im Fachbereich Informatik am Lehrstuhl fr Praktische Informatik

Robert Moeck

Themensteller: Prof. Dr. Herbert Kuchen Betreuer: Prof. Dr. Herbert Kuchen Institut fr Wirtschaftsinformatik Praktische Informatik in der Wirtschaft

Inhaltsverzeichnis
1 2 3 Einfhrung ................................................................................................................. 1 Historische Entwicklung............................................................................................ 2 Ausgewhlte Features von Fortran ............................................................................ 4 3.1 3.2 3.3 3.4 3.5 3.6 3.6.1 3.6.2 3.6.3 3.7 4 5 6 A Grundlegende Struktur eines Fortran-Programms............................................ 4 Typkonzept ....................................................................................................... 6 Selbstdefinierte Ausdrcke ............................................................................... 7 Zeiger ................................................................................................................ 7 Felder ................................................................................................................ 8 Zuordnungen................................................................................................... 10 Zuordnung ber Namen .............................................................................. 10 Zuordnung ber Zeiger ............................................................................... 11 Zuordnung ber den Speicher..................................................................... 11 Ein- und Ausgabe............................................................................................ 12

Speicherverwaltung und dynamische Kontrolle ........................................................ 9

Formatierung ........................................................................................................... 13 Anwendungsgebiete von Fortran-Systemen ............................................................ 15 Parallele Programmierung...................................................................................... 15 Quick Sort................................................................................................................ 17 Zusammenfassung und Ausblick............................................................................. 19 Fortran 95-Quellcode fr Quick Sort (rekursiv) ...................................................... 20

Literaturverzeichnis ........................................................................................................ 22

II

1 Einfhrung
Die vorliegende Arbeit stellt die problemorientierte Programmiersprache Fortran vor. Als erste Hochsprache blickt Fortran auf eine Geschichte von rund 50 Jahren zurck und ist whrend dieser Zeit vielfach berarbeitet worden. Die Pioniere von Fortran haben zwar nicht die Idee erfunden, Programme in einer Hochsprache zu schreiben und den Quellcode zu kompilieren, aber sie haben die erste erfolgreiche Hochsprache entwickelt. Einen kurzen berblick ber die historische Entwicklung von Fortran gibt Kapitel 2. Darauf folgend werden in Kapitel 3 ausgewhlte Eigenschaften und Spezifikationen der Sprache nher beleuchtet. Dabei wird weniger auf allgemeine Eigenschaften, wie z.B. Datentypen oder Konstrukte, ber die nahezu alle Programmiersprachen verfgen, eingegangen. Vielmehr werden die Besonderheiten der Sprache Fortran hervorgehoben und erlutert. Im 4. Abschnitt werden die typischen Anwendungsgebiete von Fortran-Programmen dargestellt und Anstze zur parallelen Programmierung beleuchtet. Anschlieend wird die im Rahmen dieses Seminars programmierte Beispielanwendung Quick Sort vor- und der Implementierung in Java gegenbergestellt. Die Ausarbeitung wird mit einer kurzen Zusammenfassung und einem Ausblick in Kapitel 6 abgeschlossen.

Kapitel 2: Historische Entwicklung

2 Historische Entwicklung
FORTRAN I Mitte der 1950er-Jahre verfgten die Rechner ber uerst kleine Hauptspeicher in der Grenordnung von 15 KB, waren langsam und hatten, wenn berhaupt, sehr primitive Betriebssysteme. Assembler-Programmierung war gngige Praxis. Die geistigen Vter von Fortran (Fortran = FORmula TRANslation), ein IBMTeam unter der Leitung von John W. Backus, entwickelten 1957 nach dreijhriger Arbeit den FORTRAN-I-Compiler. Besonders im wissenschaftlichen und militrischen Bereich verbreitete sich die neue Sprache schnell die Vorteile lagen auf der Hand: Anwendungen, die zuvor Wochen fr ihre Berechnungen brauchten, lieen sich binnen weniger Stunden abarbeiten. Die Anforderungen an den Programmierer waren wesentlich geringer als es bei der Assembler-Programmierung der Fall war. Und die Programme wurden portabel! FORTRAN 66 Die Entwicklung ging (ber die Zwischenversionen FORTRAN II, III und IV) weiter, die Sprache erhielt weitere Features. Seit 1962 beschftigte sich die ASA (American Standards Association; der Vorlufer des ANSI, American National Standards Institute) mit der Entwicklung eines Standards fr die Fortran, was 1966 mit der gleichnamigen Version als erstem Hochsprachen-Standard abgeschlossen wurde. FORTRAN 77 Ein weiterer Meilenstein wurde im Jahre 1977 fertig gestellt und 1978 verffentlicht. Zunchst ein amerikanischer ANSI-Standard, wurde FORTRAN 77 kurz darauf auch von der ISO (International Standards Organization) zum Standard erhoben dieser galt somit weltweit. In dieser Neuauflage wurden viele wichtige Komponenten, wie z.B. Block-IF-Strukturen (IF THEN ELSE ENDIF), der Pre-Test von DOSchleifen (vorher musste man einen Umweg ber Sprungmarken nahmen, denn die Schleife wurde nur ein einziges Mal ausgefhrt) und der CHARACTER-Datentyp hinzugefgt. Fortran 90 und 95 Dass zwischen FORTRAN 77 und seinem Nachfolger ber zehn Jahre lagen, begnstigte, dass andere Programmiersprachen, wie C oder C++, sich in den von Fortran dominierten Anwendungsgebieten Naturwissenschaften und Ingenieurwesen wachsender Beliebtheit erfreuten. Nichtsdestoweniger hat diese spte berarbeitung des FORTRAN 77-Standards eine Menge mchtiger Erweiterungen eingefhrt. Als wichtigste Neuerungen seien erwhnt: Spaltenunabhngige Codierung (in allen vorherigen Versionen mussten diesbezglich strenge Konventionen 2

Kapitel 2: Historische Entwicklung eingehalten werden), weitere moderne Kontroll-Strukturen (CASE und DO WHILE), abgeleitete bzw. abstrakte Datentypen, Operator-berladung (die Erweiterung bzw. ReDefinition der Funktionalitt von Operatoren), dynamische Speicherverwaltung und Modularisierung. Genauer wird auf die Spezifikationen in Kapitel 3 eingegangen. Mit Fortran 90 wurde im Prinzip der heutige Stand der Technik erreicht die aktuelle Version, Fortran 95, fhrte weniger Neues ein, als dass sie die Fehler und Inkonsistenzen von Fortran 90 korrigierte. Mit den in Fortran 90 implementierten Features enthielt die Sprache die wichtigsten auch heute noch gebruchlichen Konstrukte und wurde wieder konkurrenzfhig. Hierbei spielt die Abwrtskompatibilitt eine besondere Rolle: Fortran 90 enthlt den vollen Funktionsumfang der Vorgngerversion, so dass auch die modernen Compiler den Code von vor ber 20 Jahren verarbeiten knnen.

Kapitel 3: Ausgewhlte Features von Fortran

3 Ausgewhlte Features von Fortran


Fortran ist eine imperative Programmiersprache. Ein imperatives Programm besteht aus Anweisungen (Instruktion, Befehl, statement). Es gibt Variablen, deren Wert sich durch Zuweisungen (assignments) ndern kann. Imperative Sprachen basieren i. a. auf dem Von-Neumann-Rechnermodell, d.h. Variablen bezeichnen Speicherpltze, Befehle richten sich an die CPU. Der Quellcode von Fortran-Programmen muss durch einen Compiler in semantisch quivalenten Maschinencode bersetzt werden.

3.1 Grundlegende Struktur eines Fortran-Programms


Ein Hauptprogramm wird durch die Anweisung PROGRAM eingeleitet und durch END
PROGRAM beendet. Dazwischen befinden sich weitere Anweisungen, Funktions- oder

Subroutinendefinitionen, oder Modul-Spezifikationen. Ein einfaches Beispiel:


PROGRAM hallo_welt CALL hallo END PROGRAM hallo_welt SUBROUTINE hallo PRINT *, Hallo Welt! END SUBROUTINE hallo !Hauptprogramm !Aufruf einer Subroutine !Ende des Hauptprogramms !Definition der Subroutine !Ausgabe von Hallo Welt! !Ende der Subroutine

Programmeinheiten sind Hauptprogramm, externe Unterprogramme (Funktionen oder Subroutinen), block data-Unterprogramme und Module. Mit dem Hauptprogramm startet die Ausfhrung eines Programms. Das Hauptprogramm darf (ebenso wie externe Unterprogramme und Modul-Unterprogramme) hinter der Anweisung CONTAINS interne Unterprogramme enthalten. Durch die geschachtelten Aufrufe von

(Unter-)Programmen entsteht eine hierarchische Struktur von Programmeinheiten. Eine Baumstruktur ist aber nicht berall streng eingehalten, weil ein Unterprogramm von vielen Seiten aufgerufen werden kann, und weil es Rekursion gibt. Funktionen und Subroutinen knnen extern als eigenstndige Programmeinheiten, oder intern als Teile anderer Programmeinheiten definiert sein. Funktionen werden im aufrufenden Programm in Ausdrcken benutzt. Subroutinen werden mit CALL aufgerufen. Die Rekursion wird in Fortran untersttzt. Entsprechende Funktionen oder Subroutinen mssen mit dem Schlsselwort RECURSIVE gekennzeichnet werden. Eine

Kapitel 3: Ausgewhlte Features von Fortran Blockdatenprogrammeinheit ist eine nichtausfhrbare Programmeinheit, mit deren Hilfe Variablen benannter gemeinsamer Speicherbereiche initialisiert werden knnen. Ein Modul (seit Fortran 90) ist eine nichtausfhrbare Programmeinheit, die beliebige Typvereinbarungen, Schnittstellendefinitionen Modulkomponenten Spezifikationen, enthalten darf. Es wobei Unterprogramme knnen die sichtbare sichtbaren und von und/oder private anderen

definiert

werden,

Programmeinheiten genutzt werden knnen [Ge91]. Beispiel:


MODULE testmodul PUBLIC :: hochdrei CONTAINS SUBROUTINE hochdrei(zahl) INTEGER :: ergebnis ergebnis = zahl * zahl * zahl END SUBROUTINE hochdrei END MODULE testmodul PROGRAM haupt USE testmodul CALL hochdrei(5) END PROGRAM haupt !Modul mit !explizit sichtbar !deklarierter !Subroutine, die !ergebnis als Rck!gabewert hat.

!Hauptprogramm, das das Testmodul !inkl. ffentlicher Subroutine !hochdrei nutzt und !5 hoch 3 ausrechnet.

Komplexe Probleme lassen sich mit Hilfe von Unterprogrammen in Teilprobleme aufspalten. Jedes Teilproblem wird dabei in ein berschaubares Unterprogramm ausgelagert. Das ist fr die Menschen, die das Gesamtprogramm entwickeln und warten, leichter zu berblicken und auf mehrere Mitarbeiter zu verteilen als ein ungegliedertes Groprogramm. Darber hinaus knnen Compiler kleinere Einheiten oft besser optimieren als groe. Sie setzen Register und andere Schnellspeicher geschickter ein. Allerdings kostet der Aufruf von Unterprogrammen auch etwas Zeit, so dass die Unterprogramme nicht zu wenig beinhalten sollten. Hinsichtlich der

Wiederverwendbarkeit von Programmcode spielt die Modularisierung einer komplexen Anwendung eine groe Rolle: Unterprogramme knnen in UnterprogrammBibliotheken abgelegt und von mehreren Programmen aus benutzt werden (z.B. mathematische und statistische Verfahren, Algorithmen zum Suchen und Sortieren, Graphik- und GUI-Programmpakete). Auch knnen Debugging-Strategien leichter genutzt werden, denn die Unterprogramme knnen einzeln auf Korrektheit untersucht werden. Natrlich fhrt die Benutzung von Unterprogrammen zu einer Reduzierung des gesamten Quellprogramms und auch des entstehenden Maschinenprogrammcodes, wenn die Unterprogramme mehrfach aufgerufen werden [Gr99].

Kapitel 3: Ausgewhlte Features von Fortran

3.2 Typkonzept
Fortran benutzt eine statische Typbindung, d.h. der Quellcode legt die Datentypen der existierenden Gren fest. Damit wird die Typbindung und -prfung zur bersetzungszeit vorgenommen. Fortran ist nicht streng typisiert. In Fortran mssen nicht alle Variabeln deklariert werden, aber es ist sehr zu empfehlen. Die grundstzliche Typkonvention ist: Wird ein Name verwendet, der nicht explizit deklariert ist, nimmt der Compiler entsprechend den Anfangsbuchstaben implizit einen der Grundtypen an, und zwar bei i, j, k, l, m, n per Voreinstellung den Typ integer, sonst real [Gr99]. Mit der IMPLICIT-Anweisung knnen zu diesem Zweck Buchstaben(bereiche) bestimmt werden, so dass Variablen, die mit entsprechenden Buchstaben beginnen, automatisch vom festgelegten Datentyp sind. Zwar erspart sich der Programmierer damit die explizite Deklaration, also einige Schreibarbeit, aber damit werden Schreibfehler in Variablennamen evtl. erst in der Testphase erkannt. Beispiel:
IMPLICIT TYPE(student) (s), TYPE(dozent) (d) !Alle Variablen, die mit S beginnen, sind vom Typ student, !Alle Variablen, die mit d beginnen, sind vom Typ dozent.

Mit der Anweisung IMPLICIT NONE wird die Typkonvention auer Kraft gesetzt, d.h. fr jede Variable ist eine explizite Typvereinbarung erforderlich. Zustzlich zu den vordefinierten Datentypen knnen bei Bedarf weitere Typen in Fortran abgeleitet werden, d.h. mit Hilfe der existierenden Typen knnen neue Datentypen definiert werden. Ein solcher selbstdefinierter Datentyp hat mindestens eine Komponente, wobei jede Komponente wiederum einen vordefinierten oder

selbstdefinierten Datentyp spezifiziert. Beispiel:


TYPE wohnort CHARACTER (LEN=20) :: strasse INTEGER :: hausnr INTEGER :: plz CHARACTER (LEN=20) :: stadt END TYPE wohnort TYPE student CHARACTER (LEN=20) :: name INTEGER :: matr_nr TYPE (wohnort) :: adresse END TYPE student !Datentyp wohnort, der !ausschlielich aus !vordefinierten Typen !besteht.

!Datentyp student, der !eine Strukturkomponente !vom Typ wohnort hat !bitte wenden

Kapitel 3: Ausgewhlte Features von Fortran


TYPE (student), DIMENSION(150) :: ein_student !Ein Feld mit 150 Studenten PRINT *, ein_student(42)%matr_nr !Ausgabe der Matr.-Nr. von Student Nr. 42

Speicherfolge. Normalerweise ist durch die Reihenfolge der Typkomponenten keine Speicherfolge gegeben. Wenn die Typdefinition jedoch eine SEQUENCE-Anweisung enthlt, dann spezifiziert die Reihenfolge der Typkomponenten eine Speicherfolge fr Gren dieses Typs. Weiterhin wird durch SEQUENCE bewirkt, dass Gren dieses Typs mit bestimmten Einschrnkungen in COMMON- und EQUIVALENCE-Anweisungen (Kap. 3.7.3) spezifiziert werden drfen [Ge91]. Sichtbarkeit. Eine Typ- oder Komponentendefinition ist privat, wenn sie grundstzlich nur innerhalb des Moduls zugnglich ist, das die Typdefinition enthlt (PRIVATEAttribut). Eine sichtbare Typ- oder Komponentendefinition (PUBLIC-Attribut) kann mit Hilfe von USE auch auerhalb ihres Moduls zugnglich und nutzbar gemacht werden.

3.3 Selbstdefinierte Ausdrcke


Ein selbstdefinierter Ausdruck besteht aus Operanden selbstdefinierten und/oder vordefinierten Typs und selbstdefinierten und/oder erweiterten vordefinierten Operatoren [Ge91]. berladung. Die Funktionalitt sowohl vordefinierter, als auch selbstdefinierter Operatoren kann durch die Definition von mehr als einer Operatorfunktion erweitert werden. Man spricht von berladung. Wichtig ist dann die Eindeutigkeit der spezifizierten Operatorfunktionen, d.h. je zwei Operatorfunktionen mssen jeweils mindestens einen Formalparameter gleicher Position haben, die sich hinsichtlich Typ, Typparameter oder Rang unterscheiden. Bei Ausfhrung eines berladenen Operators bestimmen die Eigenschaften der Operanden, welche Operatorfunktion (implizit) aufgerufen wird [Ge91].

3.4 Zeiger
Zeiger ist in Fortran kein spezieller Datentyp, sondern ein Attribut, das fr Variablen oder selbstdefinierte Funktionen beliebigen Datentyps spezifiziert werden kann. Eine Variable oder eine Funktion mit POINTER-Attribut ist ein Zeiger. Dieser belegt eine unspezifische Speichereinheit. Ein Zeiger kann erst dann definiert und benutzt werden, 7

Kapitel 3: Ausgewhlte Features von Fortran wenn er einem Ziel zugeordnet (mittels ALLOCATE) ist erst dann kann man ihn wie eine normale Variable behandeln, d.h. jeder Zugriff auf den Zeiger entspricht einem Zugriff auf das zugeordnete Ziel. Der Wert eines Zeigers ist also ein Verweis auf eine andere Datengre desselben Typs wie der Zeiger, d.h. ein Zeiger ist typgebunden. Es gibt keine Zeigerkonstante, keinen NIL-Zeiger und auch kein Zeigerfeld, dessen Elemente Zeiger sind. Adressarithmetik ist in Fortran nicht mglich. Das Dereferenzieren erfolgt automatisch [Ge91]. Jedes Ziel, auf das ein Zeiger weisen soll, muss ein TARGET-Attribut haben, auer bei dem Ziel handelt es sich selbst um einen Zeiger. Dies dient lediglich der Verbesserung der Laufzeit-Effizienz des Fortran-Programms. Der Zuordnungsstatus eines Zeigers ist entweder undefiniert (z.B. zu Beginn der Ausfhrung eines Programms), zugeordnet oder nicht zugeordnet. Mittels
ALLOCATE wird ein Zeiger einem (anderen) Ziel zugeordnet. Durch NULLIFY oder DEALLOCATE wird die Zuordnung aufgehoben. Der Zuordnungsstatus eines Zeigers

darf bei Ausfhrung eines Unterprogramms gendert werden. Ist die Ausfhrung des Unterprogramms beendet, bleibt der Zuordnungsstatus bestehen (auer das Ziel wird beim Rcksprung in das aufrufende Programm undefiniert).

3.5 Felder
Ein Feld (array) ist in Fortran eine regelmige Anordnung von skalaren Datenelementen mit gleichem Typ und Typparameter in Zeilen, Spalten, Ebenen, Kuben (Quadern) usw. (Vektoren, Matrizen, ...). Das einzelne Element ist durch ein Index-Tupel bestimmt. Ein Feld darf bis zu 7 Dimensionen haben, jede Dimension mit 0 oder mehr Elementen. Aufgrund der Feldspezifikation wird neben dem Rang des Feldes (= Anzahl der Dimensionen) auch dessen Gestalt bestimmt, wobei die folgenden drei Arten unterschieden werden: Felder mit expliziter Gestalt: Die Index-Grenzen werden fr jede Dimension explizit festgelegt, d.h. die Obergrenze muss, die Untergrenze kann fr jede Dimension bestimmt werden (falls die Untergrenze fehlt, wird sie gleich 1 gesetzt).

Kapitel 3: Ausgewhlte Features von Fortran Felder mit bernommener Gestalt: Die Gestalt wird vom zugeordneten Aktualparameterfeld bernommen. Die Gre eines solchen Feldes ist gleich der Gre der entsprechenden Dimension des zugeordneten Aktualparameterfeldes. Felder mit bernommener Gre: Die Gre eines solchen Feldes wird durch die Gre des zugeordneten Aktualparameterfeldes bestimmt. Im Gegensatz zur vorgenannten Feldart drfen sich die zugeordneten Felder hinsichtlich Rang und Gre der Dimensionen unterscheiden.

Speicherverwaltung und dynamische Kontrolle


Ohne Benutzerintervention verluft die Speicherzuordnung dynamisch. In einigen Fllen ist es dennoch sinnvoll, Einfluss auf die Speicherverwaltung zunehmen, z.B. wenn man sicherstellen mchte, dass lokale Variablen eines Unterprogramms nach dem Rcksprung in das aufrufende Programm ihren Definitionsstatus behalten, oder wenn in einem Unterprogramm ein Feld bentigt wird, dessen Gestalt von einer oder mehreren Variablen abhngen soll, oder wenn man nur fr bestimmte Zeit ein lokales Feld bentigt, wobei die Gestalt dieses Feldes erst nach einigen Berechnungen dynamisch festgelegt werden kann. Im ersten Fall kann man COMMON-, DATA- oder SAVEAnweisungen verwenden, bzw. die entsprechenden Variablen gleich bei Initialisierung mit dem SAVE-Attribut versehen. Im zweiten Fall ist ein automatisches Feld sinnvoll, im dritten Fall bieten sich dynamische Felder oder Feldzeiger an. Ein automatisches Feld wird beim Aufruf des Unterprogramms erzeugt. Dabei wird der Speicherplatz fr das jeweilige automatische Feld zugeteilt. Beim Rcksprung in das aufrufende Unterprogramm wird das Feld wieder gelscht, d.h. der Speicherplatz automatisch wieder freigegeben. Ein dynamisches Feld wird im Spezifikationsteil eines (Unter-)Programms deklariert. Dabei wird auf Indexgrenzen verzichtet, statt dessen wird dieses dynamische Feld mit einem ALLOCATABLE-Attribut ausgestattet. Es existiert so lange noch nicht, bis im Verlauf der Ausfhrung einer Programmeinheit feststeht, welche Gestalt das Feld haben soll. Dann wird mit Hilfe der ALLOCATE-Anweisung die explizite Gestalt des Feldes spezifiziert und der Speicherplatz angefordert, d.h. das Feld wird dynamisch erzeugt. Es existiert so lange, bis es mit der DEALLOCATE-Anweisung wieder gelscht, der Speicherplatz also freigegeben wird. Wird ein dynamisches Feld vor dem Rcksprung 9

Kapitel 3: Ausgewhlte Features von Fortran aus seiner Programmeinheit in die aufrufende Programmeinheit nicht gelscht, ist der Existenzstatus undefiniert. Feldzeiger. Wie bei dynamischen Feldern, sind fr einen Feldzeiger keine Indexgrenzen spezifiziert. Die Deklaration des Feldzeigers wird aber auch im Spezifikationsteil eines (Unter-)Programms vorgenommen, wobei die Kennzeichnung als Feldzeiger ber das
POINTER-Attribut geschieht. Erst bei Ausfhrung seines (Unter-)Programms werden

die Indexgrenzen, d.h. die Gestalt des Feldes, festgelegt und der entsprechende Speicher angefordert. Die Erzeugung eines Zielfeldes wird durch eine ALLOCATE-Anweisung erreicht. Solange diese nicht erfolgt, der Zeiger also nicht zugeordnet ist, ist die Gestalt des Feldzeigers undefiniert.

3.6 Zuordnungen
Die Programmeinheiten sollen natrlich nur in den seltensten Fllen allein fr sich, d.h. ohne Kommunikation miteinander, ablaufen. Datenobjekte, Unterprogrammnamen und andere Objekte werden zwischen den Programmeinheiten weitergereicht. Dabei gibt es in Fortran folgende Mglichkeiten:

3.6.1 Zuordnung ber Namen


Unter Parameterzuordnung versteht man die Weitergabe von Datenobjekten und externer Unterprogrammnamen mittels aktueller und formaler Parameter. Die in einer Funktions-Deklaration eingefhrten Argumente werden als Formalparameter

bezeichnet. Die vom aufrufenden Programm bergebenen Werte nennt man Aktualparameter. Zu jedem Aktualparameter muss ein Formalparameter existieren, und Aktual- und Formalparameter mssen hinsichtlich ihres Typs bereinstimmen. Die Parameterbergabe erfolgt bei Fortran ber Adressen, Aktualparameter und Formalparameter sind also identisch, ohne Kopie. Bei Konstanten und Ausdrcken wird eine Hilfsvariable bergeben (nur in Eingaberichtung), wenn eine

berschreibungsgefahr besteht. Umgebungszuordnung (host association). Ein Unterprogramm ist in eine grere Programmeinheit eingebettet und kennt alle (bzw. viele) Daten dieser Umgebung. Lokale Gren berschreiben dabei allerdings die Gren, die aus der Umgebung bernommen wurden. 10

Kapitel 3: Ausgewhlte Features von Fortran


USE-Zuordnung. Gemeinsam genutzte Objekte werden in Modulen angeordnet. Die

Deklarationen im Modul-Spezifikationsteil und die expliziten Schnittstellen zu den Modul-Unterprogrammen knnen anderen Geltungseinheiten mit Hilfe der USEAnweisung zur Compilezeit zugnglich gemacht werden (abhngige Compilation).

3.6.2 Zuordnung ber Zeiger


Durch Zeigerzuordnung werden ein Zeiger und sein Ziel einander so zugeordnet, dass das Ziel benutzt oder definiert werden kann, indem man dazu auf den Zeiger (und nicht auf das Ziel) Bezug nimmt. Ein Zeiger kann bei Bedarf einem anderen Ziel zugeordnet werden, und die Zuordnung kann auch jederzeit aufgehoben werden. Ein Zeiger ist zu einem bestimmten Zeitpunkt immer nur hchstens einem Ziel zugeordnet. Umgekehrt kann ein Ziel jederzeit mehreren Zeigern zugeordnet sein (vgl. Kap. 3.4).

3.6.3 Zuordnung ber den Speicher


Datenobjekte sind ber den Speicher einander zugeordnet, wenn sich ihre Speicherfolgen mindestens eine gemeinsame Speichereinheit teilen, oder wenn ihre Speichereinheiten unmittelbar aufeinander folgen. Wenn zwei Speicherfolgen eine bestimmte Speichereinheit gemeinsam belegen, dann sind (soweit die Lngen der jeweiligen Speicherfolgen das zulassen) auch die jeweils davor liegenden

Speichereinheiten einander zugeordnet. Entsprechendes gilt auch fr die jeweils nachfolgenden Speichereinheiten der beiden Speicherfolgen.
COMMON-Blcke. Jeder gemeinsam genutzte Speicherbereich hat eine Speicherfolge, die

aus den Speicherfolgen aller Variablen besteht, die sich in ihm befinden. COMMONBlcke dienen dem Austausch von Variablen (nicht Formalparameter oder Funktionsresultate) zwischen Programmeinheiten. Im Grunde ist ein COMMON-Block ein Stck Hauptspeicher, das jedes Teilprogramm, falls erforderlich, mitbenutzen darf, die gemeinsamen Speicherblcke sind also global. Die Reihenfolge der einzelnen Speicherfolgen ist durch die Reihenfolge der entsprechenden Variablen gegeben. Die COMMON-Anweisung steht in jedem Teilprogramm, das auf den gemeinsamen Speicherraum zugreift: COMMON [/[CNAME]/] VARIABLE[,VARIABLE]... Es gibt einen blanc common (ohne CNAME-Attribut) und bei Bedarf viele named common mit eindeutigen Bezeichnern (CNAMEs). Die Variablen im blanc common knnen im Gegensatz zu denen im named common nicht initialisiert werden. Die Lebensdauer 11

Kapitel 3: Ausgewhlte Features von Fortran des blanc common ist damit so lang wie die des Hauptprogramms. Dagegen wird der Speicherplatz eines nicht mit SAVE gesicherten named common fr andere Benutzung freigegeben, wenn keines der Teilprogramme mehr aktiv ist, das auf ihn referenziert. Diese Art der Speichernutzung ist allerdings ein Relikt aus den lteren Fortran-Zeiten und fehleranfllig bzw. wenig berschaubar. Fortran 90-Programme sollten ber Module als die bessere Alternative implementiert werden.
EQUIVALENCE. ber die EQUIVALENCE-Anweisung werden zwei oder mehr Gren

einer Programmeinheit einander zugeordnet, indem sie auf dieselbe Speicherfolge verweisen. So kann dieselbe Information durch verschiedene Namen referenziert werden. Die EQUIVALENCE-Anweisung fhrt allerdings keine Typkonversionen durch und impliziert auch keine quivalenz im mathematischen Sinn, sondern assoziiert lediglich Speichereinheiten. Die folgende Abbildung verdeutlicht die Art der Zuordnung von bspw. zwei Feldern.
DIMENSION M(3,2),P(6) !zweidimensionales Feld M mit 6 !Elementen, und eindimensionales !Feld P mit 6 Elementen !Assoziiert M und P

EQUIVALENCE (M(2,1),P(1))

M(1,1) M(2,1) M(3,1) M(1,2) M(2,2) M(3,2)

P(1)

P(2)

P(3)

P(4)

P(5)

P(6)

Abb. 3.1: Assoziation zweier Felder mit EQUIVALENCE

Durch das quivalent-Setzen wird der gemeinsame Speicher bereich u. U. nach hinten erweitert. Gemeinsame Speicherbereiche drfen jedoch nie nach vorn erweitert werden.

3.7 Ein- und Ausgabe


Der Grundbaustein des Fortran-Dateisystems ist der Datensatz, d.h. eine Folge von Werten bzw. Zeichen (z.B. eine Zeile auf dem Bildschirm oder in einer Datei) mit fester Lnge. Es wird zwischen formatgebundenen (listengesteuerten) und formatfreien Datenstzen unterschieden, was Einfluss auf die auszufhrenden E/A-Anweisungen hat formatgebundene Datenstze knnen nur mit formatgebundenen Anweisungen (d.h. unter Verwendung des FMT-Attributs) bearbeitet werden, analog verhlt es sich bei

12

Kapitel 3: Ausgewhlte Features von Fortran formatfreien Datenstzen. Eine dritte Art von Datenstzen ist der Dateiendesatz (ENDFILE) [Ge91]. Als Datei wird die Folge zusammengehrender Datenstze bezeichnet. Sie kann auf externen Medien abgelegt sein, oder intern als Arbeitsspeicherbereich existieren. Es gibt zwei Zugriffsmethoden: Bei sequenzieller Verarbeitung ist durch die Reihenfolge, in der die Datenstze in die Datei geschrieben werden, auch die Reihenfolge vorgegeben, in der die Datenstze wieder gelesen werden knnen, d.h. der n-te Datensatz kann erst nach dem Lesen der (n 1) vorherigen Datenstze gelesen werden. Wenn eine externe Datei fr den direkten Zugriff geffnet ist, dann knnen Datenstze unabhngig von der Reihenfolge der Datensatznummern geschrieben werden. Die Datensatznummer wird intern vom Speichermedium verwaltet die Adresse eines Datensatzes auf dem Speichermedium kann als Produkt der Datensatznummer und der (festen) Lnge eines Datensatzes berechnet werden. Als Ein- und Ausgabeanweisungen sehen zur Verfgung:
READ WRITE PRINT

Datenbertragung

OPEN CLOSE INQUIRE

Dateistatus

BACKSPACE ENDFILE REWIND

Positionierung

OPEN (11, FILE=x, ACCESS=DIRECT, FORM=FORMATTED, RECL=80)

ffnet bspw. eine Datei x formatgebunden mit direktem Zugriff und einer Datensatzlnge von 80 Zeichen und verbindet diese mit der E/A-Einheit 11. Als weitere sinnvolle Parameter lassen sich Anweisungsmarken angeben, zu denen gesprungen wird, wenn z.B. ein Fehler auftritt (ERR=20) oder das Dateiende erreicht ist (END=30). Die Funktion INQUIRE dient der Abfrage des Zustands von Dateien und auch Ein- und Ausgabeeinheiten. Ausschlielich fr sequenzielle Dateien existieren die drei Positionierungs-Anweisungen BACKSPACE (= Zurcksetzen der Datei um einen Datensatz), REWIND (= Rcksetzen an den Dateianfang) und ENDFILE (= Ende der Datei).

Formatierung
Die Anweisung FORMAT legt in umfangreicher Weise die Formatierung sowohl eingelesener, als auch auszugebender Daten fest. Alle verfgbaren

Formatspezifikationen an dieser Stelle aufzuzhlen, wrde den Rahmen dieser Arbeit sprengen. Abgesehen davon erscheint die Formulierung der Format-Attribute auf den ersten Blick recht kryptisch. Festhalten lsst sich, dass beim Einlesen die Daten in eine 13

Kapitel 3: Ausgewhlte Features von Fortran interne Binrdarstellung konvertiert werden, bei der Ausgabe werden sie aus ihrer internen binren Darstellung entsprechend der FORMAT-Anweisung in Zeichenreihen umgewandelt [Ge91]. Formatgebundene Stze enthalten die Daten in

Zeichendarstellung, so gut wie immer in menschenlesbarer Form. Allerdings kostet die Umwandlung von der internen Darstellung in die formatierte Darstellung und umgekehrt ihre Zeit. Bei formatfreier bertragung wird die interne Darstellung des benutzten Rechners nicht umgewandelt. Vorteil ist also die Schnelligkeit und Genauigkeit der Abspeicherung. Auch der Platzbedarf ist z. T. erheblich geringer: eine Double-Zahl von 8 Byte interner Darstellung braucht z.B. zur fehlerfreien Wiedergabe ein FORMAT es24.17, also dreimal soviel Platz. Dienen daher die Daten doch wieder nur zur Computerverarbeitung, ist die formatfreie Art vorzuziehen. Ein Problem ergibt sich aufgrund der Umwandlung zwischen den internen Zahlendarstellungen vieler Rechner, wenn formatfreie Dateien zwischen Rechnern mit unterschiedlichen Zahlendarstellungen ausgetauscht werden sollen [Gr99]. Praktischerweise kann eine Formatspezifikation auch mit einer Anweisungsmarke versehen werden, so dass sie immer wieder genutzt werden kann. Eine ausfhrliche Beschreibung aller Formatspezifikationen geben [Ge91] oder auch [UH84].

14

Kapitel 4: Anwendungsgebiete von Fortran-Systemen

4 Anwendungsgebiete von Fortran-Systemen


Die Programmiersprache Fortran wird bevorzugt zur analytischen und numerischen Berechnung natur- und ingenieurwissenschaftlicher Probleme benutzt. Wesentlich sind hohe Ausfhrungsgeschwindigkeit und gute Lesbarkeit auch fr Nicht-Profis. Fortran ist die lteste hhere Programmiersprache, steht aber zu Unrecht in dem Ruf, veraltet zu sein. Die Ursachen fr das berleben sind recht nahe liegend: ein groer Nutzerkreis und die Menge an fertigen und laufenden Programmen fr nahezu alle wissenschaftlichen Problemkreise existieren umfangreichste Bibliotheken, die auch heute noch unentbehrlich sind.

Parallele Programmierung
Hierbei ist das Umdenken von sequenzieller zu paralleler Bearbeitung eines Problems entscheidend. Es stehen sich SIMD (Single Instruction Multiple Data)- und MIMD (Multiple Instruction Multiple Data)-Anstze gegenber. SIMD bedeutet, dass eine (einzige) Operation auf mehrere Datenbereiche angewendet wird. Eine Sprache mit MIMD-Features erlaubt es, simultan unterschiedliche Funktionen oder Subroutinen auf verschiedenen Datenbereichen operieren zu lassen. Die hohe Effizienz von Fortran legt nahe, dass es sich fr die Parallelisierung eignet, und es gibt eine Reihe von Forschungsprojekten, die Fortran z.B. fr die Simulation komplexer Systeme einsetzen. Fortran 90 selber hat allerdings wenige bis gar keine MIMD-Konstruktionen [PTVF96]. Fortran 95 als Weiterentwicklung von Fortran 90 bietet durch forall- und PUREKonstrukte bessere Mglichkeiten, MIMD-Features zu nutzen [PTVF96]. In einer anderen Weiterentwicklung von Fortran 90, der Programmiersprache High Performance Fortran (HPF) fr die datenparallele Programmierung sind MIMD-Features gezielt implementiert. Sie hat eine Reihe industrieller Anwendungen ermglicht, zu denen u. a. Deformationsberechnungen von Automobilteilen, Strmungssimulation von

Flugzeugteilen, Staudammberechnungen, die Berechnung elektromagnetischer Felder, umfangreiche Wetterprognosen und viele weitere gehren [PTVF96]. OpenMP (Open Multi Processing) ist eine Sammlung von Compiler-Direktiven, Bibliotheksroutinen und Umgebungsvariablen, die Parallelisierung durch gemeinsame Speichernutzung in Fortran- und C/C++-Programmen untersttzt. Die Parallelisierung luft zum Groteil ber parallele Schleifen ab. Dabei wird nach dem Fork-Join-Prinzip 15

Kapitel 4: Anwendungsgebiete von Fortran-Systemen gearbeitet, d.h. das Problem wird in parallelen Bereichen auf mehrere CPUs verteilt, die einzelnen Ergebnisse an der nchsten seriellen Stelle wieder zu einem gemeinsamen Ergebnis zusammengefhrt:
Serieller Bereich 0 Master Thread

Paralleler Bereich

Team of Threads

Serieller Bereich

Master Thread

Paralleler Bereich

Team of Threads

Serieller Bereich

Master Thread

Abb. 4.1: Fork-Join-Prinzip (Quelle: [UH03])

16

Kapitel 5: Quick Sort

5 Quick Sort
In Anlehnung an den Pseudo-Code, der in [OW96] vorgestellt wird, ist es recht einfach, den Quick Sort-Algorithmus in Fortran zu implementieren. Als Entwicklungsumgebung wurde Compaq Visual Fortran 6.6 Professional eingesetzt, eine Anwendung mit groem Funktionsumfang, um auch grere Fortran-Projekte zu verwalten und zu debuggen. Es wurde ein Fortran 90-Compiler verwendet. Ausgefhrt wurde das fertige Programm auf einem Intel Celeron II mit 433 MHz und 256 MByte Arbeitsspeicher. Die Struktur des Proramms gliedert sich zunchst in ein Modul qsort_modul und das Hauptprogramm Quick_Sort. Das qsort_modul enthlt wiederum zwei ffentliche und eine private Subroutine: Die private Subroutine partition sorgt fr das Weiterbewegen der Zeiger, den paarweisen Elementevergleich des zu testenden Arrays und das Vertauschen der Elemente, falls erforderlich. Aufgerufen wird partition von der ffentlichen Subroutine qsort_sub, die rekursiv auf alle Teilbereiche des bergebenen Arrays angewendet wird, solange deren Lnge grer Null ist. Die dritte Subroutine zufall startet einen Zufallsgenerator, der das bergebene Array mit Werten fllt. Eingabeparameter ist die Lnge, die im Hauptprogramm bestimmt wird, Rckgabewert ist das fertig gefllte Array. Hierfr wurde eine von Fortran vordefinierte Subroutine random_number zur Erzeugung einer Pseudozufallszahl verwendet, die in einer DO-Schleife so oft ausgefhrt wurde wie das Array Elemente hat. Damit ist das Modul qsort_modul zu Ende. Es folgt das Hauptprogramm
Quick_Sort, in dem zunchst die Subroutinen des vorgenannten Moduls mittels USE qsort_modul eingebunden werden. Anschlieend folgt der Spezifikationsteil, in dem

alle spter verwendeten Variablen deklariert werden. Hier besteht in der Variable
laenge die Mglichkeit, die Gre des zu sortierenden Arrays festzulegen. Dieses wird

sogleich durch Aufruf der zufall-Subroutine mit entsprechenden Werten gefllt. Um die Performance des Sortiervorgangs zu messen, wird die Zeit anhand eines auf der Uhr des Rechners basierenden Funktion gemessen. Diese wird erst initialisiert (auf Null gesetzt), wobei der Parameter count_rate spezifiziert, wie oft pro Sekunde der Wert hochgezhlt werden soll (im vorliegenden Fall von count_rate=1000 werden also Millisekunden gezhlt). Anschlieend wird der Zhlvorgang gestartet und der Startzeitpunkt in der Variablen startzeit gespeichert. Dann folgt der Aufruf der Subroutine qsort_sub, d.h. das Array wird sortiert. Zuletzt wird wiederum die Zeit 17

Kapitel 5: Quick Sort gemessen und die Differenz gebildet. So kann schlielich die aufgewendete Zeit auf dem Bildschirm ausgegeben werden. Der vollstndige Quellcode kann Anhang A entnommen werden. Fr den Vergleich mit Java ist die von [Ku03] erstellte Klasse verwendet und um einen Zufallsgenerator und die Zeitmessung erweitert worden. Der Zufallsgenerator und das sukzessive Fllen des Testarrays mit Zahlen lsst sich ber Random() und eine Schleife realisieren:
Random r = new Random(); int[] a = new int[5000000]; for (int i = 0; i < a.length-1; i++) a[i] = r.nextInt(); Die Zeitmessung wurde mittels System.currentTimeMillis() bewerkstelligt, was

wie in der zuvor besprochenen Fortran-Version vor und nach dem Sortieren ausgefhrt wird, wobei dann die Differenz den Zeitaufwand zeigt. Um den Algorithmus in Java zu testen, wurde die Entwicklungsumgebung Eclipse 2.1.3 verwendet. Die Ergebnisse beider Sprachen knnen der folgenden Tabelle entnommen werden: Array-Gre 100 1.000 10.000 20.000 50.000 100.000 250.000 500.000 1.000.000 2.000.000 5.000.000 Ausfrungszeit [Sek] in Fortran < 0,01 0,013 0,042 0,097 0,231 0,511 1,352 2,841 6,399 12,478 33,899 Ausfhrungszeit [Sek] in Java 0,010 0,020 0,020 0,081 0,150 0,271 0,762 1,732 3,695 7,490 18,266

Tab. 5.1: Dauer der Ausfhrung von Quick Sort auf einem Intel Celeron II mit 433 MHz und 256 MB Arbeitsspeicher

Es wird deutlich, dass obwohl auch die in Fortran realisierte Version vergleichsweise gute Werte erzielt Java eindeutig effizienter arbeitet. Auch der Quellcode ist in Java um einiges schlanker. Den ca. 70 reinen Lines of Code in Fortran stehen in Java lediglich ca. 25 Zeilen gegenber. 18

Kapitel 6: Zusammenfassung und Ausblick

6 Zusammenfassung und Ausblick


Man knnte Fortran (kurz fr formula translation), die ursprngliche High LevelProgrammiersprache, fr das Hightech-quivalent zur Keilschrift halten immerhin ist es mittlerweile 47 Jahre her, dass IBM sie eingefhrt hat. Doch sie wird immer noch breit eingesetzt, vor allem im wissenschaftlichen Bereich. Warum hat dieser Veteran aus der Eisenhower-ra so viele Hardware- und Softwaregenerationen berlebt? Teilweise ist es die Lernkurve, sagt Hans Boehm von den Hewlett-Packard Laboratories, frherer Vorsitzender der Programmiersprachen-Gruppe in der

Association for Computing Research. Fr einige Leute ist sie gut genug, und es ist schwierig, etwas aufzugeben, was man einmal gelernt hat. Die Anpassbarkeit und Kompatibilitt, die Fortran zur Lingua Franca des Programmierens in den 60er und 70er Jahren gemacht hat, spielen ebenfalls eine Rolle fr ihre Langlebigkeit. Grere Upgrades haben ihre Effizienz verbessert und neue Features gebracht, dabei aber die lteren Versionen intakt gelassen. Also funktioniert eine riesige Menge von erprobten Fortran 77-Programmen noch mit dem gegenwrtigen Fortran 90. So macht man das, Microsoft! [Sc04] Die anderen Technologien waren brigens: Analoguhren, Nadeldrucker,

Schreibmaschinen, Hrfunk, Pager, Tonbnder, Vakuumrhren, Faxgerte und Mainframe-Computer. Aufgrund der Tatsache, dass in der neusten Fortran-Version auch bereits objektorientierte Konzepte integriert worden sind, und aufgrund der bekannten Vorteile, die die Sprache schon ber einen so langen Zeitraum haben erfolgreich sein lassen, wird sie wohl auch in Zukunft weiterleben und in den bekannten Anwendungsgebieten und der Forschung von groer Bedeutung sein. Ein weiteres Upgrade (Fortran 2000) ist geplant, die Ankndigungen auf verschiedenen Websites weichen aber bzgl. der Verffentlichung voneinander ab.

19

Anhang A: Titel von Anhang 1

A Fortran 95-Quellcode fr Quick Sort (rekursiv)


module qsort_modul ! Modul, das vom Hauptprogramm ! genutzt wird. ! sichtbare Quicksort-Subroutine ! sichtbarer Zufallsgenerator ! interne Sortier-Subroutine

public :: qsort_sub public :: zufall private :: partition contains

recursive subroutine qsort_sub(array) real, intent(in out), dimension(:) :: array integer :: iq if(size(array) > 0) then call partition(array, iq) call qsort_sub(array(:iq-1)) call qsort_sub(array(iq+1:)) endif end subroutine qsort_sub subroutine partition(array, iq) real, intent(in out), dimension(:) :: array integer, intent(out) :: iq integer :: uzeiger, ozeiger real :: temp real :: pivot ! Pivotelement pivot = array(1) uzeiger = 0 ozeiger = size(array) + 1 do ozeiger = ozeiger - 1 do if (array(ozeiger) <= pivot) exit ozeiger = ozeiger - 1 end do uzeiger = uzeiger + 1 do if (array(uzeiger) >= pivot) exit uzeiger = uzeiger + 1 end do if (uzeiger < ozeiger) then ! array(uzeiger) und array(ozeiger) vertauschen temp = array(uzeiger) array(uzeiger) = array(ozeiger) array(ozeiger) = temp else iq = ozeiger return endif end do end subroutine partition

20

Anhang A: Titel von Anhang 1


! Der Zufallsgenerator fllt in einer DO-Schleife das Test-Array ! mit der im Hauptprogramm bergebenen Lnge sukzessive mit ! Werten. subroutine zufall(ein_array, laenge) integer, intent(in) :: laenge real, intent(out), dimension(:) :: ein_array real x do z = 1, laenge call random_number(harvest=x) ein_array(z) = x end do end subroutine zufall end module qsort_modul program Quick_Sort use qsort_modul integer :: startzeit, endzeit, rate real :: zeit ! laenge ist die Anzahl der zu sortierenden Werte integer, parameter :: laenge = 2000000 real, dimension(laenge) :: ein_array ! Aufruf der Zufalls-Subroutine, um das Test-Array mit der ! angegebenen Zahl an Elementen zufllig zu fllen call zufall(ein_array, laenge) ! Fr die Performance-Messung wird vorher die Systemzeit ! gemessen, rate = 1000 gibt an, dass der Zhler 1000mal ! pro Sekunde hochgezhlt werden soll. rate = 1000 call system_clock(count_rate=rate) call system_clock(count=startzeit) ! Aufruf der rekursiven QuickSort-Subroutine call qsort_sub(ein_array) ! Zeitmessung nach dem Sortieren und Differenzermittlung call system_clock(count=endzeit) zeit = (endzeit - startzeit) / real(rate) print *, "Sortiert: ", ein_array print *, "In ", zeit, " Sekunden" end program Quick_Sort ! Hauptprogramm

! Eingabe ! Ausgabe ! Zufallszahl

! Zufallsgeneratorfunktion

21

Literaturverzeichnis
[Ge91] [UH84] [CS70] Wilhelm Gehrke: Fortran 90: Referenz-Handbuch, Hanser-Verlag, 1991. Regionales Rechenzentrum fr Niedersachsen (RRZN), Universitt Hannover (Hrsg.): FORTRAN 77 Sprachumfang, Hannover, 1984. Harry L. Colman, Clarence Smallwood: Fortran Problem-orientierte Programmiersprache, KUNST UND WISSEN Erich Bieber, Stuttgart, 6. Aufl., 1970. G. Groten: Fortran 90/95; Kurs fr die Ausbildung von MTAs, http://www.fz-juelich.de/zam/docs/bhb/bhb_html/d0124/, Datum: 2004-05-02, Forschungszentrum Jlich, 1999. Thomas Ottmann, Peter Widmayer: Algorithmen und Datenstrukturen, Spektrum Akademischer Verlag, 3. Aufl., 1996.

[Gr99]

[OW96]

[PTVF96] William H. Press, Saul A. Teukolsky, William T. Vetterling, Brian P. Flannery: Numerical Recipes in Fortran 90 2nd Edition, Volume 2: The art of parallel scientific computing, Cambridge University Press, 1996. [UH03] Regionales Rechenzentrum fr Niedersachsen (RRZN), Universitt Hannover: Parallele Programmierung mit OpenMP, http://www.rrzn.unihannover.de/fileadmin/ful/vorlesungen/kolloquium/ss_03/open_mp.pdf, Datum: 2004-04-27, Hannover, 2003. Eric Scigliano: 10 Technologien, die berlebt haben, Technology Review Das M.I.T.-Magazin fr Innovation, Nr. 3 Mrz 2004, S. 96-99. Herbert Kuchen: Praktische Informatik; QuickSort Quellcode, http://www.wi.uni-muenster.de/pi/lehre/SS03/info2/quicksort.java, Datum: 2004-05-03

[Sc04] [Ku03]