ICL VME

Virtuell maskinmiljö

Utvecklare	International Computers Limited , Fujitsu
Skrivet i	S3 , C
Arbetstillstånd	Nuvarande
Initial release	mitten av 1970-talet
Plattformar	ICL 2900-serien , ICL-serien 39 stordatorer
Påverkad av	Multics , George 3
Licens	Proprietär kommersiell programvara
Officiell hemsida	VME webbplats

VME ( Virtual Machine Environment ) är ett stordatoroperativsystem utvecklat av det brittiska företaget International Computers Limited ( ICL, nu en del av Fujitsu -gruppen). Ursprungligen utvecklat på 1970-talet (som VME/B , senare VME 2900 ) för att driva ICL:s då nya stordatorer i 2900-serien , är operativsystemet nu känt som OpenVME med ett Unix- undersystem och körs även på ICL Series 39 och Trimetra stordatorer. som branschstandard x64- servrar.

Ursprung

Utvecklingsprogrammet för New Range- systemet startade vid sammanslagning av International Computers and Tabulators (ICT) och English Electric Computers 1968. Ett av de grundläggande besluten var att det skulle ha ett nytt operativsystem. Ett antal olika genomförbarhets- och designstudier genomfördes inom ICL, de tre mest anmärkningsvärda är:

• VME/B (ursprungligen System B), riktad till stora processorer som 2970/2980 och utvecklad i Kidsgrove , Staffordshire och West Gorton , Manchester
• VME/K (ursprungligen System T), inriktat på mellanklasssystem som 2960 och utvecklat på Bracknell efter att den ursprungliga designen för dessa små processorer, System D, lades ner. VME/K utvecklades och introducerades på marknaden men ersattes så småningom av VME/B
• VME/T, som faktiskt aldrig lanserades, men förtjänar ett omnämnande eftersom det var tänkt att stödja "feltolerans", och föregick det framgångsrika amerikanska startupföretaget Tandem Computers ansträngningar på detta område.

Huvudarkitekten för VME/B var Brian Warboys , som därefter blev professor i mjukvaruteknik vid University of Manchester . Ett antal influenser kan ses i dess design, till exempel Multics och ICLs tidigare operativsystem George 3 ; men det var i huvudsak designat från grunden.

VME/B ansågs främst konkurrera med System/370 IBM stordator som ett kommersiellt operativsystem, och antog teckenkodningen EBCDIC .

Historia

När New Range först lanserades i oktober 1974, kallades dess operativsystem "System B". När den först levererades hade den blivit "VME/B".

VME/K utvecklades oberoende (enligt Campbell-Kelly, "på ett infall av Ed Mack"), och levererades senare med de mindre stordatorerna som 2960. Vid den tiden plågades VME/B fortfarande av prestanda- och tillförlitlighetsproblem , och den huvudsakligen amerikanska ledningsgruppen hade betänkligheter om det.

ICL hade sålt ett stort system till European Space Agency för att bearbeta data från Meteosat vid dess operationscenter i Darmstadt . En skräddarsydd variant av VME/K, känd som VME/ESA, utvecklades på plats för att möta kundens krav.

Efter en finanskris 1980 togs en ny ledning in i ICL (Christopher Laidlaw som ordförande och Robb Wilmot som verkställande direktör). Ett tidigt beslut av den nya ledningen var att lägga ner VME/K. Sålunda i juli 1981 lanserades "VME2900": även om den presenterades för kundbasen som en sammanslagning av VME/B och VME/K, var den i verkligheten VME/B-basen med några utvalda funktioner från VME/K ympade på. Detta gav möjligheten att släppa några föråldrade funktioner, som förblev tillgängliga för kunder som behövde dem i form av alternativet "BONVME".

Suffixet "2900" togs bort vid systemversion 213 (SV213) när ICL lanserade Series 39 1985 som efterföljaren till den ursprungliga 2900-serien; och prefixet "Öppna" lades till efter SV294. VME blev kapabel att vara värd för applikationer som ursprungligen skrivits för Unix genom ett UNIX System V Release 3- baserat undersystem, kallat VME/X, anpassat för att köras under VME och med ASCII -teckenkodning.

2007 tillkännagav Fujitsu en VME-version som körs som ett värdundersystem, kallat superNova , inom Microsoft Windows , eller SUSE eller Red Hat Enterprise Linux på x86-64- hårdvara.

2012 meddelade VME-användargruppen, AXiS, att den efter nästan 40 år skulle upplösas på grund av den minskade användarbasen.

Fujitsu hade för avsikt att stödja VME på kunddatorer fram till 2020.

Under 2020 överförde Fujitsu 13 HM Revenue and Customs -applikationer från sina datorer till Fujitsus virtuella hanterade VME-värdplattform.

Från och med 2022 använde avdelningen för arbete och pensioner fortfarande VME-baserade system för att stödja statliga pensionsutbetalningar .

Arkitektur

VME är strukturerat som en uppsättning lager, där varje lager har tillgång till resurser på olika abstraktionsnivåer. Virtuella resurser som tillhandahålls av ett lager är konstruerade från de virtuella resurser som erbjuds av lagret nedan. Åtkomst till resurserna för varje lager kontrolleras genom en uppsättning åtkomstnivåer: för att en process ska kunna använda en resurs på en viss åtkomstnivå måste den ha en åtkomstnyckel som ger åtkomst till den nivån. Konceptet liknar "skyddsringarna" i Multics . Arkitekturen tillåter 16 åtkomstnivåer, varav de yttre 6 är reserverade för kod på användarnivå.

Ortogonalt mot åtkomstnivåerna gör operativsystemet resurser tillgängliga för applikationer i form av en virtuell maskin. En virtuell maskin kan köra flera processer. I praktiken är en VME Virtual Machine närmare konceptet med en process på andra operativsystem, medan en VME-process är mer som en tråd. Allokeringen av resurser till en virtuell maskin använder en stackmodell: när stacken släpps frisläpps alla resurser som allokerats på den stacknivån. Anrop från en applikation till operativsystemet görs därför av ett anrop som behåller samma processstack, men med en ändring i skyddsnivå; den resulterande effektiviteten av systemanrop är en av funktionerna som gör arkitekturen konkurrenskraftig.

Kommunikation mellan virtuella maskiner uppnås med hjälp av händelser (benämnda kommunikationskanaler) och delade minnesområden. Hårdvaruarkitekturen tillhandahåller också semaforinstruktioner INCT (öka-och-testa) och TDEC (testa-och-minskning).

Filer och andra beständiga objekt registreras i ett arkiv som kallas katalogen. Till skillnad från andra operativsystem är filnamnshierarkin oberoende av platsen för en fil på ett visst band eller diskvolym. I dagar då det fanns mer behov av offlinelagring gjorde detta det enkelt att hålla reda på filer oavsett var de var och att flytta filer mellan platser utan att döpa om dem. Förutom filer håller katalogen reda på användare och användargrupper, volymer, enheter, nätverksanslutningar och många andra resurser. Metadata för filer kan lagras i ett objekt som kallas en filbeskrivning. Katalogen var förmodligen det första exemplet på vad som senare skulle kallas en entitetsrelationsdatabas.

Avbrott hanteras genom att skapa en ny stackram på stacken för den relevanta processen, hantera avbrottet med den nya miljön och sedan poppa stacken för att återgå till den avbrutna processen.

Runtime-undantag, kallade kontingenser , fångas upp av Object Program Error Handler (OPEH), som kan producera en rapport (motsvarande en stackspårning ), antingen interaktivt eller skriven till en journal.

OMF

Kompilerad objektkod underhålls i ett format som kallas OMF (Object Module Format). Till skillnad från i många andra operativsystem är detta också formatet som används av laddaren. Olika kompilatorer finns tillgängliga, såväl som verktyg, särskilt Collector, som länkar koden i flera OMF-moduler till en enda modul, för effektivare laddning under körning, och Module Amender, som tillåter patchning av instruktionerna i en OMF modul för att fixa buggar med hjälp av assemblerspråksyntax.

SCL

Kommandospråket för VME är känt som SCL (System Control Language).

Detta är mycket mer igenkännligt ett maskinskrivet programmeringsspråk på hög nivå än jobbkontroll- eller skalspråken som finns i de flesta andra operativsystem: det kan liknas vid skriptspråk som JavaScript , även om dess ytsyntax härrör från Algol 68 .

SCL är utformad för att tillåta både rad-i-åt-gång interaktiv användning från en konsol eller från en kommandofil , och skapande av körbara skript eller program (när språket kompileras till objektmodulformat på samma sätt som alla andra VME-programmeringar språk). Deklarationen av en procedur inom SCL fungerar också som definitionen av ett enkelt formulär eller mall som gör att proceduren kan anropas från en interaktiv terminal, med fält validerade enligt datatyperna för de underliggande procedurparametrarna eller med hjälp av standardvärdena för procedurens parametervärden.

Den inbyggda kommandovokabulären använder en konsekvent namnkonvention med ett imperativt verb följt av ett substantiv: till exempel DELETE_FILE eller DISPLAY_LIBRARY_DETAILS. Kommandot kan skrivas i sin helhet eller i en förkortad form som kombinerar standardförkortningar för verbet och substantivet: till exempel XF (X för DELETE, F för FIL) eller DLBD (D för DISPLAY, LB för LIBRARY, D för DETAILS) .

SCL är blockstrukturerad, med start-/slutblock som tjänar de dubbla och kompletterande rollerna att definiera den lexikaliska omfattningen av variabeldeklarationer, och definiera de punkter där resurser som förvärvats från operativsystemet ska släppas. Variabler i språket (som är tillgängliga från applikationer i form av miljövariabler ) kan ha ett antal enkla typer som strängar, supersträngar (sekvenser av strängar), booleaner och heltal, och används även för att innehålla referenser till systemresurser som filer och nätverksanslutningar.

Det är möjligt att "demontera" ett SCL-program från OMF tillbaka till SCL-källkoden med kommandot READ_SCL (eller RSCL). Utdata är dock inte alltid perfekt och kommer ofta att innehålla fel som skulle stoppa omkompileringen utan användaringripande.

Ett enkelt kodexempel kan ses på webbplatsen 99 bottles of beer .

Ett mer realistiskt exempel, där SCL används för att kompilera ett program skrivet i S3 , visas nedan. Detta exempel är hämtat från Columbia University Archive av implementeringar av Kermit .

BÖRJA NÄR RESULTAT GT 0 +_ DÅ +_ SEND_RESULT_MESSAGE (RES = RESULTAT, ACT = "QUIT()") FI INT KMT_SRC, KMT_OMF, KMT_REL ASSIGN_LIBRARY (NAM = KERMIT.SOURCE, LNA = KMT_SRC) ASSIGNOMRYF (BÖRJA) , LNA = KMT_OMF) ASSIGN_LIBRARY (NAM = KERMIT.REL, LNA = KMT_REL) BÖRJA DELETE_FILE (NAM = *KMT_OMF.KMT_DATA_MODULE(101)) DELETE_FILE (NAM = *KMT_OMF.KMT_OMF.KMT_TEMFIKOMLE (10MT_0MKF) (101) MT_EH_MODULE (101)) DELETE_FILE (NAM = *KMT_OMF.KMT_FH_MODULE(101)) DELETE_FILE (NAM = *KMT_OMF.KMT_HELP_MTM(101)) DELETE_FILE (NAM = *KMT_OMF.KMT_MAIN_FILE)(ELEMKMT_MAIN_FILE) (101) _MODUL(101 )) DELETE_FILE (NAM = *KMT_OMF.KMT_PP_MODULE(101)) DELETE_FILE (NAM = *KMT_OMF.KMT_SP_MODULE(101)) DELETE_FILE (NAM = *KMT_OMF.KMT_SP_MTM (101) *DUOMFIL (101))_1MOMFTE_FILE) 01)) Delete_file (nam = *kmt_rel.kermit (101)) delete_file (nam = *kmt_rel.kermit_module (101)) slut s3_compile_defaults (lis = object & xref, dis = fellines) s3_compile (inp = *kmt_src.kmt_mt_, om 101), 101) = *KMT_OMF.KMT_DATA_MODULE(101)) S3_COMPILE (INP = *KMT_SRC.KMT_DH_MODULE(101), OMF = *KMT_OMF.KMT_DH_MODULE(101)) S3_COMPILE (INP = *KMT_SRC.KMT_OMF.KMT_OMF_101)) H_MODUL( 101)) S3_COMPILE (INP = *KMT_SRC.KMT_FH_MODULE(101), OMF = *KMT_OMF.KMT_FH_MODULE(101)) NEW_MESSAGE_TEXT_MODULE (CON = *KMT_SRC.KMT_HELP_MTM(101)_OMF_OMF1)_OMF_MTM(101)_OMFTM1) SLM 3_KOMPIERA (INP = *KMT_SRC.KMT_MAIN_MODULE(101), OMF = *KMT_OMF.KMT_MAIN_MODULE(101)) S3_COMPILE (INP = *KMT_SRC.KMT_PH_MODULE(101), OMF = *KMT_OMF.KMT_OMF.KMT_PH_MODULE(101), S3MT_PH_MODULE(101) S3MTPRC. _MODUL( 101), OMF = *KMT_OMF.KMT_PP_MODULE(101)) S3_COMPILE (INP = *KMT_SRC.KMT_SP_MODULE(101), OMF = *KMT_OMF.KMT_SP_MODULE(101)) =NEW_MESSAGE_TEXT_MODULE(101) =_TM_MESSAGE_TEXT_MODULE (OM_MESSAGE_TEXT_MODULE (KMFM_1) KMT_OMF.KMT_SP_MTM(101)) S3_KOMPIL (INP = *KMT_SRC.KMT_UI_MODULE(101), OMF = *KMT_OMF.KMT_UI_MODULE(101)) SAMLA () ---- INPUT(*KMT_OMF.KMT_0FMO.KMT_DATA_MODULE(KMT_0MOOM) (101) & *KMT_OMF.KMT_EH_MODULE(101) & *KMT_OMF.KMT_FH_MODULE(101) & *KMT_OMF.KMT_HELP_MTM(101) & *KMT_OMF.KMT_MAIN_MODULE(101) & *KMT_KFOM_) & *KMT_1. MT_PP_MODULE(101 ) & *KMT_OMF.KMT_SP_MODULE(101) & *KMT_OMF.KMT_SP_MTM(101) & *KMT_OMF.KMT_UI_MODULE(101)) NEWMODULE(*KMT_REL.KERMIT_MODULE(101)) UPPRESSNING_ KOMPLETTERA_TILLFÖR+ KOMPONERA_TILLFÖR+ KOMPLETTERA_LMOG E_SCL (INP = *KMT_SRC.KERMIT(101), OUT = *KMT_REL.KERMIT(101), COD = NOTIFWARNINGS, OPT = FIL) END

Kommandon som illustreras i det här fragmentet inkluderar WHENEVER (deklarerar felhanteringspolicy), ASSIGN_LIBRARY (binder ett lokalt namn för en filkatalog), DELETE_FILE (gör en permanent fil tillfällig, och den raderas sedan i slutet av blocket), S3_COMPILE (kompilerar ett program skrivet i S3: detta kommando bryter den vanliga verb-substantiv-konventionen), NEW_MESSAGE_TEXT_MODULE (skapar en modul som innehåller parametriserade felmeddelanden lämpliga för lokalisering) och COMPILE_SCL, som kompilerar ett SCL-program till objektkod.

COLLECT-kommandot kombinerar olika objektkodsmoduler till en enda modul och drivs av sin egen lokala kommandofil som är inbyggd i SCL mellan avgränsningarna "----" och "++++". Underkommandona INPUT och NEWMODULE identifierar namnen på ingångs- och utgångsmodulerna; SUPPRESS och RETAIN bestämmer den externa synligheten för namngivna procedurer inom den insamlade modulen; och LISTMODULE begär en rapport som beskriver utgångsmodulen.

Anteckna det "." används för att separera delarna av ett hierarkiskt filnamn. En inledande asterisk anger ett lokalt namn för ett bibliotek, bundet med kommandot ASSIGN_LIBRARY. Siffran inom parentes efter ett filnamn är ett generationsnummer. Operativsystemet associerar ett generationsnummer till varje fil, och förfrågningar om en fil får den senaste generationen om inte annat anges. Att skapa en ny fil kommer som standard att skapa nästa generation och lämna den föregående generationen intakt; detta program väljer dock medvetet att skapa generation 101, för att identifiera en offentlig utgåva.

Förbättrade säkerhetsvarianter

Som ett resultat av ICL:s stora engagemang med leverans av datortjänster till den brittiska offentliga sektorn, i synnerhet de med speciella säkerhetskrav som OPCON CCIS , var det en tidig nybörjare på marknaden för säkra system .

VME utgjorde en kärna av ICL:s verksamhet inom Secure Systems arenan. Det hade fördelen att som det sista storskaliga operativsystemet som någonsin designats, och ett som byggts från grunden, omfattade dess underliggande arkitektur många av de primitiver som behövs för att utveckla ett säkert system, särskilt de maskinvaruassisterade åtkomstkontrollregistren (ACR) för att begränsa till privilegier som kan tas av alla processer (inklusive användare).

Detta ledde till att den brittiska regeringens Central Computing and Telecommunications Agency ( CCTA ) finansierade Project Spaceman i mitten av 1980-talet för ICL Defence Technology Center (DTC) för att utveckla en förbättrad säkerhetsvariant av VME. ICL lanserade detta som ett par kompletterande produkter, där den kommersiella versionen heter High Security Option (HSO), och releasen för den offentliga sektorn, inklusive Government Furnished Encryption (GFE)-teknologier, kallas Government Security Option (GSO).

HSO och GSO testades formellt under CESG UK (Security) Evaluation Scheme, en av föregångarna till ITSEC och Common Criteria , och blev därmed det första vanliga operativsystemet som formellt certifierats.

Serie 39

Series 39-serien introducerade Nodal Architecture, en ny implementering av distribuerat delat minne som kan ses som en hybrid av ett multiprocessorsystem och en klusterdesign . Varje maskin består av ett antal noder och varje nod innehåller sin egen orderkodsprocessor (CPU) och huvudminne. Virtuella maskiner är vanligtvis placerade (när som helst) på en nod, men har förmågan att köras på vilken nod som helst och att flyttas från en nod till en annan. Skivor och annan kringutrustning delas mellan noder. Noder ansluts med hjälp av en optisk höghastighetsbuss, som används för att förse applikationer med ett virtuellt delat minne. Minnessegment som är markerade som delade (offentliga eller globala segment) replikeras till varje nod, med uppdateringar som sänds över nätverket mellan noderna. Processer som använder odelade minnessegment (nodala eller lokala) körs helt isolerade från andra noder och processer.

Utvecklingsprocess

VME skrevs ursprungligen nästan helt i S3 , ett specialdesignat systemprogrammeringsspråk baserat på Algol 68R (dock skrevs VME/K huvudsakligen på SFL assemblerspråk). Även om ett språk på hög nivå används är operativsystemet inte utformat för att vara oberoende av den underliggande hårdvaruarkitekturen: tvärtom är mjukvaru- och hårdvaruarkitekturen nära integrerade.

av 1990-talet och framåt skrevs några helt nya VME-delsystem helt eller delvis i programmeringsspråket C.

Från dess tidigaste dagar utvecklades VME med hjälp av ett programvarutekniskt förvarssystem känt som CADES , ursprungligen designat och förvaltat av David Pearson (datavetare) och byggt för ändamålet med hjälp av en underliggande IDMS- databas. CADES är inte bara ett versionskontrollsystem för kodmoduler: det hanterar alla aspekter av mjukvarans livscykel från kravfångst, designmetodik och specifikation till fältunderhåll. CADES användes i VME-modulutveckling för att hålla separata definitioner av datastrukturer (Modes), konstanter (Literals), procedurgränssnitt och kärnalgoritmerna. Flera versioner ("Liv") av var och en av dessa komponenter kan existera. Algoritmerna skrevs i System Development Language (SDL), som sedan konverterades till S3- källa av en förprocessor. Flera versioner av samma moduler kan genereras.

Verktyg för applikationsutveckling

De applikationsutvecklingsverktyg som erbjuds med VME delas in i två kategorier:

• tredje generationens programmeringsspråk
• fjärde generationens QuickBuild-verktygsuppsättning.

Verktygsuppsättningen på VME är ovanligt homogen, med de flesta kunder som använder samma kärnuppsättning av språk och verktyg. Som ett resultat är verktygen också mycket väl integrerade. Tredjepartsverktyg har gjort relativt lite intryck.

Under många år skrev den stora majoriteten av VME-användare applikationer i COBOL , vanligtvis med hjälp av IDMS- databasen och TPMS - transaktionsbearbetningsmonitorn . Andra programmeringsspråk inkluderade Fortran , Pascal , ALGOL 68RS , Coral 66 och RPG2 , men dessa tjänade minoritetsintressen. Senare, i mitten av 1980-talet, blev kompilatorer för C tillgängliga, både inom och utanför Unix-subsystemet, till stor del för att möjliggöra portering av programvara såsom relationsdatabassystem . Det är intressant att en PL/I- delmängdskompilator skrevs av EEC, för att hjälpa till att portera program från IBM till ICL-hårdvara.

De kompilatorer som utvecklats inom ICL delar en gemensam arkitektur och delar i vissa fall komponenter som kodgeneratorer. Många av kompilatorerna använde en modul som heter ALICE [Assembly Language Internal Common Environment] och producerade en tidig form av förkompilerad kod (P-Code) kallad ROSE, vilket gjorde att kompilerade OMF-bibliotek (Object Module Format) kan laddas på alla maskiner i serien. .

Systemprogrammeringsspråk: S3 och SFL

Det primära språket som används för att utveckla både själva VME-operativsystemet och annan systemprogramvara som kompilatorer och övervakare för transaktionsbearbetning är S3 . Detta är ett högnivåspråk baserat på många sätt på Algol 68 , men med datatyper och lågnivåfunktioner och operatörer som är nära anpassade till arkitekturen i 2900-serien.

Ett assemblerspråk SFL ( S ystem Function L anguage) är också tillgängligt . Detta användes för utvecklingen av VME/K, vars designers inte var säkra på att ett språk på hög nivå kunde ge adekvat prestanda, och även för IDMS-databassystemet på grund av dess ursprung som en tredjepartsprodukt. SFL kallades ursprungligen M acro A ssembler P rogramming L anguag E (MAPLE), men eftersom 2900-arkitekturen hölls på att bestå av språkmaskiner på hög nivå ändrades namnet på begäran av ICL Marketing. Det hade utvecklats som en del av verktygslådan för System D, som sedan avbröts. Besläktade familjer av montörer för andra arkitekturer (CALM-xx körs under VME, PALM-xx utvecklad i Pascal och körs på olika värdar) utvecklades för internt bruk.

Varken S3 eller SFL marknadsfördes någonsin som ett kommersiellt utvecklingsverktyg för slutanvändarapplikationer, eftersom de inte normalt levererades som en standarddel av operativsystemet, och de marknadsfördes inte uttryckligen som egna produkter. Både SFL och S3 var dock tillgängliga som tillval för användarorganisationer och tredje parter som hade ett specifikt behov av dem.

QuickBuild

QuickBuild-applikationsutvecklingsmiljön på VME har varit mycket framgångsrik trots att applikationer till stor del är låsta i VME-miljön. Denna miljö är centrerad på Data Dictionary System (DDS, även kallat OpenDDS), ett tidigt och mycket framgångsrikt försök att bygga ett omfattande arkiv som stödjer alla andra verktyg, med fullt stöd för utvecklingens livscykel. Förutom databasscheman och fil- och postbeskrivningar håller ordboken reda på objekt som rapporter och frågor, skärmdesigner och 4GL-kod; den stöder också en mängd olika modeller på kravfångningsnivån, såsom enhetsrelationsmodeller och processmodeller.

QuickBuild 4GL är förpackad i två former:

• ApplicationMaster för att skapa TP-applikationer online
• ReportMaster för batchrapportering.

Båda är deklarativa språk på hög nivå och använder Jackson Structured Programming som sitt designparadigm. ApplicationMaster är ovanlig i sin inställning till applikationsdesign genom att den fokuserar på användarsessionen som om den kördes i en enda konversationsprocess, vilket helt döljer komplexiteten i att upprätthålla tillstånd över användarinteraktioner. Eftersom 4GL och andra verktyg som skärmdesignern bara fungerar med DDS-ordboken, som också innehåller databasscheman, finns det avsevärd återanvändning av metadata som sällan uppnås med andra 4GL:er.

Källor

• Arkitekturen för OpenVME . Nic Holt. ICL-publikation 55480001. Odaterad (troligen runt 1995)

externa länkar

• VME - Into the Future , Fujitsu Storbritannien.