---------------------------------------------------------------- | SOFTWARE- | Exekutive | MOS | | DOKUMENTATION | |-----------| |-----------------| Anleitung fuer den | | | 11/87 | Programmierer | OMOS 2.0 | ---------------------------------------------------------------- Programmtechnische Anleitung fuer den Programmierer Beschreibung Teil 2 Steuerprogrammsystem (Exekutive) OMEX 1630 MGS K 1600 VEB Robotron-Vertrieb Berlin Dok.-Nr. C 8064-0467-1M2031 Die vorliegende Systemunterlagendokumentation, Anleitung fuer den Programmierer OMEX 1630, entspricht dem Stand von 11/87. Nachdruck, jegliche Vervielfaeltigung oder Auszuege daraus sind unzulaessig. Die Ausarbeitung erfolgte durch ein Kollektiv des VEB Robotron- Vertrieb Berlin. Im Interesse einer staendigen Weiterentwicklung werden alle Leser gebeten, Hinweise zur Verbesserung dem Herausgeber mitzuteilen. Herausgeber: VEB Robotron-Vertrieb Berlin Mohrenstr. 62 Berlin 1086 C KOMBINAT ROBOTRON 1987 Kurzreferat Vorliegende Schrift betrifft den Leistungsumfang der Ausgabe 2.0 des OMEX 1630. Sie ist primaer fuer Programmierer bestimmt, die ihre Programme in MACRO 1600 oder FORTRAN 1600 schreiben. Es werden Notierungsform und Leistungsumfang der Exekutive-An- weisungen sowie der FORTRAN-Entsprechungen erlaeutert. Inhaltsverzeichnis ------------------ Seite 1. Aufgabenstellung 7 1.1. Leistungen der Exekutive 7 1.2. Anforderungen an die Geraetekonfiguration 8 2. Systembeschreibung und -benutzung 9 2.1. Allgemeines Konzept der Exekutive-Anweisungen 9 2.1.1. Realisierung der Exekutive-Anweisungen in Assemblerprogrammen 9 2.1.2. Symboldefinition 13 2.1.3. Rueckkehr zur Nutzertask und Rueckkehrcodes 14 2.1.4. Fehlerroutinen 15 2.1.5. Gegenueberstellung der Realisierungsformen der Exekutive-Anweisungen 16 2.1.6. Nutzbarmachung der Exekutive-Leistungen in FORTRAN- Programmen 17 2.2. Kategorien der Exekutive-Anweisungen und Voraussetzungen ihrer Realisierbarkeit 19 2.2.1. Tasksteuerung und Beeinflussung von Taskeigenschaften 19 2.2.1.1. Beeinflussbare charakterisierende Eigenschaften der Tasks 19 2.2.1.2. Exekutive-Anweisung zur Beeinflussung der Eigenschaften und zur Steuerung der Tasks 23 2.2.2. Signifikante Ereignisse, Ereignissignalisierung und STOP-BIT Synchronisation 24 2.2.2.1. Signifikante Ereignisse 24 2.2.2.2. Ereignisflags 24 2.2.2.3. Ereignisbezogene Exekutive-Anweisungen 26 2.2.2.4. STOP-BIT Synchronisation 27 2.2.2.5. Exekutive-Anweisungen fuer die STOP-Bit- 29 Synchronisation 2.2.3. Systemtraps 29 2.2.3.1. Synchrone Systemtraps 30 2.2.3.2. Bedienungsprogramme fuer synchrone Systemtraps 30 2.2.3.3. Asynchrone Systemtraps 32 2.2.3.4. Bedienungsprogramme fuer asynchrone Systemtraps 33 2.2.3.5. Systemtrapbezogene Exekutive-Anweisungen 36 2.2.4. Speicheradressierung und -verwaltung 38 2.2.4.1. Segmentierung und Partition-Typen 38 2.2.4.2. Regionen 39 2.2.4.3. Virtuelle Adressfenster 45 2.2.4.4. Regionschutz und privilegierte Tasks 53 2.2.4.5. Exekutive-Anweisungen zur Speicheradressierung und -verwaltung 54 2.2.5. Kommunikation und Information 56 2.2.5.1. Allgemeines 56 2.2.5.2. Kommunikation zwischen Task und Peripherie 56 2.2.5.3. Kommunikation zwischen verschiedenen Tasks 60 2.2.5.4. Versorgung der Tasks mit Informationen durch die Exekutive 60 2.2.5.5. Exekutive-Anweisungen zur Kommunikation und Information 61 2.2.6. Mutter/Tochter-Taskverbindungen (Spawning) 61 2.2.6.1. Einfuehrung 61 3 Seite 2.2.6.2. Spawning-Anweisungen in OMEX 1630 63 2.2.6.2.1. Aufbau einer Mutter/Tochter-Taskverbindung 63 2.2.6.2.2. Weitergabe einer Mutter/Tochter-Taskverbindung 64 2.2.6.2.3. Statusuebergabe an die Muttertask 64 2.2.6.3. Verbindungsformen und Statusuebergabe 65 2.2.6.4. Spawning von System-Tasks 67 2.2.6.4.1. Kommandoprogramme 68 2.2.6.4.2. Dienstprogramme 68 2.3. Beschreibung der Exekutive-Anweisungen 70 2.3.1. Allgemeine Festlegungen 70 2.3.2. Einzelbeschreibungen 72 2.3.2.1. ABRT$ - Abbruch einer Task 72 2.3.2.2. ALTP$ - Aendern der Prioritaet 74 2.3.2.3. ALUN$ - Zuweisen einer logischen Geraetenummer 76 2.3.2.4. ASTX$S- Ende einer AST-Bedienung 78 2.3.2.5. ATRG$ - Binden einer Region 80 2.3.2.6. CINT$ - Verbinden einer Task mit einem Interruptvektor 82 2.3.2.7. CLEF$ - Loeschen eines Ereignisflags 88 2.3.2.8. CMKT$ - Annullieren zeitabhaengig deklarierter signifikanter Ereignisse 89 2.3.2.9. CNCT$ - Synchronisierung zweier Tasks durch Aufbau einer Mutter/Tochter-Taskverbindung 91 2.3.2.10. CRAW$ - Herstellen eines Adressfensters 94 2.3.2.11. CRGF$ - Erzeugen von gruppenglobalen Ereignisflags 97 2.3.2.12. CRRG$ - Herstellen einer Region 99 2.3.2.13. CSRQ$ - Annullieren der zeitbezogenen Taskaktivierung 102 2.3.2.14. DECL$S- Deklarieren eines signifikanten Ereignisses 104 2.3.2.15. DSAR$S oder IHAR$S - Verhindern der AST-Bearbeitung 105 2.3.2.16. DSCP$S- Verhindern des Auslagerns 107 2.3.2.17. DTRG$ - Trennen einer Region von einer Task 108 2.3.2.18. ELAW$ - Eliminieren eines Adressfensters 110 2.3.2.19. ELGF$ - Eliminieren von gruppenglobalen Ereignisflags 112 2.3.2.20. EMST$ - Uebergeben eines Statuswertes 114 2.3.2.21. ENAR$S- Erlauben der AST-Bearbeitung 116 2.3.2.22. ENCP$S- Erlauben des Auslagerns 117 2.3.2.23. EXIF$ - Bedingte Taskbeendigung 118 2.3.2.24. EXIT$S- Taskbeendigung 120 2.3.2.25. EXST$ - Taskbeendigung mit Statusuebergabe 122 2.3.2.26. EXTK$ - Aendern der Tasklaenge 125 2.3.2.27. GLUN$ - Uebernehmen der Informationen ueber eine logische Geraetenummer 128 2.3.2.28. GMCR$ - Uebernehmen einer Kommandozeile 131 2.3.2.29. GMCX$ - Uebernehmen des gegenwaertigen Zustandes der Adresszuweisung 133 2.3.2.30. GPRT$ - Uebernehmen von Parametern einer Partition 135 2.3.2.31. GREG$ - Uebernehmen von Parametern einer Region 137 2.3.2.32. GTIM$ - Uebernehmen der Zeitparameter 139 2.3.2.33. GTSK$ - Uebernehmen der Parameter einer Task 141 2.3.2.34. MAP$ - Zuweisen eines Adressfensters zu einer Region 143 4 Seite 2.3.2.35. MRKT$ - Zeitabhaengiges Deklarieren eines signifikanten Ereignisses 145 2.3.2.36. QIO$ - E/A-Exekutive-Anweisung 149 2.3.2.37. QIOW$ - E/A-Exekutive-Anweisung mit Warten auf Beendigung 153 2.3.2.38. RCST$ - Empfangen eines Datenblocks oder STOP der Task 154 2.3.2.39. RCVD$ - Empfangen eines Datenblocks 156 2.3.2.40. RCVX$ - Empfangen eines Datenblocks oder Beenden der Task 158 2.3.2.41. RDAF$ - Lesen aller Ereignisflags 161 2.3.2.42. RDXF$ - Erweitertes Lesen aller Ereignisflags 163 2.3.2.43. RPOI$ - Aktivierung einer Task und Weitergeben von Mutter/Tochter-Taskverbindungen 165 2.3.2.44. RQST$ - Aktivieren einer Task 168 2.3.2.45. RREF$ - Empfangen eines Referenzblockes 172 2.3.2.46. RSUM$ - Fortsetzen einer Task 175 2.3.2.47. RUN$ - Zeitbezogenes Aktivieren einer Task 176 2.3.2.48. SDAT$ - Senden eines Datenblocks 180 2.3.2.49. SDRC$ - Senden eines Datenblocks, Aktivieren einer Task und Aufbau einer Mutter/Tochter- Taskverbindung 182 2.3.2.50. SDRP$ - Senden eines Datenblocks, Aktivieren einer Task und Weitergeben von Mutter/Tochter- Taskverbindungen 185 2.3.2.51. SETF$ - Setzen eines Ereignisflags 189 2.3.2.52. SFPA$ - Spezifizieren von Arithmetikprozessorfehler-AST 191 2.3.2.53. SMSG$ - Senden einer Meldung 193 2.3.2.54. SPND$S- Suspendieren einer Task 196 2.3.2.55. SPRA$ - Spezifizieren von Netzwiederkehr-AST 197 2.3.2.56. SPWN$ - Erzeugen einer Tochtertask 200 2.3.2.57. SRDA$ - Spezifizieren von Datenempfangs - AST 204 2.3.2.58. SREA$ oder SREX$ - Spezifizieren von Task- Abbruch - AST 206 2.3.2.59. SREF$ - Senden eines Referenzblockes 210 2.3.2.60. SRRA$ - Spezifizieren von AST nach Senden von Referenzbloecken fuer die Task 212 2.3.2.61. STIM$ - Setzen der Systemzeit 214 2.3.2.62. STLO$ - STOP fuer logisches 'ODER' von Ereignis- flags 217 2.3.2.63. STOP$S- Stoppen einer Task 220 2.3.2.64. STSE$ - STOP fuer ein einzelnes Ereignisflag 222 2.3.2.65. SVDB$ - Spezifizieren der SST-Vektortabelle fuer eine Testhilfe 224 2.3.2.66. SVTK$ - Spezifizieren der SST-Vektortabelle fuer eine Task 226 2.3.2.67. ULGF$ - Aufheben des Schutzes gruppenglobaler Ereignisflags 228 2.3.2.68. UMAP$ - Aufheben der Adresszuweisung eines Adressfensters zu einer Region 230 2.3.2.69. USTP$ - Beenden des STOP-Zustandes 232 2.3.2.70. WSIG$S- Warten auf ein signifikantes Ereignis 234 2.3.2.71. WTLO$ - Warten auf logisches 'ODER' der Ereignisflags 236 2.3.2.72. WTSE$ - Warten auf ein einzelnes Ereignisflag 238 5 Seite Anlage 1 Uebersicht der Exekutive-Anweisung 240 Anlage 2 Zuordnung zwischen Exekutive-Anweisungen und FORTRAN- Aufruf 243 Anlage 3 Tabelle der Rueckkehrcodes 245 Abkuerzungsverzeichnis 248 Sachwortverzeichnis 252 Bildverzeichnis --------------- Seite Bild 1 Task-Zustaende und Uebergangsaktivitaeten 22 Bild 2 Uebergangsaktivitaeten zwischen abarbeitungs- faehigem und blockiertem Zustand 22 Bild 3 Uebergangsaktivitaeten zwischen abarbeitungs- faehigem und gestopptem Zustand 23 Bild 4 Uebergangsaktivitaeten zwischen blockiertem und gestopptem Zustand 23 Bild 5 Region-Definitionsblock 41 Bild 6 Region-Statuswort 42 Bild 7 Handhabung von Adressfenstern und Regionen 46 Bild 8 Fenster-Definitionsblock 47 Bild 9 Fenster-Statuswort 49 Bild 10 Reihenfolge der Programmierung der Anweisungen zur Speicheradressierung und -verwaltung 55 Bild 11 Moeglichkeiten der Zuordnung zwischen LUN und Geraet 59 Tabellenverzeichnis ------------------- Seite Tabelle 1 Realisierungsformen der Exekutive-Anweisungen 16 Tabelle 2 Auswahl der Geraete, die durch OMEX 1630 unterstuetzt werden 58 Tabelle 3 Standardmaessige Zuordnung zwischen Pseudo- und physischem Geraet 59 6 1. Aufgabenstellung --------------------- 1.1. Leistungen der Exekutive ----------------------------- Die Exekutive OMEX 1630 wird aus einer Menge von Moduln generiert und kann dadurch der Geraetekonfiguration und dem Einsatzgebiet optimal angepasst werden. Es koennen plattenspeicherorientierte Varianten der Exekutive generiert werden, die fuer folgende Einsatzgebiete geeignet sind: - Erfassung von Daten - kleine Rechenzentren - dezentrale Verarbeitungssysteme - Datenerfassungs- und -sammelsysteme - Auskunfts- und Reservierungssysteme OMEX 1630 uebernimmt die Organisation der Abarbeitung der Nutzer- tasks. Sie stellt auf der Grundlage einer Echtzeituhr Datum und Uhrzeit bereit und ermoeglicht einmalige und zyklische, sofortige und verzoegerte Taskaktivierungen und auch das zeitabhaengige Warten. OMEX 1630 erlaubt den Aufbau von Mutter/Tochter-Taskverbindungen mit der Moeglichkeit der Uebergabe von Statuswerten. Zusaetzlich koennen zwischen so verbundenen Taskkommandos analog zur MCR- Vermittlung uebergeben werden. OMEX 1630 bietet die Moeglichkeit der Signalisierung des Eintre- tens bestimmter Ereignisse und der Synchronisierung der Taskabar- beitung mit diesen. Tasks koennen blockiert oder gestoppt werden. Ausserdem koennen Software-Interrupts (Systemtraps) fuer Nutzer- tasks verfuegbar gemacht werden. OMEX 1630 gestattet weiterhin die Kommunikation der Tasks mit der Umgebung und untereinander und ermoeglicht die Versorgung der Tasks mit aktuellen Informationen ueber ihre Umgebung. OMEX 1600 uebernimmt die Organisation und Verwaltung des verfueg- baren Speicherraums. Der Leistungsumfang einer konkreten Exekutive OMEX 1630 ist ab- haengig von den fuer die Generierung getroffenen Festlegungen und stellt eine Teilmenge des in dieser Schrift beschriebenen Umfanges dar. Anmerkung: Das aus anderen vergleichbaren SKR-Betriebssystemen bekannte Konzept von Nutzer-CLI's ist im OMOS 1630 auch realisiert. Damit gebildete Anwendungsloesungen, die auf kompatiblen SKR-Betriebs- systemen arbeiten, sind somit unter OMOS 1630 auch lauffaehig. In den OMOS 1630 Dokumentationen wurden vorerst keine CLI-Be- schreibungen oder -Hinweise aufgenommen. 7 1.2. Anforderungen an die Geraetekonfiguration ---------------------------------------------- OMEX 1630 benoetigt zur Gewaehrleistung seiner Funktion eine Zentraleinheit K 1630 mit Echtzeituhr und mit einem Haupt- speicher von 128 K Worten. Als Minimalperipherie muessen eine Bedieneinheit und ein Kassettenplattenspeicher verfuegbar sein. 8 2. Systembeschreibung und -benutzung ---------------------------------------- 2.1. Allgemeines Konzept der Exekutive-Anweisungen ---------------------------------------------------- 2.1.1. Realisierung der Exekutive-Anweisungen in Assemblerprogrammen ------------------------------------------------ Die Exekutive-Anweisungen sind Anforderungen, die Tasks an die Exekutive richten, um sich deren Leistungen verfuegbar zu machen. Diese Exekutive-Anweisungen ermoeglichen es, - Tasks zu aktivieren, von der Bearbeitung zu suspendieren, fortzusetzen und zu beenden, - Mutter/Tochter-Taskbeziehungen aufzubauen, - Datenuebertragungen ueber periphere Geraete, zwischen verschiedenen Tasks sowie zwischen Tasks und der Evekutive auszufuehren, - logische und virtuelle Adressbereiche von Tasks zu hand- haben, - Taskeigenschaften zu veraendern. Die Anweisungen werden durch Makros realisiert, die in der Sy- stemmakrobibliothek enthalten sind. Die Bearbeitung einer Exekutive-Anweisung erfolgt in vier Schrit- ten: 1. Die in der Task enthaltene Exekutive-Anweisung fuehrt zur Erzeugung des Anweisungsparameterblockes (DPB, Directive Para- meter Block). 2. Mittels eines EMT 377, der von der Exekutive-Anweisung oder von einem DIR$-Makro erzeugt wurde, wird die Steuerung an die Exekutive uebertragen. 3. Die Exekutive bearbeitet die Anweisung. 4. Die Exekutive informiert die die Anweisung enthaltende Task durch Eintragungen im Carry-Bit und dem Anweisungsstatuswort (DSW, Directive Status Word) ueber das Ergebnis der Bearbei- tung. Vor der Bearbeitung einer Exekutive-Anweisung werden alle Regi- ster der Task gerettet. Bei Uebergabe der Steuerung an die Exekutive (mittels EMT 377) enthaelt der Stack der Task entweder den Anweisungsparameterblock (DPB) selbst oder dessen Adresse, abhaengig von der Modifikation der Anweisung. Das erste Wort des Parameterblockes enthaelt im niederwertigen Byte den Anweisungs-Identifikationscode (DIC, Directive Identifi- cation Code) und im hoeherwertigen Byte die Angabe ueber die Laenge des Parameterblockes in Worten. 9 Damit von der Exekutive bestimmt werden kann, ob der Stack den Parameterblock selbst oder dessen Adresse enthaelt, sind alle Identifikationscodes der Anweisungen ungeradzahlig; die Adresse des Parameterblockes dagegen ist immer ein geradzahliger Wert. Nach beendeter Bearbeitung der Exekutive-Anweisung sind die Adresse bzw. der Anweisungsparameterblock aus dem Stack entfernt und die Steuerung wird - ausser bei Exekutive-Anweisungen, die zur Beendigung der sie enthaltenden Task fuehren - zu dem Befehl zurueckgegeben, der dem EMT 377 folgt. Bevor die Exekutive-Anweisungen benutzt werden koennen, muessen die sie realisierenden Makros aus der Systemmakrobibliothek als in die Task einzubeziehende Komponenten benannt werden. Das ge- schieht mit Hilfe der Assembler-Anweisung .MCALL in der Form .MCALL arg1,arg2,...,argn wobei arg1 ... argn die Namen der die Exekutive-Anweisungen realisierenden Makros sind, die in der Task verwendet werden sollen. Die Namen der Exekutive-Anweisungen und die Namen der zugehoeri- gen Makros sind identisch und haben folgendes Format: funktion$modifikation funktion charakterisiert mit 3 oder 4 Buchstaben die Lei- stung der Anweisung, modifikation kennzeichnet die Form, in welcher die Exekutive- Anweisung in das Programm einbezogen wird: modifikation fehlt - $-Form modifikation = S - $S-Form modifikation = C - $C-Form Die $-Form ---------- Die $-Form, bei der die Modifikation fehlt, erzeugt nur den An- weisungsparameterblock waehrend der Assemblierung an der Stelle, an der die Exekutive-Anweisung steht. Die $-Form ist zweckmaessig, wenn die gleiche Operation mehrmals von verschiedenen Stellen einer Programmsektion aus angefordert werden soll, die nicht wiederaufrufbar ist. Es besteht die Moeglichkeit, waehrend der Abarbeitung der Task die Parameter im Anweisungsparameterblock, die den Vorschriften fuer die Argumente der .BYTE-, .WORD- und .RAD50-Pseudobefehle gerecht werden muessen, entsprechend den Erfordernissen der Task zu veraendern. Die $-Form der Exekutive-Anweisung erfordert die DIR$-Anweisung zu ihrer Ausfuehrung und muss in einer Datensektion der Task vereinbart werden. Die $C-Form ----------- Wird eine Exekutive-Anweisung in einer Task nur einmal benoetigt und die Programmsektion, in der sie enthalten ist, muss nicht wiederaufrufbar sein, wird empfohlen, die $C-Form der Exekutive- Anweisung zu verwenden. 10 Hierbei wird der Anweisungsparameterblock losgeloest vom Ausfueh- rungsteil der Anweisung in einer separaten Programmsektion er- zeugt, die mit dem Symbol $DPB$$ bezeichnet wird. Die Erzeugung des Parameterblockes geschieht waehrend der Assemblierung. Dem Anweisungsparameterblock folgt der Assembler-Pseudobefehl ".PSECT..." zur Rueckkehr zur auszufuehrenden Programmsektion, und in dieser wird ein Befehl zum Speichern der Parameterblock- adresse in den Stack erzeugt, dem dann der EMT 377 folgt. Damit gewaehrleistet ist, dass zur richtigen Programmsektion zurueckgekehrt wird, muss der Name dieser Sektion der Liste der Parameter der Exekutive-Anweisung folgen. Wird der Name der Sek- tion nicht angegeben, wird die unbenannte Programmsektion zur auszufuehrenden Sektion erklaert. Ist der Name faelschlicherweise ausgelassen worden, fuehrt das zu fehlerhaften Ablaeufen. Der Parameterblock einer Exekutive-Anweisung der $C-Form ist nur an der Stelle der Task erreichbar, an der die Anweisung steht, weil seine durch den Makro generierte symbolische Adresse "$$$" von jeder $C-Form-Anweisung benutzt wird und folglich staendigen Veraenderungen unterworfen ist. Wie schon bei der $-Form muessen auch bei der $C-Form die Parame- ter fuer den DPB der Anweisung den Bedingungen fuer Datenverein- barungsanweisungen (.BYTE-, .WORT-, .RAD50-Pseudobefehle) ent- sprechen. Als letzter Parameter hinter dem Namen der auszufueh- renden Programmsektion kann bei dieser Form die Adresse einer Fehlerroutine angegeben werden, die aufgerufen werden soll, wenn bei der Bearbeitung der Exekutive-Anweisung ein Fehler auf- tritt. Die $S-Form ----------- Programmsegmente, die wiederaufrufbar sein sollen, muessen die $S-Form der Exekutive-Anweisungen benutzen. Bei dieser Form der Anweisung wird der Anweisungsparameterblock waehrend der Abarbei- tung der Task im Stack aufgebaut und ein EMT 377 ausgefuehrt. Das Einspeichern der Parameter in den Stack geschieht mittels MOV- Befehlen, weshalb die Anweisungsparameter gueltige Quelloperanden fuer Transportbefehle sein muessen. Namen, die als RAD50-Zeichen-Ketten dargestellt werden, sind so ueber ihre Adresse anzugeben, dass die Namenskette direkt mit MOV-Befehlen in den Stack transportiert werden kann. Z.B. RQST$S #ATN . . . ATN: .RAD50 TSKNM . Bemerkung: Als Parameter fuer die Exekutive-Anweisung tritt der in RAD50-Form darzustellende Name "TSKNM" auf. Er wird durch seine Adresse "ATN" fuer den Makro bereitge- stellt.  11 Es ist zu beachten, dass der Stackpointer nicht zur Adressierung der Parameter benutzt werden sollte. Im Ausnahmefall muss sehr genau die Makroaufloesung bekannt sein! Wie bei der $C-Form ist auch hier die Angabe der Adresse einer Fehlerroutine moeglich, jedoch direkt ohne Angabe von "#". Die DIR$-Anweisung ------------------ Die DIR$-Anweisung aktiviert die Ausfuehrung einer Exekutive- Anweisung der $-Form. Sie speichert eine im Makro-Aufruf angegebene DPB-Adresse in den Stack und fuehrt einen EMT 377 aus. Schreibweise der Anweisung: DIR$ [adr][,err] adr und err sind Wahlparameter mit der Bedeutung adr = Adresse des DPB Die Adresse muss ein gueltiger Quelloperand fuer Trans- portbefehl sein. Diese Adresse wird auf die aktuelle Stack-Position uebertragen. Fehlt diese Angabe, wird vor ausgesetzt, dass die DPB-Adresse oder der DPB selbst bereits auf der aktuellen Stack-Position gespeichert sind. err = Adresse einer Fehlerroutine, die bei Auftreten von Feh- lern angesprungen werden sollen. Die Adressdarstellung muss den Bedingungen fuer den Adressoperanden des Assem- blerbefehls "JSR PC,adresse" genuegen. Fehlt die Adresse der Fehlerroutine, wird lediglich das C-Bit im Prozes- sorstatuswort entsprechend dem Ereignis gesetzt. Zur DIR$-Anweisung gibt es keine Modifikationen; sie ist nicht als $-Form einer Exekutive-Anweisung zu betrachten. Beispiel: --------- 1. Es soll eine Exekutive-Anweisung der $-Form ausgefuehrt wer- den, deren Parameterblock bei der symbolischen Adresse "PAR" beginnt. Bei Fehlern soll zur Behandlungsroutine "FEHL" verzweigt werden. Daraus resultiert die DIR$-Anweisung DIR$ #PAR,FEHL die uebersetzt wird in MOV #PAR,-(SP) EMT 377 BCC .+6 JSR PC,FEHL 2. Es soll eine Exekutive-Anweisung der $-Form ausgefuehrt wer- den, deren Parameterblockadresse in R1 und deren Fehlerrouti- nenadresse in R3 steht: DIR$ R1,(R3) 12 Es entsteht: MOV R1,-(SP) EMT 377 BCC .+4 JSR PC,(R3) 3. Eine Exekutive-Anweisung der $-Form ist zu aktivieren, von deren Anweisungsparameterblock die Adresse bereits im Stack steht. Eine Fehlerroutine soll nicht aktiviert werden: DIR$ Es entsteht: EMT 377 2.1.2. Symboldefinition ----------------------- Fuer alle Exekutive-Anweisungen der $- und der $C-Form, deren Anweisungsparameterblock (DPB) laenger als ein Wort ist, werden lokale Symbole zur symbolischen Adressierung der einzelnen Para- meter definiert. Diese Symbole repraesentieren den Abstand eines Parameters zum Anfang des Parameterblocks in Bytes (Offset). Darueber hinaus werden solche lokalen Symbole auch fuer im Quelltext vereinbarte Informationsbloecke erzeugt, die als Er- gebnis von Exekutive-Anweisungen (einschliesslich der $S-Form) zur Versorgung von Tasks mit Informationen durch die Exekutive belegt werden. Mit der Erzeugung dieser symbolischen Offsets ist die Vorausset- zung geschaffen, die Parameter der Anweisungsparameterbloecke und der Informationsbloecke symbolisch zu adressieren, wodurch eine einfache und wenig fehleranfaellige Handhabung der Parame- ter dieser Bloecke gewaehrleistet ist. Wird in einem Programm, das Anweisungen der $- oder der $C-Form benutzt, das Symbol $$$GLB definiert (z.B. durch die Direktanweisung $$$GLB = 0), dann werden die symbolischen Offsets als globale Symbole erzeugt. Der DPB selbst wird dann von dem die Anweisung realisierenden Makro nicht erzeugt. Diese Moeglichkeit hat den Zweck, einen Parameterblock benutzen zu koennen, der in einem anderen Modul oder Quelltext definiert wurde. Ueber die globalen Symbole kann dann auf die einzelnen Parameter zugriffen werden. Auf die Realisierung von Anweisungen der $S-Form hat die Verwen- dung des Symbols $$$GLB keinen Einfluss.  13 Beispiele zur Benutzung der Symbole: ------------------------------------ 1. Eine Task enthaelt eine Exekutive-Anweisung zur Veraenderung der Prioritaet einer anderen Task. Die Exekutive-Anweisung VP: ALTP$ VARP,75. bewirkt folgende Makroerweiterung: .BYTE 9.,4 ; .RAD50 /VARP/ ; Taskname .WORD 75. ; neue Prioritaet der Task VARP Die zugehoerigen Symboldefinitionen sind: A.LTTN - Taskname A.LTPR - Prioritaet Im weiteren Ablauf soll die Prioritaet der Task VARP von 75. auf 60. geaendert werden. Eine Moeglichkeit der Veraenderung waere mit dem Befehl MOV #60.,VP+A.LTPR gegeben. 2. Die Adresse eines Fenster-Definitionsblockes (WDB,Window Defi- nition Block) steht im Register R1. Das Statuswort inner- halb des WDB hat den symbolischen Offset W.NSTS. Innerhalb des Statuswortes dient Bit 1, das mit WS.WRT vereinbart ist, der Markierung der Schreiberlaubnis. Soll dieses Bit gesetzt werden, kann das mit BIS #WS.WRT,W.NSTS(R1) geschehen. 2.1.3. Rueckkehr zur Nutzertask und Rueckkehrcodes -------------------------------------------------- Nachdem die der Exekutive von der Nutzertask erteilte Anweisung ausgefuehrt worden ist, wird die Steuerung - mit Ausnahme von Anweisungen, die zur Beendigung der Task fuehren - zu dem Befehl zurueckgegeben, der dem EMT 377 folgt. Die im Stack uebergebenen Informationen (Adresse des DPB oder der DPB selbst) sind aus dem Stack entfernt, und das Carry-Bit des Prozessor-Statuswortes gibt Auskunft ueber das Ergebnis der Bear- beitung. Es ist geloescht, wenn die Anweisung akzeptiert wurde, und gesetzt, wenn sie abgewiesen wurde. Das Anweisungsstatuswort, das symbolisch mit $DSW adressiert werden kann und als globaler Verweis durch den TKB 1630 aufgeloest wird, enthaelt detaillierte Angaben bezueglich des Akzeptierens oder Ablehnens einer Anweisung. 14 Das Statuswort enthaelt Werte >=0 bei erfolgreicher Ausfuehrung und Werte < 0 bei Ablehnung bzw. fehlerhafter Bearbeitung der Anweisung. Diesen Werten des Anweisungsstatuswortes sind Symbole zugeordnet. Um diese in einer Task benutzen zu koennen, muss der Programmie- rer den Makro DRERR$ in sein Programm einbeziehen: .MCALL DRERR$ DRERR$ Im Makro DRERR$ werden durch Direktanweisungen den Symbolen die entsprechenden numerischen Werte (als Rueckkehrcodes bezeichnet) zugewiesen. Nach Rueckkehr zur Task kann dann symbolisch mit diesen Rueck- kehrcodes gearbeitet werden (z.B. CMP #IS.SUC,$DSW). Bei Exekutive-Anweisungen, die zur Beendigung einer Task fuehren, wird die Steuerung nur im Fehlerfall an die Task zurueckgegeben - bei erfolgreicher Ausfuehrung verbleibt die Steuerung bei der Exekutive und die von der Task gebundenen Systemressourcen werden freigegeben. Wenn von der Exekutive eine Anweisung abgewiesen wurde, wird in der Regel ein spezifiziertes Ereignisflag nicht veraendert. Aus diesem Grunde kann eine Task in einen undefinierten Wartezu- stand geraten, wenn an anderer Stelle ein Ereignisflag getestet wird, das von der abgewiesenen Anweisung veraendert werden soll- te. Zur Vermeidung solcher undefinierter Wartezustaende sollte bei diesen Anweisungen immer auf erfolgreiche Ausfuehrung getestet werden. 2.1.4. Fehlerroutinen --------------------- Die Exekutive-Anweisungen der $C- und $S-Form und die DIR$-Anwei- sung ermoeglichen die Angabe der Adresse einer Anwenderfehlerrou- tine, die aktiviert werden soll, wenn die Anweisung nicht erfolg- reich ausgefuehrt wurde. Die Fehlerroutinenadresse muss der letzte Parameter in der Para- meterkette der Exekutive-Anweisung sein und den Bedingungen fuer Adressangaben im JSR-Befehl entsprechen. Bei Angabe einer Fehlerroutinenadresse bei der %C-Form einer Exekutive-Anweisung ist zu beachten, dass der Parameter fuer die Programmsektion noch der Liste der Parameter der Exekutive-Anwei- sung folgen muss und erst danach die Fehlerroutinenadresse ange- geben wird. Die Verzweigung geschieht,indem, dem EMT 377 folgend, die Befehle BCC .+6 bzw. BCC .+4 und JSR PC,FEHL erzeugt werden,wobei "FEHL" die Adresse der Anwenderfehlerroutine ist.  15 Bei der $-Form der Exekutive-Anweisung ist die Angabe einer Feh- lerroutinenadresse nicht moeglich, da sie zur Ausfuehrung die DIR$-Anweisung erfordert. 2.1.5. Gegenueberstellung der Realisierungsformen der Exekutive-Anweisungen ----------------------------------------------------- Anhand eines Beispiels sollen die Unterschiede zwischen den ein- zelnen Realisierungsformen und ihre Besonderheiten dargestellt werden. Die Gegenueberstellung erfolgt in Tabelle 1, in der auch Besonderheiten aufgefuehrt sind. Die Bedeutung der Exekutive-Anweisung und ihrer Parameter ist ihrer Einzelbeschreibung zu entnehmen. Tabelle 1 Realisierungsformen der Exekutive-Anweisungen Assemblernotation| A | B | C -----------------|-------------|----------------|---------------- Realisierung | | .PSECT $DPB$$ | | | $$$ = . | | .BYTE 23.,5 | .BYTE 23.,5 | MOV R3,-(SP) | .WORD 6 | .WORD 6 | MOV #2,-(SP) | .WORD 4 | .WORD 4 | MOV #4,-(SP) | .WORD 2 | .WORD 2 | MOV #6,-(SP) | .WORD TAD | .WORD TAD | MOV (PC)+,-(SP) | | .PSECT ORIG | .BYTE 23.,5 | | MOV #$$$,-(SP) | EMT 377 | | EMT 377 | BCC .+6 | | BCC .+6 | JSR PC,FHL | | JSR PC,FHL | -----------------|-------------|----------------|---------------- Erzeugung des Pa-|an der Stelle|in der Programm-| rameterblocks |im Programm, |sektion $DPB$$ | im Stack |wo die Anwei-| | |sung steht | | -----------------|-------------|----------------|---------------- Zeitpunkt der Er-|bei der As- |bei Assemblie- | dynamisch bei zeugung des Para-|semblierung |rung | der Abarbei- meterblocks | | | tung -----------------|-------------|----------------|---------------- Aktivierung |erfordert die| selbstaendig | selbstaendig |DIR$-Anwei- | | |sung | | -----------------|-------------|----------------|---------------- Eignung fuer wie-| nein | nein | ja deraufrufbare | | | Programme | | | -----------------|-------------|----------------|---------------- symbolische Off- |vorh. bei al-|vorh. bei allen | nicht vorhanden sets fuer den An-|len Anweisun-|Anweisungen, de-| weisungsparameter|gen, deren |ren Parameter- | -block |Parameter- |block groesser | |block groes- |als ein Wort | |ser als 1 |ist | |Wort ist | | wobei: A = MRKT$ 6,4,2,TAD B = MRKT$C 6,4,2,TAD,ORIG,FHL C = MRKT$S #6,#4,#2,R3,FHL 16 2.1.6. Nutzbarmachung der Exekutive-Leistungen in FORTRAN- Programmen ---------------------------------------------------------- Fuer FORTRAN-Programme werden die Exekutive-Leistungen durch Subroutinen nutzbar gemacht. Diese Subroutinen sind im allgemei- nen in der Systemobjekt-Modulbibliothek (SYSLIB.OLB) enthalten. Um eine dieser Routinen zu benutzen, muss der Programmierer die entsprechende CALL-Anweisung in das FORTRAN-Programm aufnehmen. Beim Taskbilden wird zunaechst geprueft, ob eine nutzerdefinierte Routine mit dieser Bezeichnung vorhanden ist. Wird keine entspre- chende nutzerdefinierte Routine gefunden, durchsucht der Task- builder automatisch die SYSLIB.OLB und bindet die Routine in die Task ein. Diese Subroutinen koennen auch von Programmen, die in der Assemb- lersprache MACRO 1600 geschrieben wurden, verwendet werden. Die Bedingungen sind der Schrift "Programmsystem FORTRAN 1600 Teil 3 Anleitung fuer den Programmierer" zu entnehmen. Allgemeine Festlegungen fuer FORTRAN-Aufrufe -------------------------------------------- Wahlparameter Verschiedene Subroutinen haben Wahlparameter. Diese sind durch eckige Klammern gekennzeichnet. Wird ein Wahlparameter, welchem noch weitere angegebene Parameter folgen, weggelassen, so ist das nachfolgende Komma zu setzen. Steht ein Wahlparameter oder eine Folge von Wahlparametern am Ende einer Parameterkette, koennen diese Kommas auch weggelassen werden. Beispiel: CALL SUB (AA,[BB],[CC],DD[,[EE][,FF]]) Werden die Parameter BB, CC, EE und FF weggelassen, gibt es fol- gende Darstellungsmoeglichkeiten: CALL SUB (AA,,,DD,,) CALL SUB (AA,,,DD) Tasknamen Tasknamen koennen maximal 6 Zeichen lang sein. Es koennen verwen- det werden: Buchstaben A - Z Ziffern 0 - 9 Waehrungszeichen $ Punkt . Tasknamen werden im RADIX-50-Code gespeichert (3 Zeichen pro Wort). FORTRAN-Subroutinen erfordern, dass der Taskname als eine Variab- le vom Typ REAL definiert wird. Diese Variable muss zur Ueber- setzung durch eine DATA-Anweisung definiert werden, die den for- malen Parameter in einen aktuellen Wert (als RADIX-50-Konstante) umwandelt.  17 Beispiel: DATA ROBO81/6RROBO81/ . . . CALL REQUES (ROBO81) Integer-Parameter Alle Integer-Parameter sind Parameter vom Typ INTEGER*2. Ein INTEGER*2-Wort belegt ein Speicherwort. Die Werte liegen im Be- reich von - 32768 bis + 32767. Auch bei Verwendung des Compiler- Schalters /I4 ist darauf zu achten, dass die Parameter der Sub- routine explizit als INTEGER*2-Typ spezifiziert werden. GETADR-Subroutine Verschiedene Subroutinerufe enthalten einen Parameter, der ein Integerfeld beschreibt. Dieses Integerfeld enthaelt Werte, die Adressen von anderen Variablen und Feldern sind. Die Sprache liefert keine Moeglichkeit, eine Adresse als einen Wert zuzuwei- sen. Hier schafft die GETADR-Subroutine Abhilfe: CALL GETADR(ipm,[arg1],[arg2],...[,argn]) ipm = Feld der Dimension n argi = Argumente, deren Adressen in ipm einzusetzen sind. Wenn ein Nullargument angegeben wird, bleibt der zugehoerige Platz in ipm unveraendert. Beispiel: Um die Adresse des Eingabebereiches im Integerfeld der geraeteab- haengigen Parameter der QIO-Subroutine zu plazieren, programmiert man DIMENSION IBUF(80),IOSUB(2),IPARAM(6) . . . CALL GETADR(IPARAM(1),IBUF(1)) IPARAM(2) = 80 CALL QIO(IREAD,LUN.IEFLAG,,IOSB,IPARAM,IDSW) . . . 18 2.2. Kategorien der Exekutive-Anweisungen und Voraus- setzungen ihrer Realisierbarkeit --------------------------------------------------------- 2.2.1. Tasksteuerung und Beeinflussung von Taskeigenschaften -------------------------------------------------------------- 2.2.1.1. Beeinflussbare charakterisierende Eigenschaften der Tasks ------------------------------------------------------------ Die von der Exekutive behandelbare Grundeinheit aus programmtech- nischer Sicht ist die Task. Sie wird vom Taskbuilder aus Objektmoduln der Uebersetzungspro- gramme gebildet und stellt ein abarbeitungsfaehiges Speicherab- bild der miteinander verbundenen Objektmoduln dar. Ausserdem werden beim Bilden der Task auch die Verbindungen zu residenten Bibliotheken und COMMON-Bereichen hergestellt und die Eigenschaften der Task festgelegt, von denen der - Taskstatus, die - Taskauslagerbarkeit und die - Taskprioritaet fuer die Bearbeitung von besonderer Bedeutung sind. Die Bearbei- tung von Tasks erfolgt nach den Prinzipien der Multiprogrammie- rung, d.h. mehrere gleichzeitig im Arbeitsspeicher befindliche Tasks werden zeitgeteilt unter Beruecksichtigung ihrer Prioritae- ten abgearbeitet. Zur Bearbeitung kann eine Task jedoch erst gelangen, wenn sie dem System bekannt, d.h. wenn sie installiert ist. Status ------ Eine Task existiert bis zu ihrer Installierung im System nur als Taskabbild-Datei. Erst das Installieren mittels MCR/DCL-Kommando (INS) macht eine Task dem System bekannt. Dabei wird ein Tasksteuerblock (TCB, Task Control Block) im Systemtaskverzeichnis (STD, System Task Directory) aufgebaut, der alle Informationen zur organisatorischen Handhabung einer Task enthaelt. Dieser Zustand einer Task wird als ruhender Zustand bezeichnet; die Task ist dem System zwar bekannt, sie ist aber noch nicht aktiv. Im aktiven Zustand, in dem sie der Exekutive zur Ansteuerung verfuegbar ist, befindet sich eine Task vom Zeitpunkt des Akti- vierens bis zu ihrer Beendigung. Die Aktivierung erfolgt durch ein RQST$, RUN$, SPWN$, SDRC$, RPOI$ oder SDRP$-Macro oder ein MCR/DCL-RUN-Kommando. Eine aktive Task ist zur Ansteuerung verfuegbar, waehrend eine ruhende Task dies nicht ist.  19 Im aktiven Zustand werden drei Teilzustaende unterschieden, der abarbeitungsfaehige, der blockierte und der Stop-Zustand einer Task. - Abarbeitungsfaehige Tasks bewerben sich auf der Grundlage ihrer Prioritaet um die Bearbeitung, und die Task mit der hoechsten Prioritaet erhaelt die Steuerung und wird zur aktuellen Task, wenn alle die Ressourcen verfuegbar sind, die zu ihrer Abarbei- tung gebraucht werden. Diese Task wird zur laufenden Task. - Im blockierten Zustand ist eine Task der Bearbeitung entzogen, weil notwendige Voraussetzungen fuer ihre weitere Abarbeitung nicht oder nicht mehr erfuellt sind.Die Task ist aber weiterhin aktiv und bewirbt sich im Rahmen ihrer Prioritaet um Haupt- speicherplatz, falls sie zwischenzeitlich ausgelagert wurde. - Im gestoppten Zustand ist es der Task unmoeglich, sich um ZVE- Zeit zu bewerben, weil notwendige Voraussetzungen fuer ihre weitere Abarbeitung nicht oder nicht mehr erfuellt sind - z.B. Synchronisationsprobleme oder nicht verfuegbare Ressourcen. Die Prioritaet der Task wird auf 0 gesetzt. Damit kann von jeder anderen Task ihre Auslagerung erzwungen werden, falls sie auslagerbar ist. Wenn ein AST auftritt fuer eine gestoppte Task, so wird deren urspruengliche Prioritaet fuer die Dauer der Ausfuehrung der AST-Routine wiederhergestellt. Ist der AST behandelt, sinkt die Prioritaet wieder auf 0. In den Bildern 1 und 4 werden die einzelnen Zustaende einer Task und die Bedingungen des Zustandswechsels dargestellt. Prioritaet ---------- Das Kriterium, auf dessen Grundlage die Vergabe der Systemres- sourcen erfolgt, ist die Prioritaet einer Task. Die Prioritaet einer Task wird durch eine Zahl bestimmt, die der Task beim Bilden oder Installieren zugewiesen wird. Diese Zahl liegt im Bereich von 1 ... 250 (dezimal), wobei groessere Zahlen hoehere Prioritaeten repraesentieren. Zur Abarbeitung gelangt jeweils die abarbeitungsfaehige Task mit der hoechsten Prioritaet. Wenn diese Task in den blockierten oder gestoppten Zustand ueber- geht (z.B. Warten auf das Ende einer Datenuebertragung) oder beendet wird, ermittelt die Exekutive anhand der Prioritaet die naechste zu bearbeitende Task. Aus den auf Bearbeitung war- tenden Tasks wird die ausgewaehlt, die die hoechste Prioritaet hat und fuer die alle benoetigten Ressourcen zur Verfuegung stehen. Zur Gewaehrleistung niedriger Reaktionszeiten sollten Echtzeit- tasks hoehere Prioritaeten zugeordnet werden als Tasks, die nicht an Echtzeiterfordernisse gebunden sind. Bedienungsintensive Tasks (z.B. Aufbereitungsprogramme) sollten mit hoeherer Prioritaet in das System eingeordnet werden als rechenintensive, damit vertretbare Bedienerwartezeiten ermoeg- licht werden. 20 Haben mehrere Tasks die gleiche Prioritaet, erfolgt ihre Einord- nung in das Systemtaskverzeichnis (STD) in der Reihenfolge ihres Installierens, was zur Folge hat, dass die eher installierten Tasks einer Prioritaetsstufe bevorzugt zur Abarbeitung gelangen. Eine generierbare Option der Exekutive, die Zeitscheibensteue- rung, ermoeglicht durch Quantelung der ZVE-Zeit die gleichmaes- sige Bearbeitung von Tasks gleicher Prioritaetsstufen innerhalb eines Prioritaetsbereiches, indem sie die im Systemtaskverzeich- nis stehenden Tasks gleicher Prioritaet in angebbaren Zeitab- staenden zyklisch umtraegt. Damit wird gewaehrleistet, dass alle Tasks gleicher Prioritaet mit gleicher Wahrscheinlichkeit zur Abarbeitung gelangen, ohne dass das Gesamtprioritaetsgefuege gestoert wird. Auslagerbarkeit ---------------- Die Auslagerbarkeit von Tasks ist die Faehigkeit der Exekutive, eine in eine Warteposition (blockierter oder gestoppter Zustand) geratene Task im aktuellen Bearbeitungszustand auf einen ex- ternen Datentraeger speichern zu koennen und eine fuer die Bearbeitung in der gleichen Partition vorgesehene Task abzuar- beiten. Die neue Task muss dabei von hoeherer Prioritaet sein als die auszulagernde, d.h. pri < pri . alt neu Ist die neue Task fertig bearbeitet oder wird anderweitig Platz in der Partition verfuegbar, wird die zuvor ausgelagerte Task eingelesen und ihre Bearbeitung an der Stelle fortgesetzt, an der ihre Abarbeitung unterbrochen wurde. Das ermoeglicht es, den Auslastungsgrad der Anlage zu erhoehen. Voraussetzung fuer die Auslagerbarkeit von Tasks ist das Vorhan- densein von entsprechend grossen Auslagerungsbereichen auf dem externen Datentraeger. Wenn verschiedene Tasks gleicher Prioritaet in der gleichen Par- tition abgearbeitet werden sollen, kann die naechste Task erst zur Abarbeitung gelangen, wenn die aktuelle Task die Partition freigibt. Eine generierbare Option, die zeitgesteuerte Auslagerung, ermoeg- licht der Exekutive die Auslagerung von Tasks nach vorgegebenen Zeitintervallen, um anderen Tasks gleicher Prioritaet die Abar- beitung zu ermoeglichen. Ausgelagerte Tasks werden entsprechend ihrer Prioritaet in die Warteschlange der auf Speicherraum war- tenden Tasks wieder eingeordnet.  21 ----- 1 ----- 3,4,5,6,7,8,9 ----- | |--------->| |----------------->| | | T | | R | | A | | |<---------| |<-----------------| | ----- 2 ----- 10,11,12,13 ----- T: Taskabbild-Datei R: ruhende Task A: aktive Task 1: Installieren einer Task (MCR- oder DCL-Kommando INS) 2: Streichen einer Task (MCR- oder DCL-Kommando REMOVE) 3: Exekutive-Anweisung RUN$ 4: Exekutive-Anweisung RQST$ 5: Exekutive-Anweisung SPWN$ 6: Exekutive-Anweisung SDRC$ 7: Exekutive-Anweisung RPOI$ 8: Exekutive-Anweisung SDRP$ 9: MCR- oder DCL-Kommando RUN 10: Taskende durch EXIT$, EXIF$ oder RCVX$ oder Taskende durch RREF$ mit Exit-Zusatz 11: Exekutive-Anweisung ABRT$ 12: MCR-oder DCL-Kommando ABORT 13: synchrone Systemtraps (SST, Synchronous System Trap), fuer die die Task keine Bedienungsroutinen enthaelt Bild 1 Task-Zustaende und Uebergangsaktivitaeten ----- 11,12,13, ----- | |---------------->| | | A'| | B | | | 14,15,16,17 | | | |<----------------| | ----- ----- A': abarbeitungsfaehige Task B: blockierte Task 11: Exekutive-Anweisung SPND$S 12: Nicht erfuellte Wartebedingung fuer Ereignisflags 13: Auslagerung der Task durch die Exekutive 14: Exekutive-Anweisung RSUM$ 15: MCR-Kommando RESUME der DCL-Kommandos CONTINUE 16: Erfuellte Wartebedingung fuer Ereignisflags 17: Einlesen einer ausgelagerten Task durch die Exekutive Bild 2 Uebergangsaktivitaeten zwischen abarbeitungsfaehigem und blockiertem Zustand 22 ------ 1,2,3,4 ------ | |------------------------->| | | A' |<-------------------------| S | | | 5,6,7,8 | | ------ ------ A': Abarbeitungsfaehige Task S: gestoppte Task 1: Exekutive-Anweisung STOP$ 2: Exekutive-Anweisung RCST$ wurde ausgefuehrt und kein Daten- paket ist fuer die Task verfuegbar 3: nicht erfuellte STOP-Bedingungen fuer Ereignisflags 4: Es liegt eine nicht erfuellte Wartebedingung vor und die Task hat gepufferte E/A auszustehen. 5: fuer 1) und 2) Exekutive-Anweisung USTP$ 6: fuer 1) und 2) MCR-Kommando UNSTOP oder DCL-Kommando START 7: fuer 3) Setzen der spezifizierten Ereignisflags 8: fuer 4) Wartebedingung ist erfuellt. Bild 3 Uebergangsaktivitaeten zwischen abarbeitungsfaehigem und gestopptem Zustand ------ 1 ------ | |------------------>| | | B |<------------------| S | | | 2 | | ------ ------ B: Blockierte Task S: gestoppte Task 1: aktivieren einer gepufferten E/A-Operation in einer AST- Routine und anschliessendes Verlassen des AST-Zustandes 2: Beendigung aller ausstehenden gepufferten E/A-Operationen bei bestehender Wartebedingung. Bild 4 Uebergangsaktivitaeten zwischen blockiertem und ge- stopptem Zustand 2.2.1.2. Exekutive-Anweisung zur Beeinflussung der Eigen- schaften und zur Steuerung der Tasks --------------------------------------------------------- Eine Reihe von Exekutive-Anweisungen ermoeglicht es, die Task- eigenschaften und den Bearbeitungsablauf zu beeinflussen: Es gibt Anweisungen zum unmittelbaren Aktivieren von Tasks und zu deren verzoegerter und/oder zeitzyklischer Aktivierung. Andere Anweisungen ermoeglichen es, eine Task von der Bearbeitung zu suspendieren und wieder fortzusetzen, wenn die fuer die Abarbei- tung erforderlichen Bedingungen erfuellt sind. Waehrend der Abar- beitung besteht die Moeglichkeit, mittels Exekutive-Anweisungen die Prioritaet zu aendern und das Auslagern zu verhindern und wieder zu erlauben und die Tasklaenge zu veraendern. Weitere Anweisungen realisieren die Beendigung von Tasks und das Austragen aus der zeitzyklischen Bearbeitung.  23 Im einzelnen stehen folgende Exekutive-Anweisungen zur Verfue- gung, deren detaillierte Beschreibung in Abschnitt 2.3.2. er- folgt: Abschnitt ABRT$ Abbruch einer Task 2.3.2.1. ALTP$ Aendern der Prioritaet 2.3.2.2. CSRQ$ Annullieren der zeitbezogenen Taskakti- vierung 2.3.2.13. DSCP$S Verhindern des Auslagerns 2.3.2.16. ENCP$S Erlauben des Auslagerns 2.3.2.22. EXIF$ Bedingte Taskbeendigung 2.3.2.23. EXIT$S Taskbeendigung 2.3.2.24. EXTK$ Aendern der Tasklaenge 2.3.2.26. RQST$ Aktivieren einer Task 2.3.2.44. RSUM$ Fortsetzen einer Task 2.3.2.46. RUN$ Zeitbezogenes Aktivieren einer Task 2.3.2.47. SPND$S Suspendieren einer Task 2.3.2.54. 2.2.2. Signifikante Ereignisse, Ereignissignalisierung und STOP- Bit Synchronisation ----------------------------------------------------------------- 2.2.2.1. Signifikante Ereignisse -------------------------------- Ein signifikantes Ereignis ist ein Wechsel im Systemstatus. Es veranlasst die Exekutive, den Vorrang aller aktiven Tasks neu zu ueberpruefen. Ein signifikantes Ereignis wird meist (entweder direkt oder indirekt) durch eine Exekutive-Anweisung aus einer Task hervorgerufen. Die folgenden Ereignisse werden vom System als signifikant gewer- tet: - Taskende - Datenuebertragung zu einer anderen Task (SDAT$) - Ausfuehrung einer SDRC$ oder SDRP$-Anweisung - Empfangen oder Senden eines Referenzblockes (RREF$ bzw. SREF$) - Prioritaetswechsel einer Task (ALTP$) - das Weiterschalten der Uhrwarteschlange (z.B. hervorgerufen durch eine MRKT$-Anweisung oder eine zeitbezogene Taskaktivie- rung) - das Deklarieren eines signifikanten Ereignisses (DECL$S/) - das Ende eines Intervalles der Zeitscheibensteuerung - Beendigung einer E/A-Operation - Statusuebergabe von einer Tochtertask an eine Muttertask (EMIT$, EXST$) 2.2.2.2. Ereignisflags ---------------------- Durch die Benutzung der Ereignisflags kann eine Task spezifische Ereignisse erkennen. So lassen sich bei verschiedenen Anweisungen Ereignisflags festlegen, die nach Abarbeitung der Anweisung von der Exekutive gesetzt werden (z.B. beim Ende einer E/A-Opera- tion). Der Task stehen 96 Ereignisflags zur Verfuegung, mit deren Hilfe sie die einzelnen Ereignisse unterscheiden kann. Jedes dieser Flags ist durch eine Ereignisflagnummer (EFN, Event Flag Number) definiert. 24 Die Ereignisflags 1 bis 32 sind fuer die jeweilige Task bestimmt und koennen als Ergebnis taskinterner Vorgaenge gesetzt und ge- loescht werden. Die Flags 33 bis 64 stehen allen Tasks zur Ver- fuegung. Sie koennen als Ergebnis der Bearbeitung irgendeiner Task - als Reaktion der Handlungen in einer Task fuer eine andere - gesetzt oder geloescht werden. Aus ihrer Verwendbarkeit heraus werden die Flags 1 bis 32 als lo- kale Ereignisflags und die von 33 bis 64 als Common-Ereignisflags bezeichnet. Fuer alle Tasks, die den gleichen Gruppencode im TASK-UIC aufweisen, koennen weitere 32 Flags vereinbart werden (Nummer 65- 96), die sogenannten "Gruppenglobalen Ereignisflags". Sie sind global im Sinne der COMMON-Ereignisflags fuer Task's, die den gleichen Gruppencode im Task-UIC besitzen. Formal koennen also so viele von einander unabhaengige gruppenglobale Ereignisflags definiert werden, wie es Task-Gruppen im System geben kann. Diese Ereignisflags muessen durch spezielle Exekutive-Anweisungen (CRGF$-Erzeugen, ELGF$-Vernichten, ULGF$-Schutz aufheben), die jeweils alle gruppenglobalen Ereignisflags einer UIC- Gruppennummer betreffen, gewartet werden. Das MCR-Kommando FLAG bzw. das DCL-Kommando SET GROUPFLAGS dient ebenso diesem Zweck. Die letzten 8 Flags der ersten beiden Gruppen (25 bis 32 der lokalen und 57 bis 64 der Common-Flags) sind fuer die Benutzung durch das System reserviert. Einige Anweisungen koennen ein bestimmtes Ereignisflag setzen oder loeschen, mit anderen Anweisungen kann man den Zustand aller Ereignisflags ermitteln. Neben dem Setzen oder Loeschen der Ereignisflags ermoeglichen die Anweisungen SETF$ bzw. CLEF$ noch die Ermittlung des Zustandes des Ereignisflags vor Abarbeitung der Anweisung. Dieser wird im Rueckkehrrode uebergeben (siehe Beschreibung der Anweisungen). Das Setzen oder Loeschen der Common- und gruppenglobalen Ereignisflags ist mit groesster Sorgfalt durchzufuehren, da fehlerhaftes oder mehrfaches Veraendern zu Stoerungen bei der Abarbeitung der Nutzertasks fuehren kann. Einige Exekutive-Anweisungen veraendern selbst ein angegebenes Ereignisflag, ohne dass explizit die Anweisungen SETF$ bzw. CLEF$ benutzt werden muessen, z.B. SDAT$, MRKT$ oder E/A-Anweisungen. Die folgenden zwei Beispiele zeigen die Anwendung der Ereignis- flags: Beispiel 1: lokale Ereignisflags -------------------------------- Eine Task A, die zur Bearbeitung von Daten vorgesehen ist, setzt mit Hilfe der Anweisung SETF$ das Ereignisflag 20. Anschliessend werden die Daten bearbeitet. Bei der Erkennung fehlerhafter Daten oder beim Ende der Bearbeitung wird das Flag 20 durch die Anwei- sung CLEF$ geloescht. In Abhaengigkeit von der Wertigkeit des Flags 20 ermoeglicht die Anweisung EXIF$ entweder, dass die naechsten Daten bearbeitet werden oder dass die Task beendet wird.  25 Beispiel 2: COMMON-Ereignisflags -------------------------------- Dieses Beispiel zeigt die synchrone Bearbeitung zweier Tasks mit Hilfe eines Common-Ereignisflags. Task 1 uebernimmt Daten von einem externen Geraet, die Task 2 verarbeiten soll. Nach Uebernahme der entsprechenden Daten loescht Task 1 mit Hilfe der Anweisung CLEF$ das Ereignisflag 52, aktiviert Task 2 und blockiert sich danach durch die Anweisung WTSE$, in der Ereignis- flag 52 angegeben ist. Task 2 verarbeitet die Daten, setzt das Ereignisflag 52 und be- endet seine Arbeit durch die Anweisung EXIT$S. Durch diese Anwei- sung wird ein signifikantes Ereignis erzeugt, das die Weiterar- beit von Task 1 ermoeglicht, da das Ereignisflag 52 gesetzt ist. 2.2.2.3. Ereignisbezogene Exekutive-Anweisungen ----------------------------------------------- Die ereignisbezogenen Exekutive-Anweisungen ermoeglichen die Signalisierung und Synchronisierung innerhalb einer Task und zwischen verschiedenen Tasks. Diese Anweisungen muessen besonders zwischen verschiedenen Tasks sorgfaeltig angewendet werden. Im einzelnen stehen die folgenden Anweisungen zur Verfuegung, die im Abschnitt 2.3.2. beschrieben werden: Anweisung Bedeutung Abschnitt -------------------------------------------------------------- CLEF$ Loeschen eines Ereignisflags 2.3.2.7. CMKTS$ Annullieren zeitabhaengig dekla- rierter signifikanter Ereignisse 2.3.2.8. CRGF$ Erzeugen von gruppenglobalen 2.3.2.11. Ereignisflags DECLS$ Deklarieren eines signifikanten Ereignisses 2.3.2.14. ELGF$ Vernichten von gruppenglobalen 2.3.2.19. Ereignisflags EXIF$ Bedingte Taskbeendigung 2.3.2.23. MRKT$ Zeitabhaengiges Deklarieren eines signifikanten Ereignisses 2.3.2.35. RDAF$ Lesen aller Ereignisflags 2.3.2.41. RDXF$ Erweitertes Lesen aller Er- 2.3.2.42. eignisflags SETF$ Setzen eines Ereignisflags 2.3.2.51. STIM$ Setzen der Systemzeit 2.3.2.61. 26 Anweisung Beduetung Abschnitt ------------------------------------------------------------- STLO$ Stoppen fuer logisches 'ODER' 2.3.2.62. der Ereignisflags STOP$ Stoppen einer Task direkt 2.3.2.63. STSE$ Stoppen fuer ein einzelnes 2.3.2.64. Ereignisflag ULGF$ Schutz aufheben fuer gruppen- 2.3.2.67. globale Ereignisflags USTP$ Aufheben der Stop-Bedingung 2.3.2.69. fuer eine Task WSIG$S Warten auf ein signifikantes Ereignis 2.3.2.69. WTLO$ Warten auf logisches 'ODER' der Ereignisflags 2.3.2.70. WTSE$ Warten auf ein einzelnes Ereignisflag 2.3.2.71. 2.2.2.4. Stop-Bit-Synchronisation --------------------------------- Die STOP-Bit-Synchronisation ermoeglicht die Auslagerung jeder auslagerungsfaehigen Task unabhaengig von ihrer Prioritaet waehrend der Ausfuehrung von gepufferten E/A-Operationen oder wahrend des Wartens auf das Eintreten eines Ereignisses (z.B. eine USTP$-Anweisung wird gegeben oder ein Ereignisflag wird ge- setzt). Die Synchronisation dieser Ablaeufe kann ueber das STOP- Bit im Tasksteuerblock (TCB) gesteuert werden. Wenn das STOP-Bit gesetzt ist, wird die weitere Ausfuehrung der Task verhindert und ihre Prioritaet auf Null gesetzt. Damit kann sie von jeder anderen Task, unabhaengig von deren Prioritaet, ausgelagert werden, wenn damit eigene Speicherplatzanforderungen befriedigt werden koennen. Wenn die gestoppte Task ausgelagert wurde, kann sie sich erst wieder um Hauptspeicherplatz bewerben, wenn das STOP-Bit geloescht wird. Damit wird ihre zuletzt festgelegte, alte Prioritaet wiederhergestellt. Wenn eine gestoppte Task die Steuerung durch einen AST erhaelt, wird sie abarbeitungsfaehig bis die AST-Bedienungsroutine beendet ist. Waehrend dieser Zeit bewirbt sie sich um Hauptspeicherplatz aufgrund ihrer alten Prioritaet. Eine Task kann nicht gestoppt werden, waehrend eine AST-Bedie- nungsroutine arbeitet. Innerhalb dieser Routine aber kann durch die USTP$-Anweisung oder durch das Setzen von Ereignisflags auf den STOP-Zustand der diese Routine enthaltenden Task Einfluss genommen werden. Nach Ausfuehrung der ASTX$-Anweisung wird dann diese Task mit ihrer alten Prioritaet in den abarbeitungsfaehigen Zustand zurueckversetzt.  27 Drei unterschiedliche, sich gegenseitig ausschliessende Wege werden im System bereitgestellt, eine nichtpriviligierte Task zu stoppen und anschliessend wieder in den abarbeitungsfaehigen Zustand zu versetzen. 1) Eine Task wird in den STOP-Zustand versetzt, wenn sie auf das Setzen von Ereignisflags wartet (z.B. mit der WTSE$- Anweisung) und parallel dazu gepufferte E/A-Operation fuer die Task ablaufen. In den abarbeitungsfaehigen Zustand wird die Task dann versetzt, wenn diese E/A-Operation beendet ist und/oder das Warten auf Ereignisflags durch Setzen eines Ereignisflags beendet wird. 2) Eine Task wird durch Anwendung der STOP-Anweisungen, die mit Ereignisflags verbunden sind (STLO$ bsw. STSE$), in den STOP-Zustand versetzt, wenn die korrespondierenden Ereignis- flags geloescht sind. In den abarbeitungsfaehigen Zustand kann diese Task nur versetzt werden, wenn eines der angegebenen Ereignisflags gesetzt wird, eines der Ereignisse also eingetreten ist, die die Task zur Weiterarbeit benoetigt. 3) Eine Task wird in den STOP-Zustand versetzt durch Anwendung der Anweisung STOP$ oder RCST$. Im letzteren Falle nur, wenn keine Datenpakete in der Taskwarteschlange bereitstehen. In den abarbeitungsfaehigen Zustand wird diese Task nur versetzt durch Anwendung der USTP$-Anweisung oder des MCR- Kommandos UNSTOP oder des DCL-Kommandos START. Bemerkungen zur AST-Problematik ------------------------------- - Wenn eine AST-Bedienungsroutine laeuft, kann man eine Task nicht stoppen. Jede solche Anweisung, die in der AST- Bedienungsroutine gegeben wird, wird mit dem DSW-Rueckkehrcode IE.AST als fehlerhaft zurueckgewiesen. - Waehrend eine Task im STOP-Zustand ist, kann sie jedoch AST- Anforderungen bedienen. Ist die Task dazu noch ausgelagert, wird es ihr ermoeglicht, sich um Hauptspeicherplatz aufgrund ihrer alten Prioritaet zu bewerben. Die AST-Bedienungsroutine wird mit dieser alten Prioritaet, die die Task vor Auftreten des STOP-Zustandes hatte, abgearbeitet. Wenn die AST- Bedienungsroutine mit ASTX$-Anweisung verlassen wird und keine weiteren AST-Anforderungen fuer die Task vorhanden sind, wird die Task wieder in den STOP-Zustand versetzt. - Innerhalb der AST-Bedienungsroutine kann die Task Einfluss auf den STOP-Zustand nehmen (z.B. Setzen von Ereignisflags, USTP$- Anweisung). Damit kehrt sie nach Ausfuehrung der ASTX$- Anweisung in den abarbeitungsfaehigen Zustand zurueck. Es existieren im OMEX 1630 5 Exekutive-Anweisungen fuer die direkte Beeinflussung der STOP-Bit-Synchronisation. Davon kann nur die USTP$-Anweisung innerhalb eines AST-Bedienungsprogrammes gegeben werden. 28 - STOP$-Anweisung: Stopt die Task, die die Anweisung enthaelt, unmittelbar. - USTP$-Anweisung: Hebt den STOP-Zustand der in der Anweisung angegebenen Task auf. Im AST - Bedienungsprogramm einer ge- stoppten Task kann sie auch den STOP-Zustand der eigenen Task auf- heben. Der STOP-Zustand muss durch eine STOP$ oder RCST$-Anweisung eingetreten sein. - RCST$-Anweisung: Diese Anweisung versucht, Daten- pakete der angegebenen Task fuer die eigene Task aus der Warteschlange zu entnehmen. Sind keine Pakete vorhanden, wird die Task, die die Anweisung ausgibt, in den STOP-Zustand versetzt. Die Datenpakete werden z.B. mit einer SDAT$-Anweisung einer anderen Task erzeugt. - STLO$-Anweisung: Diese Anweisung versetzt die Task, die die Anweisung ausgibt, in den STOP-Zustand, bis eines der ange- gebenen Ereignisflags gesetzt ist. - STSE$-Anweisung: Diese Anweisung versetzt die Task, die die Anweisung ausgibt, in den STOP-Zustand, bis das vereinbarte Ereignisflag gesetzt wird. 2.2.2.5. Exekutive-Anweisung fuer die STOP-Bit-Synchronisation -------------------------------------------------------------- RCST$ Empfangen eines Datenblocks oder STOP 2.3.2.38. der Task STLO$ STOP fuer logisches 'ODER' der 2.3.2.62. Ereignisflags STOP$ Stoppen einer Task 2.3.2.63. STSE$ STOP fuer ein einzelnes Ereignisflag 2.3.2.64. USTP$ Beenden des STOP-Zustandes 2.3.2.69. 2.2.3. Systemtraps -------------------- Systemtraps sind Unterbrechungen der Taskbearbeitung (auch rufen- de Software-Interrupts genannt), die das Auftreten eines speziel- len Ereignisses anzeigen. Sie ermoeglichen es, Ereignisse zu ueberwachen und auf diese zu reagieren.  29 Ein Systemtrap wird erzeugt, wenn ein bestimmtes Ereignis einge- treten ist. Tritt ein Trap auf, verzweigt die Exekutive in eine bestimmte Routine der Task, die vorher mittels einer speziellen Exekutive-Anweisung durch die Task mit diesem Ereignis verbunden wurde. Diese Routine wird als Bedienungsprogramm be- zeichnet und ist vom Nutzer selbst programmiert und ist Bestand- teil der Task. Nach der Art ihres Auftretens unterscheidet man: - synchrone Systemtraps (SST) - asynchrone Systemtraps (AST) 2.2.3.1. Synchrone Systemtraps ------------------------------ Synchrone Systemtraps werden durch Ereignisse erzeugt, die direkt mit der Befehlsausfuehrung verbunden sind. Sie sind synchron, weil sie bei Wiederholung der Befehlsfolge immer an der gleichen Stelle auftreten. Folgende Ursachen erzeugen einen SST: - unzulaessige Befehle - Befehle mit falscher Adresse (Speicherschutzverletzung, Wort- befehle mit ungerader Adresse oder Befehle mit nichtexistie- render Adresse) - Trap-Befehle 2.2.3.2. Bedienungsprogramme fuer synchrone Systemtraps ------------------------------------------------------- Zu jedem dieser SST kann der Nutzer eine Routine (Bedienungspro- gramm) schreiben, deren Eintrittspunkte in einer Vektortabelle festgelegt sind. Dadurch ist es moeglich, jeden auftretenden SST speziell zu behandeln (z.B. zur Modifizierung von Trap-Befeh- len). Wenn ein SST auftritt, verzweigt die Exekutive in das entspre- chende Bedienungsprogramm. Ist fuer den aufgetretenen SST kein Eintrittspunkt definiert, wird die Task abgebrochen. Das SST-Bedienungsprogramm gibt dem Nutzer die Moeglichkeit, gezielt auf die Ursache zu reagieren und anschliessend die Task an der unterbrochenen Stelle weiterzubearbeiten. Definieren eine Task und eine zur Task gehoerige Testhilfe je- weils einen SST-Eintrittspunkt, so hat die Testhilfe den Vorrang (z.B. DEP-1630). Die Exekutive aktiviert das SST-Bedienungsprogramm, nachdem Pro- zessorstatuswort (PS, Processor Status Word) und Befehlszaehler (PC,Program Counter) in den Stack der Task gekellert worden sind. Die Rueckkehr erfolgt im allgemeinen durch die Befehle RTI bzw. RTT. Die Register R0 bis R6 werden nicht von der Exekutive gerettet. Werden diese Register im SST-Bedienungsprogramm benutzt, so sind sie von diesem selbst zu retten und wiederherzustellen, z. B. ueber den Stack der Task. 30 Die SST-Bedienungsprogrammbearbeitung unterscheidet sich nicht von der Taskbearbeitung. Es duerfen alle Anweisungen benutzt werden. Ein SST-Bedienungsprogramm kann von einem weiteren SST oder einem AST unterbrochen werden. Ausserdem kann ein SST auch innerhalb einer SST-Routine auftreten. Aus diesem Grunde muss das SST-Be- dienungsprogramm wiederaufrufbar sein. Das SST-Bedienungsprogramm kann die im Stack gekellerten Werte veraendern, z.B. den Wert des PC und so zu irgendeiner Stelle der Task verzweigen. Die Steuerung muss nicht an die Stelle im Programm zurueckgehen, an der die Unterbrechung auftrat. Wird das gewuenscht, muss das SST- Bedienprogramm durch die Befehle RTI oder RTT verlassen werden. Die Verwendung der Ereignisflags und des Prozessor- statuswortes muss sorgfaeltig durchdacht werden, da die ver- aenderten Zustaende bei der weiteren Taskbearbeitung erhalten bleiben. Die Bedienungsprogramm-Eintrittspunkte fuer die Be- handlung der entsprechenden SST werden in einer Vektortabelle festgelegt. Diese hat folgenden Aufbau: Wort 00. ungerade oder nichtexistierende Speicheradresse Wort 01. Speicherschutzverletzung Wort 02. T-Bit-Trap oder BPT-Befehl Wort 03. IOT-Befehl Wort 04. verbotener Befehl Wort 05. EMT-Befehl, der nicht von OMOS 1630 selbst benutzt wird (EMT 0 bis EMT 375) Wort 06. Trap-Befehl Soll auf einen SST nicht reagiert werden, wird der Eintrittspunkt mit "Null" definiert. In diesem Fall wird beim Auftreten dieses SST die Task abgebrochen. Eine ungerade Adresse verursacht einen SST, wenn diese Adresse als Eintrittspunkt fuer einen gerade aktiven SST verwendet werden soll. Die Anweisungen SVDB$ bzw. SVTK$ bestimmen Adresse und Laenge dieser Vektortabelle innerhalb der Task. Bei einigen SST koennen ausser Prozessorstatuswort und Befehls- zaehler noch zusaetzliche Informationen im Stack abgespeichert sein. Dies sind bei den speziellen SST: - Speicherschutzverletzung Der Stack beinhaltet: SP + 10: Prozessorstatuswort SP + 06: Befehlszaehler SP + 04: Speicherschutzstatusregister (SRO, Status Register 0) SP + 02: virtuelle Adresse des fehlerhaften Befehls (SR2, Status Register 2) SP + 00: unbenutzt (vorhanden wegen der Kompatibili- taet zu SKR) - Trap-Befehl und EMT-Befehl ausser EMT 377 (und ausser EMT 376 bei privilegierten Tasks)  31 Der Stack hat folgenden Aufbau: SP + 04: Prozessorstatuswort SP + 02: Befehlszaehler SP + 00: Befehlsoperand (niederwertiges Byte) multi- pliziert mit 2, ohne Vorzeichenerweiterung Wird das SST-Bedienungsprogramm mit Hilfe der Befehle RTI bzw. RTT verlassen, duerfen sich nur noch Prozessorstatuswort und Be- fehlszaehler im Stack befinden. Die zusaetzlichen Informationen sind vorher vom SST-Bedienungsprogramm aus dem Stack zu entfer- nen (z.B.: ADD #2,SP fuer einen SST fuer einen TRAP-Befehl). Bei SST infolge von Befehlen mit falscher Adresse kann der Stack einen falschen Befehlszaehlerzustand enthalten. Deshalb muss die- ser korrigiert werden, wenn das Bedienungsprogramm mit RTI oder RTT verlassen werden soll. 2.2.3.3. Asynchrone Systemtraps ------------------------------- Asynchrone Systemtraps (AST, Asynchronous System Traps) zeigen Ereignisse an, die zu einem beliebigen Zeitpunkt waehrend der Taskbearbeitung vorkommen. Das bedeutet, dass die Task keine Kontrolle ueber den genaue Zeitpunkt des Auftretens eines ASTs hat. Das Ende einer E/A-Operation ist ein Beispiel fuer das Auftreten eines ASTs. Der AST informiert die Task, dass ein Ereignis eingetreten ist und bewirkt die Uebergabe der Steuerung an eine ihm zugeordnete Routine, dem Bedienprogramm fuer diesen speziellen AST. Dieses Bedienprogramm muss der Anwender selbst erstellen und in die Task einbinden. Die Task kann damit das Ereignis behandeln und anschliessend an der Unterbrechungsstelle weiterarbeiten. Einige Anweisungen ermoeglichen neben der Spezifizierung einer AST-Bedienungsroutine zur Behandlung einer AST auch die Angabe von Ereignisflags zur Ereignismeldung. Dies gibt dem Anwender die Moeglichkeit, mit einem AST-Bedie- nungsprogramm verschiedene Ereignisse zu behandeln, die durch unterschiedliche Ereignisflags gekennzeichnet sind. Charakteristische Eigenschaften und Benutzung von AST: - Tritt ein AST auf, waehrend die zugehoerige Task abgearbeitet wird, erfolgt eine Unterbrechung der Taskbearbeitung und der AST wird behandelt (Sprung ins AST-Bedienungsprogramm). - Tritt ein AST auf, waehrend schon ein anderer AST bearbeitet wird, ordnet die Exekutive den letzten AST in eine Warte- schlange ein (FIFO, First in-First out) und bearbeitet ihn erst, wenn das begonnene AST-Bedienungsprogramm beendet ist. - Ist eine Task suspendiert oder gestoppt, wenn ein zu ihr gehoeriger AST auftritt, bleibt die Task auch nach dem Ende des AST-Bedienungsprogramms suspendiert oder gestoppt, es sei denn, sie wird durch dieses oder durch eine andere Task aus- druecklich fortgesetzt oder aus dem STOP-Zustand entlassen (z.B. durch eine Exekutive-Anweisung). 32 - Tritt ein AST auf, waehrend die Task auf ein spezifiziertes Ereignisflag wartet oder gestoppt ist (z.B. durch die WTSE$- oder STSE$-Anweisung), wird sie erst fortgesetzt, wenn das AST-Bedienungsprogramm selbst oder eine andere Task das spezifizierte Ereignisflag gesetzt haben. - Tritt ein AST fuer eine Task auf, die ausgelagert ist, wird der AST in die Warteschlange eingeordnet (FIFO). Die Exekutive versucht, die Task wieder in den Hauptspeicher zu bringen. Erst wenn sich die Task wieder im Hauptspeicher befindet, wird der AST wirksam. Dadurch wird verhindert, dass bei ausgelagerter Task ein aufgetretener AST verlorengeht. - Die Exekutive weist beim Spezifizieren des AST den notwendigen dynamischen Speicherbereich zu. Es ist also immer dynamischer Speicherbereich vorhanden, wenn ein AST auftritt. - Die Anweisungen "Erlauben der AST-Bearbeitung" und "Verhindern der AST-Bearbeitung" ermoeglichen die Koordinierung der Bear- beitung zwischen Task und AST-Bedienungsprogramm. Ist die AST- Bearbeitung verhindert, werden auftretende ASTs nur in die Warteschlange eingeordnet (FIFO) und erst dann bearbeitet, wenn die AST-Barbeitung wieder erlaubt ist. 2.2.3.4. Bedienungsprogramme fuer asynchrone Systemtraps -------------------------------------------------------- Im Gegensatz zu den synchronen Systemtraps "merkt" sich die Exe- kutive, dass ein Bedienungsprogramm fuer einen asynchronen Sy- stemtrap bearbeitet wird. Das AST-Bedienungsprogramm kann durch einen SST, nicht aber durch einen weiteren AST unterbrochen werden. Wenn ein AST auftritt, kellert die Exekutive immer das Ereignis- flag-Maskenwort, das Anweisungsstatuswort, das Prozessorstatus- wort und den Befehlszaehler in den Stack der Task. Anschliessend wird die Bearbeitung des AST eingeleitet. In Ab- haenigigkeit vom aufgetretenen AST koennen noch weitere AST- spezifische Informationen im Stack abgespeichert sein. Dadurch wird das AST -Bedienungsprogramm ueber den Zustand der zuge- hoerigen Task informiert und kann mit diesen Informationen arbeiten bzw. diese veraendern. Die Register R0 bis R6 werden von der Exekutive beim Auftreten eines AST nicht gerettet. Benutzt das AST-Bedienungsprogramm diese Register, so muss es diese selbst retten und wiederherstellen. Ein AST-Bedienungspro- gramm ist mit der Anweisung ASTX$S zu beenden. Vor Abarbeitung der Anweisung ASTX$S muessen die Informationen folgendermassen im Stack der Task abgespeichert sein: SP + 06 Ereignisflagmaskenwort SP + 04 Prozessorstatuswort der Task vor dem AST SP + 02 Befehlszaehler der Task vor dem AST SP + 00 Anweisungs-Statuswort der Task vor dem AST  33 Andere AST-spezifische Parameter muessen vorher aus dem Stack der Task entfernt worden sein. Nach Beendigung eines AST-Bedienungsprogramms wird entweder ein anderer AST oder die Task bearbeitet. Bedeutung des Ereignisflagmaskenwortes: Durch Veraendern des Ereignisflag-Maskenwortes kann das AST-Be- dienungsprogramm eine blockierte oder gestoppte Task wieder in den abarbeitsfaehigen Zustand versetzen. Es hat den Wert bzw. enthaelt die Ereignisflagfolge, die durch die letzte Anweisung "WTLO$" "WTSE$" STLO$ oder STSE$ fuer diese Task festgelegt wurde. Enthaelt die Task keine der Anweisungen oder wurde ihre Bedingung bereits erfuellt, ist das Ereignisflag-Maskenwort bedeutungslos. Das Ereignisflag-Maskenwort fuer Systeme, die die Stop-Bit-Syn- chronisation oder das Auslagern waehrend gepuffer- ter E/A-Operationen unterstuetzen, ist ueber die lokale Symboldefinition T.EFLM im Taskkopf zu erreichen. In Systemen ohne diese Moeglichkeiten ist das Wort ueber die lokale Symbolde- finition H.EFLM erreichbar. Das Ereignisflag-Maskenwort entspricht der Angabe des Maskenwor- tes im WTLO$-Makro. Es haette z.B. fuer das Ereignisflag 40. in einer WTSE$-Anweisung den Wert 200 (octal). Bei der Modifizierung des Ereignisflag-Maskenwortes muss groesste Vorsicht walten! Bevor zu einem AST-Bedienungsprogramm verzweigt wird, kellert die Exekutive AST-abhaengige Informationen in den Stack der Task, mit denen das AST-Bedienungsprogramm arbeiten kann. Folgende Varianten des Stacks koennen durch die Exekutive beim Auftreten eines AST aufgebaut werden: - AST bei Informationsuebergabe an eine Task Soll einer Task eine Information von einer anderen Task durch Datenpakete oder Referenzbloecke uebergeben werden, so ist die Anweisung "SRDA$" bzw. "SRRA$" zu programmieren. Stackaufbau: SP + 06 - Ereignisflag-Maskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Task vor dem AST SP + 00 - Anweisungs-Statuswort Erfolgt die Signalisierung waehrend eine Task ausgelagert ist (Neuzustand oder angearbeiteter Zustand), wird der AST wirksam, wenn sich die Task wieder im Hauptspeicher befindet. - AST bei Ende von Ein-/Ausgaben Ist in einer Ein-/Ausgabe-Anweisung ein AST-Eintrittspunkt angegeben, so wird am Ende der Ein-/Ausgabe ein AST erzeugt. 34 Stackaufbau: SP + 10 - Ereignisflag-Maskenwort SP + 06 - PS der Task vor dem AST SP + 04 - PC der Task vor dem AST SP + 02 - Anweisungs-Statuswort SP + 00 - Adresse des E/A-Statusblockes oder "0", wenn keine Adresse angegeben ist - AST bei Erreichen des Endes eines Zeitintervalls, hervorgerufen durch MRKT$ Ist in der Anweisung MRKT$ ein AST-Eintrittspunkt angegeben, tritt ein AST auf, wenn das Zeitintervall abgelaufen ist. Stackaufbau: SP + 10 - Ereignisflag-Maskenwort SP + 06 - PS der Task vor dem AST SP + 04 - PC der Task vor dem AST SP + 02 - Anweisungs-Statuswort SP + 00 - Ereignisflagnummer oder "O", wenn kein Ereignisflag spezifiziert ist - AST bei Arithmetikprozessorfehler Soll bei einem Arithmetikprozessorfehler ein AST erzeugt wer- den, so ist die Anweisung "SFPA$" zu programmieren. Stackaufbau: SP + 12 - Ereignisflag-Maskenwort SP + 10 - PS der Task vor dem AST SP + 06 - PC der Task vor dem AST SP + 04 - Anweisungs-Statuswort der Task SP + 02 - Arithmetikfehlercode SP + 00 - Arithmetikfehleradresse - AST bei Netzwiederkehr Zum Erzeugen eines AST bei Netzwiederkehr ist die Anweisung "SPRA$" zu programmieren. Stackaufbau: SP + 06 - Ereignisflag-Maskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Task vor dem AST SP + 00 - Anweisungs-Statuswort der Task Dieser AST tritt nur fuer eine Task auf, die nicht ausgelagert ist. - AST bei Beendigung einer Tochtertask Eine Tochtertask, gebildet durch eine SPWN$, CNCT$ oder SDRC$- Anweisung, erzeugt in der Muttertask einen AST bei Statusueber- gabe an die Muttertask oder durch Taskende.  35 Stackaufbau: SP + 10 - Ereignisflag-Maskenwort SP + 06 - PS der Muttertask vor dem AST SP + 04 - PC der Muttertask vor dem AST SP + 02 - Anweisungs-Statuswort SP + 00 - Adresse des Exit-Statusblocks in der Muttertask - AST beim Versuch, eine Task abzubrechen Soll eine Task auf den Versuch reagieren, sie durch eine Abbruch-Anweisung (ABRT$) oder ein MCR bzw. DCL ABO-Kommando abzubrechen, ist die Anweisung SREA$ oder SREX$ zu programmieren. Stackaufbau bei SREA$: SP + 06 - Ereignisflag-Maskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Task vor dem AST SP + 00 - Anweisungs-Statuswort Stackaufbau bei SREX$: SP + 12 - Ereignisflag-Maskenwort SP + 10 - PS der Task vor dem AST SP + 06 - PC der Task vor dem AST SP + 04 - Anweisungs-Statuswort SP + 02 - Trapabhaengige Werte SP + 00 - Zahl der Bytes (4), die zu SP addiert werden muessen, um den Stack vor dem AST-Exit zu be- reinigen. - AST bei unverlangter Terminaleingabe Soll eine Task auf unverlangte Terminaleingaben (ueber einen Vollduplextreiber fuer das Terminal) reagieren, so ist in der Task eine QIO-IO.ATA-Anweisung zu programmieren. Unverlangte Eingaben fuehren dann zu einem AST in der Task. Stackaufbau: SP + 10 - Ereignisflag-Maskenwort SP + 06 - PS der Task vor dem AST SP + 04 - PC der Task vor dem AST SP + 02 - Direktive-Statuswort der Task SP + 00 - Unverlangtes Eingabezeichen im niederwertigen Byte, Parameter 2 im hoeherwertigen Byte 2.2.3.5. Systemtrapbezogene Exekutive-Anweisungen ------------------------------------------------- Die systemtrapbezogenen Anweisungen ermoeglichen dem Nutzer die Verwendung des Hardware-Trap-Systems. Sie gestatten das Unterbre- chen der Taskbearbeitung (Software-Interrupts), um zu einem spe- ziellen Trap-Bedienungsprogramm zu verzweigen. Im einzelnen stehen die folgenden Anweisungen zur Verfuegung, die im Abschnitt 2.3.2. beschrieben werden. 36 Anweisung Bedeutung Abschnitt -------------------------------------------------------- ASTX$S Ende einer AST-Bedienung 2.3.2.4. DSAR$S Verhindern der AST-Bearbeitung 2.3.2.15. ENAR$S Erlauben der AST-Bearbeitung 2.3.2.21. IHAR$S Verhindern der AST-Bearbeitung 2.3.2.15. SFPA$ Spezifizieren von Arithmetik- prozessorfehler-AST 2.3.2.52. SPRA$ Spezifizieren von Netzwieder- kehr-AST 2.3.2.55. SRDA$ Spezifizieren von Daten- empfangs-AST 2.3.2.57. SREA$ Spezifizieren von Task-Abbruch- AST 2.3.2.58. SREX$ Spezifizieren von Task-Abbruch- AST 2.3.2.58. SRRA$ Spezifizieren von AST nach Senden von Referenzbloecken fuer die Task 2.3.2.60. SVDB$ Spezifizieren der SST-Vektor- tabelle fuer eine Testhilfe 2.3.2.65. SVTK$ Spezifizieren der SST-Vektor- tabelle fuer eine Task 2.3.2.66.  37 2.2.4. Speicheradressierung und -verwaltung --------------------------------------------- 2.2.4.1. Segmentierung und Partition-Typen ------------------------------------------ Die Wortlaenge von 16 Bit bei allen Zentraleinheiten des MRS 1600 beschraenkt den Bereich der Adressierung auf 32 K Worte. Eine Task kann damit nur 32 K Worte direkt adressieren. Um diese Be- schraenkung der Groesse einer Task zu vermeiden, wird die Technik der Ueberlagerung angewendet. Der Nutzer zerlegt die Task in ein Wurzelsegment und verschiedene Ueberlagerungssegmente. - plattenbezogene Ueberlagerung Das Wurzelsegment befindet sich immer im Hauptspeicher. Die einzelnen Segmente werden von der Platte zum Hauptspeicher befoerdert, wenn sie benoetigt werden. Die Summe der Laengen des Wurzelsegments und aller gleichzeitig im Hauptspeicher vorhandenen Segmente kann 32 K Worte nicht uebersteigen. - speicherresidente Ueberlagerung Die Task wird ebenfalls in Segmente zerlegt. Sowohl das Wurzelsegment (Task-Region) als auch die Ueberlagerungs- segmente (statische Regionen) befinden sich im Hauptspeicher. Weil damit saemtliche Uebertragungszeiten entfallen, wird die Task-Abarbeitung wesentlich schneller vollzogen als bei der plattenbezogenen Ueberlagerung. Eine Kombination beider Ueberlagerungstechniken ist moeglich. Das Anliegen dieses Abschnittes besteht darin, die Leistungen der Exekutive in bezug auf die speicherresidente Ueberlagerung darzu- stellen. Dazu werden folgende Begriffe eingefuehrt: - Physischer Speicherraum Der physische Speicherraum beinhaltet den gesamten absolut adressierten Hauptspeicher, der in Seiten variabler Groesse (bis maximal 4 K Worte pro Seite) eingeteilt ist. - Logischer Adressraum Der logische Adressraum bezieht sich auf eine bestimmte Task. Er besteht aus allen physischen Speicherbereichen, zu denen die Task generell Zugriff hat. Diese Speicherbereiche werden als Regionen bezeichnet. - Virtueller Adressraum Der virtuelle Adressraum entspricht dem durch die 16-Bit- Adresse direkt adressierbaren Wortbereich von 0 bis 32 K Worten. Er besteht aus maximal 8 Bereichen (Adressfenster). Die Zuweisung der virtuellen Adressbereiche zu den entsprechenden Seiten des physischen Speicherraumes erfolgt ueber die Seiten- register (APR, Active Page Register) und wird von der Speichervermittlungseinheit SVE 30 ausgefuehrt. Der physische Speicher wird in Partitions eingeteilt. Es gibt zwei Partitiontypen, nutzergesteuerte und systemgesteuerte Par- titions. 38 In einer nutzergesteuerten Partition kann nur eine einzige Task abgearbeitet werden. Sie kann vom Nutzer in bis zu 7 Subparti- tions unterteilt werden. Wenn in der Hauptpartition keine Task aktiv ist, koennen in den Subpartitions kleinere Tasks abgearbeitet werden. Die Verant- wortung ueber die Speicherplatzbelegung obliegt dem Nutzer. Systemgesteuerte Partitions erlauben die gleichzeitige Abarbei- tung mehrerer Tasks in einer Partition. Die Speicherplatzbelegung wird vom System vorgenommen und ist vom Nutzer nicht beeinfluss- bar. Der Begriff Adresszuweisung ist von zentraler Bedeutung fuer die dynamische Speicherverwaltung.Die Adresszuweisung ist der Vorgang des Verbindens von virtuellen Taskadressen mit dem physischen Speicher. Durch die Adresszuweisung sind ein effektiver Speicher- schutz und eine optimale Speicherausnutzung moeglich. Die Adresszuweisung wird hardwaremaessig von der Speichervermitt- lungseinheit SVE 30 ausgefuehrt. Eine konkrete Beschreibung der SVE 30 ist der Dokumentation ueber die ZVE des K 1630 zu entneh- men. Bei Systemen ohne Adresszuweisung sind der virtuelle und logische Adressraum einer Task identisch, d.h. eine virtuelle Adresse entspricht immer der gleichen logischen Adresse. Die maximale Groesse beider Adressraeume betraegt 32 K Worte. Durch die Benut- zung der Exekutive-Anweisungen der Speicherverwaltung im OMEX 1630 (System mit Adresszuweisung) koennen einer virtuellen Adresse zu verschiedenen Zeiten unterschiedliche logische Adressen zugewiesen werden. Dadurch kann der logische Adress- raum die Grenze von 32 K Worten ueberschreiten und maximal dem gesamten physischen Speicher entsprechen. Die Moeglichkeit der Adresszuweisung von virtuellen Adressberei- chen (Adressfenster) zu logischen Adressbereichen (Regionen) ist die Voraussetzung fuer speicherresidente Ueberlagerungen. 2.2.4.2. Regionen ----------------- Eine Region ist ein Teil des physischen Adressraumes, zu dem eine Task Zugriff hat oder moeglicherweise Zugriff haben kann. Die aktuelle Adressbeziehung zwischen Fenster und Region bestimmt den Teil des logischen Adressraumess, zu der die Task gerade zugreifen kann. Es existieren folgende Arten von Regionen: - Taskregion In der Taskregion - ein zusammenhaengender Speicherbereich - wird die Task ausgefuehrt. In ihr ist der Taskkopf und die Task selbst enthalten. - Statische Region Eine statische Region wird durch den Bediener oder waehrend der Systemgenerierung definiert. Sie kann eine Bibliothek oder einen globalen Datenbereich aufnehmen.  39 - Dynamische Region Eine dynamische Region wird waehrend der Taskabarbeitung durch Exekutive-Anweisungen erstellt. Sie kann beispielsweise zur Speicherung groesserer Datenmengen dienen, die im Ver- lauf der Programmabarbeitung entstehen. Dynamische Regionen koennen nur in systemgesteuerten Partitions erstellt werden. Von mehreren Tasks gemeinsam genutzte Regionen werden geteilte Regionen genannt. Das koennen nur statische oder dynamische Re- gionen sein. Zur Handhabung von Regionen gehoert das Binden. Man bezeichnet den Vorgang, bei dem eine Region Bestandteil des logischen Adressraums einer Task wird, als das Binden einer Region an die Task. Durch das Binden werden der Task alle vorher vom Eigentuemer spezifizierten Zugriffsrechte in bezug auf die Region gewaehrt. Das Binden kann in folgender Weise organisiert werden: - Fuer alle Regionen (Ueberlagerungssegmente), die bereits zur Zeit des Taskaufbaus zur Task gehoeren sollen, wird das Binden vom System vorgenommen. - Falls der Nutzer waehrend der Taskabarbeitung mittels einer CRRG$-Anweisung eine dynamische Region erstellt, ist diese Region noch nicht Bestandteil des logischen Adressraums der Task (Nutzer = Eigentuemer der Region). Die Region wird erst dann an die Task gebunden, wenn eine ATRG$-Anweisung ausge- fuehrt wird bzw. wenn die Funktion von ATRG$ in der CRRG$- Anweisung enthalten war. Mit ATRG$ kann die Task auch eine be- nannte statische Region an sich binden. - Es besteht die Moeglichkeit, Regionen einer Task an eine andere Task zu binden (ausser der Taskregion). In diesem Fall muss die Task, die die Region verwenden moechte, eine ATRG$-Anweisung ausgeben. Die Zugriffsrechte zu dieser "fremden" Region haengen dann von den Angaben des Eigentuemers beim Erstellen der Region ab (siehe Abschnitt 2.2.4.4.). Das Gegenteil des Bindens, das Losloesen einer Region vom logi- schen Adressraum einer Task, wird als Trennen einer Region von einer Task bezeichnet. Das Trennen wird mittels der DTRG$- Anweisung ausgefuehrt. Region-Definitionsbloecke ------------------------- Region-Definitionsbloecke gewaehrleisten die Kommunikation zwi- schen Nutzertask und Exekutive. Wenn der Nutzer beabsichtigt, waehrend der Taskabarbeitung eine Region zu erstellen bzw. zu binden, muss er einen Region-Defini- tionsblock (RDB, Region Definition Block) herstellen. Der RDB beinhaltet alle Informationen, die fuer die Ausfuehrung der An- weisung notwendig sind. Andererseits werden von der Exekutive bei der Ausfuehrung einer Anweisung Informationen in den RDB gespei- chert, die zu einem spaeteren Zeitpunkt von einer anderen Anwei- sung benoetigt werden. 40 Im folgenden Bild wird das Format eines RDB dargestellt. symbolische Byte- Offsets offsets ----------------------------------- 0 | | R.GID | Region-Identifikation | | | ----------------------------------- 2 | | R.GSIZ | Groesse der Region | | (in 32.Wortbloecken) | ----------------------------------- 4 | | | | R.GNAM | Name der Region | |- -| | (RADIX-50) | | | | | ----------------------------------- 10 | | | | R.GPAR | Name der Partition | |_ der Region _| | (RADIX-50) | | | | | ----------------------------------- 14 | | R.GSTS | Region-Statuswort | | | ----------------------------------- 16 | | R.GPRO | Region-Schutzwort | | | ----------------------------------- Bild 5 Region-Definitionsblock Die symbolischen Offsets haben folgende Bedeutung: R.GID - Die Region-Identifikation ist die Adresse des Bindungs- Deskriptors der Region. Sie wird vom System festgelegt. (Der Bindungs-Deskriptor ist ein Steuerblock, der In- formationen ueber das Binden der Region enthaelt. Er wird von der Exekutive im dynamischen Bereich der Exe- kutive (Pool) angelegt. R.GSIZ - Die Groesse der herzustellenden Region wird vom Nutzer festgelegt, und zwar in 32.Wortbloecken. R.GNAM - Wenn der Nutzer bei der Definition der Region einen Namen fuer die Region angibt, koennen alle Tasks, die den Namen kennen, diese Region an sich binden. Der Name besteht aus RADIX-50-Zeichen  41 R.GPAR - Der Nutzer kann bei der Herstellung der Region mittels des Namens der Partition die Partition festlegen, in der die Region erstellt werden soll. Es muss eine sy- stemgesteuerte Partition sein. R.GPRO - Im Standard-Schutzwort werden vom Eigentuemer die Zugriffsrechte der Tasks zur Region festgelegt. Detaillierte Ausfuehrungen sind dem Abschnitt 2.2.4.4. zu entnehmen. R.GSTS - Das Region-Statuswort besteht aus Bits, die durch die Task bzw. durch die Exekutive gesetzt werden koennen. Bit 15 14 7 6 5 4 3 2 1 0 ------------------------------------------------- | | |\/|\/|\/|\/|\/|\/| | | | | | | | | | | |/\|/\|/\|/\|/\|/\| | | | | | | | | ------------------------------------------------- | | | | | | | | | | RS.CRR RS.MDL|RS.ATT|RS.DEL|RS.WRT | | | | | RS.UNM RS.NDL RS.NEX RS.EXT RS.RED Bild 6 Region-Statuswort Im Statuswort legt der Region-Eigentuemer bestimmte Eigenschaften der Region fest. Gesetzte Bits des Region-Statuswortes haben folgende Bedeutung: Symbol Bit RS.RED 0 - Von der Region kann gelesen werden. RS.WRT 1 - Auf die Region kann geschrieben werden. RS.EXT 2 - Die Region kann erweitert werden. RS.DEL 3 - Die Region kann geloescht werden. RS.NEX 4 - Die herzustellende Region soll nicht erweiterungs- faehig sein. RS.ATT 5 - Bei der Herstellung der Region soll sofort das Binden an die Task (die die CRRG$-Anweisung ent- haelt) vorgenommen werden. RS.NDL 6 - Die Region soll nicht geloescht werden, nachdem sie von der letzten Task getrennt worden ist. Es ist zu beachten, dass unsachgemaesse Verwendung des Off- sets Speicherbereiche sperren kann. RS.MDL 7 - Die Region soll nach der Trennung von der letzten Task geloescht werden. RS.UNM 14 - Bei der Trennung der Region von einer Task war die Aufhebung mindestens einer Adresszuweisung zwischen Fenster und Region notwendig. RS.CRR 15 - Die Region wurde erfolgreich hergestellt. 42 Nur die Bits 14 und 15 des Statusworts werden von der Exekutive in Abhaengigkeit von der ausgefuehrten Anweisung modifiziert. Bits 13 und 12 werden geloescht. Dem Nutzer stehen fuer die Verwendung des RDB zwei Makros zur Verfuegung. Mit dem Makro RDBDF$ werden die symbolischen Offsets und die Symbole fuer die Bits des Statusworts definiert. Der Makro wird durch RDBDF$ aufgerufen. Der Nutzer muss diesen Makro nicht verwenden. Zur Herstellung des eigentlichen RDB wird der Makro RDBBK$ vom Nutzer verwendet. Der Makro wird folgendermassen aufgerufen: RDBBK$ siz,[nam],[par],sts[,pro] Die in Klammern gesetzten Argumente sind Wahlparameter. Die Argumente haben folgende Bedeutung: siz - Groesse der Region in Bloecken zu 32. Worten (R.GSIZ) nam - Name der Region in RADIX-50 (R.GNAM) par - Name der Partition in RADIX-50 (R.GPAR) sts - Region-Statuswort (R.GSTS) pro - Standard-Schutzwort als Oktalzahl (R.GPRO) Fuer die Spezifikation des Statuswortes sts verwendet der Nutzer die Darstellung , wobei xxx durch die entsprechende oben beschriebene Symboldefini- tion ersetzt wird. Ein RDB wird von verschiedenen Exekutive-Anweisungen benutzt. Falls spezifizierte Argumente von einer dieser Anweisungen nicht verwendet werden, dann werden diese Argumente uebergangen. Aus der folgenden Uebersicht geht hervor, welche Informationen die einzelnen Anweisungen aus dem RDB benoetigen (N = vom Nutzer festgelegt) und welche Informationen die Exekutive bei der Aus- fuehrung der entsprechenden Anweisung im RDB speichert (E = von der Exekutive festgelegt). Ein durch "-" gekennzeichnetes Feld zeigt an, dass das entspre- chende Argument von der Anweisung nicht verwendet wird.  43 Anweisung | RDB-Parameter |----------------------------------------------- | R.GID | siz | nam | par | sts | pro | ------------------------------------------------------------- CRRG$ | - | N | N | N | N/E | N | ------------------------------------------------------------- ATRG$ | E | E | N | - | N/E | - | ------------------------------------------------------------- DTRG$ | N | - | - | - | N/E | - | ------------------------------------------------------------- Zur Veranschaulichung der Benutzung eines RDB dient das folgende Beispiel: Der Nutzer vereinbart den Makro RDBBK$ 96.,REG,GEN,,176000 Der Makro wird erweitert zu .WORD 0 ;Region-Identifikation, vom System zur Ausfuehrungszeit belegt .WORD 96. ;Groesse der Region .RAD50 /REG/ ;Name der Region .WORD 0 ;Name der Region .RAD50 /GEN/ ;Name der Partition .WORD 0 ;Name der Partition .WORD RS.WRT!RS.RED ;Statuswort .WORD 176000 ;Schutzwort Wenn eine CRRG$-Anweisung den RDB benutzt, dann wird eine Region mit dem Namen REG in der Partition GEN hergestellt. Die Region ist 96 Bloecke gross. Tasks der Nutzergruppen System und Eigen- tuemer haben alle Zugriffsrechte zur Region. Tasks der Nutzer- gruppe Gruppe duerfen nur lesen und schreiben. Alle anderen Tasks haben keine Zugriffsrechte zur Region (siehe 2.2.4.4. Regions- schutz ...). Wenn von einer Task eine ATRG$-Anweisung fuer diese Region aus- gegeben wird, die lesen bzw. schreiben moechte und deren UIC nicht den Zugriffsrechten widerspricht, so wird das Binden der Region an die Task vollzogen. Fuer FORTRAN-Programme gilt: Ist in einem Programm ein Region-Definitionsblock bereitzustel- len, muss der Nutzer ein 8-Worte-Integerfeld einfacher Genauig- keit vereinbaren. Das gilt fuer folgende Unterprogrammrufe: CALL ATRG CALL CRRG CALL DTRG 44 Das RDB-Feld hat folgendes Format: Wort | Inhalt -------------|--------------------------------------------------- | irdb(1) | Region ID irdb(2) | Groesse der Region (in 32-Wortbloecken) irdb(3) | Name der Region (2 Worte in RADIX-50) | - erster Teil ... irdb(4) | - zweiter Teil des Namens irdb(5) | Name der Partition der Region (2 RADIX-50 Worte) | - erster Teil ... irdb(6) | - zweiter Teil des Namens irdb(7) | Region-Statuswort irdb(8) | Region-Schutzwort Der Programmierer kann das Region-Statuswort (irdb(7)) durch Setzen und Loeschen von Bits modifizieren (siehe Bild 6). Die Bedeutung der Bits des Region-Statuswortes ist im vorhergehenden bereits beschrieben. 2.2.4.3. Virtuelle Adressfenster -------------------------------- Um auf eine Region zugreifen zu koennen, muss ein Adressfenster der Region zugewiesen werden. Ein Adressfenster ist ein zu- sammenhaengender Bereich des virtuellen Adressraumes, der an einer 4K-Wortgrenze beginnt. Es wird mittels Exekutive-Anwei- sung gehandhabt. Damit besitzt der Nutzer die Moeglichkeit, der von ihm gewuenschten Region dynamisch virtuelle Adressen zuzuweisen. Die virtuellen Adressen einer Task muessen bei ihrer Benutzung Bestandteil eines existierenden Adressfensters sein, das einer zum logischen Adressraum der Task gehoerenden Region zugewiesen wurde. Dem Nutzer stehen folgende Exekutive-Anweisungen zur Handhabung der Adressfenster zur Verfuegung: Ein Adressfenster kann herge- stellt werden (CRAW$), es kann eine Adresszuweisung zu einer Region vollzogen werden (MAP$), die Adresszuweisung kann aufgeho- ben werden (UMAP$) und das Adressfenster kann eliminiert werden (ELAW$). Die Adresszuweisung kann folgendermassen erfolgen: - Ein Adressfenster kann zu einer Region bzw. zu einem Teil einer Region zugewiesen werden. - Die Adresszuweisung eines Fensters zu einem Teil einer Region kann aufgehoben und das gleiche Fenster kann zu einem anderen Teil der Region zugewiesen werden. - Die Adresszuweisung eines Fensters zu einer Region kann aufge- hoben und einer anderen Region zugewiesen werden.  45 Der Nutzer kann fuer jede Task maximal 7 Adressfenster (1 bis 7) selbst herstellen. Die maximale Anzahl der gleichzeitig hergestellten Adressfenster muss schon beim Bilden der Task angegeben werden. Das Adressfenster 0 wird vom System er- oeffnet und der Task-Region zugewiesen. Jedes Adressfenster kann maximal 32K Worte umfassen. Im folgenden Bild wird die Handhabung der Adressfenster und Re- gionen veranschaulicht. ---------- ---------- |Region A| |Region A| | | ---|--------| | | | | | | | | | | | | | | | | | | -|--------| ---------- | |---------- | | | | ------------- | |---------- |Region B| | ---------- ---------- | ||Region B| | | | | \ / | | \ / | | || | | | | | \/ | | \/ | | || | | | | | /\ | | /\ | | || | | | | | / \ | | / \ | | || | |--------|- |--|--------| |--------|--| || | | || |Fenster | |Fenster | || | | || | 1 | | 2 | || | ----------| | | | | |---------- | | | |--------|----- | | | | \ / | --------------- | \ / | | \ / | | \/ | | \/ | | /\ | | /\ | | / \ | | / \ | | / \ | ---------- - - |--------| |--------| - - ---------- | Task- | |Fenster | |Fenster | | Task- | | Region | | 0 | | 0 | | Region | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | ---------- - - ---------- ---------- - - ---------- logischer virtueller virtueller logischer Adressraum Adressraum Adressraum Adressraum Zeit 1 Zeit 2 Bild 7 Handhabung von Adressfenstern und Regionen Die Task besteht aus der Taskregion und zwei dynamischen Regionen. Zum Zeitpunkt 1 der Taskabarbeitung wurde ausser dem grundsaetzlich zur Taskregion zugewiesenen Adressfenster 0 das Adressfenster 1 zu einem Teil der Region B zugewiesen. Die Region A bzw. der nicht zugewiesene Teil der Region B koennen nicht bearbeitet werden. 46 Nach der Aufhebung der Adresszuweisung wurde zum Zeitpunkt 2 das Fenster 2 zu einem Teil der Region A zugewiesen und diese somit fuer die Benutzung freigegeben. Fenster-Definitionsbloecke -------------------------- Ein Fenster-Definitionsblock (WDB, Window Definition Block) dient als Kommunikationsbereich zwischen der Nutzer-Task und der Exeku- tive. Mittels des WDB uebergibt der Nutzer der Exekutive Informa- tionen fuer die auszufuehrenden Anweisungen. Diese Informationen werden im Taskkopf in einem Fensterblock festgehalten. Anderer- seits werden von der Exekutive Informationen ueber ausgefuehrte Anweisungen in den WDB zur weiteren Verwendung abgespeichert. Das Format eines WDB wird in folgendem Bild dargestellt: symbol. Byte- Offset offset ------------------------------------ 0 | Fenster- | Basis-APR | W.NID/W.NAPR | Identifikation| | | | | ------------------------------------ 2 | virtuelle Basisadresse, bei der | W.NBAS | das Fenster beginnt (Byte- | | Adresse) | ------------------------------------ 4 | Groesse des | W.NSIZ | Adressfensters | | (in 32.-Wortbloecken) | ------------------------------------ 6 | | W.NRID | Region-Identifikation | | | ------------------------------------ 10 | Offset innerhalb der Region, | W.NOFF | bei dem die Zuweisung beginnt | | (in 32.-Wortbloecken) | ------------------------------------ 12 | Laenge des Bereiches in der | W.NLEN | Region, zu der die Zuweisung | | erfolgt (32.-Wortbloecke) | ------------------------------------ 14 | | W.NSTS | Fenster-Statuswort | | | ------------------------------------ 16 | Adresse des Sende- oder | W.NSRB | Empfangspuffers (Byte-Adresse) | | | ------------------------------------ Bild 8 Fenster-Definitionsblock W.NAPR - Mit der Nummer des Seitenregisters (APR) legt der Nutzer die Seite fest, mit der das Adressfenster be- ginnt, d.h. das APR bestimmt die 4K-Grenze, an der das Adressfenster beginnt (ein Byte, Ziffer zwischen 0 und 7, siehe auch W.NBAS).  47 W.NID - Jedem Adressfenster wird von der Exekutive eine fuer die Kennzeichnung notwendige Adressfenster-Iden- tifikation zugeordnet. Die Identifikation ist eine Ziffer von 0 bis einschliesslich 7. Das Adressfenster 0 kann vom Nutzer nicht benutzt werden; es wird fuer die Zuweisung zur Task-Region verwendet. W.NBAS - Die virtuelle Basisadresse wird von der Exekutive aus der Nummer des APR berechnet. APR0 wird der virtuellen Adresse 0, APR1 der virtuellen Adresse 4K, APR2 der virtuellen Adresse 8K usw. zugeordnet. W.NSIZ - Die Groesse des Fensters wird vom Nutzer in 32.-Wort- bloecken angegeben. W.NRID - Die Region-Identifikation wird vom Nutzer aus dem RDB derjenigen Region uebernommen, zu welcher das Fenster zugewiesen werden soll. W.NOFF - Mit dem Offset legt der Nutzer fest, wieviel 32.-Wort- bloecke vom Region-Anfang entfernt das Adressfenster beginnen soll. Der anzugebende Wert ist vom Bit WS.64B im Fenster-Statuswort abhaengig. Er muss ein Vielfa- ches der angegebenen Blockgroesse repraesentieren, d.h. bei WS.64B = 0 muss W.NOFF ein Vielfaches von 8 sein, bei WS.64B = 1 ist jeder Wert gueltig. W.NLEN - Falls nicht das gesamte Fenster zugewiesen werden soll, sondern nur ein Teil, dann spezifiziert der Nutzer die Laenge der Adresszuweisung in 32.-Wort- bloecken. W.NSRB - Falls ueber SREF$- bzw. RREF$-Anweisungen ein Informa- tionsaustausch zwischen Tasks vorgenommen werden soll, beinhaltet W.NSRB die Adresse eines 8-Worte-Feldes, das die Nutzerinformationen enthaelt (SREF$) oder in das diese eingetragen werden sollen (RREF$). W.NSTS - Das Fenster-Statuswort besteht aus Bits, die durch die Task bzw. von der Exekutive gesetzt werden koennen. 48 Bit 15 0 ------------------------------------------------- | | | | |\/|\/|\/| | | |\/|\/| | | | | | | | | |/\||\|/\| | | |/\|/\| | | | | ------------------------------------------------- | | | | | | | | | | | WS.CRW WS.ELW WS.MAP WS.EXT WS.RED | | | | | | WS.UNM WS.RRF WS.64B WS.RCX WS.DEL WS.WRT Bild 9 Fenster-Statuswort Gesetzte Bits des Fenster-Statusworts haben folgende Bedeutung: Symbol Bit WS.RED 0 - Beim Senden wird Lesen erlaubt. WS.WRT 1 - Beim Senden und bei der Adresszuweisung wird Schreiben erlaubt. WS.EXT 2 - Beim Senden wird Erweitern erlaubt. WS.DEL 3 - Beim Senden wird Loeschen erlaubt. WS.RCX 6 - Falls beim Informationsaustausch zwischen Tasks die empfangende Task keinen Referenzblock findet, wird die Taskbearbeitung beendet (siehe RREF$-An- weisung). WS.MAP 7 - Das Adressfenster wird sofort bei seiner Herstel- lung oder beim Empfang eines Referenzblockes zuge- wiesen (siehe RREF$-Anweisung). WS.64B 8 - Der physische Speicher wird durch die Task in Bloecke zu 64. Byte eingeteilt. Ist das Bit nicht angegeben, betraegt die Blockgroesse 512. Byte. WS.RRF 12 - Mittels einer RREF$-Anweisung wurde ein Referenz- block erfolgreich empfangen. WS.ELW 13 - Bei der zuletzt ausgefuehrten Anweisung (CRAW$ oder ELAW$) musste ein Fenster eliminiert werden. WS.UNM 14 - Durch die zuletzt ausgefuehrte Anweisung (CRAW$, MAP$ oder UMAP$) wurde eine Adresszuweisung aufge- hoben. WS.CRW 15 - Ein Adressfenster wurde erfolgreich hergestellt. Nur die Bits 12 bis 15 werden von der Exekutive modifiziert, und zwar in Abhaengigkeit von der ausgefuehrten Exekutive-Anweisung. Bemerkung: 'Senden' in den obigen Angaben bezieht sich auf die SREF$-Anweisung.  49 Dem Nutzer stehen fuer die Verwendung des WDB zwei Makros zur Verfuegung. Mit dem Makro WDBDF$ werden die symbolischen Offsets und die Symbole fuer die Bits des Statuswortes definiert. Der Makro wird durch WDBDF$ aufgerufen. Der Nutzer muss diesen Makro nicht verwenden. Der eigentliche WDB wird durch den Makro WDBBK$ erstellt. Der Nutzer ruft ihn folgendermassen auf: WDBBK$ apr, siz,[rid],[off],[len],sts[,srb] Die Argumente besitzen folgende Bedeutung: apr - Nummer des Seitenregisters, Ziffer zwischen 0 und 7 (W.NAPR) siz - Groesse des Adressfensters in 32.-Wort-Bloecken (W.NSIZ) siehe Fenster-Statuswort: WS.64B rid - Region-Identifikation (W.NRID) off - Offset innerhalb der Region in 32.-Wort Bloecken (W.NOFF) Standard: 0 len - Laenge der Adresszuweisung in 32.-Wort Bloecken (W.NLEN) Standard: SIZ-Wert sts - Fenster-Statuswort (W.NSTS) srb - Adresse des Nutzerdatenpuffers (W.NSRB) Fuer die Angaben des Statuswortes sts verwendet der Nutzer die Darstellung , wobei xxx durch die entsprechende oben beschriebene Symboldefini- tion ersetzt wird. Die Region-Identifikation muss aus dem entsprechenden Feld des RDB entnommen werden, falls nicht eine RREF$-Anweisung genutzt wird. Ein Identifikationswert von 0 definiert die Task-Region. Ein WDB wird von verschiedenen Exekutive-Anweisungen benutzt. Falls im WDB Argumente spezifiziert sind, die von einer der An- weisung nicht benutzt werden, werden diese Argumente uebergangen. Aus folgender Uebersicht geht hervor, welche Informationen die einzelnen Anweisungen aus dem WDB benoetigen (N = vom Nutzer festgelegt) und welche von der Exekutive in den WDB abgelegt werden (E = von der Exekutive festgelegt). Ein durch "-" gekenn- zeichnetes Feld zeigt an, dass das entsprechende Argument von der Anweisung nicht verwendet wird. 50 Anweisung | WDB - Parameter |------------------------------------------------ | | | | | | | | | | apr |W.NID| siz | rid | off | len | sts | srb | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | CRAW$ | N | E | N | - | - | - | N/E | - | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | ELAW$ | - | N | - | - | - | - | E | - | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | MAP$ | - | N | - | N | N | N/E | N/E | - | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | UMAP$ | - | N | - | - | - | - | E | - | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | SREF$ | - | - | - | N | N | N | N | N | | | | | | | | | | ------------------------------------------------------------- | | | | | | | | | RREF$ | - | - | - | E | E | E | N/E | N | | | | | | | | | | ------------------------------------------------------------- Zur Veranschaulichung der Benutzung von Fenster-Definitionsbloek- ken dient das folgende Beispiel: Der Nutzer hat den Makro WDBBK$ 6,95.,,16.,, vereinbart. Der Makro wird erweitert zu .BYTE 0,6 ; Fenster-Identifikation,APR-Nummer .WORD 0 ; virtuelle Basisadresse .WORD 95. ; Groesse des Fensters .WORD 0 ; Region-Identifikation .WORD 16. ; Offset innerhalb der Region .WORD 0 ; Laenge der Adresszuweisung .WORD WS.MAP!WS.WRT ; Fenster-Statuswort .WORD 0 ; Adresse des Datenpakets  51 Weiterhin wird angenommen, dass eine dynamische Region mittels einer CRRG$-Anweisung hergestellt und an die Task gebunden wurde, und die Region-Identifikation aus dem RDB mittels des Befehls MOV R.GID(R0),W.NRID(R1) in den WDB uebertragen wurde (R0 beinhalte die Adresse des RDB, R1 beinhalte die Adresse des WDB). Unter diesen Voraussetzungen leistet die CRAW$-Anweisung folgen- des: Es wird ein 95 Bloecke umfassendes Adressfenster hergestellt und sofort zur Region zugewiesen. Die Zuweisung beginnt 16. Bloecke vom Anfang der Region und reicht bis zum Ende des Adressfensters oder bis zum Ende der Region (falls das Ende des Adressfensters groesser als das Ende der Region ist). Es sind die Zugriffsarten Lesen und Schreiben moeglich. Die Adressfenster-Identifikation und die virtuelle Basisadresse des Fensters wird in die Felder W.NID und W.NBAS eingetragen. Fuer FORTRAN-Programme gilt: Ist in einem Programm ein Fenster-Definitionsblock zu erstellen, muss der Nutzer ein 8-Worte-Integerfeld einfacher Genauigkeit vereinbaren. Das gilt fuer folgende Unterprogrammrufe: CALL CRAW CALL ELAW CALL MAP CALL UNMAP CALL SREF CALL RREF 52 Der WDB hat folgendes Format: Wort | Inhalt ------------|---------------------------------------------------- | iwdb(1) | Bit 0 - 7 Fensteridentifikation | Bit 8 - 15 Basis-APR iwdb(2) | virtuelle Basisadresse, bei der das Fenster be- | ginnt iwdb(3) | Groesse des Fensters (in 32.-Wortbloecken) iwdb(4) | Regionidentifikation iwdb(5) | Offset innerhalb der Region, bei dem die Zuwei- | sung beginnt (in 32.-Wortbloecken) iwdb(6) | Laenge des Bereiches der Region, zu der die Zu- | weisung erfolgt (in 32.-Wortbloecken) iwdb(7) | Fenster-Statuswort iwdb(8) | Adresse des Sende- oder Empfangspuffers Der Programmierer kann das Fenster-Statuswort (iwdb(7)) durch Setzen oder Loeschen von Bits modifizieren (siehe Bild 7). Die Bedeutung der Bits des Fenster-Statuswortes ist im vorhergehenden beschrieben. 2.2.4.4. Regionschutz und privilegierte Tasks --------------------------------------------- Im Region-Statuswort spezifiziert der Nutzer die Zugriffsarten, die zu der Region gestattet sind. Die Kontrolle, ob eine Task zu der Region zugreifen darf, erfolgt durch den Vergleich des Nut- zer-Identifikationscodes (UIC, User Identification Code) der Task, die die Region benutzen moechte, mit dem UIC der Region aus dem Bindungsdescriptor. Der Vergleich ergibt, welcher Kategorie der Nutzer angehoert. Die Rechte der vier moeglichen Kategorien sind im Standardschutzwort der Region enthalten. Mit dem Standard-Schutzwort der Region und den spezifizierten Zugriffsarten des RDB wird dann die Zugriffskontrolle realisiert. Das Standard-Schutzwort wird in folgende 4 Kategorien eingeteilt: Bit 15 12 11 8 7 4 3 0 ------------------------------------------- | | | | | | Rest | Gruppe | Eigen- | System | | | | tuemer | | ------------------------------------------- Jede 4 Bits umfassende Kategorie wird durch folgende Arten des moeglichen Zugriffs charakterisiert: Bit 3 2 1 0 ------------------------------------------- | | | | | |Loeschen |Erweitern | Schreiben| Lesen | | | | | | ------------------------------------------- Der Zugriff wird erlaubt, wenn das entsprechende Bit den Wert 0 hat.  53 Es bestehen folgende Moeglichkeiten des Zugriffs zu Regionen: - Eine benannte Region kann von allen Tasks benutzt werden, denen der Name der Region bekannt ist und die nicht gegen die Schutz- rechte verstossen. - Fuer eine unbenannte Region ist das Binden durch beliebige Tasks nur unter der folgenden Voraussetzung moeglich: Die Task, welche die Region aufgestellt hat, muss durch eine SREF$-Anwei- sung das Binden an eine andere Task (durch RREF$) ermoeglichen. Die Zugriffsrechte werden von der sendenden Task festgelegt, duerfen aber die eigenen Zugriffsrechte zu der Region nicht uebersteigen. Ein durch den Nutzer zu gewaehrleistender Schutz wird bei der Verwendung privilegierter Tasks notwendig. Eine privilegierte Task verfuegt ueber besondere Speicherzugriffsrechte. Sie kann Exekutive-Anweisungen enthalten, durch deren Ausfuehrung die vorher von anderen Tasks zugewiesenen Seitenregister neu zugewie- sen werden. Die vorherige Adresszuweisung wird dadurch aufgeho- ben, eventuell werden Adressfenster eliminiert, und dadurch wird die Fortsetzung der laufenden Tasks in Frage gestellt. Folglich sollte der Nutzer bei der Verwendung von Exekutive-Anweisungen darauf achten, dass die Task-Bearbeitung aller laufenden Tasks nicht negativ beeinflusst werden kann. 2.2.4.5. Exekutive-Anweisungen zur Speicheradressierung und -verwaltung ------------------------------------------------------- In diesem Abschnitt werden die Exekutive-Anweisungen fuer die Speicherverwaltung aufgefuehrt. Die detaillierte Beschreibung der Anweisungen erfolgt im Abschnitt 2.3.2. Anweisung Bedeutung Abschnitt ------------------------------------------------------------ ATRG$ Binden einer Region an eine Task 2.3.2.5. CRAW$ Herstellen eines Adressfensters 2.3.2.10. CRRG$ Herstellen einer Region 2.3.2.12. DTRG$ Trennen einer Region von einer Task 2.3.2.17. ELAW$ Eliminieren eines Adressfensters 2.3.2.18. GMCX$ Uebernehmen des gegenwaertigen Zustandes der Adresszuweisung 2.3.2.29. MAP$ Zuweisen eines Adressfensters zu einer Region 2.3.2.34. RREF$ Empfangen eines Referenzblockes 2.3.2.45. SREF$ Senden eines Referenzblockes 2.3.2.59. UMAP$ Aufheben der Adresszuweisung eines Adressfensters zu einer Region 2.3.2.68. 54 In Bild 10 wird der Ablauf dargestellt, nach dem der Nutzer bei der Programmierung der Anweisungen verfahren sollte. Die Pfeile geben eine moegliche Reihenfolge der Anweisungen im Programm an. --------------- | CRRG$ | --------------- | | v --------------- | ATRG$ | --------------- V --------------- | CRAW$ | --------------- | | | |----------> --------------- | | GMCX$ | | |----------- --------------- | | v v --------------- ---| MAP$ | | --------------- | V | --------------- | | UMAP$ | | --------------- | V | --------------- -->| ELAW$ | --------------- V --------------- | DTRG$ | --------------- Bild 10 Reihenfolge der Programmierung der Anweisungen zur Spei- cheradressierung und -verwaltung Es muessen nicht immer alle Anweisungen in der obigen Reihenfolge programmiert werden, da jede einzelne Anweisung je nach Verwen- dung mehrere einzelne Aktionen realisieren kann. Die Anweisung CRAW$ kann z.B. die Adresszuweisung aufheben, die mit dem neuen Adressfenster ueberschneidenden Adressfenster eli- minieren, ein neues Adressfenster erstellen und sofort die Adresszuweisung durchfuehren.  55 2.2.5. Kommunikation und Information -------------------------------------- 2.2.5.1. Allgemeines -------------------- In diesem Abschnitt werden die Moeglichkeiten beschrieben, die es einer Task erlauben, mit ihrer Umwelt zu kommunizieren und mit ihr Informationen auszutauschen. Aus dieser Sicht kann die Umwelt der Task in drei Teile gegliedert werden: die Peripherie, andere Tasks und das System. OMEX 1630 stellt jeweils einen Satz von Exekutive-Anweisungen bereit, die der speziellen Kommunikation dienen. Bei der Kommuni- kation der Tasks mit der Peripherie geht es darum, welche Moeg- lichkeiten der Task zur Verfuegung stehen, um Informationen an Geraete zu uebertragen bzw. von diesen zu empfangen. Dazu zaehlt ausserdem die Beziehung der Tasks zu den peripheren Geraeten. Die Kommunikation zwischen verschiedenen Tasks beinhaltet den Informationsaustausch zwischen diesen. Dazu muss die Task Infor- mationen empfangen und senden koennen. Die Task tritt mit dem System in eine Kommunikation ein, um sich ueber bestimmme Zustaende des Systems zu informieren. Diese Sy- steminformation kann sich die Task bereitstellen lassen und fuer ihre speziellen Belange auswerten. 2.2.5.2. Kommunikation zwischen Task und Peripherie --------------------------------------------------- In OMEX 1630 werden zwei allgemeine Exekutive-Anweisungen (QIO$ und QIOW$) bereitgestellt, um Datenuebertragungen zwischen Task und Peripherie durchzufuehren. Um eine Geraeteunabhaengigkeit zu sichern, wird von der Task kein physisches Geraet angesprochen, sondern eine logische Geraetenum- mer (LUN, logical unit number). Die logische Geraetenummer ist eine dezimale Integerzahl (1 <= LUN <= 255), der ein physisches Geraet zugeordnet sein muss, bevor sich die Task auf diese LUN in einer Exekutive-Anweisung beziehen kann. Die Zuordnung zwischen LUN und realem Geraet kann - beim Bilden der Task, - mittels Kommando REASSIGN oder - mittels Exekutive-Anweisung ALUN$ erfolgen. Fuer jede Task wird eine eigene Zuordnung zwischen LUN und phy- sischem Geraet hergestellt. Neben den physischen Geraeten gibt es in OMEX 1630 logische Geraete, die eine weitere Form der Geraete- unabhaengigkeit realisieren und die Handhabung der Geraete durch den Programmierer erleichtern. Bevor man sich auf ein logisches Geraet beziehen kann, muss diesem ein physisches Geraet zugeord- net worden sein. 56 Die von OMEX 1630 standardmaessig vorgesehenen logischen Geraete werden als Pseudogeraete bezeichnet. Ihnen werden vorzugsweise auszufuehrende Funktionen zugeordnet. Speziell die Systemprogram- me beziehen sich bei ihren Ein-/Ausgaben auf Pseudogeraete. Tabelle 2 enthaelt die von OMEX 1630 unterstuetzten Pseudogerae- te. Bevor man sich auf ein Pseudogeraet beziehen kann, muss die- sem mittels MCR-Kommando REDIRECT oder DCL-Kommando ASSIGN ein physisches Geraet zugeordnet worden sein. Durch OMEX 1630 wird standardmaessig die in Tabelle 3 enthaltene Zuordnung vorge- nommen. Zusaetzlich zu den vom System vorgesehenen logischen Geraeten kann sich der Nutzer eigene, seinem Problem angepasste logische Geraete definieren (Generierungsoption). Wenn nachfolgend von logischen Geraeten gesprochen wird, sind immer die durch den Nutzer definierten gemeint. Die Zuordnung zwischen logischen Geraeten und physischen Geraeten erfolgt ueber das MCR- oder DCL-Kommando ASSIGN. Neben den genannten Geraeten wird fuer Testzwecke und zur Arbeit mit Indirektkommando-Dateien in OMEX 1630 ein Nullgeraet (Gene- rierungsoption) unterstuetzt. Damit hat man die Moeglichkeit, Ein-/Ausgabeanweisungen abzuarbeiten, ohne dass eine Datenueber- tragung eingeleitet wird. Jedes Geraet wird eindeutig durch seinen Geraetenamen und seine Geraetenummer identifiziert. Die in OMEX 1630 verwendete Geraete- bezeichnung zur Identifikation eines Geraetes enthaelt nicht dessen vollstaendigen Geraetenamen, sondern einen symbolischen Geraetenamen, der aus zwei Buchstaben des KOI-7-Codes besteht. Der symbolische Geraetename wird im allgemeinen nach mnemonischen Gesichtspunkten ausgewaehlt. Daraus ergibt sich die allgemeine Form der in OMEX 1630 verwen- deten Geraetebezeichnung: ddnn: dd = symbolischer Geraetename, bestehend aus zwei Buch- staben des KOI-7-Codes nn = Geraeteeinheitennummer, bestehend aus einer oder zwei Oktalziffern (0 <= nn <= 77). Die Angabe der Geraeteeinheitennummer 0 kann entfallen, da sie als Standardwert angenommen wird. : = Abschluss der Geraetebezeichnung Auf Grund der Spezifik der Pseudogeraete und des Nullgeraetes ist fuer sie nur die Angabe der Geraeteeinheitennummer 0 sinnvoll. Die Tabelle 2 enthaelt eine Auswahl der von OMEX 1630 unter- stuetzten Geraete, ihre Geraetenamen und ihre symbolischen Gerae- tenamen. Beim Generieren des Systems legt der Nutzer fest, mit welchen physischen Geraeten, die durch das OMEX 1630 unterstuetzt werden, er arbeiten will und gibt an, ob das Nullgeraet und logische Geraete benutzt werden sollen.  57 Die erforderliche Zuordnung zwischen LUN und physischem bzw. Nullgeraet kann zu verschiedenen Zeitpunkten, ueber verschiedene Zwischenschritte und durch verschiedene Moeglichkeiten erfolgen (siehe Bild 11). Wichtig ist, dass am Ende der Zwischenschritte die Zuordnung zwischen LUN und physischem bzw. Nullgeraet be- steht, wenn die Bezugnahme auf das Geraet durch eine Exekutive- Anweisung erfolgt. Tabelle 2 Auswahl der Geraete, die durch OMEX 1630 unterstuetzt werden Geraeteart | Geraetename | Symbolischer | | Geraetename -------------------|--------------------------|----------------- | | physische Geraete | Bediengeraet | TT oder TG | Rastersichtgeraet | TT oder TG | Kassettenmagnetband | CT | Lochbandstanzer | PP | Lochbandleser | PR | Kassettenplattenspeicher | DK | Festplattenspeicher | DM | Magnetbandgeraet | MT | Folienspeichereinheit | DV | Zeilendrucker | LP | Bildspeicher | RM | Displayprozessor | DD | Grafiksteuerung | GD | Rollkugeeinheit | TB -------------------|--------------------------|----------------- | | Pseudogeraete | Bediengeraet der Task | TI | Listenausgabegeraet | CL | Systemmitteilungsgeraet | CO | Systembibliotheksgeraet | LB | Systemgeraet des Nutzers | SY -------------------|--------------------------|----------------- | | Nullgeraet | Nullgeraet | NL -------------------|--------------------------|----------------- | logische Geraete | Durch den Nutzer frei waehlbar ---------------------------------------------------------------- 58 -------------- |log.Geraete-| |Nr. LUN | -------------- | MCR-Kommando REA, DCL-Kommando ASSIGN, v Exekutive-Anweisung ALUN$, TKB-Option ASSIGN |->------------------------------------------- v | | ------>| | | ------------- | | |log. Geraet| | | ------------- | | | ------->-.------>-.->---------------------- -------. ASN / | | | | | ASSIGN | | v | v | | | |<----------. | | | | v | | | ------>| | | | | | -------------- | | | | | |Pseudogeraet| | | RED | | | -------------- | | ASSIGN | | | | | | v v -------. RED | | | | v ASSIGN | | .------<-.-<-------------------<-.-<---------- | | | | -------- -------- | |phys. | |Null- | | |Geraet| |geraet| | -------- -------- | v v | | | -------<-.-<----<-. | | v v Bild 11 Moeglichkeiten der Zuordnung zwischen LUN und Geraet Tabelle 3 Standardmaessige Zuordnung zwischen Pseudo- und phy- sischem Geraet Pseudogeraet | Physisches Geraet --------------|------------------- | CL: | TT0: | CO: | TT0: | LB: | DKn: | SY: | DKn: Anmerkung: DKn: (0<=n<=77) ist das Geraet, von dem das System geladen wird.  59 2.2.5.3. Kommunikation zwischen verschiedenen Tasks --------------------------------------------------- Aus verschiedenen Gruenden besteht der Wunsch, zwischen verschie- denen Tasks Informationen auszutauschen. Dazu muss die Task in der Lage sein, Informationen von einer bestimmten Task zu emp- fangen oder Informationen an andere Tasks zu senden. Im OMEX 1630 ist festgelegt, dass eine Task mit einer Anweisung maximal 13. Worte Informationen senden bzw. empfangen kann (Datenpaket). Um eine eindeutige Zuordnung der Informationen zu den Tasks vorneh- men zu koennen, muss die sendende Task angeben, fuer welche Task die Information bestimmt ist. Die Information wird in eine Warteschlange der Empfaengertask eingereiht. Von der Exekutive wird der Information der Sendertaskname (2 Worte im Format RAD50) hinzugefuegt. Die empfangende Task kann ihrerseits angeben, von welcher Sender-Task sie die Informationen uebernehmen moechte, da sich in ihrer Warteschlange gleichzeitig Informationen von mehreren unterschiedlichen Tasks befinden koennen. Gibt die Task keinen Sendertasknamen an, wird die Information, die an der Spitze der Warteschlage steht, uebermittelt. Wenn zum Zeitpunkt des Aussen- dens der Anweisung zum Empfang von Informationen noch keine durch die sendende Task bereitgestellt wurden, wird die Empfaengertask mit Hilfe des Rueckkehrcodes informiert oder an dieser Stelle beendet. Das unterschiedliche Reagieren wird durch zwei unterschiedliche Anweisungen zum Empfang eines Datenblocks festgelegt. 2.2.5.4. Versorgung der Tasks mit Informationen durch die Exekutive --------------------------------------------------------- Die Exekutive muss staendig ueber die Zustaende des Systems in- formiert sein. Bestimmte Systeminformationen aendern sich mit der Zeit oder koennen dynamisch durch den Bediener oder durch die Tasks veraendert werden. Durch einen Satz von Anweisungen hat die Task die Moeglichkeit, sich bestimmte Systeminformationen bereitstellen zu lassen, um sich auf die aktuellen Bedingungen einzustellen, oder diese In- formation fuer spezielle Belange der Task zu nutzen. Solche Informationen sind z.B. die aktuellen Zeitparameter oder die spezifischen Besonderheiten eines Geraetes. Eine andere Moeg- lichkeit besteht darin, dass sich die Task eine aus 80 alphanu- merischen Zeichen bestehende Kommandozeile bereitstellen lassen kann. Damit kann der Nutzer zusaetzlich zu den umfangreichen Moeglichkeiten des Kommandoprogramms des OMEX 1630 eine anwender- orientierte Kommandoarbeit realisieren und dabei bestimmme Funk- tionen des Kommandoprogramms nutzen. Speziell die Aufgabe der Kommunikation der Task mit dem Bediener kann so effektiv geloest werden. 60 2.2.5.5. Exekutive-Anweisungen zur Kommunikation und Information ---------------------------------------------------- Im einzelnen stehen die folgenden Exekutive-Anweisungen zur Ver- fuegung, deren detaillierte Beschreibung in den aufgefuehrten Abschnitten erfolgt: Abschnitt ALUN$ Zuweisen einer logischen Geraetenummer 2.3.2.3. CINT$ Verbinden einer Task mit einem Inter- ruptvektor 2.3.2.6. GLUN$ Uebernehmen der Informationen ueber eine logische Geraetenummer 2.3.2.27. GMCR$ Uebernehmen einer Kommandozeile 2.3.2.28. GMCX$ Uebernehmen des gegenwaertigen Zustan- des der Adresszuweisung 2.3.2.29. GPRT$ Uebernehmen von Parametern einer Partition 2.3.2.30. GREG$ Uebernehmen von Parametern einer Region 2.3.2.31. GTIM$ Uebernehmen der Zeitparameter 2.3.2.32. GTSK$ Uebernehmen der Parameter einer Task 2.3.2.33. QIO$ Ein-/Ausgabe-Exekutive-Anweisung 2.3.2.36. QIOW$ Ein-/Ausgabe-Exekutive-Anweisung mit Warten auf Beendigung 2.3.2.37. RCST$ Empfangen eines Datenpaketes oder Stoppen der Task 2.3.2.38. RCVD$ Empfangen eines Datenpaketes 2.3.2.39. RCVX$ Empfangen eines Datenpaketes oder Beenden der Task 2.3.2.40. SDAT$ Senden eines Datenpaketes 2.3.2.48. SMSG$ Senden einer Meldung 2.3.2.52. 2.2.6. Mutter/Tochter-Taskverbindung (Spawning) ----------------------------------------------- 2.2.6.1. Einfuehrung -------------------- Unter 'Spawning' versteht man den Aufbau und die Aufrechterhal- tung einer besonderen Verbindung zwischen zwei Tasks. Dabei stellt eine Task - die Muttertask - durch bestimmte Exekutive-An- weisungen diese Verbindung zu einer zweiten Task - der Tochter- task - her.  61 In Abhaengigkeit von den benutzten Anweisungen kann die Tochter- task erst aktiviert werden oder es wird eine schon aktive Task als Tochtertask genutzt. Die Besonderheiten dieser Taskverbindung sind: - Es besteht die Moeglichkeit, von der Muttertask Kommandos an die Tochtertask zu uebergeben. Diese Uebergabe erfolgt analog der MCR-Task-Kommando-Uebergabe. Die Kommandos werden von der Tochtertask direkt durch Benutzung der GCMC/CSI-Routinen des FCS 1630 empfangen. Eine Task kann damit Kommandos vom Bediener ueber MCR-Vermittlung oder als Tochtertask von der Muttertask ueber die Spawning-Anweisungen empfangen, ohne dass Aenderungen des Programmcodes vorgenommen werden muessen. - Die Tochtertask kann einmalig an einem beliebigem Punkt in ihrem Programmablauf einen Statuswert an die Muttertask ueber- mitteln. Dieser meist als Beendigungscode definierte Wert von Wortlaenge kann beliebigen Inhalt haben und hat Bedeutung nur fuer diese spezielle Mutter/Tochter-Taskverbindung. Von OMEX 1630 werden vier spezielle Statuswerte fuer die eigene Tasksteuerung bereitgestellt, die uebermittelt werden, wenn die Tochtertask keinen Status uebergibt oder uebergeben kann. - Die Muttertask kann durch OMEX 1630 ueber das Ende und/oder Statusuebergabe der Tochtertask informiert werden. Dazu wird entweder . ein in der Muttertask vereinbartes Ereignisflag gesetzt und/oder . eine AST-Bedienungsroutine in der Muttertask aktiviert. Diese besondere Taskverbindung ist sehr gut geeignet, komplexe Beziehungen zwischen verschiedenen Tasks aufzubauen und zu steuern, wie sie bei vielen Echtzeitanwendungsfaellen oder speziell angepassten Stapelverarbeitungen auftreten koennen. Diese Verbindungen koennen in beiden Richtungen mehrfach auftreten: - Eine Muttertask haelt Verbindungen zu mehreren Tochtertasks. - Eine Tochtertask ist an mehrere Muttertasks angebunden. Eine Muttertask kann sich mehrfach mit einer Tochtertask verbinden, ohne dass zwischendurch die Verbindung geloest wurde. Die Verbindung, die eine Muttertask zu einer Tochtertask unterhaelt, kann die urspruengliche Tochtertask an eine neue Tochtertask weitergeben. Damit ist die urspruengliche Task nicht mehr Tochter der Muttertask, die neue Tochtertask tritt in die besondere Verbindung zur Muttertask ein. Fuer die Muttertask ist ohne zusaetzliche Aktivitaeten dieser Wechsel nicht erkennbar. Ueber speziell vereinbarte Statuswerte koennte bei Beendigung der Verbindung durch die aktuelle Tochtertask mitgeteilt werden, welche Task als Tochtertask angebunden war. 62 OMEX 1630 erzeugt fuer jede Mutter/Tochter-Taskverbindung einen separaten Steuerblock im dynamischen Bereich der Exekutive. Dieser wird als Offspring Control Block (OCB) bezeichnet und an die OCB-Kette der Tochtertask angekettet. Diese Steuerblockkette selbst ist an den Tochtertask-TCB angebunden. Jeder OCB enthaelt unter anderem die Adresse des zugehoerigen Muttertask-TCB. 2.2.6.2. Spawning-Anweisungen in OMEX 1630 ------------------------------------------ Diese Anweisungen werden in drei Gruppen eingeteilt fuer: - den Aufbau einer Mutter/Tochter-Taskverbindung - die Weitergabe einer Mutter/Tochter-Taskverbindung - die Statusuebergabe an die Muttertask. Die Anweisungen der ersten zwei Gruppen koennen in beliebiger Kombination benutzt werden, um Mutter/Tochter-Taskverbindungen aufzubauen und weiterzugeben. 2.2.6.2.1. Aufbau einer Mutter/Tochter-Taskverbindung ----------------------------------------------------- - SPWN$ Diese Anweisung aktiviert eine Task und verbindet sie als Tochtertask mit der die Anweisung ausgebenden Muttertask. Die so erzeugte Tochtertask kann Statuswerte an die Muttertask uebermitteln, eine Kommandozeile von der Muttertask empfangen und sie bekommt als TI: das Terminal TI: der Muttertask zugeordnet. Wenn die Muttertask privilegiert ist, kann sie auch ein anderes physisches Bediengeraet als Tochtertask-TI: verein- baren. Die Beendigung der Tochtertask wird der Muttertask gemeldet. - CNCT$ Diese Anweisung bindet eine aktive Task als Tochtertask an die diese Anweisung aussendende Muttertask. Bei dieser Verbindung kann keine Kommandozeile uebergeben werden, die Tochtertask kann aber Statuswerte an die Muttertask uebermitteln und die Muttertask wird ueber das Ende der Tochtertask und/oder Status- uebergabe (wenn sie nicht mit dem Taskende zusammenfaellt) informiert. - SDRC$ Diese Anweisung sendet Daten (als Datenpaket analog zur SDAT$- Anweisung) an die spezifizierte Task, aktiviert diese, falls sie noch nicht aktiv ist und bindet sie als Tochtertask an die diese Anweisung aussendende Task. Der weitere Ablauf ist analog zur CNCT$-Anweisung.  63 2.2.6.2.2. Weitergabe einer Mutter/Tochter-Taskverbindung --------------------------------------------------------- - RPOI$ Durch diese Anweisung wird die eigene Mutter/Tochter- Taskverbindung von der die Anweisung ausgebenden Tochtertask auf eine andere Task weitergegeben. Diese Task wird als Tochtertask eingesetzt, waehrend die urspruengliche Tochtertask aus der Verbindung ausscheidet. Die Anweisung erlaubt alle Moeglichkeiten der SPWN$-Anweisung. Die Muttertask wird nicht explizit ueber die Weitergabe dieser Verbindung von OMEX 1630 informiert. Durch die Anweisung wird die neue Tochtertask aktiviert. - SDRP$ Diese Anweisung sendet Daten (als Datenpaket analog zur SDAT$- Anweisung) an die spezifizierte Task, aktiviert sie, falls sie noch nicht aktiv ist und gibt die eigene Mutter/Tochter-Task- verbindung von der die Anweisung aussendenden Task an die spezifizierte Task weiter. Diese Task wird als Tochtertask eingesetzt, waehrend die urspruengliche Tochtertask (=die die Anweisung enthaltende Task) aus der Verbindung ausscheidet. 2.2.6.2.3. Statusuebergabe an die Muttertask -------------------------------------------- - EXST$ Diese Anweisung beendet die diese Anweisung aussendende Task und uebergibt an alle mit ihr verbundenen Muttertask's - wenn vorhanden - den in der Anweisung vereinbarten Statuswert. - EMST$ Diese Anweisung beendet die zuletzt hergestellte[n] Mutter/Tochter-Taskverbindung[en] mit einer spezifizierten [allen] Muttertask[s] und uebergibt den in der Anweisung ver- einbarten Statuswert. Der uebergebene Statuswert hat nur Bedeutung durch gegenseitige Vereinbarung zwischen den beteiligten Tasks. In einigen speziellen Faellen wird jedoch folgender System- Statuswert gebildet: - Eine Tochtertask endet normal oder annormal, ohne einen Status- wert uebergeben zu haben. OMEX 1630 bildet dann selbst einen Statuswert. - einige Systemhilfsprogramme uebergeben, wenn sie als Tochter- task gerufen werden, diese Statuswerte. Diese System-Statuswerte sind als Direktwerte im Makro DIRSYM.MAC vereinbart. Sie werden auch durch die EXST$-Anweisung als lokale Werte dargestellt. 64 _________________________________________________________________ Name Wert Bedeutung _________________________________________________________________ EX$WAR 0 Warnung - Task ist beendet, aber Abweichungen koennen aufgetreten sein EX$SUC 1 Fehlerfreie Beendigung - wird von OMEX 1630 generiert bei normaler Beendigung einer Tochter- task, wenn diese keinen Status uebergibt EX$ERR 2 Fehler - Resultate sind nicht so wie erwar- tet EX$SEV 4 Schwerer Fehler - einer/mehrere schwere Fehler sind aufgetreten; wird von OMEX 1630 generiert, wenn eine Tochtertask abgebrochen wurde 2.2.6.3. Verbindungsformen und Statusuebergabe ---------------------------------------------- Eine Tochtertask kann einen Status an die mit ihr verbundene(n) Muttertask(s) durch Benutzung der EXST$-Anweisung uebergeben. Dabei wird die Tochtertask beendet und alle Verbindungen zur Tochtertask aufgehoben. Eine Tochtertask kann zu jeder Zeit einen Status an die mit ihr verbundene(n) Muttertask(s) durch Benutzung der EMST$-Anweisung uebergeben. Dabei wird nur die zuletzt aufgebaute Verbindung aufgehoben, die Task selbst bleibt aktiv. Nach dem Verbindungsaufbau zwischen Mutter- und Tochtertask sind die Mittel nicht mehr erkennbar, mit denen der Aufbau bewerk- stelligt wurde. So fuehren zum Beispiel folgende Formen zum gleichen Ziel der Verbindung der Muttertask M zur Tochtertask T: - Task M aktiviert die vorher inaktive Task T und verbindet sich mit ihr - Task M verbindet sich mit Task T, wenn diese schon aktiv ist - Task M verbindet sich mit Task T durch ein SDRC$-Anweisung, wenn Task T aktiv oder nicht aktiv ist - Task T hat Task X aktiviert und/oder sich mit ihr verbunden. Task X gibt ihre Mutter/Tochter-Taskverbindungen an Task T durch eine RPOI$- oder SDRP$-Anweisung weiter. Unabhaengig von diesen Formen des Verbindungsaufbaus kann durch Task T ein Status an Task M uebergeben werden. Alle mit der Statusuebergabe moeglichen Aktionen in der Task T werden aufgefuehrt.  65 Diese Aktionen sind: - Setzen eines in der Muttertask vereinbarten Ereignisflags - Aktivieren einer in der Muttertask vereinbarten AST-Routine. Durch die Statusuebergabe wird immer die zuletzt aufgebaute Verbindung (FIFO-Prinzip der OCB-Kettung) aufgehoben. Einige Moeglichkeiten der Statusuebergabe: - Task T gibt eine EXIT$-Anweisung. Sie endet ohne explizite Statusuebergabe. OMEX 1630 generiert den Wert EX$SUC und ueber- gibt diesen Status an die Task M, wobei die in Task M vereinbarten Aktionen ausgefuehrt werden. - Task T wird abgebrochen. OMEX 1630 generiert den Wert EX$SEV und uebergibt diesen Status an die Task M, wobei die in Task M vereinbarten Aktionen ausgefuehrt werden. - Task T gibt eine EMST$-Anweisung, in der Task M spezifiziert ist.Der zuletzt erzeugte OCB der OCB-Kette wird benutzt, um die Aktionen festzulegen, die in der Task M ausgefuehrt werden sollen. - Task T gibt eine EMST$-Anweisung fuer alle verbundene Tasks (kein Taskname in der Anweisung spezifiziert). Es werden in allen verbundenen Tasks die dort vereinbarten Aktionen ausge- fuehrt. - Task T gibt eine EXST$-Anweisung. Alle verbundene Tasks erhalten den Status, die dort vereinbarten Aktionen werden aus- gefuehrt und die Task T beendet. Wenn eine Muttertask beendet wird, ehe die mit ihr verbundenen Tochtertasks einen Status zurueckgeben konnten, werden die entsprechenden OCB's nicht entfernt. Es wird in ihnen nur die Beendigung der Muttertask angezeigt. Damit wird garantiert, dass bei nachfolgender Entfernung von OCB's durch EMST$-Anweisung oder Beendigung von Tochtertasks die vereinbarten Aktionen nicht aus- gefuehrt werden und der Status unberuecksichtigt bleibt. 66 Beispiele fuer die Tasksynchronisation durch Nutzung von 'Spawning' ----------------------------------------------------------------- Die dafuer in Task M und T benutzten Anweisungen und deren Auswirkungen werden dargestellt. _________________________________________________________________ Task M Task T Auswirkungen _________________________________________________________________ SPWN$ EXST$ Task M aktiviert Task T und verbindet sich mit ihr. Bei Beendigung von Task T wird ein Status an Task M uebergeben. CNCT$ EXST$ Task M verbindet sich mit der aktiven Task T. Bei Beendigung von Task T wird ein Status an Task M uebergeben. SDRC$ RCVX$ Task M sendet ein Datenpaket an Task T, die EMST$ aktiviert wird, wenn sie noch nicht aktiv ist. Task M wird gleichzeitig mit Task T ver- bunden. Task T empfaengt die Daten, verar- beitet sie und hebt die Verbindung durch Uebergabe eines Status an Task M wieder auf. Wenn Task T aktiviert wurde, ohne dass ein Datenpaket in der Warteschlange steht, wird sie bei dem Versuch, ein Paket zu empfangen, beendet. SDRC$ RCST$ Task M sendet ein Datenpaket an Task T, die USTP$ EMST$ aktiviert wird, wenn sie noch nicht aktiv ist. Task M wird gleichzeitig mit Task T verbunden und ein eventuell bestehender STOP- Zustand der Task T aufgehoben. Task T empfaengt die Daten, verarbeitet sie und hebt die Verbindung durch Uebergabe eines Status an Task M wieder auf. Befindet sich fuer die Task T kein Datenpaket in der Warteschlange, wird Task T durch die RCST$-Anweisung in den STOP-Zustand versetzt. Dieser STOP-Zustand kann nur durch MCR- oder DCL-Kommandos oder durch eine USTP$-Anweisung aufgehoben werden. SPWN$ RPOI$ Task M aktiviert Task T und verbindet sich SDRP$ mit ihr. Task T uebergibt ihre Verbindung zu Task M durch Benutzung einer RPOI$- oder SDRP$-Anweisung an eine dritte Task DT. Damit ist Task M die Muttertask fuer Task DT und Task T ist nicht mehr mit Task M verbunden. 2.2.6.4. 'Spawning' von System-Tasks ------------------------------------ Eine sehr wichtige Nutzung von Spawning ist der Aufruf von und die Kommandozeilenuebergabe an System-Tasks in OMOS 1600. System- Tasks sind z.B. die Kommandoprogramme wie MCR und DCL, die Dienstprogramme oder Sprachuebersetzer.  67 2.2.6.4.1. Kommandoprogramme ---------------------------- Nutzung von MCR Um eine Kommandozeile an MCR zu uebergeben, muss der Task-Name 'MCR...' benutzt werden in der SPWN$-Anweisung. Nutzung von DCL Um eine Kommandozeile an DCL zu uebergeben, muss der Task-Name '...DCL' benutzt werden in der SPWN$-Anweisung. Die Task '...DCL' darf zu diesem Zeitpunkt im System nicht aktiv sein. 2.2.6.4.2. Dienstprogramme -------------------------- Da die Dienstprogramme beim Installieren einen Tasknamen in der Form '...tsk' erhalten, koennen sie als MCR-Kommando gerufen werden. Kommandozeile: >tsk dienstprogrammparameter Dienstprogramme koennen mit Kommandozeilen auf zwei Wegen versorgt werden: - 'Spawning' eines Dienstprogrammes direkt mit dem Tasknamen '...tsk' und Uebergabe einer vollstaendigen Kommandozeile. Dieser Aufruf ist nur dann erfolgreich, wenn noch keine Task unter dem Namen '...tsk' im System aktiv ist. Im anderen Fall fuehrt die Ausfuehrung der SPWN$-Anweisung zum Fehler. Der Rueckkehrcode ist IE.ACT. - 'Spawning' von MCR und Uebergabe einer vollstaendigen MCR- Kommandozeile zum Aufruf des gewuenschten Dienstprogrammes (Kommandozeile beginnt mit 'tsk'). MCR aktiviert die Task '...tsk', wenn sie noch nicht aktiv ist. Wenn eine Task unter dem Namen '...tsk' bereits aktiv ist, versucht MCR, die Task unter dem Namen 'tskTnn' zu aktivieren. Dabei ist 'nn' die Einheitennummer des TI:, das der Task zugeordnet ist, die die SPWN$-Anweisung fuer MCR ausgegeben hat. Ist auch das nicht moeglich, weil eine Task 'tskTnn' schon atkiv ist, meldet MCR ueber den Statuswert EX$ERR (=2) einen Fehler an die aufrufende Task. MCR wird durch das 'Spawning' zur Tochtertask der aufrufenden Task. Kann MCR das Dienstprogramm aktivieren, gibt es die Mutter/Tochter-Taskverbindung an das Dienstprogramm weiter. Damit ist das Dienstprogramm zur Tochtertask der urspruenglich aufrufenden Task geworden und alle beim Verbindungsaufbau durch die SPWN$-Anweisung vereinbarten Aktivitaeten wie z.B. Status- uebergabe werden im weiteren durch das Dienstprogramm aus- geloest. Der Aufruf von (Dienst)Programmen ueber MCR ist dem direkten 'Spawning' vorzuziehen, da mit groesserer Wahrscheinlichkeit ein positives Resultat erreicht wird. 68 Die Kommandozeile, die an ein Dienstprogramm oder an Sprachueber- setzer gerichtet wird, muss auch beim direkten 'Spawning' die Form haben, die bei Eingabe auf der Bedieneinheit benutzt werden wuerde. Sie muss also mit dem 3-Zeichen Tasknamen 'tsk' beginnen, dem, durch Leerzeichen getrennt, die Kommandoparameter folgen muessen. Damit wird eine von der Art des Aufrufs unabhaengige Kommandoverarbeitung in den gerufenen Task's gewaehrleistet (siehe dazu die Beschreibung der GMCR$-Anweisung 2.3.2.28.). In OMOS 1600 geben nicht alle System-Tasks Statuswerte zurueck. Im Einzelfall ist das in der Beschreibung der einzelnen Tasks angegeben (siehe die entsprechenden OMOS-Dokumentationen). Erzeugt eine Task keinen Statuswert, werden die unter 2.2.6.2.3. angegebenen allgemeinen Statuswerte von OMEX 1630 eingesetzt.  69 2.3. Beschreibung der Exekutive-Anweisungen ----------------------------------------------- 2.3.1. Allgemeine Festlegungen -------------------------------- Fuer die Benutzung der Exekutive-Anweisungen werden folgende Festlegungen getroffen: - In den Einzelbeschreibungen wird generell die $-Form der Exeku- tive-Anweisung dargestellt, wenn nicht fuer eine spezielle Anweisung die $S-Form empfohlen wird. In diesen Faellen wird die $S-Form dargestellt. Die Anwendung der $S-Form wird bei Exekutive-Anweisungen emp- fohlen, deren Anweisungsparameterblock 1 Wort lang ist. Fuer diese Anweisungen erfordert die $S-Form weniger Speicherplatz als die $- oder $C-Form, wird aber mit der gleichen Geschwin- digkeit bearbeitet wie die DIR$-Anweisung. - Alle Zahlen in den Parameterketten der Anweisungen gelten als Oktalzahlen, wenn ihnen nicht ein Dezimalpunkt folgt. So ge- kennzeichnete Werte betrachtet das System als Dezimalzahlen. - Die Namen der Tasks und der Partitions koennen aus 1 ... 6 RADIX-50 Zeichen (Buchstaben, Ziffern, Punkt, Waehrungszeichen) bestehen. - Die Prioritaet einer Task kann 1 ... 250 (dezimal) betragen (1 <= pri <= 250). - Geraetenamen sind zwei Zeichen (Buchstaben) lang. - Logische Geraetenummern (LUNs) werden als gueltig betrachtet, wenn gilt: 1 <= LUN <= 255 (dezimal) - Gueltige Ereignisflagnummern (EFN) sind die Zahlen 1 ... 96 Die Ereignisflagnummern werden in drei Gruppen unterteilt: 1 <= EFN <= 32 sind lokale Ereignisflagnummern, 33 <= EFN <= 64 sind Common-Ereignisflagnummern, 65 <= EFN <= 96 sind Gruppenglobale Ereignisflagnummern. - In den Einzelbeschreibungen der Anweisungen werden Wahlparame- ter in eckige Klammern gesetzt. Sollen sie weggelassen werden, muss innerhalb einer Parameterkette das nachfolgende Komma als Trennzeichen geschrieben werden. Am Ende einer Parameterkette koennen Wahlparameter und Kommas weggelassen werden. - Bei einigen Anweisungen werden Parameter angefordert, die von der Exekutive bei der Bearbeitung ignoriert werden. Diese Para- meter sind notwendig, um die Kompatabilitaet zu entsprechenden Systemen des SKR aufrechtzuerhalten. 70  - Fuer FORTRAN gilt: . Alle benutzten Zahlen sind vom Typ Integer*2, wenn nicht ausdruecklich anderes in den Einzelbeschreibungen festgelegt ist. . Tasknamen sind als Variable vom Typ REAL (einfache Genauig- keit) anzugeben, die den Namen in Radix-50-Form enthalten. . Die FORTRAN-Subroutinen-Aufrufe gestatten die Angabe eines zusaetzlichen Parameters, des Anweisungsstatus (ids). Wird dieser angegeben, enthaelt er nach Abarbeitung der Subrouti- nen eine Information darueber, ob diese erfolgreich ausge- fuehrt wurden oder nicht. Im Falle der erfolglosen oder fehlerhaften Abarbeitung gibt der Wert in ids Auskunft ueber die Fehlerursache und ist identisch mit dem Rueckkehrcode der Exekutive-Anweisungen.  71  2.3.2. Einzelbeschreibungen ----------------------------- ---------------------------------------------------------------- | ABORT TASK | ABRT$ | | -- -- | | ---------------------------------------------------------------- 2.3.2.1. ABRT$ - Abbruch einer Task ----------------------------------- FORTRAN-Aufruf: --------------- CALL ABORT (tsk[,ids]) tsk = Taskname ids = Anweisungsstatus Makro-Aufruf: ------------- ABRT$ tsk tsk = Taskname Makro-Erweiterung: ------------------ ABRT$ ROBO .BYTE 83.,3 ;DIC der Anweisung und Laenge des DPB .RAD50 /ROBO/ ;Taskname Funktionsbeschreibung: ---------------------- Die Anweisung ABRT$ setzt die Exekutive davon in Kenntnis, dass die angegebene Task abzubrechen ist. Sie ist als Not- oder Feh- lerende vorgesehen. Es wird eine Endemeldung auf einem der folgenden Geraete ausgege- ben: 1. auf dem Geraet, von dem aus die abzubrechende Task angefordert wurde, 2. auf dem Geraet der Task, von dem aus versucht wird, die Task abzubrechen, 3. auf dem Bediengeraet (CO:), wenn die Task intern durch eine RUN$-Anweisung in einer anderen Task aktiviert wurde oder die Aktivierung durch ein MCR oder DCL RUN-Kommando erfolgte, in dem ein oder mehrere Zeitparameter angegeben sind. In Systemen, die Mehrnutzerbetrieb unterstuetzen, koennen nur privilegierte Tasks andere Tasks abbrechen. Nichtprivilegierte Tasks koennen nur sich selbst abbrechen und solche, die gleiches TI: besitzen. Lokale Symboldefinition: ------------------------ A.BTTN - Taskname 72  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -02 IE.INS die Task ist nicht installiert -07 IE.ACT die Task ist nicht aktiv -16 IE.PRI die abbrechende Task ist nicht privilegiert -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig Anmerkungen: ------------ - Wenn eine Task abgebrochen wird, fuehrt die Exekutive folgende Operationen aus (falls moeglich): 1. Freigeben aller gebundenen Geraete; 2. Loeschen der AST-Warteschlange; 3. Loeschen der Warteschlangen fuer Datenempfang und das Emp- fangen von Referenzbloecken; 4. Loeschen aller ausstehenden Anforderungen auf das zeitab- haengige Deklarieren signifikanter Ereignisse; 5. Abschliesen aller eroeffneten Dateien - Dateien, die fuer den Schreibzugriff eroeffnet wurden, werden gesperrt; 6. Freigeben der gebundenen Regionen, sofern die Task nicht im Speicher fixiert ist; 7. Abarbeiten der E/A-Warteschlange der Task; 8. Aufheben der Zuordnung zu gruppenglobalen Ereignisflags; 9. Aufloesen der Verbindungen zu Interupts; 10. Aufloesen der Verbindungen zu allen Tochtertasks; 11. Rueckgabe des Fehlerstatus EX$SEV an die Muttertask; 12. Freigeben des Speicherplatzes der Task, wenn die Task nicht im Speicher fixiert ist. - Wenn die abzubrechende Task einen Task-Abbruch-AST behandeln kann, wird die Task nicht abgebrochen. Stattdessen erhaelt die zugehoerige AST-Bedienungsroutine die Steuerung. Die abbrechende Task wird darueber nicht informiert. - Wenn die abzubrechende Task gerade beendet wird, deklariert die Exekutive ein signifikantes Ereignis.  73  ---------------------------------------------------------------- | ALTER PRIORITY | ALTP$ | | --- - | | ---------------------------------------------------------------- 2.3.2.2. ALTP$ - Aendern der Prioritaet --------------------------------------- FORTRAN-Aufruf: --------------- CALL ALTPRI ([tsk],[ipri][,ids]) tsk = Taskname ipri = 1-Wort-Integerwert fuer die neue Priori- taet (1 <= ipri <= 250) ids = Anweisungsstatus Makro-Aufruf: ------------- ALTP$ [tsk][,pri] tsk = Name der Task, deren Prioritaet zu aendern ist pri = neue Prioritaet der Task (1 <= pri <= 250) Makro-Erweiterung: ------------------ ALTP$ FAKT,93. .BYTE 9.,4 ;DIC der Anweisung und Laenge des DPB .RAD50 /FAKT/ ;Taskname .WORD 93. ;neue Prioritaet der Task Funktionsbeschreibung: ---------------------- Durch die Anweisung ALTP$ wird die Exekutive davon informiert, dass die Laufprioritaet der angegebenen Task zu veraendern ist. Die Prioritaet der Task wird daraufhin auf den angegebenen Wert veraendert oder, wenn keine neue Prioritaet angegeben wurde, die beim Installieren angegebene Prioritaet (Standardwert) einge- stellt. Wird der Taskname weggelassen, bezieht sich die Anweisung auf die Task selbst, die die Anweisung enthaelt. Die Task, auf die sich die Anweisung bezieht, muss sich im ak- tiven Zustand befinden. Infolge der Prioritaetsaenderung werden ausstehende E/A-Anfor- derungen der Task entsprechend der neuen Taskprioritaet neu in die E/A-Warteschlange eingeordnet und eine neue Partitionzutei- lung vorgenommen, die ein Auslagern der Task zur Folge haben kann. Wird das Ende der Task erreicht, so veraendert die Exekutive die Prioritaet der Task auf den beim Installieren angegebenen Wert. Nur privilegierte Tasks koennen den Wert der Prioritaet ueber den des installierten Wertes bis 250 erhoehen. Nichtprivilegierte Tasks koennen den Prioritaetswert nur erniedrigen oder auf diesen installierten Wert setzen. 74  Lokale Symboldefinitionen: -------------------------- A.LTTM - Taskname A.LTPR - Prioritaet Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausge- fuehrt -02 IE.INS die Task ist nicht installiert -07 IE.ACT die Task ist nicht aktiv -16 IE.PRI die Task ist nicht privilegiert -95. IE.IPR ungueltige Prioritaet -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IS.SDP die Laenge des DPB bzw. der DIC ist ungueltig  75  ---------------------------------------------------------------- | ASSIGN LUN | ALUN$ | | - --- | | ---------------------------------------------------------------- 2.3.2.3. ALUN$ - Zuweisen einer logischen Geraetenummer ------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL ASNLUN (lun,dev,unt[,ids]) lun = log.Geraetenummer dev = Geraetetypname (FORMAT: 1A2) unt = Geraeteeinheitsnummer ids = Anweisungsstatus Makro-Aufruf: ------------- ALUN$ lun,dev,unt lun = logische Geraetenummer dev = Geraetetypname (2 Buchstaben) unt = Geraeteeinheitsnummer Makro-Erweiterung: ------------------ ALUN$ 6,TT,0 ;Zuweisen der LUN 6 zum Terminal 0 .BYTE 7,4 ;DIC der Anweisung und Laenge des DPB .WORD 6 ;logische Geraetenummer .ASCII /TT/ ;Geraetetypname .WORD 0 ;Geraeteeinheitsnummer Funktionsbeschreibung: ---------------------- Diese Anweisung ordnet einer physischen Geraeteeinheit eine logi- sche Geraetenummer zu. Die Task hat aber damit das Geraet noch nicht gebunden. Die Exekutive durchsucht zunaechst die logische Zuordnungstabelle nach dem entsprechenden Geraetenamen. Falls er gefunden wird, wird die damit verbundene physische Geraeteeinheit dem logischen Geraet zugewiesen. Anderenfalls durchsucht die Exekutive danach die physische Geraetetabelle und weist die genannte physische Geraeteeinheit dem logischen Geraet zu. Wenn die Task mit der Option /SLV=YES installiert wurde, wird die logische Zuordnungstabelle nicht durchsucht. Bei Aenderung der Zuweisung einer LUN zu einem Geraet werden alle E/A-Anforderungen fuer die betreffende Task in der alten Warte- schlange gestrichen. Lokale Symboldefinitionen: -------------------------- A.LULU - logische Geraetenummer A.LUNA - phys. Geraetetypname A.LUNU - phys. Geraetenummer 76  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -90. IE.LNL die Anwendung der LUN fuehrt zu Verkettungen, d.h., die LUN ist entweder schon einem Geraet zugewiesen mit einer Dateieroeffnungs-Funktion fuer diese LUN, oder die LUN gehoert zu einem gebundenen Geraet, waehrend die Anweisung eine Aenderung der LUN-Zuordnung anstrebt -92. IE.IDU Geraetetyp und/oder Geraet unzulaessig -96. IE.ILU unzulaessige LUN -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  77  ---------------------------------------------------------------- | AST SERVICE EXIT | ASTX$S | | --- - | | ---------------------------------------------------------------- 2.3.2.4. ASTX$S - Ende einer AST-Bedienung ------------------------------------------ FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- ASTX$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ ASTX$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack spei- chern .BYTE 115.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung ASTX$S beendet die Abarbeitung eines AST-Bedie- nungsprogramms. Wenn ein weiterer AST in der Warteschlange steht und die AST- Bearbeitung nicht verhindert ist, wird sofort der naechste AST bearbeitet. Andernfalls stellt die Exekutive den Taskstatus wie- der her, der vor dem AST existierte. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -80. IE.AST die Anweisung wurde nicht von einem AST- Bedienungsprogramm ausgesendet -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- - In das AST-Bedienungsprogramm wird nur dann zurueckgekehrt, wenn die Anweisung abgewiesen wurde. Aus diesem Grund wird auch nicht der BCC-Befehl aufgebaut, wenn eine Adresse fuer die Fehlerroutine angegeben ist, da bei Rueckkehr zur Task immer das Carry-Bit gesetzt ist. 78  - Wenn ein AST auftritt, kellert die Exekutive mindestens folgen- de Informationen in den Stack der Task: SP + 06 Ereignisflagmaskenwort SP + 04 PS der Task vor dem AST SP + 02 PC der Task vor dem AST SP + 00 DSW der Task vor dem AST Der Stack der Task muss so aufgebaut sein, wenn die ASTX$S-Anwei- sung ausgefuehrt wird. Beim Start des AST-Bedienungsprogramms koennen im Stack der Task zusaetzliche Informationen abgespeichert sein, die spezifisch fuer den aufgetretenen AST sind. Fuer das E/A-Ende ist das die Adresse des E/A-Statusblocks, fuer die Anweisung MRKT$ die Ereignisflagnummer und fuer den Arithme- tikprozessorfehler-AST der Fehlercode und dessen Adresse. Diese zusaetzlichen Parameter muessen aus dem Stack entfernt werden, bevor die Anweisung ASTX$S abgearbeitet wird. Die Task kann ihre Rueckkehrbedingungen variieren, indem sie die Informationen im Stack aendert, bevor die ASTX$S-Anweisung ausgefuehrt wird (z.B. die Rueckkehr zu einer anderen Adresse der Task). Die Rueckkehradresse der Task befindet sich im Stack. Die Task kann den Befehlszaehler im Stack aendern. Diese Verfahrensweise kann vorteilhaft sein, wenn das AST-Bedie- nungsprogramm Fehlerzustaende erkennt, aber diese Aenderungen sollten mit groesster Vorsicht ausgefuehrt werden, da AST-Bedie- nungsprogrammfehler schwer zu erkennen sind.  79  ---------------------------------------------------------------- | ATTACH REGION | ATRG$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.5. ATRG$ - Binden einer Region ------------------------------------ FORTRAN-Aufruf: --------------- CALL ATRG (irdb [,ids]) irdb = 8-Worte-Integerfeld, das einen Region-Defini- tionsblock enthaelt ids = Anweisungsstatus Makro-Aufruf: ------------- ATRG$ adr adr = Adresse des Region-Definitionsblocks (RDB) Makro-Erweiterung: ------------------ ATRG$ ADRDB .BYTE 57.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADRDB ;Adresse des RDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird das Binden einer Region an die Task (wel- che die Anweisung enthaelt) vorgenommen. Damit wird die Region Bestandteil des logischen Adressraumes der Task. Es koennen be- nannte dynamische bzw. statische Regionen gebunden werden. Der im Statuswort vom Nutzer spezifizierte Zugriff wird auf Ueberein- stimmung mit dem Standard-Schutzwort der Region und dem UIC der lfd. Task geprueft. Verlaeuft die Pruefung positiv, wird der gewuenschte Zugriff erlaubt. Beim Binden legt die Exekutive eine Region-Identifikation fest, die fuer die Adresszuweisung benoetigt wird. Der Nutzer kann die Anweisung auch lediglich zur Bestimmung der Region-Identifikation einer benannten Region benutzen, die zur Zeit des Taskbildens schon an die Task gebunden wurde. In diesem Fall prueft die Exekutive, ob die benannte Region gebunden ist und speichert - wenn ja - die Region-Identifikation und die Groesse der Region in dem bereitgestellten RDB ab. Von der Exekutive im RDB benoetigte Parameter: symb. Offsets R.GNAM - Name der zu bindenden Region R.GSTS - Folgende Bits koennen im Region-Statuswort modifiziert werden: RS.RED = 1, wenn Lesen gewuenscht wird RS.WRT = 1, wenn Schreiben gewuenscht wird RS.EXT = 1, wenn Erweitern gewuenscht wird RS.DEL = 1, wenn Loeschen gewuenscht wird 80  Sind alle vier Bits geloescht, wird die Region-Identi- fikation von der Exekutive uebergeben, falls die Re- gion schon an die Task gebunden ist. Von der Exekutive im RDB abgelegte Parameter: symb. Offsets R.GID - Region-Identifikation R.GSIZ - Groesse der gebundenen Region (in 32-Wortbloecken) Lokale Symboldefinition: ------------------------ A.TRBA - Adresse des RDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN das Zuteilen eines Bindungs-Deskriptors ist nicht moeglich, da kein Platz im dyna- mischen Bereich der Exekutive verfuegbar ist. -16 IE.PRI der Privilegstatus wurde verletzt -86 IE.NVR die Region-Identifikation ist ungueltig -94 IE.PNS die benannte Region existiert nicht, bzw. die Common-Task wurde noch nicht instal- liert -98 IE.ADP ein Teil des RDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig  81  ---------------------------------------------------------------- | CONNECT TO INTERRUPT VECTOR | CINT$ | | - --- | | ---------------------------------------------------------------- 2.3.2.6. CINT$ - Verbinden einer Task mit einem Interruptvektor --------------------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- CINT$ vec, base isr, edir, pri, ast vec = Interrupt-Vektoradresse Sie muss groesser sein als oktal 60 und darf nich groesser sein als die hoechste Vektoradresse, die bei der Generierung durch SYSGEN festgelegt wurde und muss ein Vielfaches von 4 sein. base = Virtuelle Basisadresse des 'Kernel' APR 5 der Interrupt-Bedienroutine (ISR) und der Interrupt- Erlauberoutine (IESR). Diese Adresse wird auto- matisch auf eine 32.-Wortgrenze ausgerichtet. isr = virtuelle Adresse der ISR oder 0, wenn der Task vom Interruptvektor getrennt werden soll. edir = virtuelle Adresse der Interrupt-Erlauberoutine (IESR). pri = Anfangsprioritaet n, bei der die ISR angesprungen wird. Diese ist normalerweise gleich der Hardware- Interrupt-Prioritaet und wird in der Form n * 40 (oktal) angegeben, wobei n = 0...7 ist. Der Prioritaetswert wird durch diese Form in die Bits 5 ... 7 von pri gebracht. Es ist zu empfeh- len, an dieser Stelle die Symbole PR4, PR5, PR6 und PR7 zu verwenden, die in der Datei [1.1] EXEMC.MLB definiert sind. Die Prioritaetswerte muessen korrekt den Hardware- Interrupt-Prioritaeten entsprechen, da es sonst zu Systemabbruechen kommen kann. ast = virtuelle Adresse einer AST-Routine, zu der verzweigt wird, wenn die FORK-Routine einen AST anmeldet. Soll eine Task von einem Interruptvektor wieder getrennt werden, so ist isr = 0 zu setzen. Die Paramater base, edir, pri und ast werden dann ignoriert. Makro-Erweiterung: ------------------ CINT$ 420,BADR,IADR,EDADR,PR5,ASTADR .BYTE 129.,7. ;DIC der Anweisung und Laenge des DPB .WORD 420 ;Interrupt-Vektoradresse .WORD BADR ;virtuelle Basisadresse fuer APR 5 .WORD IADR ;virtuelle Adresse der ISR .WORD EDADR ;virtuelle Adresse der IESR .BYTE PR5,0 ;Prioritaet der ISR .WORD ASTADR ;virtuelle AST-Routinen-Adresse 82  Funktionsbeschreibung: ---------------------- Durch die Anweisung CINT$ kann eine Task an einen Interruptvektor angeschlossen werden. Die Task erhaelt dadurch die Moeglichkeit, Hardware-Interrupts zu bearbeiten. Die Hardware-Interrupts werden ueber eine Interrupt-Bedienroutine (ISR), die Bestandteil der Task ist, bedient. Die Systemorganisation fuer den Eintritt in die ISR bei Auftreten eines Interrupts erfordert die Ausfuehrung von etwa 10 Befehlen. Nach Verlassen der ISR werden ebenfalls 10 Befehle vom System abgearbeitet. Die Steuerungsuebergabe von der ISR an die Routinen auf Taskebene wird durch Nutzung von AST oder Ereignisflags vollzogen. Die die Anweisung aufrufende Task muss privilegiert sein. Nach dem Anschluss der Task an einen Interruptvektor besteht die Moeglichkeit, Interrupts auf drei verschiedenen Ebenen zu verar- beiten: - Interruptebene - Forkebene - Taskebene Die Taskebene kann unterteilt werden in eine AST-Stufe und eine Nicht-AST-Stufe. Interruptebene -------------- Liegt ein Interrupt vor, so wird die Steuerung ueber den Inter- rupt-Transfer-Block (ITB), der durch die CINT$-Anweisung zugewie- sen wurde, dem Unterprogramm $INTSC der Exekutive uebergeben. Von diesem Unterprogramm wird zur ISR verzweigt, die in der Anweisung spezifiziert wurde. Die ISR verarbeitet den Interrupt und verlaesst die Interruptbe- arbeitung entweder unmittelbar oder uebergibt die Steuerung an das Unterprogramm $FORK2 der Exekutive. Forkebene --------- In der Forkebene wird die Interruptverarbeitung in eine Warte- schlange, die Fork-Liste, eingetragen. Die Interruptbearbeitung wird hier unter der Prioritaet 0 durchgefuehrt. Das ermoeglicht die zwischenzeitliche Abarbeitung von anderen Interrupts mit hoehrerer Prioritaet. Falls es verlangt wird, wird ein lokales Ereignisflag fuer die Task gesetzt und/oder die Interruptbearbei- tung wird ueber einen AST mit der AST-Routine, die in der CINT$- Anweisung definiert worden ist, fortgesetzt. Taskebene --------- Als Resultat der Auswertung eines lokalen Ereignisflags oder eines AST wird in die Taskebene eingetreten. Die Task bearbeitet endgueltig den Interrupt und hat Zugriff zu den Anweisungen der Exekutive.  83  Damit eine Task die CINT$-Anweisung anwenden kann, muss sie privilegiert aufgebaut sein. Es ist jedoch erlaubt, beim Task- bilden den /PR:0 - Schalter zu benutzen, um ueber nichtprivi- legierte Adresszuweisungen den virtuellen Adressraum bis zu 32 K Worte verfuegbar zu haben. Das schliesst die Benutzung der Exekutive-Unterprogramme in der Taskebene aus. Jedoch sind die ISR und die Forkebenenroutinen immer der Exekutive zugewiesen. Auf alle Faelle sollte aber beim Taskbilden die Exekutiven-Symboldatei (OMEX.STB) mit einbezogen werden. Lokale Symboldefinitionen: -------------------------- C.INVE - Vektoradresse C.INBA - Basisadresse C.INIS - ISR-Adresse C.INDI - IESR-Adresse C.INPS - Prioritaet C.INAS - AST-Adresse Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- -01 IE.UPN es kann kein ITB zugewiesen werden (kein ausreichender zusammenhaengender Platz im dynamischen Bereich der Exekutive) -08 IE.ITS bei der Ausfuehrung der Funktion "Trennen der Interruptvektorverbindung von der Task", ist die Task nicht mit dem Vektor verbunden gewesen -16 IE.PRI die Task ist nicht privilegiert -17 IE.RSU der angegebene Vektor wird schon benutzt -19 IE.ILV die Adresse des angegebenen Vektors ist entweder kleiner als 60 oder groesser als der bei SYSGEN als groesster verein- barte Wert oder nicht ein Vielfaches von 4 -81 IE.MAP Adresszuordnungsfehler; ISR oder IESR liegen nicht innerhalb eines 4K-Berei- ches -98 IE.ADP ein Teil des DPB liegt ausserhalb des Bereiches der Task -99 IE.SDP die Laenge des DPB BZW. der DIC ist un- gueltig Bemerkungen: ------------ - Auslagerbarkeit Wird eine auslagerbare Task mit einem Interruptvektor verbun- den, so wird sie automatisch fuer eine Auslagerung gesperrt. Nach dem Trennen einer Task von allen Interruptvektoren wird die Task automatisch wieder auslagerbar gemacht. 84  - Adresszuweisung Der "base"-Parameter stellt, nachdem er auf eine 32.-Wort- grenze ausgerichtet wurde, den Beginn eines 4K- Wortbereiches dar, der ueber APR5 zugewiesen wurde. Alle Codes und Daten, die von den Routinen verwendet werden, muessen in diesem Bereich vereinbart sein. Ausserdem muessen die Codes und Daten entweder positionsunabhaengig oder in einer solchen Weise geschrieben sein, dass sie ueber das APR5 adressiert werden koennen. Wenn die Routinen ausgefuehrt werden, befindet sich die ZVE im Kernel-Modus und der virtuelle Adressraum schliesst die Exekutive, den dynamischen Bereich der Exekutive und den E/A- Bereich mit ein. Die Adressierung von Daten innerhalb der Task muss PC-relativ geschehen oder es muss ein spezieller Offset - wie unten gezeigt - angegeben werden. Die Adressierung von Daten ausserhalb der Task muss absolut sein. Folgendes ist moeglich: 1. Die ISR, IESR und benoetigten Daten koennen im positionsun- abhaengigem Code geschrieben werden. 2. Benutzt man fuer den Code und die Daten eine Commonparti- tion, so muss die Task, die mit der Commonpartition verbun- den wurde, diese absolut ueber APR 5 adressieren. (PAR=ISR:120000:20000). 3. Beim Taskbilden einer privilegierten Task sind bevorzugt das APR5 und die Konstante 120000 als Parameter "base" in der CINT$-Anweisung zu benutzen. 4. Wenn lokale Vereinbarungen innerhalb eines Taskabbildes im direkten oder absoluten Adressierungsmodus zugreifen, wird ein Offset <120000-> verwendet. - Interruptbedienroutine (ISR) Beim Eintritt in die ISR enthaelt R5 die Adresse des Forkblockes im Interrupt-Transfer-Block (ITB). R4 kann frei verwendet werden. Die Register R0 ... R3 muessen, falls sie benutzt werden, gerettet und wiederhergestellt werden. Wenn eine ISR mehrere Interruptvektoren bedient, so kann die Adresse des jeweiligen Interruptvektors ueber den Offset X.VEC im ITB erreicht werden. Uebernahme der aktuellen Vektoradresse nach R4, wenn R5 die Adresse des Fork-Blockes enthaelt: MOV X.VEC-X.FORK(R5),R4 Die ISR kann entweder direkt mit dem Befehl RTS PC verlassen werden oder $FORK2 aufrufen. Beim Aufruf der Forkroutine muss R5 die Adresse des Fork-Blockes im ITB enthalten und der Stack muss den gleichen Zustand haben wie vor dem Eintritt in die ISR. $FORK2 muss absolut adressiert sein: CALL @#$FORK2  85  - Forkebenenroutine Die Forkebenenroutine wird unmittelbar nach dem Aufruf $FORK2 gestartet. Nach Eintritt in die Forkebenenroutine enthalten R4 und R5 dieselben Werte, die sie vor dem Aufruf des $FORK2 ent- hielten. Alle Register sind frei verfuegbar. Der erste Befehl in der Forkroutine muss sein: CLR @R3 Damit wird der Forkblock als frei deklariert. Die Forkebenenroutine muss gerufen werden, wenn die Bearbeitung eines Interrupts laenger als 500 Mikrosekunden dauert, ein AST angemeldet oder ein Ereignisflag gesetzt werden soll. Ein AST wird angemeldet durch den Ruf des Unterprogramms $QASTC CALL @#$QASTC. Eingabe: R5 - Adresse des Forkblockes im ITB Ausgabe: C-Bit = 0 AST ist erfolgreich angemeldet worden, C-Bit = 1 AST ist in der CINT$-Anweisung nicht definiert worden, Die Register R0 ... R3 sind veraendert. Ein Ereignisflag wird gesetzt durch den Ruf des Unterprogramms $SETF CALL @#$SETF. Eingabe: R0 - Ereignisflagnummer R5 - TCB-Adresse der Task, fuer den das Ereig- nisflag zu setzen ist; das ist gewoehnlich (aber nicht notwendig) die Task, die die CINT$-Anweisung enthaelt. Diese TCB-Adresse steht unter dem Offset X.TCB im ITB. Ausgabe: Das Ereignisflag ist gesetzt, R1 und R2 sind veraendert. Falls diese Routinen (oder beliebige andere Exekutive-Unterpro- gramme) von der Forkebene aufgerufen werden, muss die absolute Adressierung verwendet werden (CALL @#$QASTC, CALL @#$SETF). - Interrupt-Erlauberoutine (IESR) Die IESR wird automatisch gerufen in folgenden drei Faellen: 1. Die CINT$-Anweisung (isr ungleich 0) ist erfolgreich ausge- fuehrt worden. Vor der Rueckkehr in die Task erfolgt der Ruf der IESR. 2. Die CINT$-Anweisung zum Trennen vom Interruptvekktor (isr = 0) ist erfolgreich ausgefuehrt worden. 3. Die Task wird abgebrochen oder beendet und der Interruptvek- tor ist noch mit ihr verbunden. 86  Im ersten Fall ist bei Eintritt in die IESR das C-Bit ge- loescht. In den beiden anderen Faellen ist es gesetzt. In allen drei Faellen enthaelt R1 die Adresse des ITB. R0, R2 und R3 sind frei verfuegbar. Verlassen werden muss die Routine mit: RTS PC In Abhaengigkeit vom Inhalt des Carry-Bits erfolgt eine unter- schiedliche Abarbeitung: C-Bit = 0 : Die Routine erlaubt den Interrupt und fuehrt die notwendigen Initialisierungen aus. C-Bit = 1 : Die Routine sperrt den Interrupt. - AST-Routine Die AST-Routine kann durch den Aufruf der Exekutive-Routine $QASTC erreicht werden. Nach dem Eintritt in die AST-Routine (Taskebene) enthaelt das erste Wort im Stack die Vektoradresse. sie muss aus dem Stack entfernt werden, bevor die AST-Routine verlassen wird (ASTX$S). - Offsets des Interrupt-Transfer-Blockes (ITB) X.LNK - Verbindungswort X.JSR - Unterprogrammruf zu $INTSC X.PSW - PSW fuer die ISR (niederes Byte) X.ISR - ISR-Adresse X.FORK - Beginn des Forkblockes X.REL - APR5-Adresszuweisung X.DSI - Adresse der IESR X.TCB - TCB-Adresse der eigenen Task X.AST - Beginn des AST-Blockes X.VEC - Vektoradresse X.VPC - PC-Rettungszelle beim Interrupt ueber den Vektor X.LEN - Laenge des ITB in Bytes Die Symbole X.LNK bis X.TCB werden durch den Makro ITBDF$ in [1,1]EXEMC.MLB lokal und alle Symbole durch [1,1]EXELIB.OLB global definiert.  87  ---------------------------------------------------------------- | CLEAR EVENT FLAG | CLEF$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.7. CLEF$ - Loeschen eines Ereignisflags --------------------------------------------- FORTRAN-Aufruf: --------------- CALL CLREF (efn [,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- CLEF$ efn efn = Ereignisflagnummer Makro-Erweiterung: ------------------ CLEF$ 20. .BYTE 31.,2 ;DIC der Anweisung und Laenge des DPB .WORD 20. ;Ereignisflagnummer 20. Funktionsbeschreibung: ---------------------- Die Anweisung CLEF$ loescht das angegebene Ereignisflag und zeigt im Rueckkehrcode die Wertigkeit (Polaritaet) des Flags vor dem Loeschen an. Als Ereignisflagnummer kann angegeben werden: 1 ... 32 fuer lokale Ereignisflags oder 33 ... 64 fuer Common-Ereignisflags oder 65 ... 96 fuer gruppenglobale Ereignisflags Zu beachten ist aber, dass die Ereignisflags 25 bis 32 und 57 bis 64 auch vom System benutzt werden. Lokale Symboldefinition: ------------------------ C.LEEF - Ereignisflagnummer Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +00 IS.CLR die Anweisung wurde erfolgreich ausge- fuehrt; das Ereignisflag war vorher ge- loescht +02 IS.SET die Anweisung wurde erfolgreich ausge- fuehrt; das Ereignisflag war vorher ge- setzt -97. IE.IEF unzulaessige Ereignisflagnummer -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig 88  ---------------------------------------------------------------- | CANCEL MARK TIME | CMKT$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.8. CMKT$ - Annullieren zeitabhaengig deklarierter signifikanter Ereignisse --------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL CANMT ([efn,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- CMKT$ [efn,ast] efn = Ereignisflagnummer ast = Adresse des Eintrittspunktes einer MRKT- AST-Routine Makro-Erweiterung: ------------------ CMKT$ 12.,ZAST .BYTE 27.,3 ;DIC der Anweisung und Laenge des DPB .WORD 12. ;Ereignisflagnummer 12. .WORD ZAST ;Adresse der MRKT-AST-Routine Funktionsbeschreibung: ---------------------- Die CMKT$S-Anweisung informiert die Exekutive, ein oder alle zeitabhaengig deklarierten signifikanten Ereignisse (durch MRKT$-Anweisung) fuer die aussendende Task zu annullieren. Lokale Symboldefinition: ------------------------ C.MKEF = Ereignisflagnummer C.MKAE = Adresse der MRKT-AST-Routine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP der DPB liegt ausserhalb des Adressbereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig Anmerkungen: ____________ - Wenn kein Parameter angegeben ist, ist der DPB nur ein Wort lang, und es werden alle zeitabhaengigen signifikanten Ereignisse, die durch diese Task deklariert worden sind, annulliert.  89  - Wenn ein/beide Parameter angegeben sind, ist der DPB drei Worte lang und es werden nur die zeitabhaengigen deklarierten signifikanten Ereignisse annulliert, die mit dem Ereignisflag und/oder der AST-Routine (durch MRKT$-Anweisung) verbunden sind. - Wenn das angegebene Ereignisflag ein gruppenglobales Ereignis- flag ist, wird der Zugriffszaehler der Ereignisflaggruppe erniedrigt, nachdem das zeitabhaengige deklarierte signifikante Ereignis annulliert wurde. 90  ---------------------------------------------------------------- | CONNECT | CNCT$ | | - - -- | | ---------------------------------------------------------------- 2.3.2.9. Synchronisierung zweier Tasks durch Aufbau einer Mutter/Tochter-Taskverbindung --------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL CNCT (rtname,[iefn],[iast],[iesb],[iparm][,ids]) rtname = Name der Tochtertask iefn = Ereignisflagnummer iast = Name einer AST-Routine iesb = Name eines Statusblockes von 1-Wort- Laenge iparm = Name eines Wortes, in das bei Auf- treten eines AST die Statusblock- adresse eingetragen wird. ids = Anweisungsstatus MAKRO-Aufruf: ------------- CNCT$ tname,[efn],[east],[esb] tname = Name der Tochtertask, die angebunden werden soll efn = Nummer des Ereignisflags, das bei aus- senden der Direktive geloescht wird und gesetzt wird, wenn die Tochtertask beendet wird oder einen Status ueber- gibt. east = Adresse einer AST-Routine, die aufge- rufen wird, wenn die Tochtertask beendet wird oder einen Status bereit- stellt. esb = Adresse eines Statusblocks von 1-Wort Laenge, in den Eintragungen vorge- nommen werden, wenn die Tochtertask beendet wird oder einen Status aus- sendet (Exit-Statusblock) MAKRO-Erweiterung: ------------------ CNCT$ ALPHA,1,CONAST,STBUF .BYTE 143.,6 ;DIC der Anweisung und Laenge des DPB .RAD5O /ALPHA/ ;Name der Tochtertask .WORD 1 ;Ereignisflagnummer=1 .WORD CONAST ;AST-Routinenadresse .WORD STBUF ;Adresse des Exit-Statusblock  91  Funktionsbeschreibung --------------------- Die Connect-Anweisung synchronisiert die Task (Muttertask), die die Anweisung aussendet mit der Exit- oder Emit-Status-Anweisung einer anderen Task (Tochtertask), die bereits aktiv ist; die Tochtertask wird an die Muttertask gebunden. Die Ausfuehrung der Anweisung bewirkt das Erzeugen eines Offspring-Steuerblocks (OCB) fuer die Tochtertask und erhoeht den Nutzungszaehler (enthalten im TCB der aussendenden Task). Der Nutzungszaehler existiert, um die Gesamtzahl der Tasks, die augenblicklich als Tochtertasks angebunden sind, anzuzeigen. Die Exit-AST-Routine wird aufgerufen, wenn die Tochtertask beendet wird oder eine Emit- Status-Anweisung ausfuehrt. Lokale Symboldefinition: ------------------------ C.NCTN - Taskname C.NCEF - Ereignisflagnummer C.NCEA - Adresse einer AST-Routine C.NCES - Adresse des Exit Statusblocks Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN fehlender Platz im dynamischen Bereich der Exekutive fuer einen Tochtertasksteuerblock (OCB) -07 IE.ACT die angegebene Task war nicht aktiv. -97 IE.IEF falsche Ereignisflagnummer (EFN<0 oder EFN>96, wenn gruppenglobale Ereignisflags fuer die Taskgruppe existieren oder EFN>64, wenn dies nicht der Fall ist) -98. IE.ADP ein Teil des DPB oder des Exit-Statusblocks liegt ausserhalb des Adressraumes der Tasks -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ - Ist das angegebene Ereignisflag ein gruppenglobales, so wird der Benutzungszaehler fuer diese Ereignisflaggruppe um 1 erhoeht, um das vorzeitige Loeschen des Ereignisflags zu verhindern. Der Benutzungszaehler wird wieder erniedrigt, wenn: . die angebundene Task einen Status zurueckgibt . die aussendende Task beendet wird bevor ein Status zurueck- gegeben wird. 92  - Die virtuelle Adresszuordnung fuer den Exit-Statusblock darf waehrend der Anbindung nicht veraendert werden. Veraendert man die Zuordnung wird dies zu schwerwiegenden Fehlern fuehren, da der Exit-Status immer auf die virtuellen Adressen eingetragen wird, die fuer den Statusblock angegeben wurden ohne Berueck- sichtigung ihrer Zuordnung zu physischen Adressen.  93  ---------------------------------------------------------------- | CREATE ADDRESS WINDOW | CRAW$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.10. CRAW$ - Herstellen eines Adressfensters ------------------------------------------------- FORTRAN-Aufruf: --------------- CALL CRAW (iwdb [,ids]) iwdb = 8-Worte-Integerfeld fuer Fenster-Defini- tionsblock ids = Anweisungsstatus Makro-Aufruf: ------------- CRAW$ adr adr = Adresse des Fenster-Definitionsblocks (WDB) Makro-Erweiterung: ------------------ CRAW$ ADWDB .BYTE 117.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird ein virtuelles Adressfenster hergestellt. Es werden ein Fensterblock im Taskkopf aufgebaut und die virtuel- le Basisadresse sowie das Format des Adressfensters eingeschrie- ben. Die maximale Anzahl der gleichzeitig im Taskkopf vorhandenen Fensterbloecke wird beim Taskbilden festgelegt. Bei erfolgreicher Ausfuehrung der Anweisung legt die Exekutive eine 8-Bit-Fenster- Identifikation fuer das hergestellte Fenster fest. Sollten bereits Fenster existieren, die sich mit dem neu herzustellenden Fenster ueberlagern, werden deren vorige Adresszuweisungen aufge- hoben und die Fenster geloescht. Die 8-Bit-Fenster-Identifikation ist eine Zahl von 1 bis 15. und dient als Index fuer die Fensterbloecke im Taskkopf der betrachteten Task. Wird im Fenster-Statuswort das Bit WS.MAP angegeben, werden die Funktionen der Exekutive-Anweisung MAP$ zusaetzlich ausgefuehrt, d.h. das Fenster wird hergestellt und die Adresszuweisung sofort durchgefuehrt. Von der Exekutive im WDB benoetigte Parameter: symb. Offset W.NAPR - Basis-APR des herzustellenden Adressfensters W.NSIZ - Groesse des herzustellenden Adressfensters (in 32.- Wortbloecken) 94  W.NRID - Die Region-Identifikation derjenigen Region, zu der das herzustellende Adressfenster zugewiesen werden soll (beinhaltet die Adresse des Bindungs-Deskrip- tors der Region) oder 0 fuer die Task-Region; sie wird nur spezifiziert, wenn das Fenster sofort zur Region zugewiesen werden soll (WS.MAP=1). W.NOFF - Offset vom Beginn der Region bis zur Adresse, bei der die Adresszuweisung beginnt; er wird nur spezi- fiziert, wenn das Fenster sofort bei der Herstel- lung zugewiesen wird und in diesem Fall in 32.- Wortbloecken angegeben (bei WS.64B = 0 muss der angegebene Wert ein Vielfaches von 8 sein)! W.NLEN - Der Parameter wird nur verwendet, wenn das Fenster sofort bei der Herstellung zuwiesen wird. Er be- stimmt die Laenge der Adresszuweisung (in 32.-Wort- bloecken). Falls das gesamte Fenster bzw. der Be- reich vom Zuweisungsbeginn bis zum Ende der Region zugewiesen werden soll, muss W.NLEN auf Null ge- setzt werden. W.NSTS - Folgende Bits koennen im Fenster-Statuswort modifi- ziert werden: WS.MAP = 1, wenn sofort bei der Herstellung des Fensters die Adresszuweisung erfolgen soll. WS.WRT = 1, wenn die Adresszuweisung mit Schreibzu- griff zu verbinden ist. WS.64B = 1 gibt an, dass die adressierbare Block- groesse des Speichers 64. Bytes be- traegt. Sonst betraegt die Blockgroesse 512. Bytes (WS.64B=O). Von der Exekutive im WDB gespeicherte Parameter: symb. Offset W.NID - die Fenster-Identifikation dient als Index fuer den im Taskkopf aufgebauten Fensterblock W.NBAS - virtuelle Basisadresse des neuen Adressfensters W.NLEN - Laenge der durchgefuehrten Adresszuweisung (in 32.- Wortbloecken) W.NSTS - Folgende Bits werden im Region-Statuswort modifi- ziert: WS.CRW = 1, wenn das Fenster erfolgreich herge- stellt wurde; WS.ELW = 1, wenn andere Adressfenster eliminiert werden mussten; WS.UNM = 1, wenn die Zuweisung anderer Fenster aufgehoben werden musste.  95  WS.RRF = 1, wenn ein Referenzblock erfolgreich empfangen wurde. Lokale Symboldefinition: ------------------------ C.RABA - Adresse des WDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -16 IE.PRI der Zugriff wurde verletzt -84 IE.ALG die APR-Nummer und die Groesse des Fensters bzw. der Offset der Region und die Laenge der Adresszuweisung oder WS.64B und W.NOFF wider- sprechen einander -85 IE.WOV im Task-Kopf wurden keine verfuegbaren Fen- sterbloecke gefunden -86 IE.NVR die Region-Identifikation ist ungueltig -98 IE.ADP ein Teil des WDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Eine Task kann jede Laenge fuer die Adresszuweisung festlegen, die kleiner oder gleich entweder der Fenstergroesse ist, die vereinbart wurde, als das Fenster erzeugt wurde oder der Laenge, die verbleibt zwischen dem angegebenen Offset innerhalb der Region und dem Ende der Region. - Ist W.NLEN Null, so ist die Laenge standardmaessig entweder die Fenstergroesse oder die Laenge, des in der Region verbleibenden Platzes, je nachdem was kleiner ist. - Da die Exekutive die aktuelle Laenge, die zugewiesen wurde, als Ausgabeparameter zurueckgibt, muss die Task jedesmal den Offset loeschen, bevor sie die Direktive gibt, um zu erreichen, dass die Standardlaenge der Adresszuweisung eingetragen wird. - Die Werte, die W.NOFF zugewiesen werden, haengen vom Bit WS.64B im Fensterstatuswort (W.NSTS) ab: . Ist WS.64B=0, muss der Offset, der in W.NOFF angegeben wurde, ein Vielfaches von 256. Worten (512. Bytes) sein. Da der Wert in W.NOFF in Einheiten von 32.-Wort Bloecken ausgedrueckt wird, muss der WERT ein Vielfaches von 8 sein. . Ist WS.64B=1, kann die Task eine 32.-Wort-Grenze zuordnen; der Programmierer kann deshalb jeden Offset innerhalb der Region angeben. 96  ---------------------------------------------------------------- | CREATE GROUP GLOBAL EVENT FLAGS | CRGF$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.11. CRGF$ - Erzeugen von gruppenglobalen Ereignisflags ------------------------------------------------------------- Fortran-Aufruf: --------------- CALL CRGF ([gruppe] [,ids]) gruppe = Gruppennummer der Flags, die zu erzeugen sind ids = Anweisungsstatus Makro-Aufruf: ------------- CRGF$ [gruppe] gruppe = Gruppennummer der Flags, die zu erzeugen sind Makro-Erweiterung: ------------------ CRGF$ 4 .BYTE 157.,2 ;DIC der Anweisung und Laenge des DPB .WORD 4 ;globale Ereignisflags der Gruppe 4 Funktionsbeschreibung: ---------------------- Die Anweisung erzeugt einen Group-Global-Event-Flag Steuerblock (GFB) und fuegt ihn in die GFB Liste ein. Falls noch kein GFB fuer die angegebene Gruppe existiert, wenn die Anweisung gegeben wird, erzeugt die Exekutive die GFB-Datenstruktur mit allen Ereignisflags und setzt diese auf Null. Ist ein GFB bereits vor- handen, wenn die Anweisung gegeben wird, so benutzt die Exekutive den vorhandenen GFB und die Ereignisflags werden nicht initiali- siert. Wenn jedoch der GFB zum Loeschen markiert ist (durch eine vorher gegebene ELGF$-Anweisung, loescht die Exekutive das GS.DEL Bit. Wenn der angegebene Gruppencode mit dem Gruppenschutzcode des UIC der aussendenden Task (H.CUIC+1 im Taskkopf) uebereinstimmt, so erhoeht die Anweisung den Zugriffszaehler fuer die Ereignisflags um 1. Dies schuetzt die Ereignisflags, so dass sie nicht durch eine andere Task, die sie ebenfalls nutzen, eleminiert werden koennen. Die aussendende Task kann explizit den Schutz der Ereignisflags aufheben durch Anwendung einer ULGF$- oder einer ELGF$-Anweisung. Die Exekutive hebt - wenn notwendig - automatisch den Schutz der Ereignisflags auf, wenn die Task beendet wird. Es ist anzumerken, dass eine Task den Schutz der Ereignisflags nur einmal erfolgreich vereinbaren kann. Jeder Versuch den Schutz von Ereignisflags zu vereinbaren, die bereits geschuetzt sind, wird den Fehlercode IE.RSU verursachen.  97  Rueckkehrcodes: --------------- num. symb. Code Code Beduetung ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN unzureichender Platz im dynamischen Bereich der Exekutive -16 IE.PRI Schutzrechtsverletzung -17 IE.RSU die Ereignisflags existieren bereits oder sind bereits geschuetzt -91 IE.IUI falsche Gruppennummer (>377 octal) -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Nur privilegierte Tasks koennen andere Gruppennummern angeben als die der Gruppe des Schutz-UIC der aussendenden Task. - Fehlt die Gruppenangabe in der Anweisung, verwendet die Exekutive den Gruppencode des Schutz-UIC der Task (aus H.CUIC+1 im Taskkopf). - Eine Task kann nur den Schutz der eigenen gruppenglobalen Ereignisflags vereinbaren, deren Gruppennummer also mit dem Gruppencode des Schutz-UIC der Task uebereinstimmt. Es wird kein Fehlercode zurueckgegeben, wenn die Ereignisflags nicht geschuetzt werden. 98  ---------------------------------------------------------------- | CREATE REGION | CRRG$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.12. CRRG$ - Herstellen einer Region ----------------------------------------- FORTRAN-Aufruf: --------------- CALL CRRG (irdb [,ids]) irdb = 8-Worte-Integerfeld fuer Region-Definitions- block ids = Anweisungsstatus Makro-Aufruf: ------------- CRRG$ adr adr = Adresse des Region-Definitionsblocks (RDB) Makro-Erweiterung: ------------------ CRRG$ ADRDB .BYTE 55.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADRDB ;Adresse des RDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird eine dynamische Region hergestellt. Diese Region befindet sich in einer systemgesteuerten Partition. Sie kann - falls gewuenscht - sofort bei der Herstellung der Region an die Task gebunden werden. Wenn im RDB kein Name fuer die Region angegeben wurde, muss sie sofort an die Task gebunden werden (RS.ATT). Falls der verfuegbare Raum nicht ausreicht, um die Region in die Partition aufzunehmen, meldet die Exekutive einen Fehler. Durch die Exekutive wird jede dynamische Region standardmaessig zum Loeschen nach dem letzten Trennen von einer Task markiert. Durch den Programmierer kann dies durch die Angabe des Bits RS.NDL im Region-Statuswort verhindert werden. Fuer unbenannte Regionen wird diese Angabe von der Exekutive ignoriert. Von der Exekutive im RDB benoetigte Parameter: symb. Offset R.GSIZ - Groesse der herzustellenden Region (in 32.-Wort- bloecken) R.GNAM - Name der herzustellenden Region bzw. 0, wenn kein Name spezifiziert wird R.GPAR - Name der systemgesteuerten Partition, in der die Region erstellt wird, bzw. 0, wenn es die Partition ist, in der die Task abgearbeitet wird.  99  R.GSTS - Folgende Bits koennen im Region-Statuswort modifi- ziert werden: RS.MDL = 1, wenn die Region nach der Trennung von der letzten Task geloescht werden soll; RS.NDL = 1, wenn die Region nicht mehr geloescht werden soll. (Bei unbenannten Regionen wird RS.NDL ignoriert.); RS.ATT = 1, wenn die Region sofort bei der Herstel- lung gebunden werden soll. Das Bit muss gesetzt werden, wenn der Nutzer keinen Namen fuer die Region spezifiziert hat; RS.NEX = 1, wenn die herzustellende Region nicht erweiterungsfaehig sein soll; RS.RED = 1, wenn Lesen beim Binden gewuenscht ist; RS.WRT = 1, wenn Schreiben beim Binden gewuenscht ist; RS.EXT = 1, wenn Erweitern beim Binden gewuenscht ist; RS.DEL = 1, wenn Loeschen beim Binden gewuenscht ist. R.GPRO - Das Region-Schutzwort besteht aus den Kategorien System, Eigentuemer, Gruppe, Rest mit den Bits fuer die Zugriffsarten Loeschen, Erweitern, Schreiben, Lesen. Der Zugriff wird erlaubt, wenn das entsprechende Bit geloescht ist (Eigentuemer- und System-Tasks sind unabhaengig vom Schutzwort das Loeschen er- laubt). Von der Exekutive im RDB gespeicherte Parameter: symb. Offset R.GID - Region-Identifikation (nur bei RS.ATT = 1) R.GSIZ - Groesse der gebundenen Region in 32.-Wortbloecken (nur bei RS.ATT = 1) R.GSTS - folgendes Bit kann im Region-Statuswort modifiziert werden: RS.CRR = 1, wenn die Region erfolgreich hergestellt wurde; Falls die Region bereits vorhanden ist, wird RS.CRR geloescht, und falls RS.ATT = 1 gesetzt war, er- folgt das gewuenschte Binden. 100  Lokale Symboldefinition: ------------------------ C.RRBA - Adresse des RDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN die Partition kann die Region nicht voll- staendig aufnehmen, bzw. der Bindungs-Des- kriptor oder ein Partition-Steuerblock kann nicht zugeteilt werden -16 IE.PRI das Binden konnte nicht vorgenommen werden, weil der Zugriff nicht erlaubt ist -94 IE.PNS es gilt RS.ATT = 0 und kein Region-Name wurde spezifiziert bzw. die Partition, in der sich die Region befinden sollte, kann nicht gefun- den werden, sie ist nicht systemgesteuert, oder die Common-Task wurde noch nicht instal- liert -98 IE.ADP ein Teil des RDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  101  ---------------------------------------------------------------- | CANCEL TIME BASED INITIATION REQUESTS | CSRQ$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.13. CSRQ$ - Annullieren der zeitbezogenen Taskaktivie- rung ------------------------------------------------------------ FORTRAN-Aufruf: --------------- CALL CANALL (tsk[,ids]) tsk = Taskname ids = Anweisungsstatus Makro-Aufruf: ------------- CSRQ$ tsk tsk = Name der Task, auf die eine zeitbezogene Aktivie- rungsanforderung angewendet wurde. Makro-Erweiterung: ------------------ CSRQ$ TSKNA .BYTE 25.,3 ;DIC der Anweisung und Laenge des DPB .RAD50 /TSKNA/ ;Taskname 'TSKNA' Funktionsbeschreibung: ---------------------- Die CSRQ$-Anweisung informiert die Exekutive, alle zeitbezogenen Aktivierungsanforderungen fuer eine spezifizierte Task zu annul- lieren. Diese Aktivierungsanforderungen resultieren aus der RUN- Anweisung oder den zeitbezogenen Modifikationen des MCR oder DCL RUN-Kommandos. Lokale Symboldefinition: ------------------------ C.SRTN - Taskname Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -02 IE.INS die Task ist nicht installiert -16 IE.PRI Task ist nichtprivilegiert und sie versucht, zeitbezogene Aktivierungen einer Task zu annullieren, die nicht das gleiche TI: hat. -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- bereichs der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 102  Anmerkungen: ------------ - Falls bei Benutzung der $S- bzw. der $C-Form eine Fehlerrouti- nen-Adresse angegeben werden soll, muss aus Kompatibilitaets- gruenden zu SKR-Systemen folgende Schreibweise gewaehlt werden: CSRQ$S #TASKN,,ERR ;Annullieren der zeitabhaengigen . ;Anforderungen fuer die Task'TSKNA' TASKN:.RAD50 /TSKNA/ - Eine Task muss privilegiert sein, um zeitbezogene Taskaktivie- rungen fuer andere Tasks annullieren zu koennen. Eine nichtpriviliegierte Task kann nur zeitbezogene Aktivierungen fuer Tasks mit dem selben TI: annullieren.  103  ---------------------------------------------------------------- | DECLARE SIGNIFIKANT EVENT | DECL$S | | ---- | | ---------------------------------------------------------------- 2.3.2.14. DECL$S - Deklarieren eines signifikanten Ereig- nisses --------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL DECLAR ([,ids]) ids = Anweisungsstatus Makro-Aufruf: ------------- DECL$S [,err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ DECL$S ,FEHL ;Anmerkung: Hier existiert ein ignorier- tes Argument zur SKR-Kompatibili- taet. MOV (PC)+,-(SP) ;DIC- und DPB-Laenge in den Stack spei- chern .BYTE 35.,1 ;DIC der Anweisung und Groesse des DPB EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung DECL$S veranlasst das System, ein signifikantes Ereignis zu deklarieren. Die Deklaration eines signifikanten Ereignisses veranlasst die Exekutive, die Liste der aktiven Tasks nach der prioritaets- maessig hoechsten Task zu durchsuchen, die abgearbeitet werden kann. Diese Anweisung sollte sinnvoll angewendet werden, um Zeitaufwand durch unnoetiges Durchsuchen zu vermeiden. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC Die Anweisung wurde erfolgreich ausgefuehrt. -98. IE.ADP Der DPB liegt ausserhalb des Adressraumes der Task. -99. IE.SDP Die Laenge des DPB bzw. der DIC ist unguel- tig. 104  ---------------------------------------------------------------- | DISABLE AST RECOGNIT|ON | DSAR$S | | - - - - | | | INHIBIT AST RECOGNITION | IHAR$S | | - - - - | | ---------------------------------------------------------------- 2.3.2.15. DSAR$S oder IHAR$S - Verhindern der AST-Bearbeitung ------------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL DSASTR [(ids)] oder CALL INASTR [(ids)] ids = Anweisungsstatus Makro-Aufruf: ------------- DSAR$S [err] oder IHAR$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ DSAR$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack spei- ;chern .BYTE 99.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive BCC .+6. ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung DSAR$S oder IHAR$S weist die Exekutive an, die Bearbeitung von AST fuer diese Task zurueckzustellen. In der Reihenfolge ihres Auftretens werden sie in eine AST- Warteschlange eingeordnet und in dieser Reihenfolge bearbeitet, wenn die Task die AST-Bearbeitung wieder erlaubt. Solange ein AST-Bedienungsprogramm laeuft, wird kein weiterer AST fuer diese Task bearbeitet. Beim Start einer Task ist die AST-Bearbeitung erlaubt. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Beduetung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08. IE.ITS die AST-Bearbeitung ist bereits verhindert -98. IE.ADP der DPB liegt ausserhalb des Adress-Raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig  105  Anmerkung: ---------- Nur die Bearbeitung der AST ist verhindert; die Exekutive ordnet die AST in eine Warteschlange ein (FIFO), und sie werden wirksam, wenn die Task die AST-Bearbeitung wieder erlaubt. 106  ---------------------------------------------------------------- | DISABLE CHECKPOINTING | DSCP$S | | - - - - | | ---------------------------------------------------------------- 2.3.2.16. DSCP$S - Verhindern des Auslagerns -------------------------------------------- FORTRAN-Aufruf: --------------- CALL DISCKP [(ids)] ids = Anweisungsstatus Makro-Aufruf: ------------- DSCP$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ DSCP$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack speichern .BYTE 95.,1 ;DIC der Anweisung und Laenge des DPD EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung DSCP$S informiert die Exekutive davon, dass das Auslagern einer auslagerbar installierten Task zu verhindern ist. Diese Anweisung bezieht sich stets auf die sie enthaltende Task. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08. IE.ITS das Auslagern ist schon verhindert -10. IE.CKP die Task ist nicht auslagerbar -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- Bei Beginn der Bearbeitung einer auslagerbaren Task ist das Aus- lagern einer Task nicht verhindert, d.h. die Task kann ausgela- gert werden.  107  ---------------------------------------------------------------- | DETACH REGION | DTRG$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.17. DTRG$ - Trennen einer Region von einer Task ----------------------------------------------------- FORTRAN-Aufruf: --------------- CALL DTRG (irdb[,ids]) irdb = 8-Worte-Integerfeld fuer den Region-Defini- tionsblock ids = Anweisungsstatus Makro-Aufruf: ------------- DTRG$ ADR adr = Adresse des Region-Definitionsblocks (RDB) Makro-Erweiterung: ------------------ DTRG$ ADRDB .BYTE 59.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADRDB ;Adresse des RDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird die Task von einer vorher an sie gebun- denen Region getrennt.Die Adresszuweisungen der zu dieser Region zugewiesenen Adressfenster werden dadurch aufgehoben. Wenn im Regionstatuswort (R.GSTS) des RDB das Bit RS.MDL gesetzt ist vor Ausfuehrung der Anweisung, dann wird die Region zusaetz- lich zum Loeschen durch die letzte auf sie angewandte DTRG$-An- weisung markiert. Die Task muss dazu jedoch die Region mit Loeschzugriff gebunden haben. Von der Exekutive im RDB benoetigte Parameter: symb. Offset R.GID - Region-Identifikation der zu trennenden Region R.GSTS - folgendes Bit des Region-Statuswortes kann vom Nutzer modifiziert werden: RS.MDL = 1, wenn die Region geloescht werden soll, nachdem die letzte Task von ihr ge- trennt wurde; die Task muss in diesem Fall ueber Loesch-Zugriff verfuegen. Von der Exekutive im RDB gespeicherte Parameter: symb. Offset R.GSTS - Folgendes Bit des Region-Statuswortes wird modifi- ziert: RS.UNM = 1, wenn die Adresszuweisung irgendeines Fensters bei der Trennung aufgehoben wurde. 108  Lokale Symboldefinition: ------------------------ D.TRBA - Adresse des RDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IE.SUC die Anweisung wurde erfolgreich ausgefuehrt -16 IE.PRI eine Task ohne Loesch-Zugriff wollte die Region nach der letzten Trennung loeschen, oder es sind noch nicht alle Datenuebertragungen been- det -86 IE.NVR die Region-Identifikation ist ungueltig, bzw. die Taskregion sollte geloescht werden (Region-ID=0) -98 IE.ADP ein Teil des RDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  109  ---------------------------------------------------------------- | ELIMINATE ADDRESS WINDOW | ELAW$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.18. ELAW$ - Eliminieren eines Adressfensters -------------------------------------------------- FORTRAN-Aufruf: --------------- CALL ELAW (iwdb[,ids]) iwdb = 8-Worte-Integerfeld fuer Fensterdefinitions- block ids = Anweisungsstatus Makro-Aufruf: ------------- ELAW$ adr adr = Adresse des Fenster-Definitionsblocks (WDB) Makro-Erweiterung: ------------------ ELAW$ ADWDB .BYTE 119.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit dieser Anweisung wird ein Adressfenster beseitigt. Falls es vorher zugewiesen war, wird die Adresszuweisung beim Eliminieren automatisch aufgehoben. Eine weitere Benutzung des Fensters ist damit nicht mehr moeglich. Von der Exekutive im WDB benoetigte Parameter: symb. Offset W.NID - Identifikation des zu eliminierenden Adressfensters Von der Exekutive im WDB gespeicherte Parameter: Symb. Offset W.NSTS - Folgende Bits im Fenster-Statuswort werden modifi- ziert: WS.ELW = 1, wenn das Adressfenster erfolgreich eliminiert wurde WS.UNM = 1, wenn eine Adresszuweisung aufgehoben werden musste, bevor das Fenster elimi- niert werden konnte. 110  Lokale Symboldefinition: ------------------------ E.LABA - Adresse des WDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -87 IE.NVW die Adressfenster-Identifikation ist ungueltig -98 IE.ADP ein Teil des WDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  111  ---------------------------------------------------------------- | ELIMINATE GROUP GLOBAL EVENT FLAG | ELGF$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.19. Eliminieren von gruppenglobalen Ereignisflags ------------------------------------------------------- Fortran-Aufruf: --------------- CALL ELGF ([gruppe][,ids]) gruppe = Gruppennummer der Flags, die eliminiert werden sollen. ids = Anweisungsstatus Makro-Aufruf: ------------- ELGF$ [gruppe] gruppe = Gruppennummer der Flags, die eliminiert werden sollen. Makro-Erweiterung: ------------------ ELGF$ 303 .BYTE 159.,2 ; DIC der Anweisung und Laenge des DPB .WORD 303 ; globale Ereignisflags der Gruppe 303 Funktionsbeschreibung: ---------------------- Die ELGF$-Anweisung markiert gruppenglobale Ereignisflags fuer das Loeschen. Nutzen augenblicklich keine Tasks dieser Gruppe die gruppenglobalen Ereignisflags (der Benutzungszaehler fuer diese Gruppe, der durch die Exekutive im G.CNT im GFB verwaltet wird, ist Null), werden unmittelbar alle Verbindungen zum Group-Global- Event-Flag Steuerblock (GFB) geloest und alle Zuordnungen aufgehoben. Benutzen Tasks augenblicklich Flags dieser Gruppe, so markiert die Exekutive diese Flaggruppe fuer das Loeschen (GS.DEL=1) und der GFB wird eliminiert, wenn keine Tasks mehr die Flags dieser Gruppe benutzen; wird jedoch eine CRGF$-Anweisung gegeben bevor die Flags geloescht sind, so loescht die Exekutive GS.DEL. Stimmt die angegebene Gruppe mit der Gruppe des Schutz-UIC's der aussendenden Task ueberein und die Ereignisflags sind durch diese Task (durch eine vorhergehende CRGF$-Anweisung) geschuetzt, so hebt die Exekutive den Schutz der Ereignisflags durch Erniedrigung des Zugriffszaehlers auf. Es ist anzumerken, dass eine Task den Schutz von Ereignisflags nicht mehr als einmal erfolgreich aufheben kann. Jeder Versuch den Schutz fuer Ereignisflags aufzuheben, deren Schutz bereits aufgehoben wurde, wird zum Fehlercode IE.RSU fuehren. 112  Lokale Symboldefinition: ------------------------ E.LGRP - Gruppennummer Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -16 IE.PRI Schutzrechtverletzung -17 IE.RSU Ereignisflags sind bereits fuer das Loeschen markiert -91 IE.IUI falsche Gruppe (Gruppennr. > 377 oktal) -97 IE.IEF Gruppe nicht gefunden -98. IE.ADP Ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP Die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ Nur privilegierte Task koennen andere Gruppennummern als die Gruppe des Schutz-UIC's der aussendenden Task vereinbaren. Wird keine Gruppe angegeben, so wird der Schutz-UIC (H.CUIC+1) der Task aus dem Taskkopf benutzt.  113  ---------------------------------------------------------------- | EMIT STATUS | EMST$ | | -- -- | | ---------------------------------------------------------------- 2.3.2.20. EMST$ - Uebergeben eines Statuswertes ----------------------------------------------- Fortran-Aufruf: --------------- CALL EMST ([rtn],stat[,ids]) rtn = Name der Muttertask, an die ein Statuswert uebergeben werden soll. stat = Statuswert ... (ein Wort) ids = Anweisungsstatus Makro-Aufruf: ------------- EMST$ [tn],stat tn = Name der Muttertask, an die ein Statuswert uebergeben werden soll. stat = 16-Bit-Statuswert Makro-Erweiterung: ------------------ EMST$ TASK,20. .BYTE 147.,4 ; DIC der Anweisung und Laenge des DPB .RAD50 /TASK/ ; Name der Muttertask, die den Status erhaelt .WORD 20. ; Statuswert, der zu uebergeben ist Funktionsbeschreibung: ---------------------- Die EMST$-Anweisung uebergibt ein Wort an die angegebene verbundene Task, die Muttertask. Wenn moeglich, setzt sie in der Muttertask ein Ereignisflag oder erklaert in der Muttertask einen AST, wenn vorher eine CNCT$, eine SPWN$ oder eine SDRP$-Anweisung in der Muttertask zum Anbinden benutzt wurde. Ist die angegebene Task mehrfach mit der diese Anweisung ausgebenden Task verbunden, so wird der erste (aelteste) Offspring Steuerblock (OCB) benutzt, um den Status zurueckzugeben. Ist kein Taskname angegeben, wird diese Aktion mit allen Tasks durchgefuehrt, die zu diesem Zeitpunkt mit der aussendenden Task verbunden sind. In jedem Fall, wenn immer ein Status zu einer oder mehreren Task's gesendet wird, verbleiben diese Tasks nicht laenger mit der Task verbunden, die die EMST$-Anweisusng ausgesendet hat. Lokale Symboldefinition: ------------------------ E.MSTN - Taskname E.MSST - Statuswert 114  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -08 IE.ITS Die angegebene Task ist nicht mit der aussendenden Task verbunden. -98. IE.ADP Ein Teil des DPB liegt ausserhalb des Adressraumes der Task. -99. IE.SDP Die Laenge des DPB bzw. der DIC ist ungueltig.  115  ---------------------------------------------------------------- | ENABLE AST RECOGNITION | ENAR$S | | -- - - | | ---------------------------------------------------------------- 2.3.2.21. ENAR$S - Erlauben der AST-Bearbeitung ----------------------------------------------- FORTRAN-Aufruf: --------------- CALL ENASTR [(ids)] ids = Anweisungsstatus Makro-Aufruf: ------------- ENAR$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ ENAR$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack spei- ;chern .BYTE 101.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfueh- ;rung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung ENAR$S weist die Exekutive an, die Bearbeitung der AST fuer diese Task wieder zu erlauben. Sie hebt die Wirkung der Anweisung DSAR$S bzw. IHAR$S wieder auf. AST, die in die Warteschlange eingeordnet wurden, waehrend ihre Bearbeitung verhindert war, werden nach dieser Anweisung wieder bearbeitet. Beim Start einer Task ist die AST-Bearbeitung erlaubt. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08. IE.ITS die AST-Bearbeitung war nicht verhindert -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 116  ---------------------------------------------------------------- | ENABLE CHECKPOINTING | ENCP$S | | -- - - | | ---------------------------------------------------------------- 2.3.2.22. ENCP$S - Erlauben des Auslagerns ------------------------------------------ FORTRAN-Aufruf: --------------- CALL ENACKP [(ids)] ids = Anweisungsstatus Makro-Aufruf: ------------- ENCP$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ ENCP$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack speichern .BYTE 97.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung ENCP$S verursacht, dass das Auslagern einer Task wieder erlaubt ist, nachdem es durch DSCP$S verhindert worden war, d.h. ENCP$S hebt die Wirkung von DSCP$S auf. Diese Anweisung hat keine Wirkung auf Tasks, die als 'nicht auslagerbar' durch den TKB aufgebaut wurden. ENCP$S bezieht sich immer auf die Task, in der diese Anweisung enthalten ist. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08. IE.ITS das Auslagern ist nicht verhindert -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  117  ---------------------------------------------------------------- | EXITIF | EXIF$ | | -- -- | | ---------------------------------------------------------------- 2.3.2.23. EXIF$ - Bedingte Taskbeendigung ----------------------------------------- FORTRAN-Aufruf: --------------- CALL EXITIF (efn[,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- EXIF$ efn efn = Ereignisflagnummer Makro-Erweiterung: ------------------ EXIF$ 49. .BYTE 53.,2 ;DIC der Anweisung und Laenge des DPB .WORD 49. ;Ereignisflagnummer 49. Funktionsbeschreibung: ---------------------- Die Anweisung EXIF$ beendet die sie enthaltende Task dann und nur dann, wenn das angegebene Ereignisflag geloescht ist. Ist das Ereignisflag gesetzt, wird die Steuerung wieder an die Task zurueckgegeben und ihre Abarbeitung fortgesetzt. Als Ereignisflagnummer kann angegeben werden: 1 ... 32 fuer lokale Ereignisflags, 33 ... 64 fuer Common-Ereignisflags oder 65 ... 96 fuer gruppenglobale Ereignisflags Lokale Symboldefinition: ------------------------ E.XFEF - Ereignisflagnummer Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +02 IS.SET das angegebene Ereignisflag ist gesetzt, die Task wird nicht beendet -97. IE.IEF unzulaessige Ereignisflagnummer -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressrau- mes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 118  Anmerkungen: ------------ - Die Anweisung EXIF$ ist gut geeignet, um z.B. Datenverlust zwischen miteinander verkehrenden Tasks zu vermeiden. Solch ein Datenverlust kann eintreten, wenn eine Task eine Anweisung auf Datenempfang aussendet und die Empfangswarte- schlange leer ist,die Daten aber von einer anderen Task gesen- det wurden, bevor das Ende der Task erreicht ist. In einem solchen Fall geht die Information verloren, weil bei Taskende die Warteschlange fuer Datenempfang geloescht wird. Mit der EXIF$-Anweisung laesst sich dieser Datenver- lust vermeiden, indem die sendende Task ein Common-Ereignis- flag setzt und die empfangende Task in der EXIF$-Anweisung auf das gleiche Flagtestet. Ist das Flag gesetzt, wird die Task nicht beendet, weil es der Empfaengertask signalisiert, dass Daten zum Empfang bereitstehen. - Bei Taskende fuehrt die Exekutive folgende Operationen aus: 1. Freigeben aller gebundenen Geraete; 2. Loeschen der AST-Warteschlange; 3. Loeschen der Warteschlangen fuer Datenempfang und das Emp- fangen von Referenzbloecken; 4. Loeschen aller ausstehenden Anforderungen auf das zeitab- haengige Deklarieren signifikanter Ereignisse; 5. Abschliessen aller eroeffneten Dateien - Dateien, die fuer den Schreibzugriff eroeffnet wurden, werden gesperrt; 6. Freigeben der gebundenen Regionen, wenn die Task nicht im Speicher fixiert ist; 7. Abarbeiten der E/A-Warteschlange der Task; 8. Aufheben des Zugriffs zu gruppenglobalen Ereignisflags; 9. Aufloesen der Verbindungen zu Interrupts; 10. Aufloesen der Verbindungen zu allen Tochtertasks; 11. Uebermittlung des Erfolgsstatus EX$SUC an alle Muttertasks; 12. Freigeben des Speicherplatzes der Task, wenn die Task nicht im Speicher fixiert ist. - Wenn die Task beendet wird, deklariert die Exekutive ein signifikantes Ereignis.  119  ---------------------------------------------------------------- | TASK EXIT | EXIT$S | | ---- | | ---------------------------------------------------------------- 2.3.2.24. EXIT$S - Taskbeendigung --------------------------------- FORTRAN-Aufruf: --------------- STOP-Statement oder CALL EXIT Makro-Aufruf: ------------- EXIT$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ EXIT$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack spei- ;chern .BYTE 51.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die Anweisung EXIT$S beendet die sie enthaltende Task. Sie stellt das logische Ende einer Task dar. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- - - wenn die Anweisung erfolgreich abgearbeitet wurde, wird kein Rueckkehrcode erzeugt, da die Task durch die Anweisung beendet wird -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig 120  Anmerkungen: ------------ - Da diese Anweisung die Abarbeitung einer Task beendet, wird zu ihr nur zurueckgekehrt, wenn die Anweisung von der Exekutive abgewiesen wurde. Aus diesem Grund wird auch nicht der BCC- Befehl bei der Erweiterung erzeugt, wenn die Adresse einer Feh- lerroutine angegeben wurde, weil bei Rueckkehr zur Task das Carry-Bit immer gesetzt ist. - EXIT verursacht das Deklarieren ein signifikantes Ereignis. - Bei Taskende fuehrt die Exekutive folgende Operationen aus: 1. Freigeben aller gebundenen Geraete; 2. Loeschen der AST-Warteschlange; 3. Loeschen der Warteschlangen fuer Datenempfang und das Emp- fangen von Referenzbloecken; 4. Loeschen aller ausstehenden Anforderungen auf das zeitab- haengige Deklarieren signifikanter Ereignisse; 5. Abschliessen aller eroeffneten Dateien - Dateien, die fuer den Schreibzugriff eroeffnet wurden, werden gesperrt; 6. Freigeben der gebundenen Regionen, wenn die Task nicht im Speicher fixiert ist; 7. Abarbeiten der E/A-Warteschlange der Task; 8. Aufheben des Zugriffs zu gruppenglobalen Ereignisflags; 9. Aufloesen der Verbindungen zu Interrupts; 10. Aufloesen der Verbindungen zu allen Tochtertasks 11. Uebermittlung des Erfolgsstatus EX$SUC an alle Muttertasks 12. Freigeben des Speicherplatzes der Task, wenn die Task nicht im Speicher fixiert ist.  121  ---------------------------------------------------------------- | EXIT WITH STATUS | EXST$ | | -- -- | | ---------------------------------------------------------------- 2.3.2.25. EXST$-Taskbeendigung mit Statusuebergabe -------------------------------------------------- Fortran-Aufruf: --------------- CALL EXST (istat) istat = Statuswert (ein Wort) Makro-Aufruf: ------------- EXST$ stat stat = Statuswert (ein Wort) Makro-Erweiterung: ------------------ EXST$ 120. .BYTE 29.,2 ; DIC der Anweisung und Laenge des DPB .WORD 120. ; Statuswert = 120. wird uebergeben Funktionsbeschreibung: ---------------------- Die EXST$-Anweisung veranlasst, dass an alle Tasks, die fuer die die Anweisung aussendende Task "Muttertasks" sind, (verbunden durch die Anweisungen SPWN$, CNCT$ oder SDRC$), ein 16-Bit langer Statuswert uebergeben und die aussendende Task beendet wird. Besitzt die aussendende Task keine angebundenen Tasks, so fuehrt die Anweisung zu einer einfachen Beendigung der Task. Durch die Exekutive wird kein bestimmtes Format fuer das Statuswort verlangt, dies ist ein Problem der Zusammenarbeit zwischen Mutter- und Tochtertask. Wenn jedoch aus irgendeinem Grunde eine Tochtertask abgebrochen wird, so wird der Status EX$SEV an die Muttertask zurueckgegeben. Bei erfolgreicher Beendigung einer Tochtertask ohne explizite Statusuebergabe (durch EXIT$- Anweisung) wird von der Exekutive der Status EX$SUC an alle Muttertasks uebergeben. Lokale Symboldefinition: ------------------------ E.XSTS - zu uebergebender Statuswert 122  Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- - - Wenn die Anweisung erfolgreich abgearbeitet wurde, wird kein Rueckkehrcode erzeugt, da die Task durch die Anweisung beendet wird. -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig  123  Anmerkungen: ------------ - Der Statuswert kann von der Muttertask nur empfangen werden, wenn sie einen Statusblock in der entsprechenden Anweisung zur Verbindung zur Tochtertask bereitgestellt hat. - Bei Taskende fuehrt die Exekutive folgende Operationen aus: 1. Freigeben aller gebundenen Geraete; 2. Loeschen der AST Warteschlange; 3. Loeschen der Warteschlange fuer Datenempfang und das Empfangen von Referenzbloecken; 4. Loeschen aller ausstehenden Anforderungen auf das zeit- abhaengige Deklarieren signifikanter Ereignisse; 5. Abschliessen aller eroeffneten Dateien (Dateien, die fuer den Schreibzugriff eroeffnetet wurden, werden ge- sperrt); 6. Freigeben der gebundenen Regionen, wenn die Task nicht im Speicher fixiert ist; 7. Abarbeiten der E/A-Warteschlange der Task 8. Aufheben des Zugriffs zu gruppenglobalen Ereignisflags der Gruppe der Task; 9. Trennen von Interrupts; 10. Loesen der Verbindung zu jeder Tochtertask 11. Rueckgabe des angegebenen Beendigungsstatus an jede Muttertask 12. Freigeben des Speicherplatzes der Task, wenn die Task nicht im Speicher fixiert ist. - Wenn die Task beendet wird, deklariert die Exekutive ein signifikantes Ereignis. 124  ---------------------------------------------------------------- | EXTEND TASK | EXTK$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.26. EXTK$ - Aendern der Tasklaenge ---------------------------------------- FORTRAN-Aufruf: --------------- CALL EXTTSK ([inc][,ids]) inc = Anzahl der 32.-Wortbloecke (positiv oder negativ), um die die Laenge der Task zu veraendern ist ids = Anweisungsstatus Makro-Aufruf: ------------- EXTK$ [inc] inc = Anzahl der 32.-Wortbloecke (positiv oder negativ), um die die Laenge der Task zu veraendern ist Makro-Erweiterung: ------------------ EXTK$ 50 .BYTE 89.,3 ;DIC der Anweisung und Laenge des DPB .WORD 50 ;Anzahl der Bloecke, um die die Task ver- ;laengert wird .WORD 0 ;reserviert Funktionsbeschreibung: ---------------------- Die Anweisung EXTK$ gestattet es, die Laenge einer Task in einer systemgesteuerten Partition in 32.-Wortbloecken zu vergroessern oder zu verkleinern. Wird in der Anweisung keine Blockanzahl angegeben, dann wird die Installationsgroesse eingestellt. Lokale Symboldefinition: ------------------------ E.XTIN - Anzahl der 32.-Wortbloecke  125  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01. IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01. IE.UPN unzureichender Platz im dynamischen Speicher oder in der Auslagerungsdatei -08. IE.ITS die Task laeuft nicht in einer systemge- steuerten Partition, -10. IE.CKP die Task ist nicht auslagerbar und soll vergroessert werden, -18. IE.NSW die Task verfuegt ueber vorher zugeordneten Auslagerungsbereich und sollte ueber ihre Installationsgroesse hinaus vergroessert wer- den, -83. IE.IOP bei Abarbeitung der Anweisung sind E/A- Anforderungen in Arbeit, -84. IE.ALG . die Task enthaelt speicherresidente Ueberla- gerungen und soll verkleinert werden unter die Groesse des groessten Adressfensters in der Taskpartition . Versuch der Verkleinerung unter die Laenge des Taskkopfes . Versuch der Vergroesserung ueber 32 K Worte oder ueber die durch das MCR-Kommando: SET /MAXEXT bzw. DCL-Kommando: SET EXTENSION_LIMIT vorgegebene Grenze hinaus. . Versuch der Vergroesserung fuehrt zur Ueber- lappung von Adressfenstern. -98. IE.ADP ein Teil des DPD liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die Anweisung darf nur in Tasks benutzt werden, die in system- gesteuerten Partitions laufen. - Bei Ausfuehrung der Anweisung duerfen keine E/A-Anforderungen in Arbeit sein. - Um sich vergroessern zu koennen, muss die Task auslagerbar sein. - Ist die Task auslagerbar, hat aber keinen vorher zugewiesenen Auslagerungsbereich, erfordert eine Taskvergroesserung dynami- schen Speicherbereich und einen genuegend grossen Speicherbe- reich in einer Auslagerungsdatei. - Die Exekutive veraendert die aktuellen Adresszuweisungen nicht, wenn die Task speicherresidente Ueberlagerungen hat. Hat die Task keine speicherresidenten Ueberlagerungen, kann die Adresszuweisung zur Taskregion entsprechend des Argumentes der Anweisung (inc) veraendert werden. 126  - Bezueglich der Veraenderung der Laenge einer Task mit der EXTK$-Anweisung gelten folgende Einschraenkungen: . die maximale Groesse einer Task wird von der mittels MCR- Kommando SET/MAXEXT oder DCL-Kommando SET EXTENSION_LIMIT festgelegten Grenze bzw. von der Groesse der Partition be- stimmt; . eine Task ohne speicherresidente Ueberlagerungen kann nicht groesser als 32K-32 Worte sein; . eine Task mit einem Auslagerungsbereich, der beim Taskaufbau in der Taskabbilddatei zugewiesen wurde, ist in ihrer Laenge auf die bei der Installation vorliegenden Groesse begrenzt; . eine Task mit speicherresidenter Ueberlagerung kann nicht verkleinert werden unter die Groesse des groessten Fensters in der Taskpartition.  127  ---------------------------------------------------------------- | GET LUN INFORMATION | GLUN$ | | - --- | | ---------------------------------------------------------------- 2.3.2.27. GLUN$ - Uebernehmen der Informationen ueber eine logische Geraetenummer ----------------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL GETLUN (lun,dat[,ids]) lun = logische Geraetenummer dat = 6-Worte-Integerfeld fuer die LUN- Information ids = Anweisungsstatus Makro-Aufruf: ------------- GLUN$ lun,buf lun = logische Geraetenummer (LUN) buf = Adresse eines 6 Worte langen Puffers fuer die LUN-Information Makro-Erweiterung: ------------------ GLUN$ 5,LPUF .BYTE 5,3 ;DIC der Anweisung und Laenge des DPB .WORD 5 ;logische Geraetenummer .WORD LPUF ;Pufferadresse Funktionsbeschreibung: ---------------------- Ueber die GLUN$-Anweisung erhaelt die anfordernde Task eine 6 Worte lange Information ueber das physische Geraet, das in der Anweisung mit seiner zugeordneten LUN bezeichnet wurde. Ist ein Geraet mit dem Kommando REDIRECT umadressiert worden, so bezieht sich die Information auf das effektive, d. h. auf das Geraet, auf das umadressiert wurde. 128  Aufbau des LUN-Puffers: symbol. Byte- Inhalt Offset offset _______________________________________________________ G.LUNA 0 | Name des zugeordneten Geraetes | |-----------------------------------| G.LUNU 2 | Logische Geraetenummer des zu- | G.LUFB 3 | geordneten Geraetes und Flag- | | byte | |-----------------------------------| G.LUCW 4 | 1. Geraetekennwort | |-----------------------------------| | 2. Geraetekennwort | |-----------------------------------| | 3. Geraetekennwort | |-----------------------------------| | Standard-Geraetepuffer-Laenge | | (ST-G-LG) | ------------------------------------- Erlaeuterungen: - Flagbyte: Das Flagbyte ist 200, wenn der Geraetedriver geladen ist. Das Flagbyte ist 0, wenn der Driver nicht geladen ist. - 1. Geraetekennwort Bedeutung der Bits 0 ... 15 bei gesetztem Wert (=1) Bit 0 - satzorientiertes Geraet Bit 1 - vorschubgesteuertes Geraet Bit 2 - Bediengeraet Bit 3 - dateistrukturiertes Geraet (mit mehreren Verzeichnissen [Direktories]) Bit 4 - Geraet mit einem einzigen Verzeichnis Bit 5 - Geraet fuer sequentiellen Zugriff Bit 6 - Massenspeichergeraet Bit 7 - Unterstuetzung von Nutzer-Geraetetestprogramm Bit 8 - Reserviert Bit 9 - Geraet ist softwaremaessig schreibgeschuetzt Bit 10 - Reserviert Bit 11 - Reserviert Bit 12 - Pseudogeraet Bit 13 - Reserviert Bit 14 - Geraet eingliederbar fuer Dateiformat FM 16 Bit 15 - Geraet eingliederbar - 2. und 3. Geraetekennwort Geraetedriverspezifischer Inhalt - ST-G-LG Puffergroesse spezifiziert durch MCR/DCL-Kommando SET/BUF Lokale Symboldefinitionen: -------------------------- G.LULU - logische Geraetenummer G.LUBA - Pufferadresse  129  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -05 IE.ULN der LUN ist kein physisches Geraet zugeordnet -96. IE.ILU ungueltige LUN -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 130  ---------------------------------------------------------------- | GET MCR COMMAND LINE | GMCR$ | | - --- | | ---------------------------------------------------------------- 2.3.2.28. GMCR$ - Uebernehmen einer Kommandozeile ------------------------------------------------- FORTRAN-Aufruf: --------------- CALL GETMCR (buf[,ids]) buf = 80-Zeichen-Puffer (80-BYTE Feld) ids = Anweisungsstatus Makro-Aufruf: ------------- GMCR$ Makro-Erweiterung: ------------------ GMCR$ .BYTE 127.,41 ;DIC der Anweisung und Laenge des DPB .BLKW 40. ;80-Zeichen-Puffer Funktionsbeschreibung: ---------------------- Mit der GMCR$-Anweisung kann eine Task eine aus 80 alphanumeri- schen Zeichen bestehende Kommandozeile von einem Bediengeraet oder von einer Muttertask uebernehmen. Die Task muss unter dem Namen "...tsk" oder "tskTn" installiert sein (tsk = 3 alphanu- merische Zeichen, n = zugeordnete oktale Terminalnummer). Wenn ueber das Bediengeraet mit der Terminal-Nummer N die Kommandozeile >tsk kommandoparameter (max. 80 Zeichen) einge- geben wird, aktiviert der MCR-Dispatcher diese Task. Die Task erlangt die gesamte eingegebene Kommandozeile (hinter dem Prompter beginnend), wenn es eine GMCR$-Anweisung ausfuehrt. Die Exekutive speichert die gesamte Kommandoeingabe im 80-Zeichen- Puffer, der Bestandteil des DPB ist. Lokale Symboldefinition: ------------------------ G.MCRB - Kommandozeilenpuffer  131  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +n bei erfolgreicher Abarbeitung ist n die An- zahl der Zeichen, die uebertragen worden sind (mit Ausnahme des Endezeichens). Das Ende- zeichen wird aber in den Puffer uebernommen. -80. IE.AST fuer die anfordernde Task existiert keine Kommandozeile (das heisst, die Task wurde nicht durch eine Kommandozeile der Form >tsk Kommandoparameter aktiviert, oder die Task hatte schon eine GMCR$-Anweisung abgearbeitet) -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die GMCR$S-Form der Anweisung wird nicht unterstuetzt, weil die aktuelle Kommandozeile in den DPB eingetragen wird. - Vom System werden die Kommandozeilen wie folgt bereitgestellt: 1. Tabulatoren werden in Leerzeichen umgewandelt; 2. mehrere Leerzeichen hintereinander werden in ein Leerzeichen umgewandelt; 3. Kleinbuchstaben werden in Grossbuchstaben umgewandelt; 4. alle angehaengten Leerzeichen werden nicht mit uebertragen. - Das letzte Zeichen einer Kommandozeile ist das Endezeichen ( oder ). 132  ---------------------------------------------------------------- | GET MAPPING CONTEXT | GMCX$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.29. GMCX$ - Uebernehmen des gegenwaertigen Zustandes der Adresszuweisung ---------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL GMCX (imcx [,ids]) imcx = Integerfeld mit 8 * n + 1 Worten fuer die Adresszuweisung. Die Zahl n gibt die Anzahl der Fensterbloecke im Tastkopf an (max.N=8) ids = Anweisungsstatus Makro-Aufruf: ------------- GMCX$ adr adr = Adresse eines Vektors, der n WDB enthaelt und durch ein Begrenzungswort abgeschlossen ist. Die Zahl n gibt die Anzahl der Fensterbloecke im Taskkopf an. Makro-Erweiterung: ------------------ GMCX$ ADVEK .BYTE 113.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADVEK ;Adresse des Vektors fuer WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird der gegenwaertige Zustand der Adresszu- weisung in einen Vektor fuer spaetere Verwendung uebernommen. Fuer jeden Fensterblock im Taskkopf wird ein WDB im Vektor reser- viert und mit Informationen aus dem Fensterblock gefuellt. Der Vektor wird in der Task aufgebaut, die die Anweisung enthaelt. Folgende Informationen werden in den Vektor uebertragen: - Falls der Fensterblock ein zugewiesenes Adressfenster be- schreibt, werden W.NAPR, W.NBAS, W.NSIZ, W.NRID, W.NOFF, W.NLEN und W.NSTS in den WDB des Vektors uebertragen. WS.MAP und ggf. WS.WRT werden im Fenster-Statuswort gesetzt. - Falls der Fensterblock ein nicht zugewiesenes Adressfenster beschreibt, werden W.NID, W.NAPR, W.NBAS und W.NSIZ in den WDB des Vektors uebertragen. Das Fenster-Statuswort wird geloescht. Falls ein Fensterblock nicht mit einem bestehenden Adressfenster in Verbindung steht (wenn er zu einem Adressfenster gehoert, das eliminiert wurde), werden keine Informationen im Vektor bereitge- stellt, d. h., der Fensterblock wird ignoriert. Nach dem letzten WDB im Vektor wird ein Begrenzer-Wort angegeben. Das Begrenzer-Wort kann zur Bestimmung der Anzahl der Fenster- bloecke im Taskkopf dienen. Es ist die Negation der Anzahl aller Fensterbloecke, und ueber TST- bzw. TSTB-Befehle kann damit das Ende des letzten WDB im Vektor ausgetestet werden.  133  Diese Anweisung kann verwendet werden, wenn der Nutzer mehr als 7 Adressfenster fuer die Task aufstellen moechte. Weil nur 7 Fen- sterbloecke zur Verfuegung stehen, muessen die z.Z. nicht benoe- tigten Fensterbloecke im Vektor verwahrt werden, damit sie von neuen Adressfenstern benutzt werden koennen. Falls mit den im Vektor abgespeicherten Fensterbloecken ueber CRAW$-Anweisungen neue Adressfenster hergestellt werden, muessen die neuen Fenster- Identifikationen nicht notwendig den alten entsprechen. Von der Exekutive pro Fensterblock im Vektor gespeicherte Para- meter: symb. Offset W.NID - Adressfenster-Identifikation W.NAPR - Basis-APR des Adressfensters W.NBAS - virtuelle Basisadresse des Adressfensters W.NSIZ - Groesse des Adressfensters (in 32.-Wortbloecken) W.NRID - Identifikation der zugewiesenen Region bzw. unveraendert bei nicht zugewiesenem Fenster W.NOFF - Differenz zwischen Region-Anfang und Zuweisungsbe- ginn bzw. unveraendert bei nicht zugewiesenem Fen- ster (in 32.-Wortbloecken) W.NLEN - Laenge des zugewiesenen Bereichs bzw. unveraendert bei nicht zugewiesenem Fenster (in 32.-Wort- bloecken) W.NSTS - folgende Bits des Fenster-Statusworts werden modi- fiziert: WS.MAP = 1, wenn das Fenster zugewiesen ist WS.WRT = 1, wenn das Fenster mit Schreibzugriff zugewiesen wurde Falls das Fenster nicht zugewiesen ist, werden diese Bits von W.NSTS geloescht. Lokale Symboldefinition: ----------------------- G.MCVA - Adresse des Vektors, der die WDB's und das Begren- zungswort enthaelt. Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausge- fuehrt -98 IE.ADP ein Teil des DPB bzw. Vektors liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkung: ---------- Die in W.NLEN zugewiesene Laenge kann kleiner sein als die in W.NSIZ angegebene Fenstergroesse, wenn der Bereich zwischen W.NOFF und dem Ende der Partition kleiner als die Fenstergroesse ist. 134  ---------------------------------------------------------------- | GET PARTITION PARAMETERS | GPRT$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.30. GPRT$ - Uebernehmen von Parametern einer Partition ------------------------------------------------------------ FORTRAN-Aufruf: --------------- CALL GETPAR ([prt], buf [,ids]) prt = Name der Partition buf = 3-Worte-Integerfeld zum Speichern der Partition-Parameter ids = Anweisungsstatus Makro-Aufruf: ------------- GPRT$ [prt],buf prt = Name der Partition buf = Adresse des 3-Worte-Puffers Makro-Erweiterung: ------------------ GPRT$ PART,BUFF .BYTE 65.,4 ;DIC der Anweisung und Laenge des DPB .RAD50 /PART/ ;Partition "PART" .WORD BUFF ;Adresse des 3-Worte-Puffers Funktionsbeschreibung: ---------------------- Mit der Anweisung werden in einem aus 3 Worten bestehenden Puffer Partitionparameter bereitgestellt. Je ein Wort ist fuer die phy- sische Basisadresse, fuer die Groesse und das Flagwort der Parti- tion vorgesehen. Falls der Partitionname nicht bzw. mit 0 angegeben wurde, werden die Parameter der Partition bereitgestellt, in der sich die Task bzw. ihr Wurzelsegment befindet. Ist das eine systemgesteuerte Partition, werden die Werte der unbenannten Subpartition angege- ben, in der die Task bzw. das Wurzelsegment laeuft. Zu dieser Anweisung gibt es eine Abwandlung zur Bestimmung von Parametern einer Region (GREG$). Wenn das erste Wort des Partitionsnamens 0 ist, wird das zweite Wort als Regions-Identi- fikation gedeutet. Der Puffer hat folgenden Aufbau: Nr. des symb. Wortes Offset Inhalt ----------------------------------------------------------------- 0 G.PRPB physische Basisadresse der Partition (in 32.-Wortbloecken) 1 G.PRPS Partitiongroesse (in 32.-Wortbloecken) 2 G.PRFW Flagwort der Partition = 0 fuer systemgesteuerte Partitions = 1 fuer nutzergesteuerte Partitions  135  Lokale Symboldefinitionen: -------------------------- G.PRPN - Name der Partition G.PRBA - Adresse des Puffers Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- siehe auch: Anmerkung -02 IE.INS die Partition existiert nicht im System -98. IE.ADP ein Teil des Puffers bzw. des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- Falls die Anweisung erfolgreich war, wird das Carry-Bit ge- loescht. Das DSW enthaelt die virtuelle Startadresse der Partition (= 0). War die Anweisung nicht erfolgreich, wird das Carry-Bit gesetzt und ein entsprechende Fehlercode in das DSW eingetragen. 136  ---------------------------------------------------------------- | GET REGION PARAMETERS | GREG$ | | - --- | | ---------------------------------------------------------------- 2.3.2.31. GREG$ - Uebernehmen von Parametern einer Region --------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL GETREG ([rid],buf [,ids]) rid = Region-Identifikation buf = 3-Worte-Integerfeld fuer die Regionparameter ids = Anweisungsstatus Makro-Aufruf: ------------- GREG$ [rid],buf rid = Region-Identifikation buf = Adresse eines 3-Worte-Puffers Makro-Erweiterung: ------------------ GREG$ RID,DATBU .BYTE 65.,4 ;DIC der Anweisung und Laenge des DPB .WORD 0 ;Wort zur Unterscheidung von GPRT$ .WORD RID ;Region-Identifikation .WORD DATBU ;Adresse des 3-Worte-Puffers Funktionsbeschreibung: ---------------------- Die Anweisung dient dazu, Parameter einer Region in einem 3 Worte umfassenden Puffer zu speichern. Es sind die Basisadresse der Region, die Groesse der Region und das Flagwort. Falls der Nutzer keine Region-Identifikation spezifiziert hat, wird die Taskregion beschrieben. Diese Anweisung ist eine Abwandlung der GPRT$-Anweisung. Lokale Symboldefinitionen: -------------------------- G.RGID - Region-Identifikation G.RGBA - Adresse des Puffers Der Puffer hat folgenden Aufbau: Nr. des symb. Wortes Offset Inhalt ----------------------------------------------------------------- 0 G.RGRB Basisadresse der Region (in 32.-Wort- bloecken) 1 G.RGRS Region-Groesse (in 32.-Wortbloecken) 2 G.RGFW Flagwort der Region = 0 wenn sich die Region in einer sy- stemgesteuerten Partition befindet = 1 wenn sich die Region in einer nut- zergesteuerten Partition befindet  137  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- siehe auch: Anmerkung -86 IE.NVR die Region-Identifikation ist unzulaessig -98 IE.ADP ein Teil des Puffers bzw. DPB liegt ausser- halb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- Falls die Anweisung erfolgreich ausgefuehrt worden ist, wird das Carry-Bit geloescht. Im DSW wird die virtuelle Startadressse der Region (= 0) uebergeben. War die Anweisung nicht erfolgreich, wird das Carry-Bit gesetzt und einer der obigen Rueckkehr- codes im DSW uebergeben. 138  ---------------------------------------------------------------- | GET TIME PARAMETER | GTIM$ | | - --- | | ---------------------------------------------------------------- 2.3.2.32. GTIM$ - Uebernehmen der Zeitparameter ----------------------------------------------- FORTRAN-Aufruf: --------------- CALL GETTIM (ftbuf,[ids]) ftbuf = 8-Worte-Integerfeld fuer Aufnahme der Zeitparameter ids = Anweisungsstatus Makro-Aufruf: ------------- GTIM$ buf buf = Adresse eines 8-Worte-Puffers Makro-Erweiterung: ------------------ GTIM$ PUFFER .BYTE 61.,2 ;DIC der Anweisung und Laenge des DPB .WORD PUFFER ;Adresse des 8-Worte-Puffers Funktionsbeschreibung: ---------------------- Die GTIM$-Anweisung veranlasst die Exekutive, einen angegebenen 8-Wort-Puffer mit den aktuellen Zeitparametern zu fuellen. Die Parameter werden als Binaerzahlen uebergeben. Der Puffer hat folgenden Aufbau: Nr. des symb. Wortes Offset Pufferinhalt ----------------------------------------------------------------- 0 G.TIYR Jahr (ab 1900) 1 G.TIMO Monat (1 - 12) 2 G.TIDA Tag (1 - 31) 3 G.TIHR Stunde (0 - 23) 4 G.TIMI Minute (0 - 59) 5 G.TISC Sekunde (0 - 59) 6 G.TIST Takt der Sekunde (abhaengig von der Uhrfre- quenz) 7 G.TICP Takte pro Sekunde (abhaengig von der Uhr- frequenz) Lokale Symboldefinition: ------------------------ G.TIBA - Pufferadresse  139  Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- Das Format des 8-Worte-Puffers ist gleich dem des Puffers, der in der STIM$-Anweisung benutzt wird. 140  ---------------------------------------------------------------- | GET TASK PARAMETERS | GTSK$ | | - - -- | | ---------------------------------------------------------------- 2.3.2.33. GTSK$ - Uebernehmen der Parameter einer Task ------------------------------------------------------ FORTRAN-Aufruf: --------------- CALL GETTSK (buf [,ids]) buf = 16-Worte-Integerfeld fuer die Taskparameter ids = Anweisungsstatus Makro-Aufruf: ------------- GTSK$ buf buf = Adresse eines aus 16 Worten bestehenden Puffers Makro-Erweiterung: ------------------ GTSK$ ADR .BYTE 63.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADR ;Pufferadresse Funktionsbeschreibung: ---------------------- Mit dieser Anweisung werden in einem aus 16 Worten bestehenden Puffer Informationen ueber die die Anweisung enthaltende Task eingeschrieben, um sie zu einem spaeteren Zeitpunkt wieder ver- wenden zu koennen. Der Puffer hat folgenden Aufbau: Nr. des symb. Wortes Offset Pufferinhalt ----------------------------------------------------------------- 0 G.TSTN 1. Haelfte des Namens der Task, die die Anweisung enthaelt (in RAD50-Zeichen) 1 2. Haelfte des Namens der Task, die die Anweisung enthaelt (in RAD50-Zeichen) 2 G.TSPN 1. Haelfte des Partition-Namens (in RAD50-Zeichen) 3 2. Haelfte des Partition-Namens (in RAD50-Zeichen) 4,5 dienen der Kompatibilitaet zum SKR 6 G.TSPR Laufprioritaet 7 G.TSGC, Standard-UIC der Task, die G.TSPC die Anweisung enthaelt (siehe RQST$- Anweisung) 10 G.TSNL Anzahl der logischen E/A-Einheiten (LUN)  141  Nr. des symb. Wortes Offset Pufferinhalt ----------------------------------------------------------------- 11,12 dienen der Kompatibilitaet zum SKR 13 G.TSVA Adresse der SST-Vektortabelle der Task (ist nur gueltig, wenn Wort 14 > 0 14 G.TSVL Groesse der SST-Vektortabelle der Task (in Worten) 15 G.TSTS Groesse des Adressfensters 0 (in Bytes) 16 G.TSSY enthaelt die Systemidentifikation (=1) 17 G.TSDU Schutzcode der Task (siehe RQST$- Anweisung) Lokale Symboldefinition: ------------------------ G.TSBA - Adresse des Puffers Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP ein Teil des Puffers bzw. des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig 142  ---------------------------------------------------------------- | MAP ADDRESS WINDOW | MAP$ | | --- | | ---------------------------------------------------------------- 2.3.2.34. MAP$ - Zuweisen eines Adressfensters zu einer Region ------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL MAP (iwdb [,ids]) iwdb = 8-Worte-Integerfeld fuer Fenster-Definitions- block ids = Anweisungsstatus Makro-Aufruf: ------------- MAP$ adr adr = Adresse des Fenster-Definitionsblockes (WDB) Makro-Erweiterung: ------------------ MAP$ ADWDB .BYTE 121.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird die Adresszuweisung eines bereits existie- renden Fensters zu einer an die Task gebundenen Region vorgenom- men. Falls das zuzuweisende Fenster bereits andersweitig zugewiesen ist, wird die Zuweisung dort automatisch aufgehoben und das Fenster dann dem gewuenschten Bereich zugewiesen. Es ist darauf zu achten, dass die Zugriffsrechte der Task zur Region der Adresszuweisung des Fensters zur Region nicht widersprechen. Eine Task muss mit Schreib-Zugriff an eine Region gebunden werden, wenn sie in die Region schreiben will oder mit Lese- bzw. Schreib-Zugriff, wenn die Task nur lesen will. Bei der Zuweisung eines Adressfensters kann die Laenge, die in W.NLEN spezifiziert wird, in folgenden Grenzen gewaehlt werden: - kleiner/gleich der bei der Herstellung des Fensters spezifizierten Laenge und - kleiner/gleich der durch W.NOFF und dem Regionende vorgegebenen Laenge in der Region. Von der Exekutive im WDB benoetigte Parameter: symb. Offset W.NID - Fenster-Identifikation  143  W.NRID - Region-Identifikation der Region, zu welcher das Fenster zugewiesen wird bzw. 0 fuer die Task- Region W.NOFF - Offset vom Anfang der Region bis zum Beginn der Zuweisung (in 32.-Wortbloecken; bei WS.64B = 0 muss der Offset ein Vielfaches von 8 sein) W.NLEN - Laenge der Adresszuweisung (in 32.-Wortbloecken); falls W.NLEN nicht spezifiziert wird, soll das gesamte Fenster bzw. der Bereich von W.NOFF bis zum Ende der Region zugewiesen werden W.NSTS - Folgende Bits koennen im Fenster-Statuswort modifi- ziert werden: WS.WRT = 1, wenn Schreiben gewuenscht wird WS.64B = 1, wenn die adressierbare Blockgroesse 64. Bytes betraegt. Sonst betraegt die Blockgroesse 512. Bytes (WS.64B=0). Von der Exekutive im WDB gespeicherte Parameter: symb. Offset W.NLEN - Laenge der aktuellen Adresszuweisung W.NSTS - Folgendes Bit wird im Fenster-Statuswort modifi- ziert: WS.UNM = 1, wenn die Ausfuehrung der Anweisung erst die Aufhebung einer Adresszuweisung des zu nutzenden Fensters erforderte. Lokale Symboldefinition: ------------------------ M.APBA - Adresse des WDB Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -16 IE.PRI der Privilegstatus wurde verletzt -84 IE.ALG der Offset der Region und die Laengenangabe fuer die Zuweisung bzw. WS.64B und W.NOFF widersprechen einander -86 IE.NVR die Region-Identifikation ist nicht zulaes- sig -87 IE.NVW die Fenster-Identifikation ist nicht zulaes- sig -98 IE.ADP ein Teil des WDB bzw. DPB liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig 144  ---------------------------------------------------------------- | MARK TIME | MRKT$ | | - -- - | | ---------------------------------------------------------------- 2.3.2.35. MRKT$ - Zeitabhaengiges Deklarieren eines signifikanten Ereignisses -------------------------------------------------------- FORTRAN-Aufrufe: ---------------- CALL MARK (efn,tmg,tnt [,ids]) efn = Ereignisflagnummer tmg = Zeitgroesse tnt = Zeiteinheit ids = Anweisungsstatus Als Standardruf steht ausserdem noch zur Verfuegung: CALL WAIT (tmg, tnt, ids) tmg = Zeitgroesse tnt = Zeiteinheit ids = Anweisungsstatus Makro-Aufruf: ------------- MRKT$ [efn], tmg,tnt [,ast] efn = Ereignisflagnummer tmg = Zeitgroesse tnt = Zeiteinheit ast = AST-Eintrittspunktadresse Makro-Erweiterung: ------------------ MRKT$ 50.,30.,1,ADRAST .BYTE 23.,5 ;DIC der Anweisung und Laenge des DPB .WORD 50. ;Ereignisflagnummer .WORD 30. ;Zeitgroesse .WORD 1 ;Zeiteinheit .WORD ADRAST ;Adresse der zugehoerigen AST-Routine Funktionsbeschreibung: ---------------------- Die MRKT$-Anweisung veranlasst die Exekutive, nach einem angege- benen Zeitintervall ein signifikantes Ereignis zu deklarieren. Das Intervall beginnt mit der Abarbeitung der Anweisung, wobei die Ausfuehrung der Task waehrend des Intervalls fortgesetzt wird. Falls ein Ereignisflag angegeben wurde, wird es beim Abarbeiten der Anweisung geloescht und zur Zeit des signifikanten Ereignis- ses gesetzt. Falls eine AST-Eintrittspunktadresse angegeben ist, wird ein asynchroner Systemtrap (AST) zur Zeit des signifikanten Ereignis- ses ausgefuehrt. Durch den AST werden PS, PC, DSW, das Maskenwort fuer Wartebedingungen und die in der Anweisung angegebene Ereig- nisflagnummer auf den Stack der Task gebracht.  145  Das signifikante Ereignis tritt auch dann nach dem angegebenen Zeitintervall auf, wenn weder eine Ereignisflagnummer noch eine AST-Eintrittspunktadresse angegeben wurde. Lokale Symboldefinitionen: -------------------------- M.KTEF - Ereignisflagnummer M.KTMG - Zeitgroesse M.KTUN - Zeiteinheit M.KTAE - AST-Eintrittspunktadresse Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN unzureichender dynamischer Speicherbereich der Exekutive -93. IE.ITI ungueltiger Zeitparameter -97. IE.IEF ungueltige Ereignisflagnummer -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressbereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig Rueckkehrcodes fuer CALL WAIT: ------------------------------ 1 erfolgreiche Beendigung 2 unzureichender dyn. Speicherbereich 3 spezifizierte Task ist nicht installiert 94 ungueltiger Zeitparameter (siehe Anmerkung) 98 ungueltige Ereignisflagnummer 99 ein Teil des DPB liegt ausserhalb der Task 100 die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die MRKT$-Anweisung benoetigt Platz im dynamischen Bereich der Exekutive fuer die Eintragung in die Uhrschlange. - Falls eine AST-Eintrittspunktadresse angegeben ist, wird das AST-Behandlungsprogramm mit folgendem Task-Stack-Inhalt erreicht: SP + 10 - Ereignisflagmaskenwort SP + 06 - PS der Task vor dem AST SP + 04 - PC der Task vor dem AST SP + 02 - DSW der Task vor dem AST SP + 00 - Ereignisflagnummer (0, wenn in der Anweisung keine Ereignisflagnummer angege- ben wurde). 146  - Die Ereignisflagnummer muss vom Stack der Task entfernt werden, bevor die ASTX$S-Anweisung ausgefuehrt wird. - Im Ereignisflag-Maskenwort werden die Warte-Bedingungen der Task vor dem AST-Eintritt gerettet. - Falls die Anweisung abgewiesen wurde, ist nicht sicher, ob das spezifizierte Ereignisflag gesetzt ist oder nicht. Folglich kann die Task, wenn sie in diesem Fall eine Warteanweisung ausfuehrt, unbegrenzt warten. Es ist darum immer sorgfaeltig darauf zu achten, dass die MRKT$-Anweisung erfolgreich ausgefuehrt wird (Austesten des Carry-Bits bzw. des Rueckkehrcodes). - Falls eine Task in einer MRKT$-Anweisung ein Common-Ereignis- flag bzw. ein gruppenglobales Ereignisflag angibt und ihre Ar- beit beendet, bevor die in der Anweisung angegebene Zeit ver- strichen ist, wird das Ereignisflag nicht gesetzt. - Der Zeitparameter besteht aus der Zeitgroesse (tmg) und der Zeiteinheit (tnt). Die Zeiteinheit (tnt) ist folgendermassen codiert: 1 - Takt 2 - Sekunde 3 - Minute 4 - Stunde Fuer den FORTRAN-Aufruf CALL WAIT gilt: 0 - Takt 1 - Millisekunde 2 - Sekunde 3 - Minute 4 - Stunde Jeder Uhr-Interrupt entspricht einem Taktimpuls und ist ab- haengig vom Typ der installierten Uhr im System (Netzfre- quenz-Uhr = 50 Takte/Sekunde). Bei einer programmierbaren Uhr wird die Taktfrequenz bei der Generierung festgelegt.  147  In Abhaengigkeit von der gewaehlten Zeiteinheit bestehen fuer die Zeitgroesse folgende Einschraenkungen: tnt | tmg (in dezimaler Angabe) ------------------- | 0 u.1 | <= 32 767 | 2 | <= 32 767 | 3 | <= 1 440 | 4 | <= 24 - Wenn ein gruppenglobales Ereignisflag angegeben wurde wird der Benutzungszaehler dieser Ereignisflaggruppe um 1 erhoeht, um ein vorzeitiges Eliminieren dieser Gruppe zu verhindern. Der Benutzungszaehler wird vermindert, wenn . das Zeitintervall abgelaufen ist und das signifikante Ereignis deklariert wird . das Zeitintervall vorher abgebrochen wird (siehe (MKT$) . die die MRKT$-Anweisung enthaltende Task beendet wird, bevor das Zeitintervall abgelaufen ist. - Das minimale Zeitintervall ist ein Takt. Ein Zeitintervall von 0 wird als ein Takt interpretiert. 148  ---------------------------------------------------------------- | QUEUE I/O REQUEST | QIO$ | | - --- | | ---------------------------------------------------------------- 2.3.2.36. QIO$ - E/A-Exekutive-Anweisung ---------------------------------------- FORTRAN-Aufruf: --------------- CALL QIO (fnc,lun,[efn],[pri],[isb],[prl][,ids]) fnc = E/A-Funktionscode lun = log. Geraetenummer efn = Ereignisflagnummer pri = Prioritaet; wird ignoriert, muss aber aus Kompatibilitaetsgruenden zu SKR-Systemen vorhanden sein isb = 2-Worte-Integerfeld fuer den E/A-Statusblock prl = 6-Worte-Integerfeld fuer geraeteabhaengige Parameter, die in die Parameterworte 1 bis 6 des DPB uebernommen werden. ids = Anweisungsstatus Makro-Aufruf: ------------- QIO$ fnc,lun,[efn],[pri],[isb],[ast][,prl] fnc = E/A-Funktionscode lun = logische Geraetenummer efn = Ereignisflagnummer pri = Prioritaet; wird ignoriert, muss aber aus Kompa- tibilitaetsgruenden zu SKR-Systemen vorhanden sein isb = Adresse des E/A-Statusblockes (2 Worte) ast = Adresse des Eintrittspunktes der AST-Routine, die bei E/A-Beendigung angesteuert werden soll. prl = Liste in der Form , die geraeteabhaengige Parameter enthaelt. Makro-Erweiterung: ------------------ QIO$ IO.RVB,5,15.,,SB,ASTR, .BYTE 1,12 ;DIC der Anweisung und Laenge des DPB .WORD IO.RVB ;Funktionscode (virtuellen Block lesen) .WORD 5 ;logische Geraetenummer .BYTE 15.,0 ;Ereignisflag, Prioritaet (ignoriert) .WORD SB ;E/A-Statusblock-Adresse .WORD ASTR ;Adresse der AST-Routine .WORD BUFR ;Adresse des Datenpuffers .WORD 512. ;Byte-Zaehler .WORD 0 ; .WORD 0 ; weitere funktionsabhaengige .WORD 0 ; Parameter (hier nicht genutzt) .WORD 0 ;  149  Funktionsbeschreibung: ---------------------- Diese Anweisung reiht eine E/A-Anforderung fuer ein physisches Geraet entsprechend der Prioritaet der Task in die Warteschlange dieses Geraetes ein. Das physische Geraet wird ueber eine logische Geraetenummer angesprochen, die dem Geraet zugewiesen ist. Falls ein Ereignisflag oder/und eine E/A-Statusblockadresse ange- geben wurden, loescht die Exekutive das Ereignisflag, wenn die Anweisung angenommen wurde, und setzt nach vollendeter Funktion das Ereignisflag oder/und laedt in den E/A-Statusblock den ent- sprechenden Beendigungscode. Ein AST wird nach ausgefuehrter Funktion nur ausgeloest, wenn die Adresse einer AST-Routine ange- geben wurde. Die geraeteabhaengigen Informationen ueber die QIO-Anweisung sind im Teil 3 der Anleitung fuer den Programmierer (E/A-System) enthalten (E/A-Funktionscode, geraeteabhaengige Parameter, E/A- Statusblock). Lokale Symboldefinitionen: -------------------------- Q.IOFN - E/A-Funktionscode Q.IOLU - logische Geraetenummer Q.IOEF - Ereignisflagnummer Q.IOPR - Prioritaet Q.IOSB - Adresse des E/A-Statusblockes Q.IOAE - Adresse der E/A-Beendigungs-AST-Routine Q.IOPL - Parameterliste (6 Worte) Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC im dynamischen Speicherbereich wurde ein E/A-Paket erstellt -01 IE.UPN unzureichender dynamischer Speicherbereich der Exekutive -05 IE.ULN LUN nicht zugewiesen -06 IE.HWR Driver nicht geladen -16 IE.PRI die die Anweisung ausgebende Task ist keine 'spooler'-Task und versucht das Schreiben eines logischen Blockes. -96 IE.ILU unzulaessige LUN -97. IE.IEF unzulaessiges Ereignisflag -98. IE.ADP ein Teil des DPB oder des E/A-Statusblockes liegt ausserhalb des Adressraumes der Task, die die Anweisung enthaelt -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig Anmerkungen: ------------ - Ueber den Test des Carry-Bits sollte stets geprueft werden, ob die Anweisung abgelehnt wurde, da in diesem Falle die Ereignis- flag-Anzeige nicht aussagekraeftig ist und die Task bei Aus- 150  fuehrung einer WTSE$-Anweisung evtl. staendig wartet. - Bei Eintritt in eine AST-Routine hat der Stack folgenden In- halt: SP + 10 Ereignisflag-Maske SP + 6 PS der Task vor Eintritt in die AST-Routine SP + 4 PC der Task vor Eintritt in die AST-Routine SP + 2 DSW der Task vor Eintritt in die AST-Routine SP + 0 Adresse des E/A-Statusblockes bzw. 0, falls keine angegeben wurde. Vor Beendigung der AST-Routine mit ASTX$S muss das letzte Wort vom Stack gestrichen sein, z.B. mit TST (SP)+. - Tasks koennen normalerweise aus zwei Gruenden bei laufenden E/A Operationen nicht ausgelagert werden: . Durch die E/A-Operation werden Daten direkt von oder zu einem Puffer in der Task uebertragen. . Bei spezifizierter E/A-Statusblockadresse wird der Status direkt in den Statusblock eingetragen. Die Exekutive wartet mit einer moeglichen Auslagerung der Task, bis alle E/A-Operationen fuer die Task beendet sind. Unter folgenden Bedingungen jedoch wird von der Exekutive die Auslagerung auch bei nicht beendeter E/A-Operation ermoeglicht: Wenn im System gepufferte E/A-Anforderungen unterstuetzt werden, der Driver ebenfalls E/A-Pufferung ermoeglicht, die Task auslagerbar und die Auslagerung erlaubt ist, kann die Task auch, ohne dass E/A-Operationen beendet sind, ausgelagert werden. Wenn die Task ausserdem mit einer Blockierungsanweisung (z.B. WTSE$) auf das Eintreffen eines Ereignisses wartet oder in der QIOW$ implizit angibt, wird die Task in den Stop-Zustand versetzt. Eine solche gestoppte Task kann von jeder anderen Task, die Platz in der Partition benoetigt, unabhaengig von ihrer Prioritaet zur Auslagerung gezwungen werden. Diese ausgelagerte Task kann sich erst dann wieder am Platz in der Partition bewerben, wenn die gepufferte E/A-Operation beendet oder die Blockierungsbedingung erfuellt ist. Der Bedieneinheitendriver z.B. puffert E/A-Anforderungen.  151  - Wenn das angegebene Ereignisflag ein gruppenglobales Ereignisflag ist, wird bei Annahme der QIO$-Anweisung durch die Exekutive der Benutzungszaehler der Flag-Gruppe um 1 erhoeht, um ein vorzeitiges Eliminieren dieser Ereignisflags zu verhindern. Der Benutzungszaehler wird wieder um 1 erniedrigt, wenn . die E/A-Anforderung beendet ist; . die E/A-Anforderung gestrichen wird, weil die LUN-Zuweisung durch eine ALUN$-Anweisung geaendert oder eine IO.KIL-Funk- tion fuer die urspruengliche LUN ausgefuehrt wird; . die Task beendet wird, ohne dass die E/A beendet ist. 152  ---------------------------------------------------------------- | QUEUE I/O REQUEST AND WAIT | QIOW$ | | - --- - | | ---------------------------------------------------------------- 2.3.2.37. QIOW$ - E/A-Exekutive-Anweisung mit Warten auf Beendigung -------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL WTQIO (fnc,lun,[efn],[pri],[isb],[prl][,ids]) Parameterbeschreibung siehe QIO Makro-Aufruf: ------------- QIOW$ fnc,lun, efn,[pri],[isb],[ast][,prl] Parameterbeschreibung siehe QIO$ Makro-Erweiterung: ------------------ siehe QIO$ (Unterschied: DIC der QIOW$-Anweisung = 3) Funktionsbeschreibung: ---------------------- Diese Anweisung ist eine Kombination der E/A-Exekutive-Anweisung (QIO$) und der Anweisung WTSE$. Die Taskabarbeitung wird bis zum Ende der spezifizierten E/A-Anforderung suspendiert. Es muss eine Ereignisflagnummer angegeben werden. Fehlt die Ereignisflagnum- mer, wird die Anweisung wie eine QIO$-Anweisung behandelt. Lokale Symboldefinitionen: -------------------------- siehe QIO$ Rueckkehrcodes: --------------- siehe QIO$ 153 ---------------------------------------------------------------- | RECIVE DATA OR STOP | RCST$ | | - - -- | | ---------------------------------------------------------------- 2.3.2.38. RCST$ Empfangen eines Datenblockes oder STOP der Task --------------------------------------------------------------- Fortran-Aufruf: --------------- CALL RCST ([rtn],ibuf[,ids]) rtn = Name der Task, von der der Daten- block erwartet wird ibuf = 15-Worte-Integerfeld zur Aufnahme des Tasknamens und des 13-Worte- Datenblockes ids = Anweisungsstatus Makro-Aufruf: ------------- RCST$ [tn],puf tn = Name der Task, von der der Daten- block erwartet wird buf = Adresse des 15-Worte-Puffers zur Aufnahme des Tasknamens und des 13-Worte-Datenblockes Makro-Erweiterung: ------------------ RCST$ TASKX,PUFFER .BYTE 139.,4 ;DIC der Anweisung und Laenge des DPB .RAD50 /TASKX/ ;Name der die Daten sendenden Task .WORD PUFFER ;Adresse des Empfangspuffer Funktionsbeschreibung: ---------------------- Die RCST$-Anweisung veranlasst die Exekutive einen 13-Wort Datenblock aus der Warteschlange der die Anweisung enthaltenden Task zu entnehmen und in den spezifizierten Datenpuffer einzu- tragen. Der Datenblock wurde vorher fuer die Task mit einer SDAT$- oder einer SDRC$-Anweisung eingereicht. Der 2 Worte umfassende Taskname des Senders (in Radix-50 Format) und der 13 Worte Datenblock werden in den vereinbarten 15 Wort- Puffer eingetragen. Der Taskname wird in die ersten 2 Worte des Puffers eingetragen. Wenn keine Daten gesendet wurden, wird die aussendende Task gestoppt. In diesem Fall wird von der Sendertask erwartet, dass sie eine USTP$-Anweisung fuer die gestoppte Task nach dem erneuten Senden der Daten gibt. 154 Der Status IS.SUC zeigt an, dass ein Paket empfangen wurde. Ein Status von IS.SET zeigt an, dass die Task gestoppt war und der Stop durch eine USTP$-Anweisung aufgehoben wurde. Um die Daten zu erhalten, muss dann erneut eine Anweisung zum Empfangen eines Datenblockes gegeben werden. Wenn eine Slave-Task die Anweisung aussendet, uebernimmt sie den UIC (falls sie keine aktiven Beziehungen zu gruppenglobalen Ereignisflags hat) und das TI: Terminal der Task, die die Daten gesendet hat. Lokale Symboldefinition: ------------------------ R.CSTN - Taskname R.CSBF - Pufferadresse Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +02 IS.SET es wurden keine Daten empfangen, die Task wurde gestoppt (der Stop der Task muss auf- gehoben werden bevor dieser Rueckkehrcode uebergeben wird) +01 IS.SUC Anweisung erfolgreich abgearbeitet -17. IE.RSU die diese Anweisung aussendende Task ist eine Slave-Task mit einer aktiven gruppenglobalen Verbindung und der naechste Datenblock, der empfangen werden wuerde, wuerde die Gruppen- nummer des Schutz-UIC der Task aendern. -80. IE.AST die diese Anweisung aussendende Task befindet sich im AST-Zustand -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkung: ---------- Wenn in der Anweisung kein Taskname angegeben wurde, wird der erste in der Warteschlange befindliche Datenblock bereitgestellt. 155 ---------------------------------------------------------------- | RECEIVE DATA | RCVD$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.39. RCVD$ - Empfangen eines Datenblocks --------------------------------------------- FORTRAN-Aufruf: --------------- CALL RECEIV ([tsk],buf[,,ids]) tsk = Name der Task, von der der Datenblock erwartet wird. Fehlt der Taskname, koennen Datenbloecke von jeder beliebigen Task empfangen werden. buf = 15-Worte-Integerfeld fuer die zu empfangenden Daten ids = Anweisungsstatus Makro-Aufruf: ------------- RCVD$ [tsk],buf tsk = Name der Task, von der der Datenblock erwartet wird. Fehlt der Taskname, koennen Datenbloecke von jeder beliebigen Task empfangen werden. buf = Adresse eines 15-Worte-Puffers fuer die zu empfangenden Daten Makro-Erweiterung: ------------------ RCVD$ ALPHA,DATBUF ;Taskname, Pufferadresse .BYTE 75.,4 ;DIC der Anweisung und Laenge des DPB .RAD50 /ALPHA/ ;Taskname .WORD DATBUF ;Pufferadresse Funktionsbeschreibung: ---------------------- Mit Hilfe der RCVD$-Anweisung kann ein 13-Worte-Datenblock, der von einer anderen Task mit der Anweisung SDAT$ gesendet wurde, von der rufenden Task empfangen werden. Ein zwei Worte umfassen- der Sendertaskname (RAD50) und der 13-Worte-Datenblock werden im 15-Worte-Puffer bereitgestellt, wobei der Taskname in den ersten zwei Worten eingetragen ist. Lokale Symboldefinitionen: -------------------------- R.VDTN - Taskname R.VDBA - Pufferadresse 156 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08. IE.ITS gegenwaertig keine Daten in der Schlange -17. IE.RSU die aussendende Task ist eine Slave-Task mit einer aktiven gruppenglobalen Ereignis- flag-Verbindung und das naechste zu ueber- nehmende Datenpaket wuerde die Gruppen- nummer des Task-UIC aendern. -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Bereiches der Task -99. IE.SDP die Laenge des DPB oder der DIC ist unguel- tig Anmerkungen: ------------ - Eine Task kann als Slave-Task (/SLV = YES) installiert sein. Benutzt eine Slave-Task die Anweisung zum Empfangen eines Da- tenblockes, dann uebernimmt sie UIC und TI-Terminal der Task, die die Daten gesendet hat. Hat die Slave-Task jedoch aktive gruppenglobale Ereignisflag-Verbindungen veranlasst, wird die RCVD$-Anweisung verworfen, wenn sie die Gruppennummer des Task- UIC aendern wuerde. Die Nutzung der urspruenglichen gruppenglo- balen Ereignisflags wuerde anderenfalls fehlerhaft werden (siehe IE.RSU-Rueckkehrcode). - Die gesendeten Datenbloecke werden fuer jede Empfaengertask in eine Warteschlange eingereiht. Die Anweisung durchsucht die Warteschlange nach einem Datenblock, der von der in der Anwei- sung angegebenen Task gesendet wurde und uebergibt ihn im Puf- fer. Ist kein Taskname in der Anweisung angegeben, wird der erste Datenblock der Warteschlange bereitgestellt. - Gibt die sendende Task ein Common- oder gruppenglobales Ereignisflag in der SDAT$-Anweisung an, so kann die empfangende Task das Ereignisflag zur Synchronisierung benutzen. Der Sender kann jedoch zwischen dem Zeitpunkt, zu dem der Empfaenger eine Anweisung zur Synchronisierung ausgibt und dem Zeitpunkt zu dem der Empfaenger die naechste Instruktion gibt, Daten senden und das Ereignisflag setzen. Falls die naechste Empfaenger-Instruktion eine EXIT$-Anweisung ist, so werden alle Daten verlorengehen, die waehrend dieser Zeit gesendet werden, da die Exekutive als Teil des Exitprozesses die Empfaengerliste der Task loescht. Deshalb sit die EXIF$-Anweisung oder die RCVX$-Anweisung zu benutzen, um diese Konfliktsituation zu vermeiden. 157 ---------------------------------------------------------------- | RECEIVE DATA OR EXIT | RCVX$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.40. RCVX$ - Empfangen eines Datenblocks oder Beenden der Task ---------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL RECOEX ([tsk],buf[,,ids]) tsk = Name der Task, von der der Datenblock erwartet wird. Fehlt der Taskname, koen- nen Datenbloecke von jeder beliebigen Task empfangen werden. buf = 15-Worte-Integerfeld fuer die zu empfan- genden Daten ids = Anweisungsstatus Makro-Aufruf: ------------- RCVX$ [tsk],buf tsk = Name der Task, von der der Datenblock erwartet wird. Fehlt der Taskname, koennen Datenbloecke von jeder beliebigen Task empfangen werden. buf = Adresse des 15-Worte-Puffers fuer die zu empfan- genden Daten Makro-Erweiterung: ------------------ RCVX$ ALPHA,DATBUF ;Taskname, Pufferadresse .BYTE 77.,4 ;DIC der Anweisung und Laenge des DPB .RAD50 /ALPHA/ ;Taskname .WORD DATBUF ;Pufferadresse Funktionsbeschreibung: ---------------------- Mit Hilfe der RCVX$-Anweisung kann ein 13-Worte-Datenblock, der von einer anderen Task mit der Anweisung SDAT$ gesendet wurde, von der rufenden Task empfangen werden. Ein zwei Worte umfassen- der Sendertaskname (RAD50) und der 13-Worte-Datenblock werden in einem 15-Worte-Puffer bereitgestellt, wobei der Taskname in den ersten zwei Worten eingetragen ist. Wenn keine Daten gesendet wurden, wird die Task beendet. Um den Verlust von gesendeten Datenpaketen zu verhindern, sollte die An- weisung erst gegeben werden, wenn die Task alle geoeffneten Dateien abgeschlossen hat. Lokale Symboldefinitionen: -------------------------- R.VXTN - Taskname R.VXBA - Pufferadresse 158 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -17. IE.RSU die aussendende Task ist eine Slave-Task mit einer aktiven gruppenglobalen Ereignis- flag-Verbindung und das naechste zu ueber- nehmende Datenpaket wuerde die Gruppennum- mer des Task-UIC aendern. -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Adressbereiches der Task -99. IE.SDP die Laenge des DPB oder der DIC ist unguel- tig Anmerkungen: ------------ - Eine Task kann als Slave (/SLV = YES) installiert sein. Benutzt eine solche Task eine Anweisung zum Empfangen eines Datenblocks oder Beenden der Task, uebernimmt sie UIC und TI-Terminal der Task, die die Daten gesendet hat. Hat die Slave-Task jedoch aktive gruppenglobale Ereignisflag-Verbindungen veranlasst, wird die RCVX$-Anweisung verworfen, wenn sie die Gruppennummer des Task-UIC aendern wuerde. Die Nutzung der urspruenglichen gruppenglobalen Ereignisflags wuerde anderenfalls fehlerhaft werden (siehe IE.RSU-Rueckkehrcode). - Die gesendeten Datenbloecke werden fuer jede Empfaengertask in eine Warteschlange eingereiht. Die Anweisung durchsucht die Warteschlange nach einem Datenblock, der von der in der Anwei- sung angegebenen Task gesendet wurde und uebergibt ihn im Puf- fer. Ist kein Taskname in der Anweisung angegeben, wird der erste Datenblock der Warteschlange bereitgestellt. - Wenn beim Aufruf der RCVX$-Anweisung noch keine Daten gesendet wurden (mit einer SDAT$-Anweisung), wird die Task beendet. Gesendete Datenpakete koennen verloren gehen, wenn eine Task mit ausstehenden E/A-Operationen oder eroeffneten Dateien durch diese Anweisung beendet wird. 159 Folgendes Beispiel in MACRO-1630 zeigt, wie diese Situation um- gangen werden kann: RCVBUF: .BLKW 15. ;Empfangspuffer START: RCVX$C ,RCVBUF ;erster/letzter Empfangsversuch CALL OPEN ;Ruf einer Anwenderroutine zur Dateieroeffnung ;wenn Datenpaket empfangen wurde PROC: . . . Verarbeitung Datenpaket . . . RCVD$C ,RCVBUF ;naechster Empfangsversuch BCC PROC ;wenn Sprung, Datenpaket empfangen CALL CLOSE ;Ruf einer Anwenderroutine zum ;Dateiabschluss, ;wenn kein Datenpaket mehr ;empfangen wurde JMP START ;zum eventuell letzten Empfangsver- ;such - Die RCVX$-Anweisung wird vorteilhaft benutzt, um Konfliktsi- tuationen zu verhindern, die zwischen zwei Tasks auftreten koennen, die gerade ueber Send- und Receive-Anweisungen kommunizieren. Eine Wettlaufsituation tritt ein, wenn eine Task eine RCVD$-Anweisung ausfuehrt und ihre Empfangswarteschlange leer findet; aber bevor die Task beendet werden kann, ihr von der anderen Task ein Datenblock gesendet wird. Dieser geht verloren, da die Exekutive die Empfangswarteschlange der Empfaengertask loescht, wenn sie beendet wird. Diese Bedingung kann verhindert werden durch die Ausfuehrung einer RCVX$- Anweisung von der Empfaengertask. Falls die Empfangswarte- schlange leer vorgefunden wird, wird die Task beendet, bevor die andere Task irgendwelche Daten senden kann und damit tritt kein Datenverlust ein. - Beim Beenden einer Task fuehrt die Exekutive folgende Operationen aus: 1. Freigeben aller gebundenen Geraete; 2. Loeschen der AST-Warteschlange; 3. Loeschen der Warteschlangen fuer Datenempfang und das Empfangen von Referenzbloecken; 4. Loeschen aller ausstehenden Anforderungen auf das zeitabhaengige Deklarieren signifikanter Ereignisse; 5. Abschliessen aller eroeffneten Dateien - Dateien, die fuer den Schreibzugriff eroeffnet wurden, werden gesperrt; 6. Freigeben aller gebundenen Regionen; 7. Abarbeiten der E/A-Warteschlange der Task; 8. Aufhebung des Zugriffs auf die gruppenglobalen Ereignis- flags der Task; 9. Trennen von Interrupts; 10. Uebermittlung des Erfolgsstatus EX$SUC an jede Muttertask; 11. Aufloesung der Verbindung zu jeder Tochtertask; 12. Freigabe des Speicherplatzes, wenn die Task auslagerbar ist - Wenn die Task beendet wird, deklariert die Exekutive ein signi- fikantes Ereignis. 160 ---------------------------------------------------------------- | READ ALL EVENT FLAGS | RDAF$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.41. RDAF$ - Lesen aller Ereignisflags ------------------------------------------- FORTRAN-Aufruf: --------------- CALL READEF (efn[,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- RDAF$ buf buf = Pufferadresse Makro-Erweiterung: ------------------ RDAF$ PUFEF .BYTE 39.,2 ;DIC der Anweisung und Laenge des DPB .WORD PUFEF ;Adresse des 4-Worte-Puffers Funktionsbeschreibung: ---------------------- Mit dieser Anweisung koennen nur 64 Ereignisflags gelesen wer- den. Die Exekutive speichert die einzelnen Flags in einen 4- Wort-Puffer in folgender Form: Wort 0 - lokale Flags 1 - 16 Wort 1 - lokale Flags 17 - 32 Wort 2 - Common-Flags 33 - 48 Wort 3 - Common-Flags 49 - 64 Lokale Symboldefinition: ------------------------ R.DABA - Pufferadresse Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP ein Teil des DPB oder des Puffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig 161 Anmerkungen: ------------ - Mit dieser Anweisung werden nur die lokalen und Common- Ereignisflags angezeigt. Um eventuell fuer diese Task existie- rende gruppenglobale Ereignisflags zu lesen, muss die RDXF$-An- weisung (Pkt. 2.3.2.42.) benutzt werden. - Mit dem FORTRAN-Aufruf CALL READEF kann eine Task nur ein Er- eignisflag lesen. - Um die Polaritaet des zu lesenden Flags anzuzeigen, wird bei FORTRAN in ids der Status 00 IS.CLR fuer das geloeschte und +02 IS.SET fuer das gesetzte Ereignisflag uebermittelt. 162 ---------------------------------------------------------------- | READ EXTENDED EVENT FLAGS | RDXF$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.42. RDXF$ - Erweitertes Lesen aller Ereignisflags ------------------------------------------------------- Fortran-Aufruf: --------------- CALL READEF (efn[,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- RDXF$ puf puf = Adresse eines 6-Work-Puffers Makro-Erweiterung: ------------------ RDXF$ EFPUF .BYTE 39.,3 ;DIC der Anweisung und Laenge des DPB .WORD EFPUF ;Adresse des 6-Work-Puffers Funktionsbeschreibung: ---------------------- Die RDXF$-Anweisung veranlasst die Exekutive, alle lokalen, Common und gruppenglobalen Ereignisflags der die Anweisung aus- sendenden Task zu lesen und ihre Polaritaet in einem 96-Bit ( 6 Worte) Puffer aufzuzeichnen. Pufferformat: Wort 0 lokale Flags 1-16 der Task Wort 1 lokale Flags 17-32 der Task Wort 2 Common Flags 33-48 Wort 3 Common Flags 49-64 Wort 4 gruppenglobale Flags 65-80 der Task Wort 5 gruppenglobale Flags 81-96 der Task Lokale Symboldefinition: ------------------------ R.DABA - Pufferadresse 163 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet +00 IS.CLR Gruppenglobale Ereignisflags existieren nicht. Die Worte 4 und 5 des Puffers sind auf 0 gesetzt worden. -98. IE.ADP Ein Teil des DPB oder des Puffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP Die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Mit dem FORTRAN-Aufruf CALL READEF kann eine Task nur ein Er- eignisflag lesen. - Um die Polaritaet des zu lesenden Flags anzuzeigen, wird bei FORTRAN in ids der Status 00 IS.CLR fuer das geloeschte und +02 IS.SET fuer das gesetzte Ereignisflag uebermittelt 164 ----------------------------------------------------------------- | REQUEST AND PASS OFFSPRING INFORMATION | RPOI$ | | - - - - | | ----------------------------------------------------------------- 2.3.2.43. RPOI$ Aktivieren einer Task und Weitergeben von Mutter/Tochter-Verbindungen ----------------------------------------------------------------- Fortran-Aufruf: --------------- CALL RPOI (tn,[iugc],[iumc],[ipar],[ibuf],[ibfl],[isc], [idnam],[iunit][,,,ids]) tn = Name eines Feldes, das den Namen der Task enthaelt, die aktiviert und wahlweise verket- tet werden soll. iugc = Name eines Wortes vom Typ Integer, das die Gruppennummer fuer den Schutz-UIC der ange- forderten Task enthaelt. iumc = Name eines Wortes vom Typ Integer, das die Mitgliedsnummer fuer den Schutz-UIC der an- geforderten Task enthaelt. ipar = Name eines Feldes, das den RAD50 Namen der Muttertask fuer die diese Anweisung gebenden Task enthaelt. Dieser ist im Informations- puffer der GTCMCI-Subroutine enthalten. ibuf = Name eines Feldes, das den Text einer Kommandozeile fuer die angeforderte Task enthaelt. ibfl = Name eines Wortes vom Typ Integer, das die Anzahl der Bytes des Kommandos im ibuf-Feld enthaelt. isc = Flagbyte, das die Aktionen bei Ausfuehrung dieser Anweisung steuert. Die Bitdefinitionen dieses Bytes (nur das niederwertige Byte des Wortes vom Typ Integer, das im Ruf angegeben wird, wird benutzt) sind folgende: RP.OEX--128. Bei erfolgreicher Ausfuehrung des RPOI-Aufrufes RP.OAL--1 Uebergabe aller Mutter/Tochter- Verbindungen zwischen der in ipar definierten Muttertask und dieser Task an die angeforderte Task. (Der Standard ist: keine) RP.ONX--2 Uebergabe der ersten Verbin- dung, falls eine vorhanden ist. idnam = Name eines Wortes vom Typ Integer, das den Geraetenamen des TI: der angeforderten Task enthaelt iunit = Name eines Wortes vom Typ Integer, das die mit Nummer des TI: Geraetes der angeforderten Task enthaelt. ids = Anweisungsstatus Aus Kompatibilitaetsgruenden zu anderen SKR-Systemen muessen bei Angabe von ids drei Kommas geschrieben werden. 165 Makro-Aufruf: ------------- RPOI$ tn,,,[ugc],[umc],[par],[cl],[cll],[fb],[dn],[unit] tn = Name der Task, die aktiviert und wahlweise verkettet werden soll ugc = Gruppennummer fuer den Schutz-UIC der ange- forderten Task umc = Mitgliedsnummer fuer den Schutz-UIC der an- geforderten Task par = Name der Muttertask der aussendenden Task, deren Mutter/Tochterverbindungen uebertragen werden sollen. cl = Adresse einer Kommandozeile, die an die ange- forderte Task zu uebergeben ist cll = Laenge der in cl enthaltenen Kommandozeile fb = Flagbyte RP.OEX--(200) die die Anweisung RPOI$ aus- sendende Task ist zu beenden, wenn die Anweisung erfolgreich war RP.OAL--(1) Uebergabe aller Mutter/ Tochter-Verbindungen zwischen der in par definierten Mutter- task und der die Anweisung gebenden Task (Standard ist: keine) RP.ONX--(2) Uebergabe der ersten Verbin- dung, falls eine vorhanden ist dn = ASCII-Geraetename fuer TI: der zu aktivieren- den Task un = Unit-Nummer fuer TI: der zu aktivierenden Task Makro-Erweiterung: ------------------ RPOI$ TESTT,,,200,10,MUTTER,KOM,LGKOM,RP.OEX,TT,2 .BYTE 11.,16. ;DIC der Anweisung und Laenge des DPB .RAD50 /TESTT/ ;Name der Task, die zu aktivieren ist (angeforderte Task) .BLKW 3 ;reserviert .BYTE 10,200 ;Mitglieds-, Gruppennummer des UIC .RAD50 /MUTTER/ ;Name der Task, deren Verbindungen uebergeben werden sollen (OCB) .WORD 0 ;reserviert .WORD KOM ;Adresse des Kommandopuffers .WORD LGKOM ;Laenge dieses Puffers .BYTE 2 ;Einheitennummer des TI:-Geraetes der angeforderten Task .BYTE RP.OEX ;Flagbyte .ASCII /TT/ ;ASCII-Name des TI:-Geraetes der ange- forderten Task .WORD 0,0 ;reserviert 166 Funktionsbeschreibung: ---------------------- Diese Anweisung veranlasst die Exekutive die angegebene Task zu aktivieren und sie mit einer Muttertask der aussendenden Task zu verbinden durch Uebertragung einiger oder aller Mutter/Tochter- task-Verbindungen (OCB-Verbindungen) von der aussendenden Task auf die angeforderte Task. Wahlweise kann die Direktive eine Kommandozeile an die angeforderte Task uebergeben. Nur eine privilegierte Task kann den UIC und das TI: fuer die angeforderte Task spezifizieren. Lokale Symboldefinitionen: -------------------------- R.POTK - RAD50-Name der Task, die zu aktivieren ist R.POUM - Mitgliedsnummer des UIC R.POUG - Gruppennummer des UIC R.POPT - Name der Muttertask, deren OCB uebergeben werden soll R.POBF - Adresse des Kommandopuffers R.POBL - Laenge des Kommandos R.POUN - Unit Nummer des TI:'s der Task R.POSC - Flagbyte R.PODU - ASCII-Geraetename fuer TI: Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ---------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN Fehlender Platz im dynamischen Bereich der Exekutive fuer Steuerbloecke oder den Kommandozeilenpuffer -02 IE.INS die Task ist nicht installiert -07 IE.ACT die Task ist schon aktiv -86. IE.NVR fuer die angegebene Muttertask existiert kein OCB -98. IE.ADP ein Teil des DPB-Kommandozeilenpuffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig 167 ---------------------------------------------------------------- | REQUEST | RQST$ | | - - -- | | ---------------------------------------------------------------- 2.3.2.44. RQST$ - Aktivieren einer Task --------------------------------------- FORTRAN-Aufruf: --------------- CALL REQUES (tsk,[opt][,ids]) tsk = Taskname opt = Adresse eines 4-Worte-Integerfeldes opt (1) = 1. Haelfte des Partitionnamens; wird ignoriert, muss aber aus Kompatibilitaetsgruenden zum SKR vorhanden sein opt (2) = 2. Haelfte des Partitionnamens; wird ignoriert, muss aber aus Kompatibilitaetsgruenden zum SKR vorhanden sein opt (3) = Prioritaet; wird ignoriert, muss aber aus Kompatibilitaetsgruenden zum SKR vorhanden sein opt (4) = Nutzeridentifikationscode ids = Anweisungsstatus Makro-Aufruf: ------------- RQST$ tsk,[prt],[pri][,ugc,umc] tsk = Taskname prt = Partitionname; wird ignoriert, muss aber aus Kompatibilitaetsgruenden zu SKR-Systemen im DPB vorhanden sein pri = Prioritaet; wird ignoriert, muss aber aus Kompa- tibilitaetsgruenden zu SKR-Systemen im DPB vor- handen sein ugc = UIC-Gruppencode umc = UIC-Mitgliedscode Makro-Erweiterung: ------------------ RQST$ FAKT,,,200,10 .BYTE 11.,7 ;DIC der Anweisung und Laenge des DPB .RAD50 /FAKT/ ;Taskname .WORD 0,0 ;reservierte Plaetze statt des Partition- namens .WORD 0 ;reservierter Platz statt der Prioritaet .BYTE 10,200 ;UIC, unter dem die Task laufen soll (Mit- glieds-/Gruppencode) 168 Funktionsbeschreibung: ---------------------- Die Anweisung RQST$ informiert die Exekutive davon, dass eine Task zu aktivieren ist. Sie ist eine Teilmenge der RUN$-Anwei- sung, mit deren Hilfe in Abarbeitung befindliche Tasks andere installierte, aber ruhende Tasks aktivieren. Eine mit RQST$ angeforderte Task wird aktiviert und in Abhaengig- keit von ihrer Prioritaet und von der Verfuegbarkeit des ent- sprechenden Speicherraums ohne Verzoegerung abgearbeitet. Lokale Symboldefinitionen: -------------------------- R.QSTN - Taskname R.QSPN - Partitionname R.QSPR - Prioritaet R.QSPC - UIC-Mitgliedscode R.QSGC - UIC-Gruppencode Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN unzureichender dynamischer Speicherbereich -02 IE.INS die Task ist nicht installiert -07 IE.ACT die Task ist schon aktiv -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die zu aktivierende Task muss installiert sein. - Die Prioritaet, mit der die Task bearbeitet wird, ist die, die im Taskkopf angegeben wurde. - Werden in der Parameterkette der RQST$-Anweisung die UIC-Para- meter weggelassen, dann wird der Nutzeridentifikationscode aus dem Kopf der angeforderten Task benutzt, der beim Bilden der Task angegeben wurde. - Wenn die Partition, in der die Task laufen soll, belegt ist, wird die Task in eine Warteschlange fuer Tasks eingetragen, die in dieser Partition bearbeitet werden sollen und wird abhaengig von den Prioritaetsbedingungen und der Ressourcenverfuegbarkeit abgearbeitet, wenn die Partition frei wird. - Ist die die Partition belegende aktuelle Task auslagerbar, und ist das Auslagern erlaubt und ausserdem ihre Prioritaet niedri- ger als die der auf die Partition wartenden Task, wird sie ausgelagert, wenn ausstehende nichtgepufferte Datenuebertra- gungen beendet sind. Die angeforderte Task wird dann in die Partition eingelesen. 169 - Erfolgreiche Ausfuehrung der Anweisung bedeutet nicht, dass die Task bereits bearbeitet wird, sondern lediglich, dass sie akti- viert wurde. - Die angeforderte Task erhaelt die gleiche Zuordnung fuer das Pseudogeraet TI: wie die anfordernde Task. - Soll die Task in einer systemgesteuerten Partition laufen, wird zusaetzlicher dynamischer Speicherbereich fuer den dynamisch zugewiesenen Partitionsteuerblock (PCB) benoetigt, in dem der Speicherbedarf der Task beschrieben wird. - Jede aktive Task hat zwei Nutzeridentifikationscodes; einen Schutz-UIC und einen Standard-UIC, die beide durch Abarbei- tung einer Anweisung zum Uebernehmen von Taskparametern (GTSK$) in einem Puffer bereitgestellt werden. Der Schutz-UIC legt die Zugriffsrechte fuer das Eroeffnen von Dateien und das Binden an Regionen fest. Wenn eine Task eine Datei zu eroeffnen versucht, vergleicht das System den Schutz-UIC der Task mit der Schutzmaske des angege- benen Nutzerdateiverzeichnisses (UFD). Das Ergebnis des Ver- gleiches entscheidet darueber, fuer welche Zugriffsklasse (System, Eigentuemer, Eigentuemergruppe, Rest) die Task zu beruecksichtigen ist. Der Standard-UIC wird durch die Dateizugriffsroutinen benutzt, wenn in Dateieroeffnungsoperationen kein UIC angegeben wird, um das Standard-UFD zu bestimmen. Der Standard-UIC hat keine Bedeutung, wenn eine Task an eine Region gebunden wird. - Jedes Bediengeraet hat auch einen Schutz- und einen Standard- UIC. Fuer nichtprivilegierte Bediengeraete ist der Schutz-UIC gleich dem UIC der Anmeldung und der Standard-UIC gleich dem UIC der Anmeldung oder dem der beim letzten SET-Kommando mit dem Schluesselwort /UIC angegeben wurde. Fuer privilegierte Bediengeraete sind beide Codes entweder gleich dem beim letzten SET-Kommando mit dem Schluesselwort /UIC angegebenen Nutzeridentifikationscode oder gleich dem beim Anmelden angegebenen UIC, wenn kein UIC durch ein SET-Kommando spezifiziert wurde. Die Exekutive legt die UIC einer Task fest, wenn diese akti- viert wird. Im allgemeinen erhaelt eine Task den Schutz- und Standard-UIC des Bediengeraetes, wenn sie durch den MCR-Dispatcher oder das MCR- oder DCL-Kommando RUN aktiviert wird. Gibt der Nutzer jedoch in den MCR- oder DCL-Kommandos RUN bzw. INSTALL einen UIC an, wird dieser der Standard-UIC fuer die zu aktivierende Task, und falls das Bediengeraet, von dem aus die Kommandos RUN bzw. INSTALL gegeben wurden, privilegiert ist, wird der angege bene UIC ebenfalls Schutz-UIC der zu aktivierenden Task. 170 - Wird eine Task durch eine Aktivierungsanforderung von einer anderen Task aus aktiviert, legt die Exekutive die UIC auf die gleiche Art fest. Schutz- und Standard-UIC der anfordernden Task werden Schutz- und Standard-UIC der zu aktivierenden Task. Gibt eine nichtprivilegierte Task in einer RQST$-Anweisung einen UIC an, wird dieser lediglich Standard-UIC der angefor- derten Task; die UIC-Angabe in einer RQST$-Anweisung in einer privilegierten Task findet ihren Niederschlag sowohl als Schutz- als auch als Standard-UIC der angeforderten Task. 171 ---------------------------------------------------------------- | RECEIVE BY REFERENCE | RREF$ | | - --- | | ---------------------------------------------------------------- 2.3.2.45. RREF$ - Empfangen eines Referenzblockes ------------------------------------------------- FORTRAN-Aufruf: --------------- CALL RREF (iwdb,[isrb][,ids]) iwdb = 8-Worte-Integerfeld fuer Fenster-Defini- tionsblock isrb = 10-Worte-Integerfeld als Empfangspuffer. Wird dieser Parameter weggelassen, bleibt der Inhalt von iwdb(8) unveraendert ids = Anweisungsstatus Makro-Aufruf: ------------- RREF$ adr adr = Adresse des Fenster-Definitionsblocks der Empfaengertask Makro-Erweiterung: ------------------ RREF$ ADWDB .BYTE 81.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird eine Kommunikation zwischen zwei Tasks ermoeglicht. An die Task, welche die Anweisung enthaelt (Empfaen- gertask), wird eine Region, die zum logischen Adressraum einer anderen Task (Sendertask) gehoert, gebunden. Die Uebernahme der Informationen uber die Region kann nur erfolgen, wenn in der Sendertask vorher eine SREF$-Anweisung abgearbeitet wurde. Die dabei bereitgestellten Informationen befinden sich in einem Referenzblock, der von der Exekutive im dynamischen Speicher auf- gebaut wurde. Aus dem Referenzblock werden u.a. W.NRID, W.NOFF, W.NLEN und W.NSTS uebernommen. Falls im WDB der Empfaengertask W.NSRB vom Nutzer spezifiziert war, koennen weitere 10. Worte mit Zusatzinformationen von der Sendertask erhalten werden (Sendertaskname und 8 Informationsworte). Wenn die Sendertask keine Zusatzinformationen spezifiziert hat, werden der Sender- taskname und 8 Worte 0 uebergeben. Falls in der Empfangswarteschlange der Empfaengertask kein Refe- renzblock angemeldet ist und WS.RCX gesetzt ist, wird die Task beendet. Im Falle WS.RCX = 0 erfolgt eine Fehlermeldung. Von der Exekutive im WDB benoetigte Parameter: symb. Offset W.NID - Fenster-Identifikation fuer ein existierendes Fen- ster in der Empfaengertask, wenn ein Fenster der Region zugewiesen werden soll (siehe WS.MAP) 172 W.NSTS - folgende Bits des Fenster-Statusworts der Empfaen- gertask koennen modifiziert werden: WS.MAP = 1, wenn mit dem Empfang des Referenz- blockes sofort die Adresszuweisung zur Region erfolgen soll; WS.RCX = 1, wenn kein Paket in der Empfangswarte- schlange vorhanden ist, wird die Task beendet. Ist dieses Bit 0, wird bei fehlendem Paket der Rueckkehrcode IE.ITS erzeugt. W.NSRB - Adresse des Datenpuffers (10.Worte), um den Taskna- men des Senders und 8 Worte Zusatzinformationen aufzunehmen, die durch SREF$ mitgeschickt werden koennen. Fehlt der Parameter, werden keine Zusatz- informationen uebermittelt. Von der Exekutive im WDB der Empfaengertask abgelegte Parameter: symb. Offset W.NRID - Region-Identifikation der Region der Sendertask W.NOFF - Offset innerhalb der Region W.NLEN - Laenge der Adresszuweisung W.NSTS - folgende Bits des Fenster-Statuswortes werden modi- fiziert: WS.RED = 1, wenn Lesen erlaubt ist WS.WRT = 1, wenn Schreiben erlaubt ist WS.EXT = 1, wenn Erweitern erlaubt ist WS.DEL = 1, wenn Loeschen erlaubt ist WS.RRF = 1, wenn der Empfang erfolgreich war Alle uebrigen Bits werden geloescht. Lokale Symboldefinition: ------------------------ R.REBA - Adresse des WDB der Empfaengertask Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08 IE.ITS es ist kein Paket in der Empfangswarte- schlange vorhanden (siehe WS.RCX im Fenster- Statuswort) -98 IE.ADP ein Teil des DPB, WDB bzw. Datenpuffers liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig 173 Anmerkungen: ------------ - Im Fenster-Statuswort kann vereinbart werden, dass die Region sofort einem Fenster zugewiesen wird (WS.MAP). - Wenn die Anweisung erfolgreich ausgefuehrt wurde, deklariert die Exekutive ein signifikantes Ereignis. - Wenn eine Task beendet oder gestrichen wird, waehrend noch Referenzbloecke in ihrer Warteschlange enthalten sind, werden diese aus der Warteschlange entfernt. Irgendwelche mit dem Senden der Referenzbloecke verbundenen Ereignisflags werden nicht gesetzt. 174 ---------------------------------------------------------------- | RESUME | RSUM$ | | - --- | | ---------------------------------------------------------------- 2.3.2.46. RSUM$ - Fortsetzen einer Task --------------------------------------- FORTRAN-Aufruf: --------------- CALL RESUME (tsk[,ids]) tsk = Taskname ids = Anweisungsstatus Makro-Aufruf: ------------- RSUM$ tsk tsk = Taskname Makro-Erweiterung: ------------------ RSUM$ ROBO .BYTE 47.,3 ;DIC der Anweisung und Laenge des DPB .RAD50 /ROBO/ ;Taskname Funktionsbeschreibung: ---------------------- Die Anweisung RSUM$ bewirkt, dass die Exekutive die Bearbeitung der angegebenen Task fortsetzt, nachdem sie vorher durch SPND$- Anweisung von der Bearbeitung ausgeschlossen worden war. Lokale Symboldefinition: ------------------------ R.SUTN - Taskname Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -02 IE.INS die Task ist nicht installiert -07 IE.ACT die Task ist nicht aktiv -08. IE.ITS die Task ist nicht suspendiert -16. IE.PRI die Task ist nicht privilegiert -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 175 ---------------------------------------------------------------- | RUN | RUN$ | | | | ---------------------------------------------------------------- 2.3.2.47. RUN$ - Zeitbezogenes Aktivieren einer Task ---------------------------------------------------- FORTRAN-Aufruf: --------------- CALL RUN (tsk,[opt],[smg],snt,[rmg],[rnt][,ids]) tsk = Taskname opt = 4-Worte-Integerfeld opt (1) = 1. Haelfte des Partitionnamens; wird ignoriert, muss aber aus Kom- patibilitaetsgruenden zu SKR-Syste- men im DPB vorhanden sein opt (2) = 2. Haelfte des Partitionnamens; wird ignoriert, muss aber aus Kom- patibilitaetsgruenden zu SKR-Syste- men im DPB vorhanden sein opt (3) = wird ignoriert; muss aber aus Kom- patibilitaetsgruenden zu SKR-Syste- men im DPB vorhanden sein opt (4) = Nutzeridentifikationscode smg = Verzoegerungszeitgroesse snt = Verzoegerungszeiteinheit rmg = Zykluszeitgroesse rnt = Zykluszeiteinheit ids = Anweisungsstatus Als Standardruf steht ausserdem zur Verfuegung: CALL START (tsk, smg, snt, ids) tsk = Taskname smg = Verzoegerungszeitgroesse snt = Verzoegerungszeiteinheit ids = Anweisungsstatus Makro-Aufrufe: -------------- RUN$ tsk,[prt],[pri],[ugc],[umc],[smg],snt[,rmg,rnt] tsk = Taskname prt = Partitionname; wird ignoriert, muss aber aus Kom- patibilitaetsgruenden zu SKR-Systemen im DPB vor- handen sein pri = Prioritaet; wird ignoriert, muss aber aus Kompati- bilitaetsgruenden zu SKR-Systemen im DPB vorhanden sein ugc = UIC-Gruppencode umc = UIC-Mitgliedscode smg = Verzoegerungszeitgroesse snt = Verzoegerungszeiteinheit rmg = Zykluszeitgroesse rnt = Zykluszeiteinheit 176 Makro-Erweiterung: ------------------ RUN$ FAKT,,,200,10,15.,2,20.,2 .BYTE 17.,11. ;DIC der Anweisung und Laenge des DPB .RAD50 /FAKT/ ;Taskname .WORD 0,0 ;reservierte Plaetze statt des Parti- ;tionnamens .WORD 0 ;reservierter Platz statt der Prioritaet .BYTE 10,200 ;UIC, unter dem die Task laufen soll (Mitglieds-/Gruppencode) .WORD 15. ;Verzoegerungszeitgroesse .WORD 2 ;Verzoegerungszeiteinheit .WORD 20. ;Zykluszeitgroesse .WORD 2 ;Zykluszeiteinheit Funktionsbeschreibung: ---------------------- Die Anweisung RUN$ ist das Mittel, mit Hilfe dessen Tasks zeitverzoegert, zeitzyklisch und zeitverzoegert und zeitzyklisch aktiviert werden. Die angegebenen Zeitintervalle zaehlen vom Zeitpunkt des Abarbei- tens der Anweisung an. Werden die Zeitparameter smg, rmg und rnt weggelassen, erfolgt die Aktivierung der angegebenen Task einen Uhrtakt nach dem Auf- treten der Anweisung. Ausserdem wird fuer die angeforderte Task das Pseudogeraet TI: immer auf das Pseudogeraet CO: umadressiert. Lokale Symboldefinitionen: -------------------------- R.UNTN - Taskname R.UNPN - Partitionname R.UNPR - Prioritaet R.UNPC - UIC-Mitgliedscode R.UNGC - UIC-Gruppencode R.UNSM - Verzoegerungszeitgroesse R.UNSU - Verzoegerungszeiteinheit R.UNRM - Zykluszeitgroesse R.UNRU - Zykluszeiteinheit Rueckkehrcodes fuer CALL RUN und RUN$: -------------------------------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN unzureichender dynamischer Speicherbereich -02 IE.INS Task ist nicht installiert -07 IE.ACT Name einer Mehrnutzertask ist angegeben -16. IE.PRI nicht privilegierte Task spezifiziert einen UIC-Parameter, der vom eigenen Task-Schutz- UIC abweicht. -93. IE.ITI ungueltige Zeitparameter -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 177 Rueckkehrcodes fuer CALL START ------------------------------- 2 unzureichender dynamischer Speicherbereich 3 spezifizierte Task ist nicht installiert 94 ungueltiger Zeitparameter 99 ein Teil des DPB liegt ausserhalb der Taskkette 100 die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die zu aktivierende Task muss installiert sein. - Die Prioritaet, mit der die Task bearbeitet wird, ist die, die im Tasksteuerblock (TCB) angegeben wurde. - Werden in der Parameterkette der RUN$-Anweisung die UIC-Parame- ter weggelassen, dann wird der Nutzeridentifikationscode aus dem Kopf der angeforderten Task benutzt. (Fuer weitere Infor- mationen ueber den UIC siehe Anmerkungen zu 2.3.2.44. RQST$). - Ist die die Partition belegende Task auslagerbar und ist das Auslagern erlaubt und ausserdem ihre Prioritaet niedriger als die der auf die Partition wartenden Task oder ist die aktuelle Task fuer ausstehende gepufferte E/A-Anforderungen gestoppt, wird sie ausgelagert, wenn andere ausstehende Datenuebertra- gungen beendet sind. Die angeforderte Task wird dann in die Partition eingelesen. - Wenn die Partition, in der die Task laufen soll, belegt ist, wird die Task in eine Warteschlange fuer Tasks eingetragen, die in dieser Partition bearbeitet werden sollen und wird, abhaen- gig von den Prioritaetsbedingungen und der Ressourcenverfueg- barkeit, abgearbeitet, wenn die Partition frei wird. - Erfolgreiche Ausfuehrung der Anweisung bedeutet nicht, dass die Task bereits bearbeitet wird, sondern lediglich, dass sie akti- viert wurde. - Die Zeitparameter bestehen aus Parametergroesse und Parameter- einheit. Die Parametereinheiten der Zeitparameter sind wie folgt co- diert: 1 = Takt 2 = Sekunde 3 = Minute 4 = Stunde Fuer den FORTRAN-Aufruf CALL START: 0 = Takt 1 = Millisekunde 2 ... 4 = wie oben 178 Unter Takten ist die Anzahl der Uhrunterbrechungen je Sekunde zu verstehen. Die Zeitgroesse gibt also bei der Zeiteinheit Takt an, nach wieviel Uhrtakten eine Task zu aktivieren bzw. zeitzyklisch zu aktivieren ist. Die Anzahl der Takte pro Sekunde ist abhaengig von der verwen- deten Uhr und betraegt bei netzfrequenzgesteuerter Uhr 50 Tak- te/s. Bei einer programmierbaren Uhr wird die Taktfrequenz bei der Generierung festgelegt. In Abhaengigkeit von der gewaehlten Zeiteinheit bestehen fuer die Groessenangaben folgende Einschraenkungen: snt, rnt | smg, rmt | --------------------------------- 0,1 und 2 | <= 32 767. | 3 | <= 1 440. | 4 | <= 24. - Die Verzoegerungszeit ist der zeitliche Abstand zwischen Auf- treten der Anweisung und Aktivieren der angegebenen Task. Die kleinstmoegliche Verzoegerungszeit ist ein Uhrtakt, die groesstmoegliche sind 24 Stunden. - Die Zykluszeit ist der zeitliche Abstand zwischen zwei Aktivie- rungen einer Task. Wenn nach Ablauf der Zykluszeit die Task noch aktiv ist, wird sie nicht neu aktiviert. Es beginnt ein neues Zeitintervall. - Die Bearbeitung einer zeitzyklisch aktivierten Task wird wie- derholt bis zum Annullieren der zeitzyklischen Bearbeitung mittels Anweisung oder Kommando. - Wenn ein Zeitzyklus nicht vorgesehen ist, sollten die rmg- und rnt-Parameter nicht angegeben werden. - Die RUN$-Anweisung benoetigt dynamischen Speicherbereich fuer die Uhrwarteschlange, die benutzt wird, um die Task nach einer angegebenen Verzoegerungszeit zu aktivieren. Soll die Task in einer systemgesteuerten Partition laufen, wird zusaetzlicher dynamischer Speicherbereich fuer den dynamisch zugewiesenen Partitionsteuerblock (PCB) benoetigt. - Eine nicht-privilegierte Task kann nur einen UIC angeben, der dem eigenen Schutz-UIC entspricht. Eine privilegierte Task kann jeden beliebigen UIC spezifizieren.  179 ---------------------------------------------------------------- | SEND DATA | SDAT$ | | - --- | | ---------------------------------------------------------------- 2.3.2.48. SDAT$ - Senden eines Datenblocks -------------------------------------------- FORTRAN-Aufruf: --------------- CALL SEND (tsk,buf,[efn][,ids]) tsk = Name der Task, fuer die die Daten bestimmt sind. buf = 13-Worte-Integerfeld, enthaelt die zu sen- denden Daten efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- SDAT$ tsk,buf[,efn] tsk = Name der Task, fuer die die Daten bestimmt sind buf = Adresse des 13-Worte-Datenpuffers efn = Ereignisflagnummer Makro-Erweiterung: ------------------ SDAT$ ALPHA,DATBUF,52. .BYTE 71.,5 ;DIC der Anweisung und Laenge des DPB .RAD50 /ALPHA/ ;Name der empfangenden Task .WORD DATBUF ;Adresse des 13-Worte-Puffers .WORD 52. ;Ereignisflagnummer Funktionsbeschreibung: ---------------------- Mit der SDAT$-Anweisung wird ein 13-Worte-Datenblock fuer eine bestimmte Task in eine Warteschlange eingereiht und ein signifi- kantes Ereignis deklariert. Lokale Symboldefinitionen: -------------------------- S.DATN - Taskname S.DABA - Pufferadresse S.DAEF - Ereignisflagnummer Rueckkehrccdes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN kein ausreichender Platz im dynamischen Bereich der Exekutive -02 IE.INS Empfaengertask ist nicht installiert -97. IE.IEF ungueltige Ereignisflagnummer -98. IE.ADP ein Teil des DPB oder des Datenblockes liegt ausserhalb des Bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 180 Anmerkungen: ------------ - SDAT$ erfordert Speicherbereich im dynamischen Bereich der Exekutive. - Das Ereignisflag wird gesetzt, wenn die Anweisung fehlerfrei abgearbeitet wurde. - Wenn die Anweisung das Setzen eines lokalen Ereignisflags bein- haltet, so gilt das nur fuer die sendende Task. Es ist nicht moeglich, von einer Task aus ein lokales Ereignisflag fuer eine andere Task zu veraendern. - Wenn das Ereignisflag benutzt werden soll, die Arbeit zwischen der Sendertask (d.i. die Task, die die Anweisung enthaelt) und der Empfaengertask (d.i. die, die in der Anweisung benannt ist) zu koordinieren, muss das Ereignisflag ein COMMON-Flag (33 bis 64) oder ein gruppenglobales Flag (65 bis 96) sein.  181 ---------------------------------------------------------------- | SEND, REQUEST and CONNECT | SDRC$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.49. SDRC$ - Senden eines Datenblockes, Aktivieren einer Task und Aufbau einer Mutter/Tochter-Verbindung ------------------------------------------------------------- Fortran-Aufruf: --------------- CALL SDRC (rtname,ibuf,[iefn],[iast],[iesb],[iparm][,ids]) rtname = Name der Tochtertask ibuf = Name eines 13-Worte-Puffers, der den zu sendenden Datenblock ent- haelt iefn = Ereignisflagnummer iast = Name einer AST-Routine iesb = Name eines Statusblockes vor 1-Wort Laenge iparm = Name eines Wortes, in das bei Auf- treten eines AST die Statusblock- adresse eingetragen wird. ids = Anweisungsstatus Makro-Aufruf: ------------- SDRC$ tname,buf,[efn],[east],[esb] tname = Name der Tochtertask buf = Adresse eines 13 Worte Sendepuffers efn = Nummer eines Ereignisflags, das bei Aussenden dieser Anweisung ge- loescht wird und bei Beendigung der Tochtertask oder bei Uebermittlung eines Status durch sie gesetzt wird east = Adresse einer AST-Routine, die auf- gerufen wird, wenn die Tochtertask beendet wird oder einen Status uebermittelt esb = Adresse eines Statusblockes von 1-Wort Laenge Makro-Erweiterung: ------------------ SDRC$ ALPHA,BUFFER,2,SDRCTR,STBLK .BYTE 141.,7 ;DIC der Anweisung und Laenge des DPB .RAD50 /ALPHA/ ;Name der Tochtertask .WORD BUFFER ;Pufferadresse des Sendepuffers .WORD 2 ;Ereignisflagnummer = 2 .WORD SDRCTR ;Adresse der AST Routine .WORD STBLK ;Adresse des Statusblocks 182 Funktionsbeschreibung: ---------------------- Die SDRC$-Anweisung veranlasst das Senden eines Datenblocks an die vereinbarte Empfaengertask (Tochtertask), das Aktivieren dieser Task, wenn sie nicht bereits aktiv ist und das Anbinden der an die die SDRC$-Anweisung enthaltende Sendertask (Muttertask). Die Empfaengertask gibt normalerweise einen Status an die Sendertask unter Verwendung einer EMST$- oder EXST$-Anwei- sung. Die Sendertask kann diesen Statuswert in ihrem Exitstatusblock erhalten. Lokale Symboldefinitionen: -------------------------- S.DRTN - Taskname S.DRBF - Pufferadresse S.DREF - Ereignisflag S.DREA - Adresse der AST Routine S.DRES - Adresse des Statusblocks Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN fehlender Platz im dynamischen Bereich der Exekutive fuer das Datenblock-Paket oder Steuerbloecke -02 IE.INS die angegebene Task ist ein ACP oder hat das no-send'Attribut -97 IE.IEF eine ungueltige Ereignisflagnummer wurde angegeben (EFN<0 oder EFN>96 wenn gruppen- globale Ereignisflags fuer die Task existie- ren, ansonsten EFN>64 -98. IE.ADP ein Teil des DPB oder des Exit-Statusblockes liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig Anmerkungen: ------------ - Wenn das angegebene Ereignisflag ein gruppenglobales EF ist, wird der Benutzungszaehler fuer die Ereignisflaggruppe um 1 er- hoeht, um eine vorzeitige Eliminierung der Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert, wenn: . ein Status von der angebundenen Task bereitgestellt wird oder . die aussendende Task beendet wird bevor ein Status bereitge- stellt wird.  183 - Die virtuelle Adresszuweisung des Statusblocks sollte nicht veraendert werden solange die Verbindung zwischen Mutter- und Tochtertask vorhanden ist. Dies wuerde zu schwer erklaerbaren Fehlern fuehren. - Wird die Anweisung zurueckgewiesen, ist der Zustand des vereinbarten Ereignisflags unbestimmt. - Wird die Anweisung angenommen, wird ein vereinbartes Ereignis- flag geloescht und erst wieder gesetzt, wenn die Tochtertask einen Statuswert zurueckgibt. (Dies geschieht auch implizit durch Anwendung einer Exit-Anweisung ohne Statusuebergabe). - Die vereinbarte AST-Routine wird unter den gleichen Bedingungen aufgerufen, unter denen das Ereignisflag gesetzt wird. 184 ---------------------------------------------------------------- | SEND DATA, REQUEST and PASS OFFSPRING CONTROL BLOCK | SDRP$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.50. SDRP$ - Senden eines Datenblockes, Aktivieren einer Task und Weitergeben von Mutter/Tochter-Verbindungen -------------------------------------------------------------- Fortran-Aufruf: --------------- CALL SDRP (task,ibuf,ibfl[iefn],[iflag],[iparm],[,,ids]) task = Name der Tochtertask ibuf = Adresse eines 13-Worte-Puffers, der den zu sendenden Datenblock enthaelt ibfl = Laenge zu sendenden Datenblockes, muss immer 13. sein iefn = Ereignisflagnummer iflag = Flagbyte, das die Aktionen bei Ausfueh- rung dieses Rufes steuert. Die Bitdefinitionen dieses Bytes (nur das wiederwertige Byte des Wortes vom Typ Integer, das im Ruf angegeben wurde, wird benutzt) sind folgende: SD.REX = 128. Veranlasst die Beendigung dieser Task bei erfolg- reicher Ausfuehrung dieser Anweisung. SD.RAL = 1 Uebergabe aller Mutter/ Tochter-Verbindungen die- ser Task an die angefor- derte Task (Standard: keine Ueber- gabe). Ist dieses Bit an- gegeben, darf der Name der Muttertask nicht angegeben werden. SD.RNX = 2 Uebertragung der ersten Verbindung, falls eine vorhanden ist, an die angeforderte Task. Ist Bit angegeben, darf der Name der Muttertask nicht angegeben werden. iparm = Name eines Feldes, das den RAD50-Namen der Muttertask der aussendenden Task enthaelt, deren Verbindung an die an- geforderte Task uebergeben werden soll. ids = Anweisungsstatus  185 Makro-Aufruf: ------------- SDRP$ task,bufa,bufl,[efn],[flag],[par] task = Name der Tochtertask bufa = Adresse eines 13-Worte-Puffers, der den an die Tochtertask zu sendenden Datenblock enthaelt bufl = Laenge des zu sendenden Datenblockes, muss immer 13. sein efn = Ereignisflag flag = Flagbyte, das die Ausfuehrung dieser Anweisung steuert. Die Flagbits sind folgendermassen definiert: SD.REX = 128. Veranlasst die Beendi- gung dieser Task bei er- folgreicher Ausfuehrung dieser Anweisung SD.RAL = 1 Uebergabe aller Mutter/ Tochter-Verbindungen die- ser Task an die angefor- derte Task (Standard: keine Uebergabe). Ist dieses Bit angegeben,darf der Name der Muttertask nicht angegeben werden. SD.RNX = 2 Uebertragung der ersten Verbindung, falls eine vorhanden ist, an die an- geforderte Task. Ist die- ses Bit angegeben, darf der Name der Muttertask nicht angegeben werden. par = Name der Muttertask der aussendenden Task, deren Verbindung uebergeben werden soll. Wenn nicht angegeben, werden alle Verbindungen oder keine uebergeben in Abhaengigkeit vom Flagbyte Makro-Erweiterung: ------------------ SDRP$ TESTT,SPUF,13.,10,SD.REX,MUTTER .BYTE 141.,9. ;DIC der Anweisung und Laenge des DPB .RAD50 /TESTT/ ;Task-Name in RAD50 .WORD SPUF ;Adresse des zu sendenden Datenblockes .BYTE 10,SD.REX ;Ereignisflag und Flag-Bits .WORD .RAD50 /MUTTER/ ;Name der Mutter-Task .WORD 186 Funktionsbeschreibung: ---------------------- Diese Anweisung veranlasst die Exekutive, ein Datenpaket zur Uebergabe eines 13. Worte langes Datenblockes an die angeforderte Task zu senden. Gleichzeitig koennen Mutter/Tochter- Verbindungen, der diese Anweisung gebenden Task auf die angefor- derte Task weitergegeben werden: die angeforderte Task wird an die spezifizierte Muttertask gebunden. Falls die angeforderte Task noch nicht aktiv ist, wird sie durch Ausfuehrung dieser Anweisung aktiviert. Lokale Symboldefinitionen: -------------------------- S.DRTK - RAD50-Name der Tochtertask, die angefordert ist S.DRAD - Adresse des Sendepuffers S.DREF - Ereignisflag S.DRFL - Flagbyte: SD.REX - (200) (=128.) veranlasst die Taskbeendigung bei erfolgreicher Ausfuehrung der Anweisung SD.RAL - (1) Uebergabe aller Verbindungen an die ange- forderte Task (Standard: keine Uebergabe). Ist dieses Bit angegeben, darf der Name der Mutter- task nicht angegeben werden. SD.RNX - (2) Uebergabe der ersten Verbindung, falls eine vorhanden ist, an die angeforderte Task. Ist dieses Bit angegeben, darf der Name der Mutter- task nicht angegeben werden. S.DRBL - Laenge des Senderdatenpakets (immer 13.Worte) S.DRPT - Name der Muttertask, deren Verbindungen uebergeben werden sollen. Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -86. IE.NVR zur angegebenen Muttertask gibt es keine Tochter-Verbindungen -84. IE.ALG Angabe des Muttertaskparameters steht im Widerspruch zu den Flagbits SD. RAL oder SD.RNX -89. IE.IBS Laenge des zu uebergebenden Datenblockes ist nicht 13. -01 IE.UPN fehlender Platz im dynamischen Bereich der Exekutive fuer das zu uebersendende Daten- paket oder fuer Steuerbloecke. -02 IE.INS die angegebene Task ist eine ACP-Task oder hat das Attribut: 'NO-SEND' -97. IE.IEF es wuerde eine ungueltige Ereignisflagnummer angegeben (EFN<0 oder EFN>96 falls gruppen- globale Ereignisflags existieren. Ansonsten EFN>64). -98. IE.ADP ein Teil des DPB oder des Sendepuffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  187 Anmerkungen: ------------ - Wenn die Anweisung zurueckgewiesen wird (Rueckkehrcode ungleich IS.SUC), ist die Belegung des Ereignisflags unbestimmt. - Ist das angegebene Ereignisflag ein gruppenglobales Ereignis- flag, wird bei Annahme der Anweisung der Benutzungszaehler fuer die Ereignisflaggruppe um 1 erhoeht, um die vorzeitige Eleminierung des Ereignisflags zu verhindern. Der Benutzungs- zaehler wird wieder erniedrigt, wenn: . ein Status von den angebundenen Tasks zur Verfuegung gestellt wird, . die die Anweisung ausgebende Task beendet wird, bevor ein Status zur Verfuegung gestellt wird. - Das Ereignisflag wird gesetzt, wenn die Anweisung erfolgreich ausgefuehrt wurde. Das Ereignisflag steht also in keiner Beziehung zur Arbeit der angeforderten Task. Das hat seinen Grund darin, dass die Anweisung ausgebende Task durch die Aus- fuehrung der Anweisung keinerlei Verbindungen mehr zu der angeforderten Task hat. 188 ---------------------------------------------------------------- | SET EVENT FLAG | SETF$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.51. SETF$ - Setzen eines Ereignisflags -------------------------------------------- FORTRAN-Aufruf: --------------- CALL SETEF (efn[,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- SETF$ efn efn = Ereignisflagnummer Makro-Erweiterung: ------------------ SETF$ 20. .BYTE 33.,2 ;DIC der Anweisung und Laenge des DPB .WORD 20. ;Ereignisflagnummer Funktionsbeschreibung: ---------------------- Die Anweisung SETF$ setzt das angegebene Ereignisflag und zeigt im Rueckkehrcode die Wertigkeit (Polaritaet) des Flags vor dem Setzen an. Als Ereignisflagnummer kann angegeben werden: 1 bis 32 fuer lokale Ereignisflags, 33 bis 64 fuer Common-Ereignisflags. 65 bis 96 fuer gruppenglobale Ereignisflags, wenn diese fuer die Task existieren. Zu beachten ist aber, dass die Ereignisflags 25 bis 32 und 57 bis 64 auch vom System genutzt werden. Lokale Symboldefinition: ------------------------ S.ETEF - Ereignisflagnummer Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +00 IS.CLR die Anweisung wurde erfolgreich ausgefuehrt; das Ereignisflag war vorher geloescht +02 IS.SET die Anweisung wurde erfolgreich ausgefuehrt; das Ereignisflag war vorher gesetzt -97. IE.IEF unzulaessige Ereignisflagnummer -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig.  189 Anmerkung: ---------- Diese Anweisung deklariert kein signifikantes Ereignis. Sie setzt nur das angegebene Ereignisflag. 190 ---------------------------------------------------------------- | SPECIFY FLOATING POINT PROCESSOR EXCEPTION AST | SFPA$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.52. SFPA$ - Spezifizieren von Arithmetikprozessorfehler-AST ----------------------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- SFPA$ [ast] ast = Adresse des Eintrittspunktes des AST-Bedienungs- programms Makro-Erweiterung: ------------------ SFPA$ ARFAST .BYTE 111.,2 ;DIC der Anweisung und Laenge des DPB .WORD ARFAST ;Eintrittsadresse in das AST-Bedienungspro- gramm Funktionsbeschreibung: ---------------------- Die Anweisung SFPA$ informiert das System darueber: 1. dass Arithmetikprozessorfehler-AST fuer die Task gewuenscht sind und die Exekutive zu der angegebenen Adresse verzweigen soll, wenn ein derartiger AST fuer diese Task auftritt, oder 2. dass keine weiteren Arithmetikprozessorfehler bearbeitet wer- den sollen. Wenn ein AST-Bedienungsprogrammeintrittspunkt spezifiziert ist, wird bei einem Fehler, den der Arithmetikprozessor erkennt, ein AST erzeugt und zur angegebenen Adresse verzweigt. Ist kein AST-Bedienungsprogrammeintrittspunkt angegeben, werden diese ASTs unterdrueckt, bis eine Anweisung SFPA$ mit einem Ein- trittspunkt abgearbeitet wird. Lokale Symboldefinition: ------------------------ S.FPAE - Eintrittspunktadresse  191 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01. IE.UPN fehlender im dynamischen Bereich der Exekutive -08. IE.ITS dieser AST ist schon verhindert oder die Task wurde gebildet ohne Gleitkomma-Unterstuetzung (/FP-Schalter beim TKB-Lauf nicht angegeben) -80. IE.AST die Anweisung wurde aus einem AST-Bedienungs- programm gesendet, oder alle ASTs sind verhin- dert -98. IE.ADP der DPB liegt ausserhalb des Adressbereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - DIE SFPA$-Anweisung benoetigt Speicherbereich im dynamischen Bereich der Exekutive. - Tritt ein Arithmetikprozessorfehler-AST auf, wird er von der Exekutive registriert. Der naechste wird erst wieder vorgemerkt, wenn der erste Arithmetikprozessorfehler-AST bearbeitet ist. - Beim Ansprung des AST-Bedienungsprogramms enthaelt der Stack der Task folgende Informationen: SP + 12 - Ereignisflagmaskenwort SP + 10 - PS der Task vor dem AST SP + 06 - PC der Task vor dem AST SP + 04 - DSW der Task vor dem AST SP + 02 - Arithmetikfehlercode SP + 00 - Adresse des Befehls. Wird das Bedienungsprogramm mit der Anweisung ASTX$S beendet, muessen die beiden obersten Werte aus dem Stack entfernt sein. - Diese Anweisung darf nicht aus einem AST-Bedienungsprogramm, oder wenn AST verhindert sind, gesendet werden. - Diese Anweisung darf nur benutzt werden, wenn ein Arithmetik- prozessor ARP30 vorhanden ist. - Wenn in der Rechnerkonfiguration der Arithmetikprozessor nicht enthalten ist, koennen alle seine Funktionen (und auch diese AST-Realisierungen) durch den Gleitkommaemulator des OMOS 1630 nachgebildet werden. 192 ---------------------------------------------------------------- | SEND MESSAGE | SMSG$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.53. SMSG$ - Senden einer Meldung -------------------------------------- Fortran-Aufruf: --------------- CALL SMSG (itgt,ibuf,ibufl,iprm,iprml,ids) itgt = Der Name eines Wortes vom Typ Integer, das SM.SER (Zielidentifikator) enthaelt. ibuf = Der Name eines Integerfeldes, das die Daten enthaelt, die in das formierte Datenpaket eingefuegt werden sollen. ibufl = Der Name eines Wortes vom Typ Integer, das die Laenge des ibuf Feldes enthaelt. iprm = Der Name eines Integerfeldes, das alle zusaetzlichen Parameter enthaelt. iprml = Der Name eines Wortes vom Typ Integer, das die Anzahl der Parameter im iprm Feld enthaelt. ids = Anweisungsstatus Makro-Aufruf: ------------- SMSG$ tgt,buf,len, tgt = Zielidentifikator (SM.SER) buf = Adresse eines wahlfreien Daten- puffers len = Laenge des wahlfreien Daten- puffers in Bytes pri,...,pru = Zielspezifische Parameterliste: Parameterliste fuer Error Logging SMSG$ SM.SER,buf,len, typ = Error-Log Paket Typcode sub = Error-Log Paket Subtypcode lun = LUN des Geraetes msk = Steuermaskenwort Makro-Erweiterung: ------------------ SMSG$ SM.ERR,DATBUF,DATLEN, .BYTE DIC,8. ;DIC, DPB Groesse = 8 Worte .WORD SM.ERR ;Ziel Identifikator - Error Logging .WORD DATBUF ;Adresse des Datenpuffers .WORD DATLEN ;Laenge des Datenpuffers .WORD PR1 ;Parameter 1 .WORD PR2 ;Parameter 2 .WORD PR3 ;Parameter 3 .WORD PR4 ;Parameter 4  193 Funktionsbeschreibung: ---------------------- Die SMSG$-Anweisung veranlasst die Exekutive ein Datenpaket eines bestimmten Formates an eine systemdefinierte Zieltask zu senden. Das einzige gueltige Ziel fuer die diese Anweisung ist der Error Logger und das fuer die Fehlerprotokollierung aufbereitete Datenpaket ist ein Error-Log Paket. Die Task, die die SMSG$- Anweisung aussendet, muss privilegiert sein. Das gueltige systemdefinierte Ziel und der Identifikator sind: Ziel-Identifikator | Code ----------------------------- Error Logging | SM.SER Die Anweisung erzeugt ein Error-Log Paket des angegebenen Typs und Subtyps. Wenn man eine LUN angibt, so zeichnet die Anweisung auch Informationen ueber das Geraet auf, auf das die LUN Bezug nimmt. Das Steuermaskenwort setzt Flags, um E/A- und Fehlerzaehler fuer das angegebene Geraet auf Null zu setzen, wie folgt: SM.ZER - E/A- und Fehlerzaehler fuer das durch LUN ver- einbarte Geraet werden Null Die Anweisung erzeugt folgende Subpakete und traegt sie in das Error-Log Paket in der Folge, wie aufgelistet, ein: 1. Kopf Subpaket - Das Kopfsubpaket, das den Typ und den Subtyp, das Zeitraster und die Systemidentifikation enthaelt, wird immer aufgezeichnet. 2. Task Subpaket - Das Tasksubpaket, das die Task identifiziert, die die Anweisung ausgesendet hat, wird immer aufgezeichnet. 3. Geraete Subpaket - Das Geraetesubpaket, das das Geraet identi- fiziert, wird aufgezeichnet, wenn die Anweisung ein LUN-Argu- ment angibt. 4. Daten Subpaket - Das Datensubpaket wird aufgezeichnet wenn die Anweisung die Adresse und Laenge eines wahlfreien Datenpuffers angibt. Diese Daten werden uebernommen. Lokale Symboldefinitionen: -------------------------- S.MTGT - Zielidentifikator S.MDBA - Pufferadresse S.MDBL - Pufferlaenge S.MPRL - Parameterliste S.MERR - Error-Log Zielidentifikator 194 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code --------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -96. IE.ILU ungueltige LUN -05 IE.ULN nicht zugewiesene LUN -01 IE.UPN fehlender Platz im dynamischen Bereich der Exekutive -02 IE.INS Zieltask ist nicht installiert -08. IE.ITS ungueltiger Zielidentifikator oder ungueltige Steuermaske -98. IE.ADP ein Teil des DPB oder des Datenpuffers liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  195 ---------------------------------------------------------------- | SUSPEND | SPND$S | | - - -- | | ---------------------------------------------------------------- 2.3.2.54. SPND$S - Suspendieren einer Task ------------------------------------------ Fortran-Aufruf: --------------- CALL SUSPND [(ids)] ids = Anweisungsstatus Makro-Aufruf: ------------- SPND$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ SPND$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack speichern .BYTE 45.,1 ;DIC der Anweisung und DPB-Laenge EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die SPND$-Anweisung informiert die Exekutive, dass die sie ent- haltende Task von der Bearbeitung auszuschliessen ist. Eine Task kann nur sich selbst, aber keine andere Task von der Bearbeitung ausschliessen. Die Fortsetzung ist moeglich durch die Anweisung RSUM$ oder durch das MCR- oder DCL-Kommando RESUME. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt (Task war suspendiert) -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Eine von der Bearbeitung ausgeschlossene Task behaelt die Steuerung ueber die Systemkomponenten, die ihr zugeteilt worden sind; erst die Beendigung der Task bewirkt deren Freigabe. - Eine suspendierte Task kann ausgelagert werden, wenn das Aus- lagern erlaubt ist und die Task nicht im Speicher fixiert ist. 196 ---------------------------------------------------------------- | SPECIFY POWER RECOVERY AST | SPRA$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.55. SPRA$- Spezifizieren von Netzwiederkehr-AST ----------------------------------------------------- FORTRAN-Aufruf: --------------- Spezifizieren des AST EXTERNAL sub CALL PWRUP [(sub)] sub = Name einer Subroutine, die bei Netzwiederkehr aufgerufen wird Die PWRUP-Subroutine bewirkt letztlich ein CALL sub (ohne Argumente) Diese Subroutine wird als Ergebnis eines Netz- wiederkehr-AST's aufgerufen und kann deshalb an kritischen Programmpunkten durch die Be- nutzung der DSASTR und ENASTR Subroutinenrufe kontrolliert werden. Streichen des AST CALL PWRUP Makro-Aufruf: ------------- SPRA$ [ast] ast = Adresse des Eintrittspunktes des AST-Bedienungspro- gramms Makro-Erweiterung: ------------------ SPRA$ SPAST .BYTE 109.,2 ;DIC der Anweisung und Laenge des DPB .WORD SRAST ;Eintrittsadresse in das AST-Bedienungs- ;programm Funktionsbeschreibung: ---------------------- Die Anweisung SPRA$ informiert das System darueber: 1. dass auftretende Netzwiederkehr-AST vom entsprechenden AST- Bedienungsprogramm bearbeitet werden sollen, oder 2. dass auf Netzwiederkehr-AST nicht mehr reagiert werden soll. Ist die Adresse des Eintrittspunktes angegeben, verzweigt das System sofort zum AST-Bedienungsprogramm wenn ein Netzwiederkehr- AST fuer die die Anweisung beinhaltende Task auffritt. Ist keine Adresse angegeben, werden auftretende Netzwiederkehr- AST ignoriert. Lokale Symboldefinition: ------------------------ S.PRAE - Eintrittspunktadresse  197 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01. IE.UPN fehlender Platz im dynamischen Bereich der Exekutive -08. IE.ITS dieser AST ist schon verhindert -80. IE.AST die Anweisung wurde aus einem AST-Bedienungs- programm gesendet, oder alle AST sind verhin- dert -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die SPRA$-Anweisung benoetigt Speicherbereich im dynamischen Bereich der Exekutive. - Die Exekutive merkt den Netzwiederkehr-AST vor, wenn ein Netz- wiederkehrinterrupt auftritt, der einem Spannungsfehler folgt. Ein weiterer Netzwiederkehr-AST wird erst wieder vorgemerkt, wenn der erste AST bearbeitet ist. - Beim Start des AST-Bedienungsprogramms enthaelt der Stack der Task: SP + 06 - Ereignisflagmaskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Task vor dem AST SP + 00 - DSW der Task vor dem AST Es gibt keine Trap-Parameter, die vom Netzwiederkehr-AST ab- haengen, deshalb braucht der Stack der Task vom AST-Bedienungs- programm nicht veraendert zu werden, wenn es mit der ASTX$S- Anweisung beendet wird. - Wenn fuer den Netzwiederkehr-AST ein Eintrittspunkt in einer auslagerbaren Task spezifiert ist, wird der Spannungsfehler weder bearbeitet noch vorgemerkt, wenn die Task ausgelagert ist. Deshalb darf eine Task, die den Spannungsfehler bearbeiten soll, nicht auslagerbar sein. - Diese Anweisung darf nicht aus einem AST-Bedienungsprogramm, oder wenn AST verhindert sind, gesendet werden. - Beim FORTRAN-Aufruf: Die PWRUP-Subroutine verursacht den Aufruf CALL sub (ohne Argumente) Die Subroutine sub wird als Ergebnis eines Netzwiederkehr-AST aufgerufen und kann an kritischen Stellen der Task durch Be- nutzung der DSASTR- und ENASTR-Subroutinerufe gesteuert werden. 198 Das Weglassen des Subroutine-Namen im Aufruf CALL PWRUP bewirkt, dass keine Netzwiederkehr-AST mehr bearbeitet werden.  199 ---------------------------------------------------------------- | SPAWN | SPWN$ | | -- -- | | ---------------------------------------------------------------- 2.3.2.56. SPWN$ - Erzeugen einer Tochtertask -------------------------------------------- Fortran-Aufruf: --------------- CALL SPAWN (rtn,[ingc],[iumc],[iefn],[iast],[iesb],[iparm], [ieml],[icmll],[iut],[dn][,ds] rtu = Name (RAD50) der Tochtertask iugc = Gruppennummer fuer den UIC der Tochtertask iumc = Mitgliedsnummer fuer den UIC der Tochtertask iefn = Ereignisflag, das zu setzen ist, wenn die Tochtertask beendet wird oder einen Status aussendet. iast = Name der AST-Routine, die aufgerufen wird, wenn die Tochtertask beendet wird oder einen Status ausgibt. iesb = Name des 1-Wort-Statusblockes, der den Statuswert enthaelt, wenn die Tochtertask beendet wird oder wenn sie einen Status uebergibt, z.B. mit der EMST$-Anweisung. iparm = Name eines Wortes fuer den Empfang der Statusblockadresse, wenn ein AST ein- tritt. (Analog der Information, die ein MACRO 1600-Programm in diesem Falle im Stack uebermittelt bekommt.) icml = Name einer Kommandozeile, die fuer die Tochtertask in die Warteschlange einzureihen ist. icmml = Laenge der Kommmandozeile (maximal 79. Zeichen) iut = Physische Einheiten-Nummer des Termi- nals, das als TI: von der Tochtertask zu nutzen ist. Ist der Wert 0 angegeben, wird das TI: der aussendenden Task vereinbart. Eine Task muss priviligiert sein, um ein anderes TI: anzugeben als das TI: der Muttertask. dn = Mnemonik des Geraetenamens des Termi- nals, das von der Tochtertask als TI: zu nutzen ist. ids = Anweisungsstatus 200 Makro-Aufruf: ------------- SPWN$ tname,,,[ugc],[umc],[efn],[east],[esb],[cml],[cmll], [un],[dn] tname = Name (RAD50) der Tochtertask ugc = Gruppennummer fuer den UIC der Tochtertask umc = Mitgliedsnummer fuer den UIC der Tochtertask efn = Ereignisflag, das bei Aussenden der Anweisung geloescht werden soll und gesetzt werden soll, wenn die Tochtertask beendet wird oder einen Status bereitstellt. east = Adresse einer AST-Routine in der Muttertask, die aufgerufen wird, wenn die Tochtertask beendet wird oder einen Status bereitstellt. esb = Adresse eines 1-Wort-Statusblockes,in den der Statuswert eingetragen wird, der von der Beendigung der Tochtertask oder von einer expliziten Statusuebergabe durch die Tochtertask (z.B. durch die EMST$-Anweisung) herruehrt. cml = Adresse einer Kommandozeile, die fuer die Tochtertask in die Warteschlange einzureiben ist. cmll = Laenge der Kommandozeile (maximale Laenge = 79.). un = Physische Einheiten-Nummer des Terminals, das als TI: durch die Tochtertask genutzt werden soll. Ist der Wert 0 angegeben, wird das TI: der aussendenden Task vereinbart. Eine Task muss privilegiert sein, um ein anderes TI: als das eigene zu vereinbaren. dn = Mnemonik des Geraetenamens des Terminals, das von der Tochtertask als TI: zu nutzen ist. Makro-Erweiterung: ------------------ SPWN$ ALPHA,,,3,7,1,ASTRUT,STBLK,CMDLIN,72.,2,TT .BYTE 11.,14. ;DIC der Anweisung und Laenge des DPB .RAD50 /ALPHA/ ;Name der Task, die erzeugt werden soll .BLKW 3 ;reserviert .BYTE 7,3 ;UIC-Mitgliedsnummer, UIC-Gruppennummer .WORD 1 ;Nummer des Ereignisflags = 1 .WORD ASTRUT ;Adresse der AST Routine .WORD STBLK ;Adresse des Statusblocks .WORD CMDLIN ;Adresse der Kommandozeile .WORD 72. ;Laenge der Kommandozeile = 72. Zeichen .WORD 2 ;Einheiten-Nummer des Terminals (TI:) .ASCII /TT/ ;Geraetemnemonik des Terminals (TI:) Werden die letzten beiden Parameter ausgelassen, so wird ein DPB der Laenge 13. erzeugt. In diesem DPB ist das letzte Wort auf Null gesetzt.  201 Funktionsbeschreibung: ---------------------- Die SPWN$-Anweisung veranlasst die Exekutive, die angegebenen Tasks als Tochtertask der die Anweisung gebenden Task - der Muttertask - zu aktivieren, wahlweise das Einreihen einer Kommandozeile in die Warteschlange der angegebenen Task und die Zuordnung des TI: der Task zu einem physischen Terminal. Wenn diese Anweisung ausgesendet wird, wird ein Tochtertask- Steuerblock (OCB) dem Tochtertask-TCB zugeordnet und ein Benutzungszaehler im Muttertask-TCB um 1 erhoeht. Der Benutzungs- zaehler wird benutzt, um die Exekutive zu informieren, dass die Task eine Muttertask ist und eine oder mehrere Tochtertasks hat, er muss geloescht werden, wenn eine Muttertask mit noch aktiven Tochtertasks beendet wird. Der Benutzungszaehler wird um 1 erniedrigt, wenn die Tochtertask beendet wird. Der OCB enthaelt die Adresse des TCB der Muttertask und zusaetzliche Informatio- nen, um alle vereinbarten Massnahmen zu ergreifen, wenn die Tochtertask beendet wird. Ist eine Kommandozeile angegeben, wird sie im dynamischen Speicherbereich der Exekutive gepuffert und in die Warteschlage der Tochtertask eingereiht. Dort steht sie fuer eine nachfolgende Uebergabeanforderung durch die Tochtertask mittels einer GMCR$- Anweisung zur Verfuegung. Die maximale Laenge der Kommandozeile betraegt 79 Zeichen. Ist eine AST-Adresse angegeben wird eine AST-Routine in der Muttertask aktiviert, wenn die Tochtertask beendet wird. Im Stack wird dabei unter anderem die Adresse des Statusblockes, der fuer diese Mutter/Tochter-Verbindung vereinbart wurde, uebergeben. Die AST Routine muss dieses Wort aus dem Stack entfernen, bevor sie mit der ASTX$-Anweisung die AST-Bearbeitung beendet. Lokale Symboldefinition: ------------------------ S.PWTN - Taskname S.PWXX - reserviert S.PWUM - UIC-Mitgliedsnummer S.PWUG - UIC-Gruppennummer S.PWEF - Ereignisflagnummer S.PWEA - Adresse der AST-Routine S.WES - Adresse des Status-Blocks S.PWCA - Adresse der Kommandozeile S.PWCL - Laenge der Kommandozeile S.PWVT - Einheiten-Nummer des Terminals S.PWDN - Geraetename des Terminals 202 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN Fehlender Platz im dynamischen Bereich der Exekutive, um die Kommandozeile abzu- speichern oder Steuerbloecke anzulegen -02 IE.INS angegebene Task ist nicht installiert -07 IE.ACT angegebene Task ist schon aktiv -16. IE.PRI eine nicht privilegierte Task versucht fuer die Tochtertask ein anderes TI: zu vereinbaren als ihr eigenes TI: -92. IE.IDU das angegebene Terminal existiert nicht oder das Geraet ist kein Terminalgeraet -97. IE.IEF ungueltige Ereignisflagnummer (EFN<0, oder EFN>96 falls gruppenglobale Ereig- nisflags fuer die Gruppe der Task existieren oder EFN>64 falls dies nicht der Fall ist) -98. IE.ADP ein Teil des DPB des Exit-Statusblockes oder der Kommandozeile liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ - Wird der Standardwert fuer den UIC benutzt, so wird die Ausfuehung der Task unter dem UIC der Muttertask gefordert. Weitere Informationen ueber die UIC-Nutzung sind in den Anmerkungen zur RQST$-Anweisung enthalten. - Falls es sich bei den angegebenen Ereignisflags um ein gruppen- globales Ereignisflag handelt, wird der Benutzungszaehler fuer die Ereignisflaggruppe um 1 erhoeht, um die vorzeitige Elimi- nierung von Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert, wenn: . die Tochtertask einen Status bereitstellt oder . die aussendende Task beendet wird, bevor ein Status bereit- gestellt wurde. - Die virtuelle Adresszuweisung des Statusblocks sollte nicht veraendert werden, solange die Verbindung besteht, da sonst schwer erkennbare Fehler verursacht werden koennen.  203 ---------------------------------------------------------------- | SPECIFY RECEIVE DATA AST | SRDA$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.57. SRDA$ - Spezifizieren von Datenempfangs - AST ------------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- SRDA$ [ast] ast = Adresse des Eintrittspunktes des AST-Bedienungspro- gramms Makro-Erweiterung: ------------------ SRDA$ DEAST .BYTE 107.,2 ;DIC der Anweisung und Laenge des DPB .WORD DEAST ;Eintrittspunkt in das AST-Bedienungs- ;programm Funktionsbeschreibung: ---------------------- Die Anweisung SRDA$ informiert das System darueber: 1. dass AST fuer Datenempfang zugelassen sind, und zur angegebe- nen Adresse verzweigt werden soll, wenn fuer die die Anweisung SRDA$ enthaltende Task Daten in die Empfaengerwarteschlange eingetragen werden oder 2. dass kein weiterer Datenempfangs-AST fuer die Task bearbeitet werden soll. Ist bei dieser Anweisung eine AST-Bedienungsprogramm-Eintritts- punktadresse angegeben, tritt ein AST auf, wenn fuer die Task Daten zur Verfuegung stehen, und es wird zur angegebenen Ein- trittspunktadresse verzweigt. Ist keine Eintrittspunktadresse angegeben, verhindert die Exeku- tive das Auftreten dieser AST fuer die die Anweisung enthaltende Task. AST durch Datenempfang treten fuer die Task erst wieder nach einer SRDA$-Anweisung mit Angabe eines AST-Eintrittspunktes auf. Lokale Symboldefinition: ------------------------ S.RDAE - Eintrittspunktadresse 204 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01. IE.UPN fehlender Platz im dynamischen Bereich der Exekutive -08. IE.ITS dieser AST ist schon verhindert -80. IE.AST die Anweisung wurde aus einem AST-Bedienungs- programm erteilt, oder alle AST sind verhin- dert -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die Anweisung SRDA$ benoetigt Speicherbereich im dynamischen Bereich der Exekutive. - Die Exekutive merkt den AST vor, wenn dieser fuer die Task eintrifft. Weitere AST dieser Art werden erst wieder vorge- merkt, wenn der erste AST bearbeitet worden ist. - Das AST-Bedienungsprogramm kann aus dem Stack der Task folgen- des entnehmen: SP + 06 - Ereignisflag-Maskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Tasks vor dem AST SP + 00 - DSW der Tasks vor dem AST Der AST durch Datenempfang stellt nur diese Parameter im Stack zur Verfuegung. Wenn das AST-Bedienungsprogramm mit der Anweisung ASTX$S been- det wird, braucht der Stack nicht veraendert zu werden. - Diese Anweisung darf nicht aus einem AST-Bedienungsprogramm, oder wenn AST verhindert sind, gesendet werden. - Wird eine ausgelagerte Task in den Hauptspeicher uebertragen, erzeugt die Exekutive einen AST fuer die Task, wenn ihre Daten- empfangswarteschlange eine Eintragung enthaelt. Dadurch wird verhindert, dass Datenempfangs-AST bei ausgelager- ter Task verloren gehen.  205 ---------------------------------------------------------------- | SPECIFY REQUESTED EXIT AST DIREKTIVE | SREA$ | | - - - - | SREX$ | ---------------------------------------------------------------- 2.3.2.58. SREA$ oder SREX$ - Spezifizieren von Task-Abbruch-AST (EXIT-AST) ---------------------------------------------------------------- Fortran-Aufruf: --------------- Es existieren 2 Formen, deren Unterschiede unten erlaeutert werden. CALL SREA (ast[,ids]) ast = Name der AST-Bedienungsroutine ids = Anweisungsstatus CALL SREX (ast,ipblk,ipblkl[,,ids]) ast = Name der AST-Bedienungsroutine ipblk = Name eines Integer-Feldes, das bei Ein- tritt des AST-Zustandes die trap-ab- haengigen Parameter aufnehmen soll (siehe Beschreibung des StackAufbaus bei der SREX$Anweisung) ipblkl = Zahl der nach ipblk zu uebergebenden Parameter ids = Anweisungsstatus Makro-Aufruf: ------------- Es existieren 2 Formen, deren Unterschiede unten erlaeutert werden. SREA$ [ast] SREX$ [ast] ast = Eintrittspunktadresse der EXIT-AST-Bedienungsroutine Makro-Erweiterung: ------------------ SREA$ ASTAD .BYTE 167.,2 ;DIC der Anweisung und Laenge des DPB .WORD ASTAD ;Adresse des Eintrittspunktes der EXIT- AST-Bedienungsroutine SREX$ ASTAP .BYTE 167.,3 ;DIC der Anweisung und Laenge des DPB .WORD ASTAD ;Adresse des Eintrittspunktes .WORD 0 ;reserviert Die beiden Anweisungen unterscheiden sich formal nur in der Laenge ihres DPB (fuer SREA$: LG DPB = 2,fuer SREX$: LG DPB = 3). 206 Funktionsbeschreibung: ---------------------- Die SREA$- oder SREX$-Anweisung vereinbart fuer die die Anweisung enthaltende Task eine AST-Bedienungsroutine, die die Steuerung erhaelt, wenn der Versuch gemacht wird, diese Task durch eine ABRT$-Anweisung oder ein MCR- oder DCL-ABO-Kommando abzubrechen. Damit kann die Task eine ordnungsgemaesse Beendigung ausfuehren statt des sonst stattfindenden abrupten Abbruches. Ist keine AST-Eintrittspunktadresse in der Anweisung angegeben, wird die Spezifikation wieder aufgehoben. Lokale Symboldefinitionen: -------------------------- S.REAE - Adresse der EXIT-AST-Bedienungsroutine Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ---------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -01 IE.UPN fehlender Platz im dynamischen Bereich der Exekutive -80. IE.AST die Anweisung wurde von einer AST-Be- dienungsroutine ausgesendet oder AST's sind verboten. -08 IE.ITS AST's sind bereits nicht erlaubt oder eine nichtprivilegierte Task hat ver- sucht, einen AST abzubrechen oder er- neut zu vereinbaren, nachdem er bereits eingetreten war. -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ - Bei privilegierten Tasks wird jedesmal zur vereinbarten AST- Routine verzweigt, wenn ein Abbruch eingeleitet wird. Jedoch werden nachfolgende Exit-AST's nicht vorgemerkt, bis der erste Exit-AST eingetreten ist. Nicht privilegierte Task verzweigen nur einmal zur vereinbarten AST-Routine. Nachfolgende Versuche die Task abzubrechen fuehren augenblicklich zum Abbruch der Task. - Die SREX$-Form der Anweisung wird empfohlen fuer Tasks, die alle privilegierten und nicht privilegierten Abbruchversuche, die nicht die Multiuserschutzpruefung verletzen, behandeln moechten. Die aussendende Task kann die Informationen, die fuer diese Version ueber den Stack bereitgestellt werden, nutzen, um zu entscheiden, wie der Abbruchversuch zu behandeln ist.  207 Nachdem der AST unter Nutzung der SREX$-Anweisung vereinbart wurde, wird von der Exekutive zum EXIT-AST-Bedienungsprogramm verzweigt, wenn der Versuch gemacht wird, die Task abzubrechen. Nicht privilegierte Abbruchversuche muessen vom gleichen TI: ausgehen, das die die Anweisung aussendende Task benutzt. Erhaelt die AST-Bedienungsroutine die Steuerung und der AST ist unter Nutzung der SREX$-Version der Direktive-Anweisung vereinbart worden, so hat der Stack der Task folgenden Inhalt: SP+12 - Ereignisflagmaskenwort SP+10 - PS der Task vor dem AST SP+06 - PC der Task vor dem AST SP+04 - DSW der Task vor dem AST SP+02 - Trapabhaengiger Parameter SP+00 - Anzahl der Bytes, die zum SP zu addieren sind, um den Stack zu bereinigen Der trapabhaengige Parameter hat folgende Bedeutung: (Art der Abbruchversuche) Bit 0 = 0 wenn der Abbruchversuch privilegiert war = 1 wenn der Abbruchversuch nicht privilegiert war Bit 1 = 0 wenn die ABRT$-Direktive ausgesendet wurde = 1 wenn das MCR oder DCL-Abbruch-Kommando genutzt wurde Bit 2 -15 reserviert Die Task muss die trapabhaengigen Parameter aus dem Stack entfernen, bevor eine ASTX$-Anweisung ausgefuehrt werden darf. Die empfohlene Methode ist, den Wert, der in SP+00 gespeichert ist, zum SP zu addieren. Dies ist auch der einzige empfehlens- werte Weg auf die nicht trapabhaengigen Parameter des Stacks zuzugreifen. - Die SREA$-Anweisung wird fuer privilegierte Tasks empfohlen, die Abbruchversuche durch MCR- oder DCL-ABO-Kommando von nicht privilegierten Terminals nicht beachten wollen und die deshalb auch keine Untersuchungen ueber die Art des Abbruchversuches anstellen muessen. Sie wird auch fuer nicht privilegierte Tasks empfohlen, die sich nicht fuer die Art der Abbruchversuche interessieren. Nachdem der EXIT-AST durch die SREA$-Anweisung vereinbart wurde, wird von der Exekutive bei privilegierten Tasks jedesmal zur AST-Bedienungsroutine verzweigt, wenn folgende Abbruchver- suche gemacht werden: . privilegierte ABRT$-Anweisungen und/oder privilegierte MCR- oder DCL-ABO-Kommandos . nicht privilegierte ABRT$-Anweisungen von Tasks, die das gleiche TI:-Geraet benutzen wie die Task, die die SREA$-An- weisung enthaelt. Fuer nicht privilegierte Tasks kann nur ein Abbruchversuch ueber den EXIT-AST behandelt werden. Zur AST-Bedienungsroutine wird neben den obigen zwei Anlaessen auch noch verzweigt: . nicht privilegierte MCR- oder DCL-ABO-Kommandos vom gleichen TI:, wie es der betrachteten Task zugeordnet ist. 208 Wenn zur AST-Bedienungsroutine, die ueber die Anweisung SREA$ vereinbart wurde, verzweigt wird hat der Stack der Task folgenden Aufbau: SP+06 - Ereignisflagmaskenwort SP+04 - PS der Task vor dem AST SP+02 - PC der Task vor dem AST SP+00 - DSW der Task vor dem AST Ein AST, der durch SREA$ vereinbart wurde, wird von keinen trapabhaengigen Parametern begleitet; deshalb kann der Stack unveraendert bleiben bei der Ausfuehrung der ASTX$-Anweisung. - Ist fuer eine privilegierte Task die SREX$-Anweisung nicht angegeben, gibt es keine Moeglichkeit, diese Task von einem nicht privilegierten Terminal durch MCR- oder DCL-ABO-Kommando abzubrechen. - Die zwei Formen dieser Anweisung sollten nicht in einem Programm wechselweise benutzt werden, da sich das Stackformat und die trapabhaengigen Parameter unterscheiden. Jede Vermischung zwischen der Art der Anweisung und der AST-Routine wird unvorhersagbare Resultate haben.  209 ---------------------------------------------------------------- | SEND BY REFERENCE | SREF$ | | - --- | | ---------------------------------------------------------------- 2.3.2.59. SREF$ - Senden eines Referenzblockes ---------------------------------------------- FORTRAN-Aufruf: --------------- CALL SREF (tsk,[efn],iwdb,[isrb][,ids]) tsk = Name der Task, der der Referenzblock uebergeben werden soll. efn = Ereignisflagnummer iwdb = 8-Worte-Integerfeld fuer den Fenster-Defini- tions-Block isrb = 8-Worte-Integerfeld fuer zusaetzliche Informa- tionen. Seine Adresse wird nach IWDB(8) ge- bracht. Fehlt der Parameter, bleibt IWDB(8)un- geaendert. ids = Anweisungsstatus Makro-Aufruf: ------------- SREF$ name,adr[,efn] name = Name des Empfaengers adr = Adresse des Fenster-Definitionsblocks (WDB) efn = Ereignisflag Makro-Erweiterung: ------------------ SREF$ NAME,ADWDB,35. .BYTE 69.,5 ;DIC der Anweisung und Laenge des DPB .RAD50 /NAME/ ;Name des Empfaengers .WORD 35. ;Ereignisflag .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird eine Kommunikation zwischen zwei Tasks ermoeglicht. Die Task, die die SREF$-Anweisung enthaelt (Sender), versetzt die andere Task (Empfaenger) in die Lage, auf eine Re- gion zuzugreifen, die zum logischen Adressraum des Senders ge- hoert. Die Informationen ueber die Region werden in einem Refe- renzblock im dynamischen Bereich der Exekutive gespeichert. Er enthaelt u. a. folgende Informationen: W.NRID, W.NOFF, W.NLEN, den Task-Namen des Senders sowie die Zugriffsrechte zur Region. Die gesendeten Zugriffsrechte duerfen die Zugriffsrechte des Senders nicht uebersteigen. Falls W.NSRB vom Nutzer spezifiziert war, werden weitere 8 Zusatzinformations- worte in den Referenzblock aufgenommen, anderenfalls wird er mit 8 Nullen aufgefuellt. Der Referenzblock wird in der fuer die Kommunikation vorgesehenen Empfangswarteschlange des Empfaengers angemeldet. Falls der Nutzer im Makro-Aufruf ein Ereignisflag spezifiziert, wird es von der Exekutive im Sender gesetzt, wenn der Referenzblock beim Empfaenger angemeldet wurde. Alle Versuche, das Flag zu setzen, wenn die Task beendet ist, werden unterbunden, aber die Anmeldung in der Empfangswarteschlange wird nicht aufgehoben. 210 Von der Exekutive im WDB benoetigte Parameter: symb. Offset W.NRID - Region-Identifikation der mit SREF$ zu uebergeben- den Region W.NOFF - Offset vom Anfang der Region bis zum Anfang der Adresszuweisung (wird ohne Ueberpruefung weiterge- geben) W.NLEN - Laenge der Adresszuweisung (wird ohne Ueberpruefung weitergegeben) W.NSTS - Folgende Bits des Fenster-Statusworts (Zugriffs- rechte fuer die Empfaengertask) WS.RED = 1, falls Lesen erlaubt wird, WS.WRT = 1, falls Schreiben erlaubt wird, WS.EXT = 1, falls Erweitern erlaubt wird, WS.DEL = 1, falls Loeschen erlaubt wird, (jeweils fuer die Empfaengertask) W.NSRB - Adresse des Puffers, der 8 Worte mit zusaetzlichen Informationen enthaelt Lokale Symboldefinitionen: -------------------------- S.RETN - Name des Empfaengers S.REBA - Adresse des WDB S.REEF - Ereignisflag Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01 IE.UPN der Bindungsdeskriptor bzw. das Paket konnte nicht zugeteilt werden -02 IE.INS Der Empfaenger ist nicht installiert bzw. eine ACP-Task -16 IE.PRI Die zu sendenden Zugriffsrechte widersprechen den eigenen Zugriffsrechten der Sendertask -86 IE.NVR die Region-Identifikation ist unzulaessig -97 IE.IEF die Ereignisflagnummer ist unzulaessig -98 IE.ADP ein Teil des WDB bzw. Datenpuffers liegt ausserhalb des Adressraumes der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  211 ---------------------------------------------------------------- | SPECIFY RECEIVE - BY - REFERENCE AST | SRRA$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.60. SRRA$ - Spezifizieren von AST nach Senden von Referenzbloecken fuer die Task ------------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- SRRA$ [ast] ast = Adresse des Eintrittpunktes des AST-Bedienungspro- gramms Makro-Erweiterung: ------------------ SRRA$ EDBAST .BYTE 21.,2 ;DIC der Anweisung und Laenge des DPB .WORD EDBAST ;Eintrittspunkt in das AST-Bedienungsprogramm Funktionsbeschreibung: ---------------------- Die Anweisung SRRA$ informiert das System darueber: 1. dass AST nach Senden von Referenzbloecken fuer die Task ge- wuenscht sind und zur angegebenen Adresse verzweigt werden soll, wenn fuer die diese Anweisung enthaltende Task ein solcher AST auftritt oder 2. dass keine weiteren dieser AST fuer die Task bearbeitet werden sollen. Wenn bei dieser Anweisung ein Eintrittspunkt angegeben ist, ver- zweigt die Exekutive bei Auftreten eines solchen AST zur spezifi- zierten Adresse. Ist in der Anweisung keine Eintrittspunktadresse angegeben, wer- den solche AST unterdrueckt. Diese treten erst wieder auf, nach- dem erneut eine SRRA$-Anweisung, bei der ein Eintrittspunkt spe- zifiziert ist, gesendet wurde. Lokale Symboldefinition: ------------------------ S.RRAE - Eintrittspunktadresse 212 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -01. IE.UPN fehlender Platz im dynamischen Bereich der Exekutive -08. IE.ITS dieser AST ist schon verhindert -80. IE.AST die Anweisung wurde aus einem AST-Bedienungs- programm gesendet, oder alle AST sind verhin- dert -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- bereiches der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Die Anweisung SRRA$ benoetigt Speicherbereich im dynamischen Bereich der Exekutive. - Die Exekutive merkt den AST in einer speziellen Empfaengerwarteschlange vor,wenn dieser fuer die Task auftritt. Weitere dieser AST werden erst wieder vorgemerkt, wenn der erste AST bearbeitet ist. - Das AST-Bedienungsprogramm kann aus dem Stack der Task folgen- des entnehmen: SP + 06 - Ereignisflag-Maskenwort SP + 04 - PS der Task vor dem AST SP + 02 - PC der Task vor dem AST SP + 00 - DSW der Task vor dem AST Wenn das AST-Bedienungsprogramm mit der Anweisung ASTX$S beendet wird, braucht der Stack nicht veraendert zu werden. - Diese Anweisung darf nicht aus einem AST-Bedienungsprogramm, oder wenn AST verhindert sind, gesendet werden. - Wird eine ausgelagerte Task in den Hauptspeicher uebertragen, sendet die Exekutive einen AST fuer die Task, wenn waehrend der ausgelagerten Zeit Informationen fuer die Task bereitgestellt wurden. Dadurch wird verhindert, dass dieser AST bei ausgela- gerter Task verlorengeht.  213 ---------------------------------------------------------------- | SET SYSTEM TIME DIREKTIVE | STIM$ | | - --- | | ---------------------------------------------------------------- 2.3.2.61. STIM$ - Setzen der System-Zeit ---------------------------------------- Fortran-Aufruf: --------------- CALL SETTIM (ibufn[,ibufa[,ids]]) ibufn = 8 Worte Integerfeld, Puffer fuer die neue Zeitangabe (Eingabepuffer) ifufa = 8 Worte Integerfeld, Puffer fuer die vor- herige Zeitangabe (Ausgabepuffer) ids = Anweisungsstatus Makro-Aufruf: ------------- STIM$ bufn[,bufa] bufn = Adresse eines 8-Worte-Puffers fuer die neue Zeitangabe bufa = Adresse eines 8-Worte-Puffers zur Aufnahme der vorherigen Systemzeitparameter Makro-Erweiterung: ------------------ STIM$ NEWTI,OLDTI .BYTE 61.,3 ;DIC der Anweisung und Laenge des DPB .WORD NEWTI ;Adresse des 8. Worte-Eingabepuffers .WORD OLDTI ;Adresse des 8. Worte-Ausgabepuffers Funktionsbeschreibung: ---------------------- Die STIM$-Anweisung veranlasst die Exekutive, die interne Systemzeit entsprechend den angegebenen Parametern des Eingabe- puffers zu setzen. Wahlweise stellt die Anweisung der Task die augenblickliche interne Systemzeit im Ausgabepuffer zur Verfuegung, bevor sie sie auf die angegebenen Werte einstellt. Alle Time Parameter muessen als binaere Werte angegeben werden. Format fuer Ein- und Ausgabepuffer: [Die Angaben in (...) geben den moeglichen Wortebereich an.] Wort 0 - Jahr (seit 1900) Wort 1 - Monat (1 - 12) Wort 2 - Tag (1-n, wobei n der hoechste Tag ist, der fuer gegebenen Monat und das Jahr moeglich ist) Wort 3 - Stunde (0 - 23) Wort 4 - Minute (0 - 59) Wort 5 - Sekunde (0 - 59) 214 Wort 6 - Takt der Sekunde ( 0-n wobei n die Frequenz der Systemuhr-1 ist). Ist der naechste Parameter (Takte pro Sekunde) Standard, wird dieser Parameter igno- riert. Wort 7 - Takte pro Sekunde (muss der Standardwert sein oder muss mit der Frequenz der Systemuhr uebereinstim- men). Dieser Parameter wird benutzt, um die beab- sichtigte Zeitquantisierung des Wortes 6 zu prue- fen. Lokale Symboldefinitionen: -------------------------- S.TIBA - Adresse des Eingabepuffers S.TIBO - Adresse des Ausgabepuffers Die folgenden Offsets sind relativ zum Anfang jedes Zeitparameterpuffers zugewiesen. S.TIYR - Jahr S.TIMO - Monat S.TIDA - Tag S.TIHR - Stunde S.TIMI - Minute S.TICS - Sekunde S.TICT - Uhrtakte der Sekunde S.TICP - Uhrtakte pro Sekunde Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -16. IE.PRI die aussendende Task ist nicht privilegiert -93. IE.ITI einer der angegebenen Zeitparameter liegt ausserhalb des Bereiches oder der 'Takte der Sekunde'-Parameter und der 'Takte pro Sekun- de'-Parameter stimmen nicht mit der Frequenz der Systemuhr ueberein. Die Systemzeit zum Zeitpunkt des Aussendens dieser Anweisung (eingetragen im zweiten Puffer) kann nuetzlich sein fuer die Bestimmung der Ursache eines Fehlers, wenn irgendein angegebener Zeitpara- meter fehlerhaft war. -98. IE.ADP ein Teil des DPB oder einer der Puffer liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Wird irgendeiner der Werte im Eingabepuffer ausgelassen (durch setzen auf '-1'), so bleibt der korrespondierende Wert der Systemzeit unveraendert. - Die Task, die diese Anweisung aussendet, muss privilegiert sein.  215 - Wenn diese Anweisung die Systemzeit um ein angegebenen Betrag aendert, wird auch eine Veraenderung aller Eintragungen in der Uhrworteschlange um den gleichen Betrag vorgenommen. Dadurch wird die Synchronisierung der Ereignisse erreicht. - Die Ausfuehrung dieser Anweisung erzeugt ein Error Log Paket und sendet es zum Error Log Subsystem. - Die hoechste Uhrfrequenz, die durch das Betriebssystem unterstuetzt wird ist 1000 Hz fuer eine programmierbare Uhr. Es ist anzumerken, dass jemehr sich die Uhrfrequenz diesem Wert naehert, desto zeitkritischer die maximale Aufloesung fuer diese Anweisung wird. Die Genauigkeit dieser Anweisung haengt von der Zeit ab, die vergeht zwischen dem Moment zu dem eine neue Systemzeit vereinbart wird und dem Zeitpunkt zu dem die Anweisung tatsaechlich zur Exekutive verzweigt. - Die Puffer, die in dieser Direktive benutzt werden, sind mit denen aus der GTIM$-Anweisung kompatibel. - Der zweite Puffer (vorherige Zeit) wird nur gefuellt, wenn die Anweisung erfolgreich ausgefuehrt wurde oder wenn sie mit dem Fehlercode IE.ITI zurueckgewiesen wird. 216 ---------------------------------------------------------------- | STOP FOR LOGICAL OR of EVENT FLAGS | STLO$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.62. STLO$ - STOP fuer logisches 'ODER' von Ereignisflags -------------------------------------------------------------- Fortran-Aufruf: --------------- CALL STLOR (ief1,ief2,ief3,...iefn) ief1...iefn = Liste von Ereignisflagnummern Makro-Aufruf: ------------- STLO$ grp,msk grp = gewuenschte Ereignisflaggruppe msk = 16-Bit-Maskenwort zur Auswahl der EF der gewuenschten Gruppe. Makro-Erweiterung: ------------------ STLO$ 2,43 .BYTE 137.,3 ;DIC der Anweisung und Laenge des DPB .WORD 2 ;EF-Gruppe 2 (EF der Nummern 33-48 .WORD 43 ;Masken-Wort (EF=33,34,38) Funktionsbeschreibung: ---------------------- Die STLO$-Anweisung veranlasst die Exekutive die aussendende Task zu stoppen bis die Exekutive ein oder mehrere der angezeigten Ereignisflags aus einer der folgenden Gruppen gesetzt hat: GR 0 - Lokale Flags 1 - 16 GR 1 - Lokale Flags 17 - 32 GR 2 - Common Flags 33 - 48 GR 3 - Common Flags 49 - 64 GR 4 - gruppenglobale Flags 65 - 80 GR 5 - gruppenglobale Flags 81 - 96 Die Task stoppt sich nicht selbst, wenn irgendeines der angezeigten Flags zu dem Zeitpunkt bereits gesetzt ist, wenn die Task die Anweisung aussendet. Diese Anweisung kann nicht im AST- Zustand ausgegeben werden. Der Stop-Zustand der Task wegen eines oder mehrerer Ereignisflags kann nur aufgehoben werden durch das Setzen des vereinbarten Ereignisflags, er kann nicht aufgehoben werden mit der USTP$- Anweisung oder dem MCR-UNSTOP- oder dem DCL-START-Kommando.  217 Lokale Symboldefinitionen: -------------------------- S.TLGR - Ereignisflaggruppennummer S.TLMS - Maskenwort Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -80. IE.AST Task befindet sich im AST-Zustand -97. IE.IEF Ereignisflaggruppe ist falsch (nicht 0 bis 5) oder das Maskenwort ist Null -98. IE.ADP ein Teil des DP liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ - Es besteht eine eins zu eins Korrespondenz zwischen den Bits im Maskenwort und den Ereignisflags in der vereinbarten Gruppe. Das bedeutet, wenn Gruppe 2 vereinbart wurde (wie in der Makroerweiterung im vorhergehenden Beispiel), das Bit 0 im Maskenwort mit dem Ereignisflag 33 korrespondieren wuerde, Bit 1 mit dem Ereignisflag 34 usw. - Die Exekutive loescht nicht die angegebenen Ereignisflags, wenn die STLO$-Anweisung abgearbeitet wird. Einige Anweisungen (QIO z.B.) loeschen implizit ein Ereignisflag, ansonsten muessen sie explizit durch eine CLEF$-Anweisung geloescht werden. - Die Argumentliste, die in einem FORTRAN-Ruf angegeben wird, darf nur die Flagnummern enthalten, die innerhalb einer Ereignisflaggruppe liegen. Werden Ereignisflagnummern angegeben, die in mehr als einer Gruppe liegen oder es wird eine ungueltige Ereignisflagnummer angegeben wird ein 'Fatal'- FORTRAN-Fehler erzeugt. - Tasks, die wegen Ereignisflagbedingungen gestoppt sind, koennen nicht durch das Aussenden der USTP$-Anweisung aus dem STOP- Zustand entlassen werden; Tasks, die auf diese Art und Weise gestoppt wurden, koennen nur durch Eintritt der Ereignisflagbe- dingungen aus dem STOP-Zustand entlassen werden. - Der grp-Operand muss immer die Form n haben, unabhaengig von der benutzten Makroform. In allen anderen Makroaufrufen werden numerische oder Adresswerte fuer die $S-Form der Makros so angegeben: #n Fuer STLO$S muss die Form der grp-Operanden n sein. 218 - Ist die vereinbarte Ereignisflaggruppe vom Typ gruppenglobal, wird der Benutzungszaehler der Gruppe um 1 erhoeht um die vorzeitige Eliminierung der Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert wenn: . die Stop-Bedingung befriedigt ist oder . die aussendende Task beendet wird bevor die Stop-Bedingung befriedigt wird.  219 ---------------------------------------------------------------- | STOP | STOP$S | | ---- | | ---------------------------------------------------------------- 2.3.2.63. STOP$S - Stoppen einer Task ------------------------------------- Fortran-Aufruf: --------------- CALL STOP ([ids]) ids = Anweisungsstatus Makro-Aufruf: ------------- STOP$S Makro-Erweiterung: ------------------ STOP$S MOV (PC)+,-(SP) ;DPB auf Stack bringen .BYTE 131.,1 ;DIC der Anweisung und Laenge DPB EMT 377 ;Trap zur Exekutive Funktionsbeschreibung: ---------------------- Die STOP$-Anweisung stoppt die aussendende Task selbst. Die Anweisung kann nicht im AST-Zustand ausgesendet werden. Eine Task, die auf diese Art und Weise gestoppt wurde, kann nur in den abarbeitungsfaehigen Zustand ueberfuehrt werden durch: - eine andere Task, die eine USTP$-Anweisung an diese Task richtet; - durch Aussenden einer USTP$-Anweisung durch diese Task selbst AST-Zustand oder - durch das MCR UNSTOP- oder DCL START-Kommando. Lokale Symboldefinitionen: -------------------------- keine Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +02 IS.SET Anweisung erfolgreich abgearbeitet -80. IE.AST Task ist im AST-Zustand -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 220 Anmerkungen: ------------ Der Rueckkehrcode IS.SET wird erst empfangen, wenn die durch STOP$S gestoppte Task durch eine USTP$-Anweisung durch das MCR- Kommando UNSTOP oder durch das DCL-Kommando START aus dem STOP- Zustand entlassen wurde.  221 ---------------------------------------------------------------- | STOP FOR SINGLE EVENT FLAG | STSE$ | | -- - - | | ---------------------------------------------------------------- 2.3.2.64. STOP fuer ein einzelnes Ereignisflag ---------------------------------------------- Fortran-Aufruf: --------------- CALL STOPFR (iefn[,ids]) iefn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- STSE$ efn efn = Ereignisflagnummer Makro-Erweiterung: ------------------ STSE$ 8. .BYTE 135.,2 ;DIC der Anweisung und Laenge des DPB .WORD 8. ;Nummer des Ereignisflags Funktionsbeschreibung: ---------------------- Die STSE$-Anweisung veranlasst die Exekutive, die aussendende Task zu stoppen bis das vereinbarte Ereignisflag gesetzt wurde. Ist das Ereignisflag bei Aussenden der Anweisung bereits gesetzt, wird die Task nicht gestoppt. Eine Task, die wegen eines Ereignisflags gestoppt ist, kann nur durch Setzen des Ereignisflags aus dem Stop-Zustand entlassen werden. Dieser STOP-Zustand kann nicht durch die USTP$-Anweisung oder die MCR-UNSTOP oder DCL-START-Kommandos aufgehoben werden. Lokale Symboldefinitionen: -------------------------- S.TSEF - Ereignisflagnummer 222 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -80. IE.AST Task ist im AST-Zustand -97. IE.IEF Ereignisflagnummer ist falsch (EFN<1 oder - wenn gruppenglobale Ereignisflags existieren fuer die Task EFN>96. -, sonst EFN>64.) -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ Ist das Ereignisflag gruppenglobal, so wird der Benutzungszaehler um 1 erhoeht, um die vorzeitige Elemenierung der Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert, wenn: - die Stop-Bedingung befriedigt wurde oder - die aussendende Task beendet wird bevor die Stop-Bedingung befriedigt ist.  223 ---------------------------------------------------------------- | SPECIFY SST VECTOR TABLE FOR DEBBUGGING AID | SVDB$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.65. SVDB$ - Spezifizieren der SST-Vektortabelle fuer eine Testhilfe ----------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- SVDB$ [adr][,len] adr = Adresse der SST-Vektortabelle len = Laenge der Tabelle in Worten (Zahl der Eintra- gungen) Makro-Erweiterung: ------------------ SVDB$ SVEKA,5 .BYTE 103.,3 ;DIC der Anweisung und Laenge des DPB .WORD SVEKA ;Adresse der Anweisung und Laenge des DPB .WORD 5 ;Laenge der Vektortabelle Funktionsbeschreibung: ---------------------- Diese Anweisung bewirkt das Festlegen der SST-Bedienungsprogramm- Eintrittspunkte, die in einer Vektortabelle vereinbart sind, fuer eine Testhilfe. Zum Aufheben der Vektortabelle werden die Parameter 'adr' und 'len' weggelassen. Wenn ein Eintrittspunkt sowohl durch eine Task als auch durch die zur Task gehoerige Testhilfe definiert ist, wird der Trap fuer die Testhilfe wirksam. Die Vektortabelle hat folgendes Format: Wort 00 - ungerade oder nichtexistierende Speicheradresse Wort 01 - Speicherschutzverletzung Wort 02 - T-Bit-Trap oder Ausfuehrung eines BPT-Befehls Wort 03 - Ausfuehrungen eines IOT-Befehls Wort 04 - Ausfuehrung eines reservierten Befehls Wort 05 - Ausfuehrung eines EMT-Befehls, der nicht von OMEX 1630 selbst benutzt wird (EMT 0 bis EMT 375) Wort 06 - Ausfuehrung eines Trap-Befehls Wort 07 - Gleitkommafehler Der Wert 'Null' in der Tabelle legt fest, dass der entsprechende SST von der Task nicht bearbeitet wird. Lokale Symboldefinitionen: -------------------------- S.VDTA - Adresse der Vektortabelle S.VDTL - Laenge der Vektortabelle 224 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist unguel- tig  225 ---------------------------------------------------------------- | SPECIFY SST VECTOR TABLE FOR TASK | SVTK$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.66. SVTK$ - Spezifizieren der SST-Vektortabelle fuer eine Task ----------------------------------------------------- FORTRAN-Aufruf: --------------- nicht verfuegbar Makro-Aufruf: ------------- SVTK$ [adr][,len] adr = Adresse der SST-Vektortabelle len = Laenge der SST-Vektortabelle Makro-Erweiterung: ------------------ SVTK$ SVEKAT,5 .BYTE 105.,3 ;DIC der Anweisung und Laenge des DPB .WORD SVEKAT ;Adresse der Vektortabelle .WORD 5 ;Laenge der Vektortabelle Funktionsbeschreibung: ---------------------- Diese Anweisung bewirkt das Festlegen der SST-Bedienungsprogramm- Eintrittspunkte, die in einer Tabelle vereinbart sind, fuer die die Anweisung enthaltende Task. Zum Aufheben der Vektortabelle werden die Parameter 'adr' und 'len' weggelassen. Wenn ein Eintrittspunkt fuer das SST-Bedienungsprogramm sowohl fuer die zur Task gehoerige Testhilfe, als auch fuer die Task vereinbart wird, so wird der entsprechende Trap der Testhilfe zugeordnet und nicht der Task. Die Vektortabelle hat folgendes Format: Wort 00 - ungerade oder nichtexistierende Speicheradresse Wort 01 - Speicherschutzverletzung Wort 02 - T-Bit-Trap oder Ausfuehrung eines BPT-Befehls Wort 03 - Ausfuehrung eines IOT-Befehls Wort 04 - Ausfuehrung eines reservierten Befehls Wort 05 - Ausfuehrung eines EMT-Befehls, der nicht von OMEX 1630 selbst benutzt wird Wort 06 - Ausfuehrung eines Trap-Befehls Wort 07 - Gleitkommafehler Der Wert 'Null' in der Tabelle legt fest, dass der entsprechende SST von der Task nicht bearbeitet wird. Lokale Symboldefinitionen: -------------------------- S.VTTA - Adresse der Vektortabelle S.VTTL - Laenge der Vektortabelle 226 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  227 ---------------------------------------------------------------- | UNLOCK GROUP GLOBAL EVENT FLAGS | ULGF$S | | - - - - | | ---------------------------------------------------------------- 2.3.2.67. ULGF$S - Aufheben des Schutzes gruppenglobaler Ereig- nisflags ---------------------------------------------------------------- Fortran-Aufruf: --------------- CALL ULGF ([ids]) ids = Anweisungsstatus Makro-Aufruf: ------------- ULGF$S [err] err = Fehlerroutinenadresse Makro-Erweiterung: ------------------ ULGF$S FEHL MOV (PC)+,-(SP) ;DPD auf Stack bringen .BYTE 159.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;TRAP zur Exekutive BCC .+6 ;Sprung, wenn Anweisung fehlerfrei abgelaufen JSR PC,FEHL ;sonst: Aufruf der Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die ULGF$-Anweisung veranlasst die Exekutive, den Benutzungszaehler fuer die gruppenglobalen Ereignisflags, die der Gruppennummer des Schutz-UIC der aussendenden Task zugeordnet sind, um 1 zu erniedrigen. Der Schutz-UIC befindet sich im Kopf der Task unter H.CUIC (Gruppennummer: H.CUIC+1). Das hebt den Schutz dieser Flags auf, die durch Anwendung der CRGF$-Anweisung geschuetzt waren. Lokale Symboldefinitionen: -------------------------- keine 228 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -17. IE.RSU Schutz der Ereignisflags durch diese Task bereits aufgehoben -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist un- gueltig Anmerkungen: ------------ - Eine Task kann gruppenglobale Ereignisflags nur einmal durch Anwendung der CRGF$-Anweisung schuetzen. Vor dem Wiedererrichten des Schutzes muss er durch die ULGF$-Anweisung aufgehoben worden sein. - Gruppenglobale Ereignisflags werden eliminiert, wenn die folgenden zwei Bedingungen erfuellt sind: 1. Der Benutzungszaehler der gruppenglobalen Ereignisflags im Group-Global-Event-Flag Steuerblock (GFB) ist Null geworden nach Ausfuehrung der ULGF$-Anweisung. 2. Der GFB ist zum Loeschen markiert.  229 ---------------------------------------------------------------- | UNMAP ADDRESS WINDOW | UMAP$ | | - --- | | ---------------------------------------------------------------- 2.3.2.68. UMAP$ - Aufheben der Adresszuweisung eines Adressfensters zu einer Region ---------------------------------------------------- FORTRAN-Aufruf: --------------- CALL UNMAP (iwdb[,ids]) iwdb = 8-Worte-Integerfeld fuer den Fenster- Definitionsblock ids = Anweisungsstatus Makro-Aufruf: ------------- UMAP$ adr adr = Adresse des Fenster-Definitionsblocks (WDB) Makro-Erweiterung: ------------------ UMAP$ ADWDB .BYTE 123.,2 ;DIC der Anweisung und Laenge des DPB .WORD ADWDB ;Adresse des WDB Funktionsbeschreibung: ---------------------- Mit der Anweisung wird die Adresszuweisung eines Adressfensters zu einer Region aufgehoben. Alle Versuche, auf die entsprechenden virtuellen Adressen nach der Aufhebung Bezug zu nehmen, scheitern und rufen einen entsprechenden Trap hervor. Mit einer MAP$- Anweisung kann das Fenster spaeter neu zugewiesen werden. Von der Exekutive im WDB benoetigte Parameter: W.NID - Fenster-Identifikation des aufzuhebenden Fensters Von der Exekutive im WDB gespeicherte Parameter: W.NSTS - folgendes Bit des Fenster-Statusworts wird modifiziert: WS.UNM = 1, falls die Aufhebung der Adresszuweisung erfolgreich war Lokale Symboldefinition: ------------------------ U.MABA - Adresse des WDB 230 Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -08 IE.ITS das Adressfenster war nicht zugewiesen -86 IE.NVW die Fenster-Identifikation ist ungueltig -98 IE.ADP ein Teil des WDB bzw. DPB liegt ausserhalb des Adressbereiches der Task -99 IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig  231 ---------------------------------------------------------------- | UNSTOP TASK | USTP$ | | - -- - | | ---------------------------------------------------------------- 2.3.2.69. USTP$ - Beenden des STOP-Zustandes -------------------------------------------- Fortran-Aufruf: --------------- CALL USTP (rtn[,ids]) rtn = Name der Task, deren STOP-Zustand beendet werden soll ids = Anweisungsstatus Makro-Aufruf: ------------- USTP$ tn tn = Name der Task, deren STOP-Zustand beendet werden soll Makro-Erweiterung: ------------------ USTP$ OTGTSK .BYTE 133.,3 ;DIC der Anweisung und Laenge des DPB .RAD50 /OTGTSK/ ;Name der Task Funktionsbeschreibung: ---------------------- Die USTP$-Anweisung hebt den STOP-Zustand fuer solche Tasks auf, die sich durch Anwendung der STOP$- oder RCST$-Anweisung selbst gestoppt haben. Task's die wegen nicht gesetzter Ereignisflags oder gepufferte E/A-Operationen gestoppt sind, werden davon nicht beeinflusst. Wird die USTP$-Anweisung fuer eine Task gegeben, die vorher gestoppt wurde unter Verwendung der STOP$- oder RCST$-Anweisung waehrend des Taskzustandes und die Task befindet sich augenblicklich im AST-Zustand, so wird die Task erst dann aus dem STOP-Zustand entlassen, wenn der AST-Zustand beendet ist. Lokale Symboldefinitionen: -------------------------- U.STTN - Taskname 232 Rueckkehrcodes: --------------- num. symb. Bedeutung Code Code ----------------------------------------------------------------- +01 IS.SUC Anweisung erfolgreich abgearbeitet -02 IE.INS angegebene Task ist nicht installiert -07 IE.ACT angegebene Task ist nicht aktiv -08. IE.ITS angegebene Task ist nicht gestoppt oder sie ist gestoppt aufgrund von Ereignisflags oder gepuffert E/A-Arbeit. -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ Die USTP$-Anweisung verursacht kein signifikantes Ereignis.  233 ---------------------------------------------------------------- | WAIT FOR SIGNIFICANT EVENT | WSIG$S | | - --- | | ---------------------------------------------------------------- 2.3.2.70. WSIG$S - Warten auf ein signifikantes Ereignis -------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL WFSNE Makro-Aufruf: ------------- WSIG$S [err] err = Adresse einer Fehlerroutine Makro-Erweiterung: ------------------ WSIG$S FEHL MOV (PC)+,-(SP) ;DIC und DPB-Laenge in den Stack speichern .BYTE 49.,1 ;DIC der Anweisung und Laenge des DPB EMT 377 ;Trap zur Exekutive BCC .+6 ;Verzweigen bei erfolgreicher Ausfuehrung JSR PC,FEHL ;Verzweigen zur Fehlerroutine 'FEHL' Funktionsbeschreibung: ---------------------- Die WSIG$S-Anweisung wird benutzt, um die Abarbeitung einer Task solange zu blockieren, bis das naechste signifikante Ereignis auftritt. Die Anweisung bewirkt selbst kein signifikantes Ereignis. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Falls eine Anweisung wegen des Fehlens von dynamischem Spei- cherbereich im dynamischen Bereich der Exekutive nicht ausge- fuehrt werden kann, ist diese Anweisung die einzige Moeglich- keit, eine Task solange zu blockieren, bis wieder dynamischer Speicherbereich zur Verfuegung steht. 234 - Die Blockierung der Task wird mit dem ersten auftretenden sig- nifikanten Ereignis aufgehoben, unabhaengig davon, ob es sich auf die die WSIG$S-Anweisung enthaltende Task bezieht oder nicht. - Signifikante Ereignisse sind: 1. Ende einer E/A-Operation; 2. Taskende; 3. erfolgreiche Abarbeitung einer SDAT$-Anweisung; 4. erfolgreiche Abarbeitung einer ALTP$-Anweisung; 5. Das Weiterschalten der Uhrwarteschlange (z.B. als Ergebnis einer MRKT$-Anweisung oder einer zeitzyklischen Taskaktivie- rung); 6. erfolgreiche Abarbeitung einer DECL$S-Anweisung; 7. erfolgreiche Abarbeitung einer SREF$- oder RREF$-Anweisung; 8. Abarbeitung der Zeitscheibensteuerung am Ende eines Zeit- scheibenintervalls. 9. erfolgreiche Abarbeitung einer SDRP$-Anweisung 10. erfolgreiche Abarbeitung einer SDRC$-Anweisung 11. erfolgreiche Abarbeitung einer EXIT$, EXST$ oder EMIT$- Anweisung  235 ---------------------------------------------------------------- | WAIT FOR LOGICAL 'OR' OF EVENT FLAG | WTLO$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.71. WTLO$ - Warten auf logisches 'ODER' der Ereignisflags --------------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL WFLOR (efn1,efn2,...efnn) efni = Reihe von Ereignisflagnummern Makro-Aufruf: ------------- WTLO$ grp,msk grp = Ereignisflaggruppe msk = 16-Bit-Flagmaskenwort Makro-Erweiterung: ------------------ WTLO$ 1,24460 .BYTE 43.,3 ;DIC der Anweisung und Laenge des DPB .WORD 1 ;Nummer der Ereignisflaggruppe .WORD 24460 ;Ereignisflags 21, 22, 25, 28, 30 Funktionsbeschreibung: ---------------------- Die Anweisung WTLO$ blockiert die Abarbeitung einer Task solange, bis mindestens eines der angegebenen Ereignisflags gesetzt ist. Ist zur Zeit der Abarbeitung dieser Anweisung schon eines der angegebenen Flags gesetzt, wird die Task nicht blockiert. Lokale Symboldefinition: ------------------------ keine Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -97. IE.IEF Ereignisflag-Maskenwort nicht spezifiziert, oder Angabe der Nummer der Ereignisflaggruppe unzulaessig (nicht 0, 1, 2, 3, 4, 5) -98. IE.ADP der DPB liegt ausserhalb des Adressraumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig Anmerkungen: ------------ - Zwischen der Nummer der Ereignisflaggruppe und den Ereignis- flags besteht folgende Zuordnung: 236 Nr. der Ereignisflaggruppe | Ereignisflags ---------------------------------------------------- | 0 | 1 - 16 1 | 17 - 32 2 | 33 - 48 3 | 49 - 64 4 | 65 - 80 5 | 81 - 96 Es besteht eine eins-zu-eins Korrespondenz zwischen dem spe- ziellen Bit im Flagmaskenwort und dem Ereignisflag in der spe- ziellen Gruppe. So ist z. B. bei der Gruppe 0 das Bit 0 dem Ereignisflag 1, das Bit 1 dem Ereignisflag 2 usw. zugeordnet. - Tritt fuer eine Task ein Wartezustand ein, werden von der Exe- kutive die Ereignisflags im allgemeinen nicht geloescht. Dies ist vom Nutzer selbst zu realisieren (Anweisung CLEF$). - Der grp-Operand muss immer in der Form n angegeben werden, unabhaengig davon, um welche Makro-Form es sich handelt (auch bei der $S-Form). - die Argumentliste, die im FORTRAN-Ruf angegeben wird, darf nur Ereignisflagnummern enthalten, die innerhalb einer Ereignisflaggruppe liegen. Werden Ereignisflagnummern angegeben, die in mehr als einer Gruppe liegen oder wird eine ungueltige Ereignisflagnummer angegeben, wird ein schwerer (Fatal) Fehler-Zustand durch FORTRAN generiert. - Hat die aussendende Task eine ausstehende gepufferte E/A- Operation, wenn sie auf das Setzen von Ereignisflags wartet, wird sie gestoppt. Befindet sich die Task im STOP-Zustand, kann sie durch eine jede andere Task ausgelagert werden, falls die gestoppte Task ueberhaupt auslagerbar ist. Die Task wird aus dem Stop-Zustand entfernt, wenn: . die ausstehende gepufferte E/A-Operation beendet wird, . die Warte-Bedingung durch Setzen von Ereignisflags befriedigt wird. - Ist die angegebene Gruppe der Ereignisflags gruppenglobal, so wird der Benutzungszaehler um 1 erhoeht, um das vorzeitige Eliminieren von Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert, wenn: . das Warten auf diese Ereignisflags beendet ist, . die die Anweisung aussendende Task beendet wird, bevor das Warten auf die Ereignisflags befriedigt wird.  237 ---------------------------------------------------------------- | WAIT FOR SINGLE EVENT FLAG | WTSE$ | | - - - - | | ---------------------------------------------------------------- 2.3.2.72. WTSE$ - Warten auf ein einzelnes Ereignisflag ------------------------------------------------------- FORTRAN-Aufruf: --------------- CALL WAITFR (efn[,ids]) efn = Ereignisflagnummer ids = Anweisungsstatus Makro-Aufruf: ------------- WTSE$ efn efn = Ereignisflagnummer Makro-Erweiterung: ------------------ WTSE$ 45. .BYTE 41.,2 ;DIC der Anweisung und Laenge des DPB .WORD 45. ;Ereignisflagnummer Funktionsbeschreibung: ---------------------- Die diese Anweisung enthaltende Task wird solange blockiert bis das angegebene Ereignisflag gesetzt ist. Ist das Flag gesetzt, wird die Task weiterbearbeitet. Ist zur Zeit der Abarbeitung der Anweisung das Ereignisflag schon gesetzt, wird die Task nicht blockiert. Lokale Symboldefinition: ------------------------ W.TSEF - Ereignisflagnummer Rueckkehrcodes: --------------- num. symb. Code Code Bedeutung ----------------------------------------------------------------- +01 IS.SUC die Anweisung wurde erfolgreich ausgefuehrt -97. IE.IEF unzulaessige Ereignisflagnummer -98. IE.ADP ein Teil des DPB liegt ausserhalb des Adress- raumes der Task -99. IE.SDP die Laenge des DPB bzw. der DIC ist ungueltig 238 Anmerkungen: ------------ - Hat die die Anweisung aussendende Task noch nicht beendete gepufferte E/A-Operationen, wenn sie auch ein einzelnes Ereignisflag wartet, so wird sie gestoppt. Wenn sich ein Task im Stop-Zustand befindet, kann sie durch jede andere Task ausgelagert werden, falls die gestoppte Task ueberhaupt auslagerbar ist. Der Stop-Zustand wird beendet, wenn: . die gepufferte E/A-Operation beendet wird, . das Ereignisflag, auf das die Task wartete, gesetzt wird. - Handelt es sich bei dem angegebenen Flag um ein gruppenglobales Ereignisflag, so wird deren Benutzungszaehler um 1 erhoeht, um ein vorzeitiges Eliminieren der Ereignisflags zu verhindern. Der Benutzungszaehler wird vermindert, wenn: . das Warten durch Setzen des Ereignisflags beendet wird, . die die Anweisung aussendende TAsk beendet wird, bevor das Warten auf das Ereignisflag befriedigt wird.  239 Anlage 1 Uebersicht der Exekutive-Anweisungen ----------------------------------------------------------------- Name Parameter Funktion ----------------------------------------------------------------- ABRT$ tsk Abbruch einer Task ALTP$ [tsk][,pri] Aendern der Prioritaet ALUN$ lun,dev,unt Zuweisen einer logischen Geraetenummer ASTX$S [err] Ende einer AST-Bedienung ATRG$ adr Binden einer Region an eine Task CINT$ vec,base,isr,edir,pri,ast Verbinden einer Task mit einem Interruptvektor CLEF$ efn Loeschen eines Ereignis- flags CMKT$ [efn,ast,err] Annullieren zeitabhaengig deklarierter signifikanter Ereignisse CNCT$ tname,[efn],[east],[esb] Synchronisierung zweier Task durch Aufbau einer Mutter/Tochter-Taskver- bindung CRAW$ adr Herstellen eines Adress- fensters CRGF$ [gruppe] Erzeugen von gruppenglo- balen Ereignisflags CRRG$ adr Herstellen einer Region CSRQ$ tsk Annullieren der zeitbezo- genen Taskaktivierung DECL$S [,err] Deklarieren eines signifi- kanten Ereignisses DSAR$S [err] Verhindern der AST-Bear- beitung DSCP$S [err] Verhindern des Auslagerns DTRG$ adr Trennen einer Region von einer Task ELAW$ adr Eliminieren eines Adress- fensters ELGF$ [gruppe] Eliminieren von gruppen- globalen Ereignisflags EMST$ [tn],stat Uebergeben eines Status- wertes ENAR$S [err] Erlauben der AST-Bearbei- tung ENCP$S [err] Erlauben des Auslagerns EXIF$ efn Bedingte Taskbeendigung EXIT$S [err] Taskbeendigung EXST$ stat Taskbeendigung mit Status- uebergabe EXTK$ [inc] Aendern der Tasklaenge GLUN$ lun,buf Uebernehmen der Informa- tionen ueber eine logische Geraetenummer GMCR$ - Uebernehmen einer Komman- dozeile GMCX$ adr Uebernehmen des gegenwaer- tigen Zustandes der Adresszuweisung 240 ----------------------------------------------------------------- Name Parameter Funktion ----------------------------------------------------------------- GPRT$ [prt],buf Uebernehmen von Parametern einer Partition GREG$ [rid],buf Uebernehmen von Parametern einer Region GTIM$ buf Uebernehmen der Zeitpara- meter GTSK$ buf Uebernehmen der Parameter einer Task IHAR$S siehe DSAR$S Verhindern der AST-Bear- beitung MAP$ adr Zuweisen eines Adressfen- sters zu einer Region MRKT$ [efn],tmg,tnt[,ast] Zeitabhaengiges Deklarie- ren eines signifikanten Ereignisses QIO$ fnc,lun,[efn],[pri],[isb],[ast][,prl] E/A-Exekutive-Anweisung QIOW$ fnc,lun,efn,[pri],[isb],[ast][,prl] E/A - Exekutive-Anweisung mit Warten auf Beendi- gung RCST$ [tn],puf Empfangen eines Daten- blockes oder STOP der Task RCVD$ tsk,buf Empfangen eines Daten- blocks RCVX$ tsk,buf Empfangen eines Daten- blocks oder Beenden der Task RDAF$ buf Lesen aller Ereignisflags RDXF$ puf Erweitertes Lesen aller Ereignisflags RPOI$ tn,,,[ugc],[umc],[par],[cl],[cll],[fb],[dn],[unit] Aktivieren einer Task und Weitergeben von Mutter/ Tochter-Taskverbindungen RQST$ tsk,[prt],[pri][,ugc,umc] Aktivieren einer Task RREF$ adr Empfangen eines Referenz- blockes RSUM$ tsk Fortsetzen einer Task RUN$ tsk,[prt],[pri],[ugc],[umc],[smg],snt[,rmg,rnt] zeitbezogenes Aktivieren einer Task SDAT$ tsk,buf[,efn] Senden eines Datenblockes SDRC$ tname,buf,[efn],[east],[esb] Senden eines Datenblockes, Aktivieren einer Task und Aufbau einer Mutter/Toch- ter-Taskverbindung SDRP$ task,bufa,bufl,[efn],[flag],[par] Senden eines Datenblockes Aktivieren einer Task und Weitergeben von Mutter/ Tochter-Taskverbindungen SETF$ efn Setzen eines Ereignisflags SFPA$ [ast] Spezifizieren von Arith-  241 ----------------------------------------------------------------- Name Parameter Funktion ----------------------------------------------------------------- metikprozessorfehler-AST SMSG$ tgt,buf,len, Senden einer Meldung SPND$S [err] Suspendieren einer Task SPRA$ [ast] Spezifizieren von Netzwie- derkehr-AST SPWN$ tname,,,[ugc],[umc],[efn],[east],[esb],[anl],[cmll], [un],[dn] Erzeugen einer Tochtertask SRDA$ [ast] Spezifizieren von Daten- empfangs-AST SREA$ [ast] Spezifizieren von Task-Ab- bruch-AST SREF$ name,adr[,efn] Senden eines Referenz- blockes SREA$ [ast] Spezifizieren von Task-Ab- bruch-AST SREX$ siehe SREA$ SRRA$ [ast] Spezifizieren von AST nach Senden von Referenz- bloecken fuer die Task STIM$ bufn,[bufa] Setzen der System-Zeit STLO$ grp,msk STOP fuer logisches 'ODER' von Ereignisflags STOP$S Stoppen einer Task STSE$ efn STOP fuer ein einzelnes Ereignisflag SVDB$ [adr][,len] Spezifizieren der SST- Vektortabelle fuer eine Testhilfe SVTK$ [adr][,len] Spezifizieren der SST- Vektortabelle fuer eine Task ULGF$S [err] Aufheben des Schutzes gruppenglobaler Ereignis- flags UMAP$ adr Aufheben der Adresszuwei- sung eines Adressfensters zu einer Region USTP$ tm Beenden des STOP-Zustandes WSIG$S [err] Warten auf ein signifikan- tes Ereignis WTLO$ grp,msk Warten auf logisches 'ODER' der Ereignisflags WTSE$ efn Warten auf ein einzelnes Ereignisflag vec Interrupt-Vektoradresse 242 Anlage 2 Zuordnung zwischen Exekutive-Anweisungen und FORTRAN- Aufrufen ---------------------------------------------------------------- | Exekutive- | FORTRAN- | Funktion | | Anweisung | Subroutine | | ---------------------------------------------------------------- | ABRT$ | ABORT | Abbruch einer Task | ALTP$ | ALTPRI | Aendern der Prioritaet | ALUN$ | ASNLUN | Zuweisen einer logischen Geraete- | | | nummer | ASTX$S | - | Ende einer AST-Bedienung | ATRG$ | ATRG | Binden einer Region | CINT$ | - | Verbinden einer Task mit einem | | | Interruptvektor | CLEF$ | CLREF | Loeschen eines Ereignisflag | CMKT$S | CANMT | Annullieren zeitabhaengig dekla- | | | rierter signifikanter Ereignisse | CNCT$ | CNCT | Synchronisierung zweier Task | | | durch Aufbau einer Mutter/Tochter | | | Taskverbindung | CRAW$ | CRAW | Herstellen eines Adressfensters | CRGF$ | CRGF | Erzeugen von gruppenglobalen | | | Ereignisflags | CRRG$ | CRRG | Herstellen einer Region | CSRQ$ | CANALL | Annullieren der zeitbezogenen | | | Taskaktivierung | DECL$S | DECLAR | Deklarieren eines signifikanten | | | Ereignisses | DSAR$S | DSASTR | Verhindern der AST-Bearbeitung | | | (identisch mit IHAR$) | DSCP$S | DISCKP | Verhindern des Auslagerns | DTRG$ | DTRG | Trennen einer Region von einer Task | ELAW$ | ELAW | Eliminieren eines Adressfensters | ELGF$ | ELGF | Eliminieren von gruppenglobalen | | | Ereignisflags | EMST$ | EMST | Uebergeben eines Statuswertes | ENAR$S | ENASTR | Erlauben der AST-Bearbeitung | ENCP$S | ENACKP | Erlauben des Auslagerns | EXIF$ | EXITIF | Bedingte Taskbeendigung | EXIT$S | EXIT | Taskbeendigung | EXST$ | EZST | Taskbeendigung mit Statusuebergabe | EXTK$ | EXTTSK | Aendern der Tasklaenge | GLUN$ | GETLUN | Uebernehmen der Informationen ueber | | | eine logische Geraetenummer | GMCR$ | GETMCR | Uebernehmen einer Kommandozeile | GMCX$ | GMCX | Uebernehmen des gegenwaertigen Zu- | | | standes der Adresszuweisung | GPRT$ | GETPAR | Uebernehmen von Parametern einer | | | Partition | GREG$ | GETREG | Uebernehmen von Parametern einer | | | Region | GTIM$ | | Uebernehmen der Zeitparameter | GTSK$ | GETTSK | Uebernehmen der Parameter einer Task | IHAR$ | INASTR | Verhindern der AST-Bearbeitung | | | (identisch mit DSAR$) | MAP$ | MAP | Zuweisen eines Adressfensters zu | | | einer Region | MRKT$ | MARK/WAIT | Zeitabhaengiges Deklarieren eines | | | signifikanten Ereignisses  243 ----------------------------------------------------------------- | Exekutive- | FORTRAN- | Funktion | | Anweisung | Subroutine | | ----------------------------------------------------------------- | QIO$ | QIO | E/A-Exekutive-Anweisung | QIOW$ | WTQIO | E/A-Exekutive-Anweisung mit Warten | | | auf Beendigung | RCST$ | RCST | Empfangen eines Datenblockes oder | | | STOP der Task | RCVD$ | RECEIV | Empfangen eines Datenblockes | RCVX$ | RECOEX | Empfangen eines Datenblockes oder | | | Beenden der Task | RDAF$ | READEF | Lesen aller Ereignisflags | RDXF$ | READEF | Erweitertes Lesen aller Ereignisflags | RPOI$ | RPOI | Aktivieren einer Task und Weitergeben | | | einer Mutter/Tochter-Taskverbindung | RQST$ | REQUES | Aktivieren einer Task | RREF$ | RREF | Empfangen eines Referenzblockes | RSUM$ | RESUME | Fortsetzen einer Task | RUN$ | RUN/START | Zeitbezogenes Aktivieren einer Task | SDAT$ | SEND | Senden eines Datenblockes | SDRC$ | SDRC | Senden eines Datenblockes, Aktivie- | | | rung einer Task und Aufbau einer | | | Mutter/Tochter-Taskverbindung | SDRP$ | SDRP | Senden eines Datenblockes, Aktivie- | | | rung einer Task und Weitergeben von | | | Mutter/Tochter-Taskverbindungen | SETF$ | SETEF | Setzen eines Ereignisflags | SFPA$ | - | Spezifizieren von Arithmetikprozes- | | | sorfehler-AST | SMSG$ | SMSG | Senden einer Meldung | SPND$S | SUSPND | Suspendieren einer Task | SPRA$ | PWRUP | Spezifizieren von Netzwieder- | | | kehr-AST | SPWN$ | SPAWN | Erzeugen einer Tochtertask | SRDA$ | - | Spezifizieren von Datenempfangs-AST | SREA$ | SREA | Spezifizieren von Task-Abbruch-AST | SREF$ | SREF | Senden eines Referenzblockes | SREX$ | SREX | siehe SREA$ | SRRA$ | - | Spezifizieren von AST nach Senden | | | von Referenzbloecken | STIM$ | SETTIM | Setzen der Systemzeit | STLO$ | SRLOR | STOP fuer logisches 'ODER' von | | | Ereignisflags | STOP$S | STOP | Stoppen einer Task | STSE$ | STOPFR | STOP fuer ein einzelnes Ereignisflag | SVDB$ | - | Spezifizieren der SST-Vektortabelle | | | fuer eine Testhilfe | SVTK$ | - | Spezifizieren der SST-Vektortabelle | | | fuer eine Task | ULGF$ | ULGF | Auheben des Schutzes gruppenglobaler | | | Ereignisflags | UMAP$ | UNMAP | Aufheben der Adresszuweisung eines | | | Adressfensters zu einer Region | USTP$ | USTP | Beenden des Stop-Zustandes | WSIG$S | WFSNE | Warten auf ein signifikantes Ereig- | | | nis | WTLO$ | WFLOR | Warten auf logisches 'ODER' der | | | Ereignisflags | WTSE$ | WAITFR | Warten auf ein einzelnes Ereignisflag 244 Anlage 3 Tabelle der DSW-Rueckkehrcodes (RC) Vorbemerkungen: --------------- - Alle RC's mit dem Praefix "IE" werden nach Abarbeitung der Exekutive-Anweisung durch setzen des C-Bits im PSW angezeigt. Alle RC's mit dem Praefix "IS" werden nach Abarbeitung der Exekutive-Anweisung durch Loeschen des C-Bits im PSW angezeigt. - Die Zahlenreihe unter der Bedeutungsangabe in der Tabelle gibt die Exekutive-Anweisung an, bei deren Abarbeitung der RC auftreten kann. Die jeweilige Zahl "nn" an 2.3.2. angefuegt, ergibt die entsprechende Nummer in der Anwenderdokumentation: Anleitung fuer den Programmierer - Teil 2 (Steuerprogrammsystem OMEX 1630), unter der die Exekutive-Anweisung beschrieben wurde. - Die RC's IS.SUC IE.SDP sind nicht auf die Exekutive-Anweisungen aufgeschluesselt worden, da sie in allen Anweisungen auftreten koennen. - Einige RC's haben von der in dieser Tabelle angegebenen Bedeutungen abweichende Bedeutungen. Im Einzelfall sollte immer die Beschreibung der Exekutive-Anweisung zu Rate gezogen werden.  245 DIREKTIVE - FEHLER - CODE ------------------------- MNEMONIK I DEZ. I OKT. I BEDEUTUNG I WERT I ================================================================= I I I IE.UPN I -1 I 377 I UNZUREICHENDER PLATZ IM DYNAMISCHEN I I I BEREICH DER EXEKUTIVE I I I (5 9 11 12 26 35 36 37 43 44 47 48 49 I I I 50 52 53 55 56 57 58 59 60 ) I I I IE.INS I -2 I 376 I TASK IST NICHT INSTALLIERT I I I (IST INSTALLIERT) I I I (1 2 13 30 43 44 46 47 48 49 50 53 59 I I I 69) I I I IE.ULN I -5 I 373 I LUN IST NICHT ZUGEWIESEN I I I (27 36 37 53) I I I IE.HWR I -6 I 372 I DRIVER IST NICHT GELADEN I I I (36 37) I I I IE.ACT I -7 I 371 I TASK IST AKTIV (IST NICHT AKTIV) I I I (1 2 9 43 44 46 47 56 69) I I I IE.ITS I -8. I 370 I WIDERSPRUCH ZUM TASKSTATUS I I I (6 15 16 20 21 22 26 39 45 46 52 53 55 I I I 57 58 60 68 69) I I I IE.CKP I -10. I 366 I TASK IST NICHT AUSLAGERBAR I I I (16 26) I I I IE.PRI I -16. I 360 I VERLETZUNG VON PRIVILEGIEN-BEDINGUNGEN I I I (1 2 5 6 10 11 12 13 17 19 34 36 37 46 I I I 47 56 59 61) I I I IE.RSU I -17. I 357 I VEKTOR WIRD SCHON BENUTZT I I I (6 11 19 38 39 40 67) I I I IE.NSW I -18. I 356 I KEIN AUSLAGERUNGSBEREICH VERFUEGBAR I I I (26) I I I IE.ILV I -19. I 355 I VEKTOR IST UNGUELTIG I I I (6) I I I IE.AST I -80. I 260 I ANWEISUNG WIDERSPRICHT DER AST-BEDIN- I I I GUNG DER TASK (WURDE/WURDE NICHT VOM I I I AST-BEDIENUNGSPROGRAMM GEGEBEN) I I I (4 28 38 52 57 58 60 62 63 64) I I I IE.MAP I -81. I 257 I ADRESSZUORDNUNGSFEHLER I I I (6) I I I IE.IOP I -83. I 255 I E/A-OPERATION IN AUSFUEHRUNG I I I (26) I I I 246 MNEMONIK I DEZ. I OKT.I BEDEUTUNG I WERT I ================================================================= IE.ALG I -84. I 254 I LAENGENANGABE IST NICHT REALISIERBAR I I I (10 26 34 50) I I I IE.WOV I -85. I 253 I FENSTERBLOECKE IM TASKKOPF NICHT I I I VORHANDEN I I I (10) I I I IE.NVR I -86. I 252 I UNGUELTIGER REGION-ID I I I (5 10 17 31 34 43 50 59 68) I I I IE.NVW I -87. I 251 I UNGUELTIGER FENSTER-ID I I I (18 34 68) I I I IE.IBS I -89. I 247 I FEHLERHAFTE PUFFERGROESSE FUER I I I SEND-DATEN I I I (50) I I I IE.LNL I -90. I 246 I LUN WIRD SCHON BENUTZT I I I (3) I I I IE.IUI I -91. I 245 I FEHLERHAFTE UIC-ANGABE I I I (11 19) I I I IE.IDU I -92. I 244 I UNZULAESSIGES GERAET/UNZULAESSIGER I I I GERAETETYP I I I (3 56) I I I IE.ITI I -93. I 243 I UNGUELTIGE ZEITPARAMETER I I I (35 47 61) I I I IE.PNS I -94. I 242 I PARTITION/REGION EXISTIERT NICHT IM I I I SYSTEM I I I (5 12) I I I IE.IPR I -95. I 241 I UNGUELTIGE PRIORITAET I I I (2) I I I IE.ILU I -96. I 240 I UNGUELTIGE LUN I I I (3 27 36 37 53) I I I IE.IEF I -97. I 237 I UNGUELTIGE EREIGNISFLAG-NUMMER I I I (7 9 19 23 35 36 37 48 49 50 51 56 59 I I I 62 64 71 72) I I I IE.ADP I -98. I 236 I DPB ODER ANDERE BLOECKE LIEGEN AUSSER- I I I HALB DES ADRESSRAUMES DER TASK I I I IE.SDP I -99. I 235 I DPB-LAENGE ODER ANWEISUNGS-DIC SIND I I I UNGUELTIG I I I IS.SET I +02 I 2 I EREIGNISFLAG WAR GESETZT I I I (7 23 38 51 36 63) I I I IS.SUC I +01 I 1 I ANWEISUNG ERFOLGREICH AUSGEFUEHRT I I I IS.CLR I +0 I 0 I EREIGNISFLAG WAR GELOESCHT I I I (7 42 51)  247 Abkuerzungsverzeichnis ---------------------- ACNT (Account File Maintenance Wartungsprogramm fuer Nutzer- Program) verzeichnisse ACP (Ancillary Control Processor) Zusatzsteuerroutine AS Anschlusssteuereinheit AFP - fuer Festplattenspeicher AFS - fuer Folienspeichereinheit AIP - fuer paralleles Interface AIS - fuer serielles Interface AKP - fuer Kassettenplatten- speicher AMB - fuer Magnetbandspeicher APR (Address Page Register) Seitenadressregister ASCII (American Standard Code entspricht KOI7-Code for Information Interchange) AST (Asynchronous Systemtrap) Asynchroner Systemtrap AT Verarbeitungsprogramm fuer Indirekt-Kommandodateien BAD (Bad Block Locator Utility) Plattenpruefprogramm BDE Bedieneinheit BOT (Begin Of Tape) Bandanfang BRU (Backup and Restore Utility) Datensicherungsprogramm BS Betriebssystem CDA (Crash Dump Analyzer) Abbruchanalyseprogramm CIB (Controller Initialization Initialisierungsblock Block) fuer die Anschlusssteuer- einheit CLI (Command Line Interpreter) Programm zur Bearbeitung von Kommandos CMP (File Compare Utility) Dateivergleichsprogramm CSI (Command String Interpreter) Kommandozeileninterpreter DCB (Device Control Block) Geraetetypsteuerblock DCL Kommandosprache DCL DDT (Driver Dispatch Table) Tabelle der Eintrittspunkte eines Drivers DEP (Debugging Program) Testprogramm DFNB (Default File Name Block) Standarddateinamenblock DIC (Directive Identifikation Code) Anweisungsidentifikationscode DMP (Dump Utility) Dateidruckprogram DPB (Directive Parameter Block) Anweisungsparameterblock DSC (Disk Save and Compress) Dateirettungs- und Ver- dichtungsprogramm DSW (Directive Status Word) Anweisungsstatuswort E/A Ein- und Ausgabe EDI (Line Text Editor) Editor EDT (Standard Editor) " EFN (Event Flag Number) Ereignisflagnummer EOF (End of File) Dateiendekennsatz EOV (End of Volume) Datentraegerendekennsatz ERL (Error Logging) Fehlerregistrierung 248 FCB (File Control Block) Dateisteuerblock FCS (File Control Services) Dateizugriffsroutinen FDB (File Descriptor Block) Dateibeschreibungsblock FD16 Datensicherungsformat FE16 Global genormte Dateiformate (Dateiformat "established") FEX (File Exchange Utility) Dateiaustauschprogramm FIFO (First in - first out) FIFO-Speicherprinzip FL16 Dateiformat LAOS 1630 FLX (File Transfer Utility) Dateiumwandlungsprogramm FMT (Format Utility) Formatierungsprogramm fuer Magnetplatten FM16 Dateiformat MOOS 1600 und OMOS 1630 FNB (File Name Block) Dateinameblock FPEM (Floating-point Emulation Program) Gleitkommaemulator FPS Festplattenspeicher FQ16 Lokal genormte Dateiformate (Datenformat "queered") FSE Folienspeichereinheit FSR (File Storage Region) Dateispeicherbereich GCML (Get Command Line) Kommandozeilenlesen HDR (Header Label) Dateianfangskennsatz ICB (Interrupt Control Block) Interruptsteuerblock ID Identifikation IESR (Interrupt Enable/Disable Service Routine) Interrupt-Erlauberoutine IOX (I/O Exerciser) Allgemeines Geraete testprogramm ISR (Interrupt Service Routine) Interrupt-Bedienroutine ITB (Interrupt Transfer Block) Interrupt-Transfer-Block KBR Kommerzielles Basisrechner- system KMBE Kassettenmagnetbandeinheit KOI-7 entspricht ASCII-Code KPS Kassettenplattenspeicher KROS Kombinat Robotron Standard LBL Lochbandleser LBN (Logical Block Number) Logische Blocknummer LBR (Librarian Utility) Bibliothekar LC (Location Counter) Speicherplatzzaehler des Assemblers LUN (Logical Unit Number) logische Geraetenummer LUT (Logical Unit Table) Tabelle der logischen Geraetenummern LP (Line Printer) Zeilendrucker MAC Makro-Assembler MBG Magnetbandgeraet MCR (Monitor Console Routines) Kommandoprogramm MFD (Master File Directory) Hauptdateiverzeichnis MGS Mikrorechnergeraetesystem MOEX Exekutive des MOOS MOOS 1600 Modulares Operationssystem  249 NP Nutzerprogramm OCB (Offspring Control Block) Block zur Steuerung der Mutter/Tochter-Taskverbindung ODT (On-Line Debugging Tool) Testprogramm OMEX Exekutive des OMOS OMOS 1630 Optimiertes Modulares Betriebssystem PAR (Page Address Register) Seitenadressregister PAT (Object Module Patch Utility) Objektmodul-Korrekturprogramm PC (Program Counter) Befehlszaehler PCB (Partition Control Block) Partitionsteuerblock PDR (Page Description Register) Seitenbeschreibungsregister PIP (Peripheral Interchange Dateitransferprogramm Program) PRESRV (Preservation Utility) Duplizier- und Sicherungs- programm PRT (Print spooler) Print-Spooler PSW (Processor Status Word) Prozessorstatuswort RAM (Random Access Memory) Speicher mit wahlfreiem Zu- griff RDB (Region Definition Block) Region-Definitionsblock SCB (Status Control Block) Statussteuerblock SD Seriendrucker SHF (Shuffler) Speicherverdichtungsprogramm SLP (Source Line Processor) Quelltext-Korrekturprogramm SKR System der Kleinrechner SP (Stack-pointer) Stackpointer, Kellerzeiger SR (Status Register) Statusregister SRD (Sort Directory Program) Sortierprogramm fuer Verzeichnisdateien SST (Synchronous Systemtrap) Synchroner Systemtrap STD (System Task Directory) Systemtaskverzeichnis SVE Speichervermittlungseinheit TCB (Task Control Block) Tasksteuerblock TKB (Task Builder) Taskbilder TKTN (Task Termination Noti- Mitteilungsroutine fuer Task- fication Routine) beendigung UCB (Unit Control Block) Geraetesteuerblock UFD (User File Directory) Nutzerdateiverzeichnis UIC (User Identification Code) Nutzeridentifikationscode UHL (User Header Label) Nutzereigene Dateikennsaetze UTL (User Trailer Label) " UVL (User Volume Label) " VB (Virtual Block) Virtueller Block VBN (Virtual Block Number) Virtuelle Blocknummer VCB (Volume Control Block) Datentraegersteuerblock VFY (File Structure Verification Dateipruefprogramm Utility) VMR (Virtual Monitor Console Virtuelles Kommandoprogramm Routine) 250 VOL (Volume Label) Datentraegerkennsatz WDB (Window Definition Block) Fenster-Definitionsblock XDT (Executive Debugging Tool) Exekutivetesthilfe ZAP (Task Image File Patch) Dateikorrekturprogramm ZVE Zentrale Verarbeitungseinheit  251 Sachwortverzeichnis ------------------- Seite Adressraum, logischer 38 Adressraum, virtueller 38 Adresszuweisung 39 Anweisungs-Identifikationscode 9 Anweisungsparameterblock 9,70 Anweisungsstatuswort 9,14 Auslagerbarkeit 21 Auslagerung 151 Auslagerung, zeitgesteuerte 21 Bearbeitungszustand 21 Befehlszaehler 30,31,33 Carry-Bit 9,14 Common-Ereignisflag 25 DIR$-Anweisung 12 Datensektion 10 Dienstprogramm 68 E/A-Anforderung 76 E/A-Anforderungen 74 Endemeldung 72 Ereignisflag 15,94 Ereignisflag, gruppenglobal 25 Ereignisflag, lokal 25 Ereignisflag-Maskenwort 33 Ereignisflagnummer 24,70 Exekutive-Anweisung 9 FORTRAN 71 Fehlerende 72 Fehlerroutine 11,12,15 Fenster-Definitionsblock 47 Fenster-Statuswort 49 Forkebene 83 GETADR-Subroutine 18 Generierung 7 Geraete, periphere 56 Geraetebezeichnung 57 Geraetename 57 Geraetenummer, logische 56,70,76 Informationsaustausch 56 Informationsbloecke 13 Installieren 19 Integer-Parameter 18 Interrupt-Transfer-Block 83 Interruptebene 83 Kommandoprogramm 60,68 Kommandozeile 60 Kommunikation 56,60 Kompatabilitaet 70 252 Laufprioritaet 74 Liste der aktiven Tasks 104 Makro 10 Modifikation 10,11 Multiprogrammierung 19 Mutter/Tochter-Taskverbindung 61,63 Nullgeraet 57,58 Nutzeridentifikationscode 169,179 Objektmodul 19 Offset 13 Partition, nutzergesteuerte 38 Partition, systemgesteuerte 38,99 Partitionzuteilung 74 Peripherie 56 Prioritaet 20,70 Programmsektion 10,11 Prozessorstatuswort 31,33 Pseudogeraete 57 Reaktionszeit 20 Region-Definitionsblock 40 Region-Statuswort 53 Rueckkehrcode 15 Software-Interrupt 29 Spawing 63 Speicherbereich, dynamischer 33 Speicherraum, physisch 38 Stack 9,11,30 Stackpointer 12 Status 64,65,114 STOP-Bit 27,29 Subpartition 39 Subroutine 17 Symbol, global 13 Symbol, lokal 13 Systemidentifikation 112 Systeminformation 56,60 Systemmakrobibliothek 10 Systemressourcen 15 Systemstatus 24 Systemtask 68 Systemtaskverzeichnis 19 Task 19,20 Task, aktuelle 20 Taskabbild-Datei 19 Taskbuilder 19 Taskebene 83 Taskname 17 Taskstatus 19 Tasksteuerblock 19 Testhilfe 30 Ueberlagerung, plattenbezogene 38 Ueberlagerung, speicherresidente 38  253 Ueberlagerungssegment 38 Unterbrechungsstelle 32 Vektortabelle 31 Wahlparameter 17,70 Warteposition 21 Warteschlange 32 Wurzelsegment 38 Zahlen in den Parameterketten 70 Zeiteinheit 147 Zeitgroesse 148 Zeitparameter 178 Zeitscheibensteuerung 21,24 Zustand, abarbeitungsfaehig 20 Zustand, aktiv 20 Zustand, blockiert 20 Zustand, gestoppt 19 Zustand, ruhend 19 Zustandswechsel 20 254