Meer

Gegevensgestuurde pagina's gebruiken voor paginanummers met telling?

Gegevensgestuurde pagina's gebruiken voor paginanummers met telling?


Ik heb een set van 100 datagedreven pagina's met verschillende wegen. Ik wil het kaartenboek over de weg exporteren. bijv. één weg zal één pdf zijn, een andere weg wordt geëxporteerd naar een andere pdf.

Het probleem dat ik heb is met de paginanummering. Ik heb elke pagina ingesteld op een dynamisch paginanummer met telling. Op dit moment, wanneer ik export Weg A, de paginanummers tonen 'Pagina 1 van 100', 'Pagina 2 van 100' etc.

ik wil Weg A om 'Pagina 1 van 5', 'Pagina 2 van 5', enz. te hebben dan Weg B heeft 'Pagina 1 van 2', 'Pagina 2 van 2'.

Ik weet niet hoe ik dit moet doen, ik weet zeker dat ik het al eens eerder heb gedaan, maar mijn vreselijke geheugen laat me in de steek!


Vergelijkbaar met een eerdere vraag (De toename van het aantal pagina's van gegevensgestuurde pagina's regelen met ArcPy?).

Er is een manier om dynamische paginanummers te omzeilen.

Zorg er allereerst voor dat in uw paginanummerveld al uw paginanummers zijn zoals u ze wilt (bijv. Weg A gaat maar tot 5, weg B begint bij 1)

Voeg dynamische tekst toe vanuit de werkbalk voor gegevensgestuurde pagina's >> Paginatekst >> Gegevensgestuurde paginakenmerk. Kies het PageNumber attribuut. Dubbelklik op de tekst. En verander het in iets als dit:

Bladzijde  van 5

Hiermee wordt Pagina # van 5 weergegeven of welk nummer u ook opgeeft aan het einde. Doe hetzelfde voor weg B, maar verander de 5 in een 2

Ook wat extra lectuur over dynamische tekst


Kaartseries kunnen zonder enige scripting worden gemaakt door de Data Driven Pages-werkbalk vanuit ArcMap te gebruiken. Het omgekeerde is ook waar: kaartseries kunnen volledig worden gescript met arcpy.mapping zonder de gebruikersinterface van Data Driven Pages in ArcMap te gebruiken, maar er zijn goede redenen om beide technieken te combineren. De ArcMap Data Driven Pages-werkbalk biedt mogelijk niet genoeg opties voor het maken van de "perfecte" kaartserie, maar het inherente gedrag van een Data Driven Pages-enabled kaartdocument kan veel regels code besparen omdat de pagina-extensies, schalen, dynamische tekst en enzovoort, worden allemaal automatisch beheerd in het kaartdocument, zodat er geen code hoeft te worden geschreven.

Een voorbeeld hiervan is een scenario waarin de tekenreeksinformatie van een tekstelement moet worden opgemaakt met behulp van aangepaste logica of moet worden opgebouwd uit meerdere velden. Het zou niet nodig zijn om alles in arcpy.mapping te doen vanwege zo'n eenvoudige, aangepaste vereiste. In dit geval kan het kaartdocument nog steeds worden geschreven terwijl Data Driven Pages is ingeschakeld, en kan arcpy.mapping de vereisten voor aangepaste tekstelementen aan. Een codevoorbeeld hieronder verhelpt dit scenario.

Gegevensgestuurde pagina's moeten eerst worden ingeschakeld en geschreven in een kaartdocument (.mxd) met behulp van de gegevensgestuurde pagina's-werkbalk in ArcMap voordat ernaar kan worden verwezen met arcpy.mapping.

De klasse DataDrivenPages heeft slechts één exportToPDF-methode, maar dat betekent niet dat er geen andere exportbestanden kunnen worden gemaakt. Zie het eerste codevoorbeeld hieronder.

Zie de volgende onderwerpen voor meer informatie over gegevensgestuurde pagina's:


Hier is een eenvoudig werkend voorbeeld, waarbij een BindingNavigator GUI-besturingselement een BindingSource-object gebruikt om pagina-einden te identificeren, door de DataSource in te stellen op een aangepaste subklasse van IListSource. (Dankzij dit antwoord voor het sleutelidee.) Wanneer de gebruiker op de knop "volgende pagina" klikt, activeert de BindingNavigator bindingSource1_CurrentChanged en kan uw code de gewenste records ophalen. Instructies:

  1. Een Windows Forms-toepassing maken
  2. Sleep naar het formulier een BindingNavigator, een DataGridView en een BindingSource
  3. Vervang Form1.cs door de volgende code:

Hier is mijn oplossing: het kostte me bijna een jaar om het te vinden en ik ben er trots op

Hoe te gebruiken? Voeg bovenstaande code toe aan uw project, sleep de Supergrid en een bindingnavigator-besturingselement naar uw win-formulier.

En je krijgt een gepagineerde Datagridview met databinding zonder veel gedoe/

Een andere aanpak voor dit probleem:

Opmerking: de klasse DataPrivier is hier niet opgenomen, het is een eenvoudige klasse die gegevens uit elke bron retourneert.

Probeer dit, deze code is voor OleDb, maar werkt ook voor SqlServer-verbindingen. Het object dt (DataTable) is gevuld met geselecteerde paginarijen, ervan uitgaande dat de pagina begint met 1 (niet 0)

In dit artikel wordt uitgelegd hoe u Paging DataGridView implementeert in Windows Forms (WinForms) Application met behulp van C# en VB.Net. DataGridView-besturing in Windows Forms (WinForms) Toepassing heeft geen paging-mogelijkheden en daarom moet aangepaste paging met behulp van Stored Procedure worden geïmplementeerd. De Stored Procedure accepteert PageIndex en PageSize als invoerparameters om de records voor de gewenste pagina-index op te halen. Om de Pager aan de voorkant te vullen, is het totale aantal records in de tabel nodig dat wordt opgehaald met behulp van de RecordCount Output-parameter.

Aanvankelijk is de waarde van de PageSize ingesteld op 5 en de PageIndex is ingesteld op 1. De waarde van de parameter RecordCount Output en PageIndex worden doorgegeven aan de methode PopulatePager (later besproken).

Aan elke dynamische knop wordt een gebeurtenishandler voor klikken toegewezen, wanneer op de knop wordt geklikt, wordt de waarde van de naam ervan als PageIndex-parameter doorgegeven aan de functie BindGrid, die de DataGridView vult met de nieuwe set records.


Vitale statistische gegevens voor beperkt gebruik

Sinds 2005 zijn nationale microgegevensbestanden met vitale statistieken die de geografie van de staat, de provincie of een grotere stad bevatten niet langer beschikbaar zonder goedkeuring. Deze beperking was nodig om de vertrouwelijkheid te bewaren. De gegevens in de afgeschermde bestanden zijn van een zodanig detailniveau dat open toegang voor het publiek niet passend is.

Toegang tot en gebruik van beperkte versies van nationale vitale statistische bestanden vereisen beoordeling en goedkeuring van het onderzoeksvoorstel door het National Center for Health Statistics (NCHS). Hieronder vindt u informatie over beschikbare beperkte gegevensbestanden en hoe u deze kunt aanvragen. Lees ons beleid voor het vrijgeven van gegevens voor microgegevensbestanden met vitale statistieken voordat u een aanvraag voorbereidt.

Beschrijvingen van gegevensbestanden/recordlay-outs

Hieronder volgen beschrijvingen van gegevensbestanden/recordlay-outs voor verschillende soorten beperkte gegevens:

Hoe toe te passen?

Degenen die geïnteresseerd zijn in toegang tot beperkte datasets, moeten het Project Review Form pdf-pictogram [PDF &ndash 439 KB] invullen. E-mail het ingevulde formulier, samen met ALLE ondersteunend materiaal (zie hieronder), naar [email protected]

  • CV's opnemen van alle personen die toegang zullen hebben tot de dataset(s)
  • Geef eventuele aanvullende details over het project die nodig zijn om ons te helpen begrijpen hoe u de gegevens gaat gebruiken. Dit helpt extra vragen van NCHS te voorkomen die vertragingen in de verwerking kunnen veroorzaken.
  • Dien slechts één aanvraag per project in, ongeacht het aantal medeonderzoekers.

Aanvragers van studenten moeten ook altijd het volgende vermelden:

  • Adviseur&rsquos CV
  • Ondersteuningsbrief van adviseur
    • Dit kan zijn in de vorm van een ondertekende brief op het briefhoofd van de adviseur (die als pdf bij de aanvraag kan worden gevoegd) of een e-mail die rechtstreeks van de adviseur naar NCHS is verzonden

    Het niet opnemen van alle vereiste informatie die hierboven en in de aanvraag wordt vermeld, zal de verwerking vertragen.

    Als u met een deadline werkt, vermeld dan de datum in uw oorspronkelijke e-mailinzending. Hoewel we de verwerking niet op een specifieke datum kunnen garanderen, zullen we de opgegeven deadline noteren.

    Let op: NCHS accepteert geen aanvragen meer op basis van het vorige (NAPHSIS) Projectbeoordelingsformulier.

    Een succesvolle aanvraag voorbereiden

    Passende verzoeken zullen aantonen:

    • Een beoogd gebruik dat zich richt op onderzoek naar gezondheid en de factoren die van invloed zijn op gezondheid
    • Een redelijke kans om bij te dragen aan kennis over een gezondheidsgerelateerd probleem

    Soorten verzoeken die NIET geschikt zijn, zijn onder meer:

    • Verzoeken die geen evaluatie van gezondheid of factoren gerelateerd aan gezondheid inhouden
    • Verzoeken die van plan zijn om een ​​enkele staat te beoordelen (verzoek eerst rechtstreeks bij het vitale archiefkantoor van die staat)
    • Verzoeken om geografische gegevens onder de niveaus beschreven in de bestandsbeschrijvingen
    • Verzoeken die exacte datums vereisen (maand en jaar zijn beschikbaar, exacte dag niet. Zie het beleid voor het vrijgeven van gegevens voor details)
    • Verzoeken om gegevensbestanden die worden verzonden of op afstand worden geopend van buiten de Verenigde Staten of hun territoria
    • Verzoeken die de gegevens zouden koppelen aan andere gegevenssets die gevallen kunnen heridentificeren
    • Verzoeken die betrekking hebben op het gebruik van de gegevens voor commerciële of wederverkoopdoeleinden

    Ingediende aanvragen

    NCHS zal het gegevensverzoek evalueren. Houd rekening met een verwerkingstijd van 4-6 weken. Tijdens het proces kunnen NCHS-recensenten per e-mail om aanvullende informatie van de aanvrager vragen. Controleer uw e-mails en beantwoord eventuele NCHS-vragen zo snel mogelijk om verdere vertragingen te voorkomen.

    Indien goedgekeurd, heeft de aanvrager toegang tot de bestanden na indiening van een ondertekende NCHS-overeenkomst voor gegevensgebruik. Een functionaris die bevoegd is om namens de instelling of organisatie van de aanvrager overeenkomsten uit te voeren, moet aangeven dat hij zich aan de voorwaarden van de overeenkomst houdt. Dit moet iemand anders zijn dan de hoofdonderzoeker(s), medeonderzoekers of analisten van het project. Indien kopieën van de bestanden bij meer dan één instelling worden ondergebracht, is per instelling een Overeenkomst vereist.

    Bij afwijzing ontvangt de aanvrager de reden(en) voor de weigering.

    Als u na 4-6 weken nog geen beslissing heeft ontvangen, kunt u de status van uw aanvraag controleren. Stuur uw oorspronkelijke aanvraag door en vraag een statusupdate aan door NCHS te e-mailen op [email protected]

    Gebruiksvoorwaarden voor beperkte gegevens

    Zodra onderzoekers toestemming hebben aangevraagd en gekregen voor toegang tot gegevens voor beperkt gebruik, moeten alle gegevensgebruikers die zijn gekoppeld aan een goedgekeurd onderzoeksproject akkoord gaan met specifieke gebruiksvoorwaarden, waaronder de volgende:


    Paginering is relatief eenvoudig. Er zijn bibliotheken beschikbaar om het voor je te doen, maar ik begin ze meer problemen te geven dan ze waard zijn.

    U hebt drie stukjes informatie uit het verzoek nodig (of ingesteld op standaardwaarden):

    1. Paginanummer (standaard op 1)
    2. Paginaformaat (standaard ingesteld op 10, maar wat je maar wilt)
    3. Sorteren (niet strikt noodzakelijk, maar u moet op zijn minst op iets sorteren om de resultaten consistent te houden over de pagina's)

    Het paginanummer en de grootte geven u de waarden voor "overslaan" en "nemen":

    U kunt de resultaten dan ophalen via:

    Where-query is een IQueryable - ofwel uw DbSet rechtstreeks of de DbSet met een Where-clausule, OrderBy, enz. toegepast.

    Vervolgens hoeft u alleen het totale aantal items te berekenen om de pagina's te berekenen:

    Pro-tip, kunt u de twee query's (resultaten en totaal aantal) parallel zetten door te doen:

    Taken komen hot terug, of zijn al begonnen. Het wait-sleutelwoord houdt eenvoudigweg de voortzetting van de rest van de code vast totdat de taak is voltooid. Het resultaat is dat als je op elke regel wacht, ze in serie worden voltooid, maar als je eerst beide begint en vervolgens op elke regel wacht, worden ze parallel verwerkt.

    Hoe dan ook, als je eenmaal de telling hebt:

    Opmerking: u kunt bepalen of de knoppen eerste/vorige en laatste/volgende worden weergegeven op basis van of ze respectievelijk gelijk zijn aan firstPage of lastPage.

    Bouw vervolgens zelf een model met deze informatie, en u kunt dat naar de weergave sturen om de resultaten weer te geven en de pagina-HTML te genereren.


    Paginaweergaven en schermweergaven

    Paginaweergaven in Universal Analytics worden vertaald naar de gebeurtenis page_view in Google Analytics 4-property's. Een page_view-gebeurtenis wordt automatisch geactiveerd door het gtag.js-fragment 'config' of door de Google Analytics 4-configuratiesjabloontag in Google Tag Manager.

    Sommige Universal Analytics-paginaweergavekenmerken hebben Google Analytics 4-equivalenten, zoals hieronder weergegeven:

    Paginaweergavekenmerk in Universal Analytics

    Pageview-kenmerk in Google Analytics 4

    Een schermweergave is de app analoog aan een paginaweergave. In Google Analytics 4-property's wordt een screen_view-gebeurtenis geactiveerd telkens wanneer een gebruiker een scherm bekijkt.


    Overzicht chronische aandoeningen

    Het Office of Enterprise Data and Analytics, binnen de Centers for Medicare & Medicaid Services (CMS), heeft een reeks informatieproducten en analyses ontwikkeld die chronische aandoeningen onderzoeken bij begunstigden van Medicare-vergoedingen. OEDA produceert deze informatie om onderzoekers en beleidsmakers een beter inzicht te geven in de last van chronische aandoeningen bij begunstigden en de implicaties voor ons gezondheidszorgsysteem. Informatie over prevalentie, gebruik en Medicare-uitgaven voor specifieke chronische aandoeningen en meerdere chronische aandoeningen toont de algehele last en complexiteit van chronische aandoeningen onder Medicare-begunstigden en kan worden gebruikt om begunstigden van Medicare met een hoog risico te identificeren, en om beleidsmakers en aanbieders te informeren over middelen gebruik van patiënten met chronische ziekten.

    Er zijn verschillende bronnen beschikbaar voor onderzoekers, beleidsmakers en andere gebruikers die meer willen weten over chronische aandoeningen bij Medicare-begunstigden, waaronder rapporten met geografische gegevens in tabelvorm (gegevensjaren 2007-2018) evenals interactieve dashboards en atlas (gegevensjaar 2018).


    We bieden 15+ sociale en marketingtools die helpen om diepere connecties met je publiek te creëren en hen te helpen om van nieuwe bezoeker naar terugkerende klant te gaan.

    "AddThis bood precies wat we zochten. De tools waren eenvoudig te implementeren en te testen, en we begonnen onmiddellijk resultaten te zien. Feit is dat we het totaal van vorig jaar nog maar 6 maanden in het jaar verslaan!"

    Brian Gerhardstein
    Online Media Manager, Rails-to-Trails


    Voorbeeldexamenantwoorden besturingssystemen

    Let op: deze antwoorden zijn de afgelopen jaren gegeven door berichten van studenten op het forum of door de docent. Ze zijn bedoeld als leidraad voor de juiste antwoorden. Veel dank aan degenen die hebben bijgedragen.

    Voor de vragen zonder antwoorden, post je pogingen op het forum en ik zal ze corrigeren.

    Antwoorden op voorbeeldpapier.

    &bull Een kleiner paginaformaat leidt tot kleinere paginatabellen &ndash False &ndash heeft meer vermeldingen nodig omdat we meer pagina's hebben
    &bull Een kleiner paginaformaat leidt tot meer TLB-missers &ndash True &ndash minder waarschijnlijk dat die pagina het adres bevat dat we zoeken.
    &bull Een kleiner paginaformaat leidt tot minder paginafouten &ndash True

    In de praktijk is de initiële storing meestal minder belangrijk dan paginafouten die worden gegenereerd zodra de toepassing actief is.

    Als de app eenmaal actief is, resulteert het verkleinen van de paginagrootte in een nauwkeurigere bepaling van de werkset, die op zijn beurt kleiner is, waardoor er minder geheugen nodig is, wat op zijn beurt leidt tot een lager aantal paginafouten.

    &bull Een kleiner paginaformaat vermindert de I/O-doorvoer voor paging &ndash True
    &bull-threads zijn goedkoper te maken dan processen &ndash True
    &bull Kernel-geplande threads zijn goedkoper om te maken dan threads op gebruikersniveau &ndash False
    &bull Een blokkerende kernel-geplande thread blokkeert alle threads in het proces &ndash False. Dit geldt voor threads op gebruikersniveau
    &bull Threads zijn goedkoper om van context te wisselen dan processen &ndash True &ndash don&rsquot moet de adresruimte besparen
    &bull Een blokkerende thread op gebruikersniveau blokkeert het proces - True
    &bull Verschillende threads op gebruikersniveau van hetzelfde proces kunnen verschillende planningsprioriteiten hebben &ndash False. Threads op gebruikersniveau zijn gepland, ze leveren () de CPU op
    &bull Alle kernel-geplande threads van een proces delen dezelfde virtuele adresruimte &ndash True
    &bull Het optimale algoritme voor het vervangen van pagina's is in de praktijk de beste keuze &ndash False - het is onmogelijk te implementeren
    &bull Het besturingssysteem is niet verantwoordelijk voor de toewijzing van middelen tussen concurrerende processen &ndash False &ndash het is hiervoor verantwoordelijk
    &bull Systeemaanroepen veranderen niet naar de privilege-modus van de processor &ndash False &ndash we vallen in de kernel, dus we veranderen de privilege-modus
    &bull Het Challenge-Response-authenticatieprotocol is vatbaar voor herhalingsaanvallen door indringers die op het netwerk rondsnuffelen &ndash False
    &bull Een planner die de voorkeur geeft aan I/O-gebonden processen, vertraagt ​​gewoonlijk de voltooiing van CPU-gebonden processen niet significant. &ndash True &ndash de I/O-processen krijgen de I/O en leveren vervolgens de CPU weer op.
    Q2 a)

    99 TLB-hits, waarvoor slechts één geheugentoegang nodig is (de daadwerkelijke vereiste)

    .0095 TLB missen, één keer gelezen uit het geheugen om de paginatabelinvoer TLB te laten laden, en één keer gelezen om het werkelijke geheugen te lezen.

    .0005 paginafout plus eventueel uit het geheugen gelezen plus iets als een van de volgende (ik zou hier een paar variaties nemen)

    1) Een geheugenreferentie om de paginatabel bij te werken
    2) Een geheugenreferentie om de paginatabel bij te werken en een geheugenreferentie voor de hardware om hetzelfde item opnieuw te lezen om de TLB te vullen
    3) Elke redelijke scebario die resulteert in een geldige paginatabel en hervulde TLB.

    Ik ga uit van optie 2 voor het laatste antwoord

    .99 * 100ns + .0095 *2 * 100ns + .0005 (3 * 100ns + 5ms)

    zou een antwoord zijn dat ik zou accepteren.

    i) FCFS-order doorlopen: 119,58,114,28,111,55,103,30,75
    gevolgde sporen: 547
    ii) SSTF-order doorlopen: 75,58,55,30,28,103,111,114,119
    gevolgde sporen: 143
    iii) SCAN-volgorde doorlopen: 103,111,114,119,75,58,55,30,28
    gelopen sporen: 130
    iv) C-SCAN-bestelling doorlopen: 103,111.114,119,28,30,55,58,75
    gevolgde sporen: 177

    Q5 b)

    Het staat in de multi-proces collegeaantekeningen.
    http://cgi.cse.unsw.edu.au/

    Slechts enkele opmerkingen die misschien goed zijn om te vermelden

    Test-en-set
    Hardware vergrendelt de bus tijdens de TSL-instructie om:
    geheugentoegang door een andere CPU voorkomen
    Probleem:
    Draaien op een slot vereist busvergrendeling die
    vertraagt ​​alle andere CPU's
    &ndash Onafhankelijk van of andere CPU's een slot nodig hebben of niet
    &ndash Veroorzaakt busconflict
    Caching helpt niet bij deze test en set.

    Vandaar om busconflicten te verminderen.
    &stier Lezen voor TSL
    &ndash Spin lezen van de slotvariabele
    wachten tot het verandert
    &ndash Als dit het geval is, gebruik dan TSL om te verwerven
    het slot
    &bull Staat toe dat slot alleen-lezen wordt gedeeld
    in alle caches totdat deze wordt vrijgegeven
    &ndash geen busverkeer tot de daadwerkelijke release
    &stier Geen racevoorwaarden, als aanwinst
    zit nog bij TSL.

    Antwoorden op voorbeeldvragen.

    De vetgedrukte vragen zijn door mij nagekeken, andere kunnen wel of niet juist zijn.
    Ik ga er vanavond zo snel als ik kan doorheen.

    1. Beschrijf de twee algemene rollen van een besturingssysteem en leg uit waarom deze rollen belangrijk zijn.

    Besturingssystemen bieden:
    - een redelijk gestandaardiseerde abstractie tussen hardware en userspace-software, waarmee userspace-software kan worden geschreven met weinig zorg voor de hardware waarop het draait, en toegang heeft tot een heleboel nuttige dingen zoals geheugen, bestanden, schermen, i/o enz.
    - resourcebeheer en toewijzing aan processen en threads. bronnen omvatten bestanden, geheugen, cpu-runtime, enz.

    i) abstracties op hoog niveau
    waarom?
    - vriendelijker voor programmeurs
    - biedt een gemeenschappelijke kern voor alle toepassingen
    - verbergt details van hardware om applicatiecode draagbaar te maken

    ii) resourcemanager
    waarom?
    - verdeelt middelen onder concurrerende programma's of gebruikers volgens een bepaald systeembeleid om eerlijkheid en waar mogelijk geen hongersnood te garanderen.


    2. Gebruik een eenvoudige systeemaanroep als voorbeeld (bijv. getpid of uptime) en beschrijf wat er in het algemeen komt kijken bij het leveren van het resultaat, vanaf het aanroepen van de functie in de C-bibliotheek tot het punt waar die functie terugkeert.

    Het gebruikersruimteprogramma doet een functieaanroep naar de C-bibliotheek, b.v. 'uptime', waarmee een systeemoproep op de juiste manier voor de hardware wordt ingesteld. Het gebruikersruimteprogramma moet parameters op de juiste manier instellen en vervolgens trap, zodat de kernel de controle overneemt en het verzoek in gebruikersruimte verwerkt. In MIPS wordt dit bereikt door de syscall-instructie.
    Zodra de kernel de controle heeft, wordt de gebruikersstatus opgeslagen. De kernel voert de nodige beveiligings- en gezondheidscontroles uit en probeert vervolgens aan het verzoek te voldoen. In het geval van 'uptime' zou het de waarde van een teller kopiëren, die (vermoedelijk) seconden telt sinds het opstarten. De gebruikersstatus wordt hersteld, de teller wordt deze in de stapel of een register geplaatst en keert terug naar de gebruikersruimte. De C-bibliotheekroutine leest de stapel / het register dat de kernel zojuist heeft geschreven, en stuurt het terug naar het gebruikersruimteprogramma.

    cs3231/07s1/lectures/lect03.pdf
    Het draait allemaal om systeemoproepen en heeft de vereiste informatie.
    Op pagina 63 staat een mooi diagram van de producenten.

    De stappen kunnen zijn:
    - Stel de vereiste syscall-argumenten in
    - Bel syscall uitzondering
    &ndash Wijzigen in kernel-stack
    &ndash Behoud registers door op te slaan in het geheugen (de stapel)
    &ndash Bewaar opgeslagen registers ergens die toegankelijk zijn voor
    &stier Lees argumenten
    &bull Retourwaarden opslaan
    &ndash Doe de &ldquoread()&rdquo
    &ndash Registers herstellen
    &ndash Terugschakelen naar gebruikersstack
    &ndash Keer terug naar applicatie


    3. Waarom moet het besturingssysteem voorzichtiger zijn bij het benaderen van invoer voor een systeemaanroep (of het produceren van het resultaat) wanneer de gegevens in het geheugen staan ​​in plaats van registers?

    Het besturingssysteem moet controleren of het geheugen waarnaar wordt geschreven/gelezen een geldig adres is dat eigendom is van het proces dat het verzoek doet. Het moet voorkomen dat processen andere processen beschadigen of geheugen lezen dat eigendom is van andere processen.
    Het besturingssysteem besteedt veel zorg aan invoer uit het geheugen als:

    a) Het adres dat door de toepassing is opgegeven als het adres van de invoer of uitvoer zou kunnen zijn:
    - een adres van een illegaal geheugengebied
    - een adres van een juridisch gebied dat naar schijf wordt gepagineerd

    b) of, kan veranderen als de toepassing multithreaded is.

    Kortom, het besturingssysteem moet ervoor zorgen dat het niet kan worden beschadigd, gecrasht of omzeild als gevolg van toegang tot geheugen zoals aangegeven door de toepassing.


    4. Is het een goed of een slecht idee om veiligheidscontroles in de C-bibliotheek te plaatsen? Waarom?

    Het plaatsen van veiligheidscontroles in de C-bibliotheek is geen garantie voor veiligheid, omdat het de keuze/het gemak is van het gebruikersruimteprogramma om de C-bibliotheek te gebruiken. Er is niets dat een gebruikersruimteprogramma weerhoudt om rechtstreeks een systeemaanroep te doen, met welke parameters het ook wil, die potentieel kwaadaardig zijn.
    Beveiligingscontroles moeten worden uitgevoerd in de kernelruimte, waar het gebruikersruimteprogramma geen invloed heeft en beveiligingscontroles niet kan omzeilen.

    5. Beschrijf het procesmodel met drie toestanden, beschrijf welke overgangen geldig zijn tussen de drie toestanden en beschrijf een gebeurtenis die een dergelijke overgang zou kunnen veroorzaken.

    6. Multi-programmering (of multi-tasking) maakt het mogelijk dat meer dan een enkel proces schijnbaar tegelijkertijd wordt uitgevoerd. Hoe wordt dit bereikt op een uniprocessor?

    Preventief multitasken wordt bereikt door snel van context te wisselen tussen processen. Elk proces krijgt een tijdvenster om uit te voeren, een zogenaamde 'timeslice'. De processor wordt dan onderbroken door een timer, waardoor hij overschakelt naar een ander proces, dat doorgaat tot het blokkeert, of tot de volgende tik. Door snel genoeg te schakelen, ontstaat de illusie dat er meerdere processen tegelijk lopen.

    Coöperatief multitasken wordt bereikt door elk proces af en toe te laten renderen, zodat andere processen kunnen draaien.

    7. Wat is een proces? Wat zijn kenmerken van een proces?

    Een proces is een of meer uitvoeringsdraden die zich in een enkele virtuele geheugenruimte bevinden. Een proces heeft zijn eigen set bestandsdescriptors, vm-ruimte, tijdwaarnemingsgegevens, pwd, (misschien wat andere dingen)

    1. een programma in uitvoering
    2.een voorbeeld van een actief programma
    3. een eigenaar van de bron die is toegewezen aan de uitvoering van het programma
    4. een taak of een baan
    5. omsluit een of meer threads

    kenmerk van een proces:
    Adresruimte
    Open bestanden - (zou kunnen worden beargumenteerd, maken deel uit van bronnen)
    Proces-ID
    Procesgroep
    Bovenliggende proces
    signalen
    enz.

    attributen van draden:
    Planningsparameters
    registreert
    Programmateller
    Programmastatuswoord
    Stapelwijzer
    Onderwerp staat:

    Als het besturingssysteem geen toepassingen met meerdere threads ondersteunt, worden threadattributen procesattributen.

    8. Wat is de functie van de klaar-wachtrij?

    9. Wat is de relatie tussen threads en processen?

    10. Beschrijf hoe een toepassing met meerdere threads kan worden ondersteund door een threads-pakket op gebruikersniveau. Het kan nuttig zijn om de componenten van zo'n pakket en de functie die ze vervullen te overwegen (en te tekenen).

    Vanuit het perspectief van de kernel heeft elk proces zijn eigen adresruimte, bestandsdescriptors, enz. en één uitvoeringsdraad. Om meerdere threads op gebruikersniveau te ondersteunen, bevat het proces code voor het maken, vernietigen, plannen en synchroniseren van threads op gebruikersniveau - wat kan worden gezien als het mulitplexen van vele threads op gebruikersniveau op de enkele kernelthread, allemaal beheerd binnen het proces. De planner kan willekeurige planningsalgoritmen uitvoeren en is onafhankelijk van de planner van de kernel.

    Threads op gebruikersniveau kunnen indien nodig ook een groot aantal threads bevredigen, omdat het gebruik kan maken van virtueel geheugen om threadcontroleblokken en -stapels op gebruikersniveau op te slaan.

    Dit zijn vaak coöperatieve planners, omdat er meestal alleen rudimentaire ondersteuning (indien aanwezig) is voor het leveren van timerticks aan de planner op gebruikersniveau. De toepassing moet echter specifiek zijn geschreven voor coöperatieve planning, met opbrengsten die zodanig zijn dat andere threads de mogelijkheid hebben om een ​​enkele slecht geschreven thread uit te voeren zonder voldoende opbrengsten, wat de cpu-tijd kan monopoliseren. Als alternatief kunnen dit ook preventieve multitaskers zijn, waarbij het threadpakket op gebruikersniveau regelmatig signalen ontvangt van het besturingssysteem, wat de contextwisseling kan initiëren. Deze hebben echter een hoge granulariteit en zijn niet echt praktisch.

    Een andere belangrijke overweging is om systeemaanroepen niet-blokkerend te maken, zodat de threadplanner op gebruikersniveau de uitvoering van een andere thread met I/O-latentie kan plannen (overlappen) in plaats van het hele proces te blokkeren. Dit is niet altijd mogelijk (ofwel vanwege het ontbreken van asynchrone I/O-systeemaanroepen), of omdat gebeurtenissen zoals paginafouten (die altijd synchroon zijn) het proces en alle threads op gebruikersniveau aan de zijkant blokkeren.

    11. Noem enkele voor- en nadelen van threads op gebruikersniveau.

    Voordelen: Threads op gebruikersniveau zijn beter configureerbaar, omdat ze elk planningsalgoritme kunnen gebruiken, en ze kunnen ook op elk besturingssysteem (waarschijnlijk zelfs DOS) worden uitgevoerd, omdat ze geen kernelondersteuning nodig hebben voor meerdere threads. Threading op gebruikersniveau is ook veel sneller, omdat ze niet naar de kernelruimte en weer terug hoeven te vallen. (hmmm. voorschot?)

    Nadelen: zonder ondersteuning voor kernelthreads moeten de threads samenwerken. Opbrengsten zijn vervelend en vereisen dat elke thread goed is geschreven, b.v. voldoende opbrengsten hebben en de cpu-tijd niet monopoliseren. De I/O moet niet-blokkerend zijn en moet dan extra worden gecontroleerd om zaken af ​​te handelen die normaal gesproken blokkeren. Dit is niet altijd mogelijk (hetzij vanwege het ontbreken van asynchrone I/O-systeemaanroepen of pollingsysteemaanroepen), of omdat gebeurtenissen zoals paginafouten (die altijd synchroon zijn) het proces en alle threads op gebruikersniveau aan de zijkant blokkeren. . . Threads op gebruikersniveau kunnen niet profiteren van meerdere CPU's, omdat het besturingssysteem geen threads naar verschillende processors kan verzenden, of mogelijk echt parallellisme kan uitvoeren, omdat het besturingssysteem slechts 1 proces met 1 thread ziet.

    12. Waarom worden threads-pakketten op gebruikersniveau over het algemeen gezamenlijk gepland?

    13. Noem de voor- en nadelen van het ondersteunen van toepassingen met meerdere threads met threads op kernelniveau.

    1. ervan uitgaande dat het pakket met gebruikersthreads coöperatief is, hoeven gebruikersprogramma's niet overal met opbrengsten te worden geschreven
    2. elke thread is gegarandeerd een behoorlijke hoeveelheid uitvoeringstijd (zo eerlijk als het besturingssysteem is)
    3. userspace-programma's vereisen geen extra controle rond het blokkeren van i/o om dit te vermijden - d.w.z. andere kant-en-klare threads binnen het proces kunnen worden gepland als de actieve thread blokkeert bij een systeemaanroep of een paginafout.
    4. multitasking met lage granulariteit, geeft de illusie van parallellisme
    5. kan profiteren van multiprocessors, omdat de kernel threads naar andere cpu's kan sturen als hij dat gepast acht
    1. het gebruikersprogramma moet vergrendelingen en mutexen op de juiste manier gebruiken rond kritieke secties, omdat het niet kan bepalen wanneer contextomschakeling zal plaatsvinden (. maar so what)
    2. code is minder draagbaar omdat hiervoor ondersteuning van het besturingssysteem nodig is
    3. kan het planningsalgoritme niet kiezen
    4. Threadbeheer (maken, verwijderen, enz.) is duurder omdat er nu systeemaanroepen voor nodig zijn

    14. Beschrijf een reeks de volgorde van stappen die optreden wanneer een timeronderbreking optreedt die uiteindelijk resulteert in een contextwisseling naar een andere toepassing.

    - Draad 1 loopt vrolijk door
    - Timer tik
    - Trap in kernelruimte
    - schakel over naar kernelstack voor thread 1
    - thread 1 gebruikersregisters opgeslagen
    - zoek de volgende thread om uit te voeren (met de naam thread 2) vanuit de planner
    - context-switch naar thread 2 (wijzig naar de kernel-stack, maak de thread-besturingsstroom, flush tlb)
    - thread 2 gebruikersregisters geladen
    - in draad trekken 2
    - draad 2 loopt

    15. Het wisselen van context tussen twee uitvoeringsdraden binnen het besturingssysteem wordt meestal uitgevoerd door een kleine assembleertaalfunctie. Wat doet deze kleine functie in het algemeen intern?

    Kijk voor een echt voorbeeld van een dergelijke functie naar de OS/161 mips_switch-code

    Over het algemeen doet de assembleertaalcontext swith-code:

    • Bespaart voldoende registers op de stapel om uiteindelijk terug te keren naar de aanroepende C-functie
    • slaat de stapelaanwijzer op in het besturingsblok van de huidige thread
    • laad de stapelaanwijzer vanuit het besturingsblok van de bestemmingsthread
    • herstelt de bestemmingsthreads-registers van de stapel
    • keert terug naar 'C' in de bestemmingsthread.

    16. Wat is een raceconditie? Geef een voorbeeld.

    Een raceconditie treedt op wanneer er een ongecoördineerde gelijktijdige toegang is tot gedeelde bronnen (bijvoorbeeld geheugen of apparaatregisters), wat leidt tot onjuist gedrag van het programma, impasses of verloren werk.

    Een voorbeeld is het gelijktijdig bijwerken van een teller door twee processen. Stel dat de teller een waarde van 1 heeft. Proces A leest de variabele, maar voordat Proces B wordt bijgewerkt, leest en werkt de teller bij naar 2. Proces A, zonder te weten wat Proces B doet, werkt de teller bij naar 2. Het juiste gedrag van de programma zou hebben dat de teller wordt verhoogd naar 3, niet naar 2.

    17. Wat is een kritieke regio? Hoe verhouden ze zich tot het controleren van de toegang tot gedeelde bronnen?

    18. Wat zijn drie vereisten voor een oplossing voor het probleem van de kritieke secties? Waarom zijn de eisen nodig?

    uit collegeaantekeningen:
    Wederzijdse uitsluiting: geen twee processen tegelijk in kritieke regio
    Voortgang: geen enkel proces buiten een kritieke regio kan ervoor zorgen dat een ander proces blokkeert
    Begrensd: geen enkel proces moet eeuwig wachten om zijn kritieke gebied binnen te gaan

    19. Waarom is het passeren van de beurt een slechte oplossing voor het probleem van de kritieke secties?

    20. Interrupt uitschakelen en inschakelen is een gebruikelijke benadering voor het implementeren van wederzijdse uitsluiting, wat zijn de voor- en nadelen?

    Voordelen: Het is gemakkelijk en efficiënt op een uniprocessor.
    Nadelen: het werkt niet op multiprocessors omdat andere processors parallel toegang hebben tot bronnen - zelfs als alle interrupts op alle processors zijn uitgeschakeld. Gebruikersruimteprogramma's zouden dit niet mogen doen, omdat ze voorrang kunnen uitschakelen en de CPU kunnen monopoliseren.
    Vertraagt ​​de responstijd van interrupts.

    21. Wat is een test-en-set instructie? Hoe kan het worden gebruikt om wederzijdse uitsluiting te implementeren? Overweeg het gebruik van een fragment van pseudo-assembly taalhulp bij je uitleg.

    Test and set is een atomaire instructie (wat betekent ononderbroken) die altijd de inhoud van de geteste geheugenlocatie retourneert, en bovendien de locatie instelt op 1 als (en alleen als) de geheugenlocatie 0 bevat.

    college aantekeningen:
    enter_critical_regio:
    tsl register, lock // probeer het slot in te stellen en kopieer het slot naar 'register'
    cmp register, 0 // als het register nul is
    jne critical_region // dan houden we het slot niet vast.
    ret // keer terug naar de beller na het uitvoeren van de kritieke regio

    leave_regio:
    verplaats 0, vergrendel // zet vergrendel op nul om het vrij te geven.
    ret

    22. Wat is het producentenconsumentenprobleem? Geef een voorbeeld van het voorkomen ervan in besturingssystemen.

    Het producentenconsumentenprobleem is een probleem waarbij een begrensde buffer wordt gevuld en uitgeput. De producent voegt vermeldingen in de buffer in en kan slapen als deze vol is. De consument moet data uit de buffer halen, eventueel slapend als deze leeg is. Transacties op de buffer zelf kunnen een mutex vereisen. Dit is te zien in besturingssystemen in buffers voor alles, met name invoerwachtrijen voor i/o-apparaten.

    Gegeven een enkele wachtrij van vaste grootte, genereert/genereert de producent(en) een item om in de wachtrij te plaatsen, terwijl de consument(en) het item uit de wachtrij halen en consumeren.

    Geef een voorbeeld van het voorkomen ervan in besturingssystemen.
    Neem bijvoorbeeld de buffercache van het bestandssysteem, de schrijfbewerkingen van het bestandssysteem worden geproduceerd door de toepassingsverzoeken. Het besturingssysteem moet een vrije ingang in de buffercache vinden om het schrijven op te slaan of het verzoek blokkeren totdat er een vrij slot beschikbaar is in de begrensde buffercache.

    23. Een semafoor is een blokkerende synchronisatieprimitief. Beschrijf hoe ze werken met behulp van pseudo-code. Je kunt uitgaan van het bestaan ​​van een thread_block() en een thread_wakeup() functie.

    Een semafoor heeft twee bewerkingen: Verhogen en Proberen, increment.en decrement
    P (verlagend) verlaagt een teller atomair met 1 als deze hierdoor negatief wordt, hij blokkeert totdat de teller minimaal 0 is.
    V (ophogen) verhoogt atomair een teller met 1, en wekt threads die op deze semafoor slapen.

    Interrupts zijn uitgeschakeld rond deze codegebieden zodat ze atomair zijn.

    Psuedocode:
    P:
    // terwijl het verlagen het negatief zou maken, slaap.
    sem.count--
    while (sem.telling < 0) <
    voeg dit proces toe aan de semphore-wachtrij
    thread_block()
    >

    V:
    // andere threads verhogen en wakker maken
    sem.count++
    if (sem.telling <= 0) <
    verwijder hoofd van semafoorwachtrij
    thread_wakeup(head)
    >

    24. Beschrijf hoe u een vergrendeling implementeert met behulp van semaforen.

    Een vergrendeling met semaforen wordt bereikt door de semafoor op 1 te initialiseren. De telling van een semafoor is in feite het aantal dat mag worden toegestaan ​​voordat er meer binnenkomt, dus als het 1 is, werkt het als een slot. bijv.:

    /* semafoor verlagen (vergrendelen) */
    P(sem)

    /* increment sem (slot ontgrendelen) */
    V(sem)

    25. Wat zijn monitoren en conditievariabelen?

    Monitors zijn een programmeertaalconstructie die is ontworpen om de controle over gelijktijdige toegang te vereenvoudigen. Code met betrekking tot een gedeelde bron (en de gedeelde bron zelf) wordt in een monitor geplaatst, waarna de compiler ervoor zorgt dat er slechts één thread tegelijk in de monitor wordt uitgevoerd.

    Conditievariabelen zijn entiteiten die binnen monitors worden gebruikt om een ​​gebeurtenis te blokkeren en erop te wachten, de bewerkingen 'wachten' wachten op de gebeurtenis en 'signaleren'.
    bewerking wordt gebruikt om de gebeurtenis te genereren. Kortom, de thread die 'wacht' oproept, slaapt totdat een andere thread hem met 'signaal' wekt.

    26. Wat is een impasse? Wat is starten? Hoe verschillen ze van elkaar?

    Deadlock is de toestand van een set threads waarbij alle threads in de set zijn geblokkeerd en wachten op een andere thread in de set om een ​​resource vrij te geven, en een vereiste resource kan alleen worden vrijgegeven door een thread in de geblokkeerde set. De set blijft voor altijd geblokkeerd.

    Voorbeeld met een ingestelde grootte van 2 <1,2>: Thread 1 heeft resource A en B nodig om verder te gaan, het bevat A. Thread 2 heeft resource A en B nodig om verder te gaan, het bevat B. Beide blokkeren de resource die ze nodig hebben en kunnen niet loslaten wat ze vasthouden.

    Honger is het fenomeen waarbij de toewijzing van middelen 'oneerlijk' is, en iets niet kan doorgaan omdat het nooit de middelen krijgt die het nodig heeft, ook al kunnen de middelen beschikbaar komen omdat de middelen altijd aan iets anders worden toegekend.

    In een impasse stoppen processen omdat ze niet verder kunnen en de middelen nooit worden vrijgegeven. Bij uithongering boekt het systeem over het algemeen vooruitgang door de bronnen te gebruiken (en opnieuw te gebruiken), maar bepaalde processen lopen consequent mis om hun verzoek om bronnen te krijgen.

    27. Wat zijn de vier voorwaarden die vereist zijn voor het optreden van een impasse?

    28. Beschrijf vier algemene strategieën om met impasses om te gaan.

    1) negeer het
    - eenvoudig
    - vooral als de andere strategieën erg duur zijn en een impasse zelden voorkomt

    detectie:
    - doe pagina's met wiskunde
    - en nog wat wiskunde
    - dan nog wat
    - of misschien een grafiek verkennen
    - met wiskunde

    herstellen :
    - stel vervolgens verwijderbare bronnen, of probeer geldige statussen van processen op te slaan en terug te draaien naar hen
    - ziet er ingewikkeld uit.

    3) het vermijden van een impasse
    - impasse niet toestaan ​​door te proberen te bepalen of het toestaan ​​van een bepaalde toewijzing van middelen tot een deadlock leidt
    - alleen voortgang van programma's naar 'veilige toestanden' toestaan, die de voltooiing van het proces garanderen.
    - moeilijk, omdat we de procesvereisten van tevoren moeten kennen, of controles moeten doen voordat we middelen toewijzen. dit kan vaak praktisch onmogelijk zijn

    4) preventie van impasse
    - ontken een van de 4 vereisten van een impasse.
    - los vasthouden en wachten op door threads middelen te laten vallen die ze vasthouden als ze niet alle middelen kunnen krijgen die ze nodig hebben voor vooruitgang. dit kan honger veroorzaken.
    - meestal gedaan door geordende middelen te gebruiken, om de circulaire afhankelijkheidsvoorwaarde te doorbreken. het doorbreken van andere voorwaarden is zelden een haalbare optie.

    29. Voor resources van één eenheid kunnen we resourcetoewijzing en verzoeken modelleren als een gerichte grafiek die processen en resources met elkaar verbindt. Gegeven zo'n grafiek, wat is betrokken bij deadlock-detectie.

    30. Is het volgende systeem van vier processen met 2 resources vastgelopen?

    Huidige toewijzingsmatrix
    P1 1 3
    P2 4 1
    P3 1 2
    P4 2 0

    Huidige verzoekmatrix
    P1 1 2
    P2 4 3
    P3 1 7
    P4 5 1


    Geef 1 2 aan P1:
    Huidige toewijzingsmatrix
    P1 2 5
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P1 0 0
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheid
    0 2

    P1 eindigt, releases 2 5.
    Huidige toewijzingsmatrix
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheid
    2 7

    Geef 1 7 aan P3:
    Huidige toewijzingsmatrix
    P2 4 1
    P3 2 9
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P3 0 0
    P4 5 1
    Beschikbaarheid
    1 0

    P3 eindigt, releases 2 9:
    Huidige toewijzingsmatrix
    P2 4 1
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P4 5 1
    Beschikbaarheid
    3 9

    Nu is er geen mogelijk verzoek waaraan kan worden voldaan, dus het is vastgelopen.


    Als de beschikbaarheidsvector zoals hieronder is, zit het bovenstaande systeem dan nog steeds in een impasse?
    2 3

    Scenario 2:
    Huidige toewijzingsmatrix
    P1 1 3
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P1 1 2
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    2 3

    Geef 1 2 aan P1:
    Huidige toewijzingsmatrix
    P1 2 5
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P1 0 0
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    1 1

    P1 eindigt, releases 2 5:
    Huidige toewijzingsmatrix
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    3 6

    Nu is er niets meer bevredigend. vastgelopen

    Scenario 3: Is het systeem vastgelopen als de beschikbaarheid is
    2 4

    Huidige toewijzingsmatrix
    P1 1 3
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P1 1 2
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    2 4

    Geef 1 2 aan P1
    Huidige toewijzingsmatrix
    P1 2 5
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P1 0 0
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    1 2

    P1 eindigt, laat 2 5 . los
    Huidige toewijzingsmatrix
    P2 4 1
    P3 1 2
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P3 1 7
    P4 5 1
    Beschikbaarheidsvector
    3 7

    Voer P3 uit (releases 1 2):
    Huidige toewijzingsmatrix
    P2 4 1
    P4 2 0
    Huidige verzoekmatrix
    P2 4 3
    P4 5 1
    Beschikbaarheidsvector
    4 9

    Voer P2 uit (releases 4 1):
    Huidige toewijzingsmatrix
    P4 2 0
    Huidige verzoekmatrix
    P4 5 1
    Beschikbaarheidsvector
    8 10

    Dan kan P4 draaien. Systeem is niet vastgelopen.

    a) zoek een proces waarvan <= de beschikbaarheid vraagt.
    we weten dat we dan aan de vereisten voor dit proces kunnen voldoen, dus we nemen aan dat het de benodigde middelen krijgt en eindigt. Zo kunnen we

    b) alle resources die *momenteel* aan dat proces zijn toegewezen, vrijgeven en vervolgens aan de pool toevoegen.

    c) herhaal voor alle processen. Als je uiteindelijk een punt bereikt waarop je dit niet kunt doen, en er zijn nog steeds processen over, dan zit het systeem vast. Als je ze allemaal loslaat, ben je veilig.

    31. Ervan uitgaande dat het besturingssysteem detecteert dat het systeem vastloopt, wat kan het besturingssysteem dan doen om uit de impasse te komen?

    Een besturingssysteem kan bronnen gebruiken als ze verwijderbaar zijn (wat betekent dat het proces niet sterft als het wordt weggenomen). Het kan een proces doden om middelen vrij te maken. Anders kan het proberen snapshots van processtatussen te maken en terug te draaien naar de status waarin het systeem niet vastzat.

    32. Wat moet het algoritme van de bankier a priori weten om een ​​impasse te voorkomen?

    Het bankiersalgoritme moet nu aan de maximale resourcevereisten van alle processen voldoen.

    We gaan ervan uit dat de bankier de beschikbaarheid en het gebruik van middelen kan bijhouden, en het proces dat de benodigde middelen ontvangt, deze uiteindelijk kan voltooien en vrijgeven.

    33. Beschrijf de algemene strategie achter dealockpreventie en geef een voorbeeld van een praktische deadlockpreventiemethode.

    Deadlock-preventie is het verwijderen van de mogelijkheid dat een deadlock optreedt, door een van de vier voorwaarden voor deadlock teniet te doen. Een praktisch voorbeeld om dit te bereiken is het gebruik van geordende middelen, zodat er geen circulaire afhankelijkheden kunnen ontstaan. zie hierboven

    Opmerking: het vermijden van een impasse via zorgvuldige toewijzing (bijv. bankieralgoritme) is geen preventie, het is vermijding.

    34. Bestandssystemen kunnen schaarse bestanden ondersteunen, wat betekent dit? Geef een voorbeeld van de bestandsorganisatie van een toepassing die baat zou kunnen hebben bij de schaarse bestandsondersteuning van een bestandssysteem.

    Dunne bestanden betekenen dat er geen fysieke blokken op de schijf zijn die bestemd zijn om lege delen van het bestand te bevatten. Een toepassing die hiervan kan profiteren, is een cd-rom-image die een niet-volle schijf voorstelt. de bestandsgrootte zou de grootte van de harde schijf zijn, maar ongebruikte delen in de afbeelding betekenen niet dat er blokken worden verspild.
    Dit betekent dat bestandssystemen dit soort bestanden ondersteunen dat als enkele hele blokken van een bestand niet-betekenisvolle gegevens bevatten (moeten null zijn), deze blokken niet op de schijf hoeven te worden toegewezen.

    Sommige database-applicaties die streven naar grote offsets die worden verkregen uit grote hash-waarden, kunnen voordelen hebben voor schaarse bestanden.

    35. Geef een voorbeeld van een scenario dat baat zou kunnen hebben bij een bestandssysteem dat een schrijven met alleen-toevoeging ondersteunt.

    36. Geef een scenario waarin het kiezen van een grote blokgrootte van het bestandssysteem een ​​voordeel kan zijn, geef een voorbeeld waar het een belemmering kan zijn.

    Grote blokgroottes zouden goed zijn wanneer uber grote bestanden worden gebruikt, b.v. een videocollectie op een schijf, en bijna geen kleine bestanden. Bijzondere voordelen bij sequentiële toegang. (en minder metadata nodig om het kleinere aantal blokken bij te houden)

    Het zou een verspilling zijn van schijfblokken in bestandssystemen die veel kleine bestanden opslaan, zoals nieuws, /etc, mijn fysiologische studie tot nu toe, enz. Het is ook slechtere prestatie wanneer er willekeurige toegang is tot kleine gegevenssegmenten, zoals we nodig hebben om het hele blok te laden, ook al hebben we er misschien maar een klein deel van nodig.

    37. Geef een voorbeeld waarbij in de praktijk gebruik kan worden gemaakt van aaneengesloten toewijzing van bestandsblokken op schijven.

    38. Welk bestandstoegangspatroon is in het bijzonder geschikt voor geketende bestandstoewijzing op schijf?

    Opeenvolgende bestandstoegang is geschikt voor geketende bestandstoewijzing. De keten is in feite een gekoppelde lijst die wordt doorlopen terwijl het bestand wordt gelezen.
    Willekeurige toegang is slecht, omdat elke voorafgaande schakel van de keten moet worden overwogen om bij elk punt van het bestand te komen.

    39. Welke bestandstoewijzingsstrategie is het meest geschikt voor willekeurig toegankelijke bestanden?

    40. Vergelijk op bitmap gebaseerde toewijzing van blokken op schijf met een gratis blokkenlijst.

    Op bitmap gebaseerde bloktoewijzing is een vaste grootte die evenredig is aan de grootte van de schijf. Dit betekent verspilde ruimte wanneer deze vol is. Een lijst met vrije blokken wordt kleiner naarmate de ruimte opgebruikt is, dus wanneer de schijf vol is, is de grootte van de lijst met vrije blokken klein.

    Aaneengesloten toewijzing is gemakkelijker uit te voeren/vinden met een bitmap.

    41. Hoe kan het aantal blokken in een inode verschillen van de (bestandsgrootte / blokgrootte) naar boven afgerond op het dichtstbijzijnde gehele getal. Kan het aantal blokken groter, kleiner of beide zijn.

    Het aantal blokken kan groter zijn dan de bestandsgrootte, als het bestand niet schaars is, en er zijn extra blokken nodig voor het bewaren van metagegevens. Dit is de norm.

    Het aantal blokken kan kleiner zijn, in het geval van een dun bestand dat slechts een klein deel van het bestand gebruikt, zijn de gegevens en metagegevens kleiner dan de nominale grootte van het schaarse bestand.

    Ze kunnen gelijk zijn met precies de juiste afweging van de bovenstaande gevallen.

    42. Waarom kunnen de directe blokken in de inode zelf worden opgeslagen?

    43. Aangezien de maximale bestandsgrootte van een combinatie van directe, enkele indirecte, dubbele indirecte en drievoudige indirecte in een op inodes gebaseerd bestandssysteem ongeveer hetzelfde is als een bestandssysteem dat alleen drievoudige indirectie gebruikt, waarom zou u dan niet gewoon alleen drievoudige indirectie gebruiken om alle bestandsblokken?

    44. Wat is de maximale bestandsgrootte die wordt ondersteund door een bestandssysteem met 16 directe blokken, enkele, dubbele en drievoudige indirectheid? De blokgrootte is 512 bytes. Diskbloknummers kunnen worden opgeslagen in 4 bytes.

    aantal bloknummers in een indirectieblok
    = blokgrootte / 4
    = 128

    aantal blokken voor bestandsgegevens in dat bestandsobject

    = 16 + 128 + 128^2 + 128^3
    Maximale bestandsgrootte:
    (direct + enkel indirect + dubbel indirect + drievoudig indirect) * (blokgrootte)
    = (16 + 512/4 + (512/4)^2 + (512/4)^3) * (512)
    = 68853964800 bytes,

    45. Het razendsnelle bestandssysteem (en Linux Ext2fs) gebruiken het idee van blokgroepen. Beschrijf wat dit idee is en welke verbeteringen blokgroepen hebben ten opzichte van de eenvoudige bestandssysteemlay-out van het System V-bestandssysteem (s5fs).

    Blokgroepen zijn geclusterde arrangementen van gerelateerde datablokken en inodes. Dit verhoogt de prestaties door de ruimtelijke locatie van gegevens die op de schijf zijn gerangschikt. Systeem V deed dit niet, dus het zag geen prestatieverbeteringen door lokaliteit.

    Ook werd het superblok in elke groep gerepliceerd, zodat het bestandssysteem niet langer verloren ging als het ene s5fs-superblok kapot ging.

    46. ​​Wat is het referentietelveld in de inode? U moet rekening houden met de relatie met directory-items in uw antwoord.

    47. De buffercache van het bestandssysteem doet zowel buffering als caching. Beschrijf waarom buffering nodig is. Beschrijf hoe buffering de prestaties kan verbeteren (mogelijk ten koste van de robuustheid van het bestandssysteem). Beschrijf hoe de caching-component van de buffercache de prestaties verbetert.

    Buffering is vereist wanneer de overdrachts-/update-eenheid tussen twee entiteiten verschilt (bijv. het bijwerken van 1 byte in een schijfblok vereist het bufferen van het schijfblok in het geheugen). Buffering kan de prestaties verbeteren omdat schrijfacties naar schijf kunnen worden gebufferd en op de achtergrond naar schijf worden geschreven - dit vermindert de robuustheid van het bestandssysteem bij stroomstoringen en dergelijke.

    Caching is het laden van gebruikte gegevens in de buffercache, zodat latere leesbewerkingen naar hetzelfde gegevensgebied worden versneld door de gegevens in de cache te gebruiken en geen toegang tot de schijf te hebben. De versnelling wordt gezien als gevolg van het principe van lokaliteit als gegevens worden gebruikt, gegevens in de buurt zullen snel worden gebruikt, dus de toepassing zal veel sneller werken als deze zich in RAM bevindt in plaats van dat er naar een schijf moet worden gezocht, wat enkele ordes van grootte langzamer is.

    48. Wat doet flushd op een UNIX-systeem?

    Synchroniseert (schrijft) vuile blokken periodiek naar de schijf (elke 30 seconden) om aanzienlijk gegevensverlies te voorkomen bij onverwachte uitschakeling/stroomuitval van het besturingssysteem.

    Verbetert indirect ook de prestaties omdat het het aantal schone blokken verhoogt, en schone blokken kunnen onmiddellijk worden opgestart vanuit de buffercache in plaats van ze terug te schrijven, wat een versnelling zou moeten zijn.

    49. Waarom zouden bestandssystemen die externe opslagapparaten beheren, write-through-caching gebruiken (vermijd schrijfbuffers) ook al heeft dit een nadelig effect op de prestaties?

    50. Beschrijf het verschil tussen externe en interne fragmentatie. Geef aan welke van de twee het meest waarschijnlijk een probleem zijn op a) een eenvoudige geheugengeheugenbeheermachine die basislimietregisters en statische partitionering gebruikt, en b) een vergelijkbare machine die dynamische partitionering gebruikt.

    - Interne fragmentatie: de ruimte die intern wordt verspild aan de toegewezen regio. Het toegewezen geheugen is mogelijk iets groter dan het gevraagde geheugen.
    - Externe fragmentatie: de verspilde ruimte buiten de toegewezen region.memory bestaat om aan een verzoek te voldoen, maar het is onaanvaardbaar omdat het niet aangrenzend is.

    Statische partitionering heeft meer kans op interne fragmentatie.
    Dynamische partitionering heeft meer kans op externe fragmentatie.

    51. Noem en beschrijf de vier geheugentoewijzingsalgoritmen die in de colleges worden behandeld. Welke twee van de vier worden in de praktijk het meest gebruikt?

    First fit - wijs toe aan de eerste beschikbare ruimte die voldoende groot is, beginnend bij het begin van het geheugen.
    Volgende aanpassing - wijs toe aan de eerste beschikbare opening die is gevonden en hervat de zoekopdracht vanaf de laatste toewijzing.
    Best passend - doorzoek het hele geheugen om de kleinste geldige opening te vinden en deze toe te wijzen, op basis van de kleinste onbruikbare opening.
    Slechtste pasvorm - zoek en plaats in het grootste gebied, op basis van het feit dat het waarschijnlijk een opening laat die groot genoeg is om door iets anders te worden gebruikt.

    First en next fit worden in de praktijk gebruikt omdat ze sneller zijn, met vergelijkbare prestaties.
    First-fit
    Scan de geheugenregiolijst vanaf het begin voor de eerste aanpassing.
    Moet altijd mogelijk veel regio's aan het begin van de lijst overslaan.

    Next-fit
    Scan de geheugenregiolijst vanaf het punt van de laatste toewijzing tot de volgende aanpassing.
    Breekt een groot blok aan het einde van het geheugen op

    Best-fit
    Kies de dichtstbijzijnde gratis regio in de hele lijst
    Laat kleine onbruikbare regio's achter en langzamer vanwege het doorzoeken van de hele lijst.

    Slechtste pasvorm
    Vindt de slechtste pasvorm in de hele lijst
    Langzamer omdat het de hele lijst doorzoekt. Fragmentatie nog steeds een probleem.

    First-fit en next-fit worden het meest gebruikt omdat het gemakkelijker te implementeren is en beter werkt.

    52. MMU's met een basislimiet kunnen swapping ondersteunen. Wat is ruilen? Kan swapping een applicatie toestaan ​​die 16M geheugen nodig heeft om te draaien op een machine met 8M RAM?

    Swappen is de handeling waarbij elk proces een tijdje in het hoofdgeheugen wordt uitgevoerd en vervolgens weer op de schijf wordt geplaatst en omgekeerd. Het wordt gebruikt wanneer het systeem niet genoeg hoofdgeheugen heeft om alle actieve processen op te slaan.

    Ervan uitgaande dat een applicatie één programma is en dus een enkel proces, zal swapping een applicatie (proces) die 16M geheugen nodig heeft niet toestaan ​​om te draaien op een machine met 8M RAM (hoofdgeheugen), aangezien het hele proces te groot is om in het hoofdgeheugen te passen .

    53. Beschrijf paginagebaseerd virtueel geheugen. U moet in uw antwoord rekening houden met pagina's, frames, paginatabellen en geheugenbeheereenheden.

    Elk proces heeft zijn eigen paginatabel, die een toewijzing is tussen virtuele pagina's en fysieke frames. Een pagina is een stuk virtueel geheugen (meestal 4KB) dat bestaat binnen de virtuele geheugenruimte van het proces. Dit wordt toegewezen aan een fysiek frame (4 KB echte 1s en 0s in RAM) met behulp van een paginatabel.

    Het programma krijgt de illusie dat het in zijn eigen adresruimte draait. CPU-instructies voeren het programma uit, dat geheugenverzoeken uitvoert naar virtuele adressen. Deze worden geconverteerd naar fysieke adressen door omhoog te kijken in de paginatabel (meer specifiek de Translation Lookaside Buffer (TLB)), waarna toegang wordt verkregen tot het fysieke geheugen.

    De TLB is de snelle hardware-implementatie van het opzoeken van een paginatabel. Het bevat recent gebruikte paginatabelitems, die een heel snelle toewijzing tussen virtuele pagina's en fysieke frames mogelijk maken. In het geval dat de TLB het gevraagde virtuele adres niet bevat, wordt een paginafout geactiveerd. Het besturingssysteem wordt aangeroepen om de juiste toewijzing te vinden in de paginatabel, opgeslagen in RAM, en deze naar wens in de TLB te laden. (in MIPS. Pentium-architecturen hebben speciale hardware voor pagetables en daarom enige hardware-ondersteuning voor tlb-refill).

    54. Geef enkele voordelen van een systeem met op pagina's gebaseerd virtueel geheugen in vergelijking met een eenvoudig systeem met basislimietregisters dat swapping implementeert.

    Een eenvoudige basislimiet met swapsysteem vereist dat alle gegevens van basis tot limiet aanwezig moeten zijn in aaneengesloten hoofdgeheugen voor uitvoering. Dit kan leiden tot externe fragmentatie en swapping is veel waarschijnlijker wanneer het geheugen vol raakt. Dit levert een enorme boete op bij het wisselen van context, omdat een groot deel moet worden uitgewisseld naar schijf en vervolgens een groot deel van de schijf moet worden opgehaald voordat de uitvoering kan worden hervat. Schijf is verschrikkelijk traag in vergelijking met ram.

    In een pagingsysteem hoeft het fysieke geheugen niet aaneengesloten te zijn en is er geen externe fragmentatie, dus hoeft alleen de minimale hoeveelheid geheugen te worden verplaatst in een contextswitch. Alleen de pagina's die nodig zijn om de residente set te bevatten, hoeven in het geheugen voor uitvoering.

    Het paging-schema maakt het mogelijk dat de residente sets van veel processen in het geheugen aanwezig zijn, wat de prestatie van een contextomschakeling drastisch verhoogt, aangezien er veel minder kans is op schijftoegang bij het wisselen van context.

    Paging ondersteunt ook het uitvoeren van een proces waarvan het gebruik van virtueel geheugen groter is dan de grootte van het fysieke RAM-geheugen in de machine.

    55. Beschrijf op segmentatie gebaseerd virtueel geheugen. U moet in uw antwoord rekening houden met de componenten van een geheugenadres, de segmenttabel en de inhoud ervan, en hoe het uiteindelijke fysieke adres wordt gevormd.

    Segmentatie bestaat uit vele kleine basislimietdelen (segmenten), elk met een segmentnummer en een grootte. Met de segmenten kunnen meerdere processen gegevens delen per segment, en aangezien segmenten willekeurig kunnen worden gedefinieerd om code/stack/wat dan ook te bevatten, kan dit per subroutine zijn. Het maakt het ook mogelijk om de rechten van elk segment op de juiste manier in te stellen. Een ergernis is dat de programmeur zich bewust moet zijn van de segmentatie, en dit is niet triviaal. Segmenten worden geladen in aangrenzende gebieden van fysiek geheugen. Het segmentnummer, de basis, de limiet en de machtigingen worden opgeslagen in een segmenttabel per proces.

    Een instructie ziet er als volgt uit:
    operatie, wat dan ook, segmentnummer, offset.

    Wanneer de instructie wordt berekend, wordt de segmenttabel opgezocht om het juiste segment te vinden op basis van het segmentnummer. Als het segmentnummer aanwezig is in een tabelinvoer en de offset kleiner is dan limiet - basis, wordt het fysieke adres gevormd uit basis + offset. Vervolgens wordt het fysieke geheugen opgehaald en wordt de bewerking uitgevoerd. Als het segment niet aanwezig is of de offset buiten de grenzen is, wordt een fout doorgegeven aan het besturingssysteem dat het proces vervolgens afhandelt.

    56. Wat is een zoekbuffer voor vertalingen? Wat staat er in elk item dat het bevat?

    TLB is een snelle hardware-implementatie van het opzoeken van paginatabellen. Recente paginatabelitems die zijn gebruikt, worden in de TLB geladen, zodat de conversie van virtueel naar fysiek adres echt snel gaat. Wanneer een virtueel adres niet met succes kan worden vertaald door de TLB, wordt een paginafout gegenereerd en vindt het besturingssysteem het juiste frame in de paginatabel, of als het een ongeldige bewerking is, wordt het proces afgebroken. zie 53

    Elk TLB-item heeft een paginanummer (voor matching) en een framenummer dat is gekoppeld aan die pagina, privileges en ASID (soms).
    Het framenummer zijn de significante bits van het fysieke geheugenadres. Bevoegdheden zijn de bewerkingen die kunnen worden uitgevoerd. Dit biedt enige geheugenbescherming voor gedeelde bibliotheken en codesegmenten, b.v. een proces kan niet worden uitgevoerd in zijn stapel, of kan niet naar code schrijven, enz.

    Adresruimten en de paginatabellen die worden gebruikt om ze in kaart te brengen, zijn een entiteit per proces. De ASID (address space identifier) ​​wordt gebruikt om te controleren of de aanwezige tlb-vermeldingen die zijn van het huidige proces en dus van de momenteel actieve paginatabel. ASID's zorgen ervoor dat meerdere processen hot TLB-vermeldingen kunnen hebben door de TLB op een contextswitch niet volledig te wissen. Dit zal de prestaties verbeteren net na een contextwisseling.

    57. Sommige TLB's ondersteunen adresruimte-ID's (ASIDS), waarom?

    58. Beschrijf een paginatabel met twee niveaus? Hoe verhoudt het zich tot een eenvoudige paginatabelarray?

    Voor een 32 bit (4GB) virtuele adresruimte, met 4K pagina's/frames:
    Een paginatabel met twee niveaus gebruikt indirectheid om geheugen te besparen en dit gaat ten koste van tijd. De paginatabel op het hoogste niveau (een array van 1024 verwijzingen naar arrays op het 2e niveau) zou zodanig worden geïndexeerd dat de meest significante bits van het virtuele adres (VADDR[31:22]) worden gebruikt om de array op 2 niveaus op te zoeken ( paginatabelitems - framenummers en machtigingen), waarbij enkele van de minder significante bits VADDR[21:12] worden gebruikt om die tabel te indexeren.

    Dit heeft de voorkeur boven eenvoudige paginatabelarrays, omdat pagina's op het tweede niveau kunnen worden weggelaten als ze niet nodig zijn. Het betekent ook dat een belachelijk lange array ook niet nodig is. 2^20 paginatabelinvoeren, elk 4 bytes, is 2^22 bytes, is 4 MB geheugen vereist om een ​​paginatabel met 1 niveau te bevatten. Als de paginatabel zelf kan worden verwisseld, is dit een grote schijfhit. Als dat niet het geval is, moet 4 MB als aaneengesloten segmenten in het fysieke geheugen aanwezig zijn, wat fragmentatie kan veroorzaken.

    Paginatabel met 2 niveaus is langzamer om op te zoeken omdat er 2 geheugenverwijzingen per zoekopdracht nodig zijn.
    neem aan dat we een virtueel adres van 32 bits en een paginagrootte van 4k hebben, tabel A op het hoogste niveau en tabel B op het tweede niveau, de eerste 10 is om de index van A te lokaliseren en de volgende 10 bits is de offset om de index van B te lokaliseren, waarbij de inhoud van A wordt gebruikt om te lokaliseren het basisadres van de B, en plus de offset naar de index van B, we kregen de fysieke frame-index en gebruikten vervolgens de laatste 12 bits plus de inhoud van de B, en tenslotte het fysieke adres.

    De tabel met twee niveaus vermijdt het toewijzen van paginatabellen voor alle mogelijke vertalingen, als de vertalingen niet vereist zijn. Een nadeel is dat er 2 geheugenverwijzingen nodig zijn om een ​​paginatabelitem op te zoeken, in plaats van één.

    59. Wat is een omgekeerde paginatabel? Hoe verhoudt het zich tot een paginatabel met twee niveaus?

    Een omgekeerde paginatabel is een lijst met pagina's gesorteerd op framenummer. Omgekeerde paginatabellen hash het virtuele adrespaginanummer om in de paginatabel te zoeken, die vervolgens overeenkomt met het paginanummer (of een gekoppelde lijststructuur gebruikt om de pagina te vinden). Deze index is het framenummer.

    De grootte van de paginatabel is evenredig met de grootte van het fysieke geheugen, niet met de grootte van de adresruimte. Dit is vooral belangrijk op 64-bits machines, waar de grootte van de virtuele adresruimte, indien 2^64 bytes, 16 giga gigabytes is om een ​​paginatabel met meerdere niveaus op te slaan, omdat dit te veel niveaus van indirectheid zou vereisen en traag zou zijn, en veel ruimte zou vergen opslaan.
    Omgekeerde paginatabel is een reeks paginanummers gesorteerd (geïndexeerd) op framenummer. Het virtuele adres wordt gehasht om het item in de frametabel te vinden. Het belangrijkste voordeel is dat de grootte gerelateerd is aan de fysieke geheugengrootte, niet aan het virtuele geheugen. Omgekeerde paginatabel is goed voor een systeem met een grote adresseringsruimte maar aanzienlijk minder fysiek geheugen (bijvoorbeeld 64-bits adressering met 2 GB RAM)

    60. Wat zijn temporele lokaliteit en ruimtelijke lokaliteit?

    61. Wat is de werkset van een proces?

    62. Hoe beïnvloedt het paginaformaat van een bepaalde architectuur de grootte van de werkset?

    Als de paginagrootte klein is, is de grootte van de werkset kleiner (in termen van gebruikt geheugen, niet absoluut aantal pagina's), omdat de pagina's nauwkeuriger het huidige geheugengebruik weerspiegelen (d.w.z. er zijn minder niet-gerelateerde gegevens op de pagina).

    Als het paginaformaat groot is, neemt de werkset ook toe naarmate er meer niet-gerelateerde gegevens binnen de grotere pagina's in de huidige werkset worden opgenomen.

    63. Wat is geselen? Hoe kan het worden gedetecteerd? Hoe kan iemand ervan herstellen als het eenmaal is ontdekt?

    Thrashing is wanneer je java 'hello world' en elk ander proces op een systeem probeert uit te voeren. De geheugenvereisten van de momenteel lopende processen zijn zo groot dat de werksets van de uitvoerende processen niet in het fysieke geheugen kunnen worden opgenomen. Dus het ene proces probeert te draaien, krijgt een paginafout, haalt de pagina op uit swap, start het frame van een ander proces op en doet dat. Dan wisselt het van context en probeert het andere proces te draaien, maar het geheugen is opgestart, dus paginafouten om te wisselen, enz. De tijd wordt besteed aan het verwisselen van frames in plaats van iets gedaan te krijgen.

    Het kan worden gedetecteerd door de swapping-niveaus te controleren in vergelijking met het echte cpu-gebruik. Als het ruilen enorm is en het gebruik laag is, is er sprake van thrashing. Het opschorten van processen kan het geselen verlichten, hopelijk zullen sommige processen onder de drempel van het geselen gaan, worden uitgevoerd, beëindigd en vervolgens geheugen vrijmaken voor andere processen. Meer ram installeren helpt, en java hello world niet draaien helpt.
    Thrashing treedt op wanneer er te veel processen tegelijkertijd op een processor worden uitgevoerd. Wat er gebeurt, is dat het aantal paginafouten dramatisch toeneemt en dat het virtuele geheugensubsysteem voortdurend pagina's in en uit het geheugen oproept. Dit gebeurt wanneer de werkset van alle processen groter is dan de hoeveelheid RAM die beschikbaar is op een systeem.

    Dit kan worden gedetecteerd door de paginafoutfrequentie en het CPU-gebruik te bewaken. Als het verhogen van het aantal processen resulteert in een hoger aantal paginafouten en een lager CPU-gebruik, dan is het systeem aan het spartelen.

    Om van deze toestand te herstellen, moet het aantal processen dat zich momenteel in de actieve/klaar-wachtrij bevindt, worden verminderd. Dit kan worden bereikt door processen op te schorten (ze in de slaapwachtrij te duwen), zodat de druk op het fysieke geheugen wordt verminderd (opgeschorte processen worden uiteindelijk uitgewisseld) en het geselen afneemt.

    64. Noem enkele voor- en nadelen voor het vergroten van de paginagrootte.

    pluspunten:
    verkleint de grootte van de paginatabel
    verhoogt de tlb-dekking
    verhoogt de I/O-doorvoer van swapping, aangezien kleine schijftransactietijden worden gedomineerd door zoek- en rotatievertragingen.

    nadelen:
    verhoogt de latentie van paginafouten, omdat de reactietijd van de swap langzamer is vanwege meer gegevens.
    verhoogt de interne fragmentatie van pagina's, omdat er meer 'verspilde pagina' in de werkset zit

    65. Beschrijf twee beleidsmaatregelen voor het ophalen van pagina's voor virtueel geheugen. Wat komt in de praktijk minder vaak voor? Waarom?

    Vraagoproep - relevante pagina's worden geladen als er paginafouten optreden
    Pre-paging - probeer pagina's voor een proces te laden voordat ze worden geopend. Verspilt I/O-bandbreedte als pagina's onnodig worden geladen, en erger als een onnodige pagina een noodzakelijke pagina eruit gooit.
    Veeleisende paging (of ophalen op aanvraag): laad pagina's wanneer paginafout optreedt, en komt vaker voor.

    Prepaging-beleid: Pre-paging levert meer pagina's op dan nodig zijn op de
    moment. IO is verbeterd door het lezen van grote stukken maar verspilling van bandbreedte als pagina's niet worden gebruikt. Vooral erg als we pagina's uit de werkset verwijderen om ongebruikte pagina's vooraf op te halen. Moeilijk om in de praktijk goed binnen te komen.

    66. Welke besturingssysteemgebeurtenis kunnen we waarnemen en gebruiken als invoer voor een algoritme dat bepaalt hoeveel frames een applicatie ontvangt (d.w.z. een algoritme dat de residente setgrootte van de applicatie bepaalt)?

    67. Noem en beschrijf vier algoritmen voor het vervangen van pagina's. Vergelijk ze kritisch met elkaar.

    Van best naar slechtst (collegenota's):

    1) Optimaal - gebruik tijdreizen om de pagina te vinden die de meeste tijd niet zal worden gebruikt en start deze op. Onmogelijk om te implementeren - wordt alleen gebruikt als een theoretisch referentiepunt voor het vergelijken van algoritmen.

    2) Minst recentelijk gebruikt - bereken welke pagina het langst niet is gebruikt en start deze op. onmogelijk om efficiënt te implementeren in de praktijk - vereist een tijdstempel op elke geheugenreferentie.

    3) Vervanging van de klokpagina - stel 'verwezen' bit in op 1 wanneer iets wordt gebruikt. als je op zoek bent naar een item om op te starten, stel deze bits in op 0 als ze 1 zijn en kick de eerste 0 kandidaat die wordt gevonden. hervat zoekopdrachten vanaf de laatste opgestart. Efficiënte (uitvoerbare) benadering van LRU - gebruikt in de praktijk.

    4) FIFO - verwijder de pagina die er het langst is geweest - houdt geen rekening met het daadwerkelijke geheugengebruik in zijn beslissing - het zal de meest gebruikte pagina in het systeem verwijderen.

    68. Beschrijf buffering in het I/O-subsysteem van een besturingssysteem. Geef redenen waarom het nodig is en geef een geval aan waarin het een voordeel is en een geval waarin het een nadeel is.

    Buffering in het i/o-subsysteem is vereist om twee entiteiten te matchen wanneer de overdrachtseenheid verschillend is (bijv. het bijwerken van 1 byte in een schijfblok vereist het bufferen van het schijfblok in het geheugen).

    Buffering is voordelig als de pieksnelheden van het produceren en consumeren van gegevens verschillen. Gegevens kunnen asynchroon aankomen, zich opstapelen in een buffer terwijl de processor iets anders nuttigs doet, dan zal het context-overschakelen naar het proces dat op die buffer wacht, dat dan een bewerking op veel gegevens kan uitvoeren

    Te veel bufferen in netwerken met echt hoge snelheid kan de prestaties verminderen, als de tijd die nodig is om tussen buffers te kopiëren vergelijkbaar is met de tijd die wordt besteed aan gegevensverwerking.

    69. Device controllers worden over het algemeen steeds complexer in de functionaliteit die ze bieden (denk bijvoorbeeld aan het verschil tussen het implementeren van een seriële poort met een flip-flop bestuurd door de CPU en een multi-gigabit netwerkadapter met de TCP/IP-stack op de kaart zelf). Welk effect kan dit hebben op het besturingssysteem en de systeemprestaties?

    Door meer I/O-functionaliteit in apparaatcontrollers te duwen, hoeft het besturingssysteem het niet meer uit te voeren (bijvoorbeeld door DMA aan een apparaatcontroller toe te voegen, hoeft het besturingssysteem geen gegevens naar het geheugen te kopiëren). Dit resulteert in verbeterde prestaties, aangezien het besturingssysteem alleen toezicht hoeft te houden op het apparaat, in plaats van al het werk zelf in de apparaatdriver te doen, maar ook de I/O-functionaliteit kan nu parallel met het besturingssysteem/de toepassing iets anders doen. Het kan ook de complexiteit van de apparaatstuurprogramma's verminderen en de betrouwbaarheid verbeteren, maar dat hangt af van de vraag of het complexe apparaat zelf ook echt betrouwbaar is.

    70. Vergelijk I/O op basis van polling met interruptgestuurde I/O. In welke situatie zou je de ene techniek verkiezen boven de andere?

    Bij op polling gebaseerde I/O is het besturingssysteem gewoon bezig met wachten op een lus, voortdurend controlerend op I/O, terwijl bij interrupt-gestuurde I/O, wanneer een I/O-taak arriveert, een interrupt wordt gegenereerd en het besturingssysteem de onderbreking uitvoert. handler, daarna keert het terug naar wat het aan het doen was voordat de interrupt kwam.

    Als de kosten voor het afhandelen van interrupts (de kosten van het overschakelen naar de kernelmodus en het behouden van de context op gebruikersniveau en uiteindelijk weer terugkeren) groter zijn dan de tijd die wordt besteed aan druk wachten bij polling en het aantal I/O-taken dat binnenkomt, is hoog dan heeft pollen de voorkeur, anders is dat laatste een betere keuze.
    1 poll is goedkoper dan 1 interrupt maar 1 interrupt garandeert een evenement, polling kan duizenden verspilde polls hebben. Interrupt-gestuurde I/O heeft de voorkeur wanneer de invoer onvoorspelbaar is, b.v. pakketten, typen, muizen. Polling is gunstig wanneer de tijd die wordt besteed aan druk wachten minder is dan de tijd die wordt besteed aan het omgaan met overheadkosten voor onderbrekingen

    71. Leg uit hoe het producent-consumentprobleem relevant is voor de I/O van het besturingssysteem.

    Veel I/O-apparaten gebruiken een buffer om binnenkomende informatie op te slaan. Bij een gebeurtenis, zoals het invoeren van het teken 'nieuwe regel', wordt het besturingssysteem / gebruikersprogramma op de hoogte gebracht. Gegevens worden vervolgens gekopieerd van de buffer naar een locatie waar ze kunnen worden gebruikt, en de verbruikte gegevens worden uit de buffer gewist.

    Dit is een voorbeeld van een producent-consumentprobleem met een begrensde buffer, waarbij de producent het I/O-apparaat is, de consument het besturingssysteem/gebruikersprogramma en de buffer wordt begrensd door zijn grootte. Daarom moet gelijktijdigheidscontrole worden geïmplementeerd om ervoor te zorgen dat er geen race-omstandigheden optreden. Bovendien moet het besturingssysteem / programma de buffer snel genoeg verbruiken om te voorkomen dat deze overloopt en informatie verliest.

    72. Wat is schijfinterleaving? Welk probleem probeert het op te lossen?

    73. Wat is cilinderscheefstand? Welk probleem probeert het op te lossen?

    74. Noem vier disk-arm scheduling-algoritmen. Geef voor elk het basisalgoritme.

    75. Wat zijn de drie algemene doelen van computerbeveiliging?

    76. Op welke van de drie doelen van computerbeveiliging is het volgende een aanval op:

    A) Netwerk snuffelen

    B) Een gedistribueerde denial of service-aanval

    C) Je cijfers in de studentenadministratie wijzigen

    77. Geef een voorbeeld van waarom het belangrijk is om rekening te houden met de vaardigheden en middelen die beschikbaar zijn voor mogelijke indringers bij het ontwerpen van computerbeveiligingsmechanismen en -beleid ter verdediging tegen die indringers?

    Als de indringer weinig vaardigheden of middelen heeft (bijvoorbeeld oma), dan kan een eenvoudig goedkoop beveiligingsmechanisme voldoende zijn (bijvoorbeeld wachtwoorden).

    Als de tegenstander de Amerikaanse overheid is, zullen wachtwoorden weinig verdediging bieden.

    78. U ontwerpt een authenticatiemechanisme dat door een gebruiker met een webclient moet worden gebruikt om het te authenticeren bij een webserver. Het is bekend dat de netwerkverbinding gemakkelijk kan worden bekeken, maar vertrouwelijkheid van verkeer na authenticatie is geen probleem. Welk authenticatieprotocol dat in colleges wordt behandeld, zou het meest geschikt zijn en waarom.

    79. Beschrijf wat een bufferoverschrijdingsaanval is.

    80. Wat is het beginsel van de minste privileges? Waarom is de setuid-rootfaciliteit in UNIX over het algemeen een schending van het principe? Geef een illustratief voorbeeld van die overtreding.

    81. Het veilig uitvoeren van actieve webinhoud in een webbrowser is een moeilijk probleem. JAVA (met zijn gecontroleerde interpretatie van de gedownloade code) is een benadering van het probleem, ActiveX met zijn digitaal ondertekende code om authenticiteit te garanderen is een andere benadering. Geef van elke aanpak een voordeel en een nadeel.

    java is veiliger, maar er is een prestatiehit bij het interpreteren van code.
    activex is dwaas, het maakt het mogelijk om native binaries te draaien, die erg snel zijn, maar 'Hé! Wilt u dat ik spyware installeer? Was dat een ja? OKE. ' is geen beveiliging. als ik een virusschrijver was, zou ik het geweldig vinden.

    JAVA:
    voordeel: in staat om te controleren of adressen geldig zijn tijdens runtime
    nadeel: traag werken in vergelijking met native code uitvoeren

    ActiveX:
    voordeel: Sneller dan interpretatie
    nadeel: beschermt de gebruiker niet tegen slechte/buggy-code

    82. Wat is het verschil tussen verplichte toegangscontrole en discretionaire toegangscontrole?

    verplicht is de strikte handhaving van een beveiligingsbeleid dat buiten de controle van de gebruiker valt (beleid ingesteld door systeembeheerder/-eigenaar). naar eigen goeddunken is het aan jou (de gebruiker) om te kiezen wat je verbergt en onthult.

    83. Wat zijn toegangscontrolelijsten en -mogelijkheden, en hoe verhouden ze zich tot het beschermingsmatrixmodel van het vertegenwoordigen van autoriteit in een systeem.

    Toegangscontrolelijsten bepalen welke gebruikers/processen bepaalde acties op een resource kunnen uitvoeren. Bijvoorbeeld UNIX-machtigingen: lezen, schrijven, uitvoeren. Mogelijkheden bepalen voor elke gebruiker/proces welke acties ze kunnen uitvoeren op verschillende bronnen. Het zijn beide manieren om het beschermingsmatrixmodel van autoriteit in een systeem weer te geven.

    ACL's vertegenwoordigen de beveiligingsmatrix die is opgeslagen per kolom, mogelijkheden vertegenwoordigen de beveiligingsmatrix die is opgeslagen per rij (ervan uitgaande dat, zoals in de opmerkingen, elke rij is gelabeld per proces en elke kolom is gelabeld door een object/bron).

    84. Leg uit hoe het gemakkelijker is om het principe van de minste bevoegdheden toe te passen in een op capaciteiten gebaseerd systeem dan in een systeem op basis van toegangscontrolelijsten.

    toegangscontrolelijsten geven doorgaans machtigingen aan brede categorieën domeinen, b.v. unix-bestanden die domeinen groeperen per gebruiker/groep/iedereen. dit betekent dat elk proces dat als die gebruiker werkt, toegang heeft tot elk bestand waartoe de gebruiker toegang heeft, wat meestal veel meer is dan het proces nodig heeft, tenzij er een speciale gebruiker wordt gemaakt om dat proces uit te voeren, wat lastig is (veel unix-daemons doe dit).

    om daadwerkelijk de minste privileges toe te passen waarvoor acls ofwel een speciale gebruiker voor elk proces vereist, of om elke bron te vinden waartoe het proces toegang heeft en de privileges tijdelijk te wijzigen. dit is moeilijk, tijdrovend en onpraktisch.

    door gebruik te maken van op capaciteiten gebaseerde systemen, krijgt elk proces bij het maken een minimale set capaciteiten toegewezen. het proces krijgt de minste privileges wanneer het wordt gemaakt, wat gemakkelijk te handhaven is.
    Het belangrijke punt is dat met ACL's alle processen die eigendom zijn van de gebruiker dezelfde privileges hebben, dus het is moeilijk om POLP toe te passen.

    Met mogelijkheden heeft elk proces mogelijkheden voor de objecten waartoe het toegang heeft. Het is gemakkelijker bij het maken van een nieuw proces om het proces alleen de limieten te geven die het nodig heeft, d.w.z. de minste privileges die het nodig heeft.

    Aangezien ACL's (Access Control Lists) worden gedaan op de eigenlijke bronnen (bestanden, printers enz.), stellen deze toegangsrechten de gebruiker in staat om van de bronnen gebruik te maken. Daarom zou elk proces met de ID van de gebruiker ook toegang hebben tot deze bronnen.

    Om het principe van de minste privilege toe te passen op het proces, zouden we het recht voor dit proces om toegang te krijgen tot elke afzonderlijke bron vóór de runtime moeten verwijderen (dit is het moeilijke deel). Dat zou betekenen dat u moet zoeken naar elke afzonderlijke bron waartoe het proces toegang heeft (ZEER MOEILIJK TE DOEN met ACL) en vervolgens elke afzonderlijke bron te wijzigen (ook tijdrovend).

    De betere manier om het te doen zou zijn met capaciteiten.

    85. Wat is een vertrouwde computerbasis?

    De vertrouwde computerbases is de set componenten van het systeem die vertrouwd moeten worden om correct te werken om het beveiligingsbeleid te handhaven.

    Het volledige besturingssysteem maakt deel uit van de vertrouwde computerbasis.

    Idealiter zijn vertrouwde computerbases klein, begrijpelijk en hebben ze verifieerbare modellen waar het proces doorheen moet.

    86. Het Bell-La Padula Multilevel-beveiligingsbeleid is een beveiligingsbeleid dat is ontworpen om geheime informatie geheim te houden. Beschrijf het model inclusief de eigenschappen die moeten worden gegarandeerd om de geheimhouding te bewaren.

    87. Wat is een geheime zender?

    een verborgen kanaal is een ongeautoriseerd communicatiekanaal dat in een systeem kan worden gecreëerd door meetbare prestatiekenmerken van het systeem te observeren en te manipuleren. bijv. codering van gegevens via busvergrendelingslatenties, b.v. door logische 1 weer te geven met een lees (latentie induceren) en 0 zonder lezen (geen latentie brengen).
    Een verborgen kanaal is een ongeautoriseerd en impliciet communicatiekanaal dat wordt gecreëerd door het beïnvloeden en observeren van gedeelde bronnen in het systeem.

    Elke gedeelde systeembron (CPU, schijfzoekactie) kan worden gebruikt voor signalering om geheimen te verzenden. Terwijl een proces met een geheim afwisselt tussen bezig en slapend, kan een proces dat een geheim wil verkrijgen, controleren hoe snel het dit doet om het geheim te verkrijgen.

    88. Welke van RAID 1 of RAID 5 zou u gebruiken in de volgende scenario's en waarom:

    A) Een transactiedatabase die vele duizenden updates per seconde uitvoert.

    B) Een webserver die bijna volledig statische webinhoud bedient.

    a) Een transactiedatabase die vele duizenden updates per seconde uitvoert.

    Bij gebruik van een database zou RAID 1 de voorkeur hebben om te gebruiken. De reden hiervoor is dat de schrijf- en updateprestaties van RAID 1 beter zijn dan die van RAID 5.

    b) Een webserver die bijna volledig statische webinhoud bedient.

    RAID 5 zou hier voordeliger zijn, omdat de gegevens snel toegankelijk zijn. Aangezien de pagina's statisch zijn, en ervan uitgaande dat er geen backend-database is, wordt er niet echt naar de schijf geschreven, wat betekent dat de updateprestaties van RAID 5 geen probleem zijn en dat u net zo goed kunt besparen op het aantal schijven en raid 5 kunt gebruiken.

    89. Vergelijk RAID 0, RAID 1 en RAID 5 in termen van prestatieverbetering, vermogen om storingen te weerstaan ​​en ruimteoverhead die nodig zijn om het specifieke RAID-niveau te implementeren.

    gecorrigeerd: raid1 schrijfprestaties > raid 5 schrijfprestaties

    RAID 0, of striping, verbetert de lees- en schrijfprestaties als de blokken die worden gelezen of geschreven op verschillende fysieke volumes worden opgeslagen. De storingsdrempel is erger dan het falen van een logisch volume met één schijf, is de kans dat een van de fysieke volumes uitvalt. er is geen ruimteoverhead, de logische volumegrootte is de som van de fysieke volumegroottes.

    RAID 1 of mirroring verbetert de leesprestaties aanzienlijk, omdat elke leesactie naar elke schijf kan worden verzonden. schrijfprestaties zijn hetzelfde, omdat elke schrijfactie op beide schijven moet worden uitgevoerd (maar parallel). storingsdrempel is beter dan enkele schijven (kan een enkele schijffout verdragen), ruimteoverhead is slecht, verdubbelt het aantal schijven.

    RAID 5, gedistribueerde blokpariteit?? raid5 verbetert, net als raid0, de leesprestaties als verzoeken naar verschillende schijven zijn. schrijfprestaties zijn slechter dan raid 0, slechter dan een enkele schijf en slechter dan raid 1. elke schrijfactie vereist: schrijven naar het blok, dan de pariteit lezen om de pariteit opnieuw te berekenen, dan schrijven naar het pariteitsblok. storingsdrempel is beter dan een enkele schijf en raid 0, kan een enkele schijfstoring tolereren.

    90.Waarom is het over het algemeen juist om I/O-gebonden processen te verkiezen boven CPU-gebonden processen?

    91. Wat is het verschil tussen preventieve planning en niet-preventieve planning? Wat is het probleem met dat laatste?

    92. Gegeven een eerste reeks batchtaken, laat zien dat de kortste taak eerst de gemiddelde doorlooptijd minimaliseert.

    doorlooptijd is doorlooptijd - indieningstijd.
    ook: wachttijd + looptijd

    gemiddelde doorlooptijd = som van doorlooptijden / aantal processen

    = ((voltooitijd 1 - indiening1) + (voltooiingstijd 2 - indieningstijd 2) . (ct n - st n)) / n

    neem aan dat de indieningstijd = 0 voor iedereen

    = ((taak1) + (taak1 + taak2) + (taak1 + taak2 + taak3) . sum(task1..taskn)) / n
    = (n taak1 + n-1 taak2 + n-2 taak3 . + 1 taakn) / n

    door taken van de laagste naar de hoogste uitvoeringstijd te ordenen, zijn de coëfficiënten naast de hogere n kleiner, waardoor de algehele expressie wordt verminderd.
    ga voor de volgende processen uit van deze uitvoeringstijden:
    * A: een
    * B: b
    * C: c
    * D: d

    Proces A eindigt op tijdstip a, B eindigt op tijdstip a+b, C op a+b+c enzovoort
    gemiddelde doorlooptijd is dan: (4a+3b+2c+d)/4
    * uit bovenstaande vergelijking blijkt dat a het meest bijdraagt ​​aan de gemiddelde doorlooptijd, ook omdat a de kortste tijd is, daarom minimaliseert SJF de doorlooptijd

    93. Beschrijf round robin-planning. Wat is de parameter die aan de planner is gekoppeld? Wat is het probleem bij het kiezen van de parameter?

    Round robin-planning voert elk proces uit voor timelice t, preëmpt het vervolgens en plaatst het aan het einde van een wachtrij die gereed is. voert vervolgens het volgende proces uit voor timelice t.

    Als t te groot is, reageert deze niet. als t te klein is, wordt veel tijd verspild aan overhead van contextomschakeling.

    94. De traditionele UNIX-planner is een op prioriteit gebaseerde round robin-planner (ook wel een multi-level round robin-planner genoemd). Hoe gaat de planner te werk om I/O-gebonden jobs te verkiezen boven langlopende CPU-gebonden jobs?'

    Het gebruikt meerdere kant-en-klare wachtrijen van elke prioriteit. prioriteiten worden in de loop van de tijd geleidelijk verhoogd om uithongering van processen met een lage prioriteit te voorkomen. Ze worden verhoogd door de prioriteit te verhogen op basis van de hoeveelheid verbruikte CPU. I/O-gebonden taken hebben indirect de voorkeur omdat ze minder CPU verbruiken.
    .

    95. In een loterijplanner met 40 tickets. Hoe verdeel ik de tickets over 4 processen (A, B, C, D) zodat elk proces respectievelijk 10%, 5%, 60% en 25% krijgt?

    96. Wat is het probleem dat een fair share-planner probeert aan te pakken?

    97. Hoe worden in een real-time systeem met een periodieke takenset, prioriteiten toegekend aan elk van de periodieke taken?

    In een snelheidsmonotone planner worden prioriteiten toegewezen op basis van de periode van elke taak.
    In een eerste planner met een eerste deadline worden prioriteiten dynamisch toegewezen op basis van de deadlines van elke taak.

    + Monotoon tarief: hoe korter de periode, hoe hoger de prioriteit van het proces
    + EOF : hoe vroeger de deadline, hoe hoger de prioriteit.

    98. Wat is een EDF-planner? Wat is het voordeel ten opzichte van een tarief monotische planner?

    EDF levert gegarandeerd een haalbaar schema als het CPU-gebruik <= 100% is

    RMS geeft zo'n garantie alleen als het gebruik lager is dan aangegeven in de formule in de collegenota's, dat is beduidend minder dan 100%

    99. Beschrijf waarom het gebruik van spinlocks geschikter kan zijn dan het blokkeren van sloten op een multiprocessor in vergelijking met een uniprocessor. Is er een afweging tussen draaien en blokkeren op een multiprocessor? Bespreken.

    Spinlocken op een uniprocessor is nutteloos, omdat een andere thread op dezelfde processor het moet vrijgeven, dus zo snel mogelijk blokkeren is wenselijk.

    Op een multiprocessor kan de thread die de vergrendeling vasthoudt momenteel actief zijn op een andere processor en kan deze de vergrendeling op elk moment vrijgeven. Op een multiprocessor kan spin-locking de moeite waard zijn als de gemiddelde tijd die aan het draaien wordt besteed minder is dan de gemiddelde overheadkosten van contextomschakeling van en terug naar de verzoeker van het slot.

    100. Is een enkele wachtrij op een multiprocessor een goed idee? Waarom?

    Nee, omdat het een gedeelde bron is, die vergrendelingsconflicten introduceert wanneer processors werk proberen te plannen, omdat ze allemaal moeten wachten op een enkele vergrendeling in de wachtrij om te bepalen wie ze als volgende moeten plannen.

    101. Wat is draadaffiniteit. Waarom zou het de prestaties kunnen verbeteren?

    Threadaffiniteit is waar een thread een voorkeursprocessor heeft voor planning op een machine met meerdere processors. Dit vergroot de kans om te worden gepland op de processor die eerder was gepland op, wat op zijn beurt de kans vergroot om te worden gepland op een processor met een hot-cache. Hot cache is goed, het betekent minder cachemissers en hogere prestaties.


    Met benchmarking kunt u uw gegevens vergelijken met geaggregeerde branchegegevens van andere bedrijven die hun gegevens delen. Dit biedt waardevolle context, waardoor u zinvolle doelen kunt stellen, inzicht kunt krijgen in trends in uw branche en kunt ontdekken hoe u het doet in vergelijking met uw concurrentie. Leer meer.

    Gebruikersstroom is een grafische weergave van de paden die gebruikers via uw site hebben gevolgd, vanaf de bron, via de verschillende pagina's en waar ze uw site op hun pad hebben verlaten. Leer meer.


    Bekijk de video: Voettekst met paginanummer