diff --git a/assets/ostep_1680491762166_0.edn b/assets/ostep_1680491762166_0.edn
index 2330e0d..74ad6f8 100644
--- a/assets/ostep_1680491762166_0.edn
+++ b/assets/ostep_1680491762166_0.edn
@@ -1865,672 +1865,1322 @@
:page 138},
:content {:text "Linux Multiprocessor Schedulers"},
:properties {:color "yellow"}}
- {:id #uuid "64302439-30a1-4724-ab5f-0d90ab8530e2",
- :page 193,
- :position {:bounding {:x1 321.890625,
- :y1 927.90625,
- :x2 547.6137084960938,
- :y2 956.90625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 321.890625,
- :y1 927.90625,
- :x2 547.6137084960938,
- :y2 956.90625,
- :width 1036.8,
- :height 1555.2}),
- :page 193},
- :content {:text "external fragmentation"},
+ {:id #uuid "642faf44-5876-46b3-acb4-b786f390716f",
+ :page 141,
+ :position {:bounding {:x1 151.36608123779297,
+ :y1 528.0178985595703,
+ :x2 312.84705352783203,
+ :y2 550.3036041259766,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 151.36608123779297,
+ :y1 528.0178985595703,
+ :x2 312.84705352783203,
+ :y2 550.3036041259766,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 141},
+ :content {:text "super-linear speedup"},
:properties {:color "yellow"}}
- {:id #uuid "6430258a-4890-4fea-97c3-2d6bef20b251",
- :page 194,
- :position {:bounding {:x1 206.265625,
- :y1 392.46875,
- :x2 360.2623596191406,
- :y2 418.46875,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 206.265625,
- :y1 392.46875,
- :x2 360.2623596191406,
- :y2 418.46875,
- :width 1036.8,
- :height 1555.2}),
- :page 194},
+ {:id #uuid "642fb2f2-b9a4-48f4-b847-2b30d632db32",
+ :page 142,
+ :position {:bounding {:x1 498.49041748046875,
+ :y1 861.4910888671875,
+ :x2 549.4505004882812,
+ :y2 878.0625305175781,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 498.49041748046875,
+ :y1 861.4910888671875,
+ :x2 549.4505004882812,
+ :y2 878.0625305175781,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 142},
+ :content {:text "paranoid"},
+ :properties {:color "green"}}
+ {:id #uuid "642fb3d2-e51f-4b9b-8a79-dea9d8e6a7b0",
+ :page 143,
+ :position {:bounding {:x1 641.2160110473633,
+ :y1 464.18752670288086,
+ :x2 665.7519607543945,
+ :y2 480.75893783569336,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 641.2160110473633,
+ :y1 464.18752670288086,
+ :x2 665.7519607543945,
+ :y2 480.75893783569336,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 143},
+ :content {:text "rage"},
+ :properties {:color "green"}}
+ {:id #uuid "642fb4c0-5c56-44e9-aac6-396212698309",
+ :page 144,
+ :position {:bounding {:x1 408.4881896972656,
+ :y1 858.1786193847656,
+ :x2 470.48919677734375,
+ :y2 874.7500610351562,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 408.4881896972656,
+ :y1 858.1786193847656,
+ :x2 470.48919677734375,
+ :y2 874.7500610351562,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 144},
+ :content {:text "inundated "},
+ :properties {:color "green"}}
+ {:id #uuid "642fb51d-f82c-40b4-82ad-878ee13a2264",
+ :page 145,
+ :position {:bounding {:x1 185.1488800048828,
+ :y1 464.1875228881836,
+ :x2 222.21925354003906,
+ :y2 480.7589340209961,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 185.1488800048828,
+ :y1 464.1875228881836,
+ :x2 222.21925354003906,
+ :y2 480.7589340209961,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 145},
+ :content {:text "errant"},
+ :properties {:color "green"}}
+ {:id #uuid "642fb54e-23c4-4667-955d-ad09fbbf6268",
+ :page 146,
+ :position {:bounding {:x1 467.1715717315674,
+ :y1 444.8214416503906,
+ :x2 508.98282051086426,
+ :y2 461.39288330078125,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 467.1715717315674,
+ :y1 444.8214416503906,
+ :x2 508.98282051086426,
+ :y2 461.39288330078125,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 146},
+ :content {:text "darned"},
+ :properties {:color "green"}}
+ {:id #uuid "642fb9df-d4c2-4b75-9341-e9ea53d42dcc",
+ :page 148,
+ :position {:bounding {:x1 406.32401275634766,
+ :y1 702.6160888671875,
+ :x2 457.8776626586914,
+ :y2 720.3303833007812,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 406.32401275634766,
+ :y1 702.6160888671875,
+ :x2 457.8776626586914,
+ :y2 720.3303833007812,
+ :width 864,
+ :height 1296}),
+ :page 148},
+ :content {:text "pesky "},
+ :properties {:color "green"}}
+ {:id #uuid "642fbad1-cda0-4ef4-97f7-38c3519042f4",
+ :page 148,
+ :position {:bounding {:x1 328.5535888671875,
+ :y1 740.8035888671875,
+ :x2 439.8475036621094,
+ :y2 764.232177734375,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 328.5535888671875,
+ :y1 740.8035888671875,
+ :x2 439.8475036621094,
+ :y2 764.232177734375,
+ :width 864,
+ :height 1296}),
+ :page 148},
+ :content {:text "address space"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fbb24-877c-4c90-9e13-4e613e2e23d3",
+ :page 149,
+ :position {:bounding {:x1 658.6038513183594,
+ :y1 977.8750610351562,
+ :x2 690.0156555175781,
+ :y2 995.58935546875,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 658.6038513183594,
+ :y1 977.8750610351562,
+ :x2 690.0156555175781,
+ :y2 995.58935546875,
+ :width 864,
+ :height 1296}),
+ :page 149},
+ :content {:text "alas"},
+ :properties {:color "green"}}
+ {:id #uuid "642fbb6e-9a9a-4ff6-92ea-b36903da1b88",
+ :page 150,
+ :position {:bounding {:x1 116.09821701049805,
+ :y1 440.86608123779297,
+ :x2 176.94826126098633,
+ :y2 458.58040618896484,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 116.09821701049805,
+ :y1 440.86608123779297,
+ :x2 176.94826126098633,
+ :y2 458.58040618896484,
+ :width 864,
+ :height 1296}),
+ :page 150},
+ :content {:text "tandem "},
+ :properties {:color "green"}}
+ {:id #uuid "642fbc3d-d70b-4adb-bb0b-6b7038480589",
+ :page 150,
+ :position {:bounding {:x1 295.0501594543457,
+ :y1 1102.3929138183594,
+ :x2 362.9385566711426,
+ :y2 1116.1072082519531,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 295.0501594543457,
+ :y1 1102.3929138183594,
+ :x2 362.9385566711426,
+ :y2 1116.1072082519531,
+ :width 864,
+ :height 1296}),
+ :page 150},
+ :content {:text "stipulated "},
+ :properties {:color "green"}}
+ {:id #uuid "642fbfcb-7327-44b8-9b25-308728264a81",
+ :page 159,
+ :position {:bounding {:x1 185.8641815185547,
+ :y1 987.4286193847656,
+ :x2 255.6378631591797,
+ :y2 1005.1429138183594,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 185.8641815185547,
+ :y1 987.4286193847656,
+ :x2 255.6378631591797,
+ :y2 1005.1429138183594,
+ :width 864,
+ :height 1296}),
+ :page 159},
+ :content {:text "scribble "},
+ :properties {:color "green"}}
+ {:id #uuid "642fc139-afc3-4ba4-ad01-4cc33d9e535c",
+ :page 155,
+ :position {:bounding {:x1 532.6004333496094,
+ :y1 346.8839416503906,
+ :x2 691.9529724121094,
+ :y2 384.5982360839844,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 532.6004333496094,
+ :y1 346.8839416503906,
+ :x2 691.9529724121094,
+ :y2 384.5982360839844,
+ :width 864,
+ :height 1296}),
+ :page 155},
+ :content {:text "Memory API"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fc48b-e5bf-4043-b042-218445c2b714",
+ :page 167,
+ :position {:bounding {:x1 171.89286041259766,
+ :y1 642.3482513427734,
+ :x2 300.2626724243164,
+ :y2 664.0625457763672,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 171.89286041259766,
+ :y1 642.3482513427734,
+ :x2 300.2626724243164,
+ :y2 664.0625457763672,
+ :width 864,
+ :height 1296}),
+ :page 167},
:content {:text "Assumptions"},
:properties {:color "yellow"}}
- {:id #uuid "64302a62-c183-4dbf-94de-1861deb192f4",
- :page 195,
- :position {:bounding {:x1 275.55950927734375,
- :y1 565.21875,
- :x2 372.89495849609375,
- :y2 586.21875,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 275.55950927734375,
- :y1 565.21875,
- :x2 372.89495849609375,
- :y2 586.21875,
- :width 1036.8,
- :height 1555.2}),
- :page 195},
- :content {:text "coalescing"},
+ {:id #uuid "642fc65f-1147-459c-8906-5ffca38b1e66",
+ :page 170,
+ :position {:bounding {:x1 108.3486328125,
+ :y1 864.0803985595703,
+ :x2 460.24578857421875,
+ :y2 884.6518249511719,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 108.3486328125,
+ :y1 864.0803985595703,
+ :x2 460.24578857421875,
+ :y2 884.6518249511719,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 170},
+ :content {:text "Dynamic (Hardware-based) Relocation"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fc677-cbd4-47fd-bd90-3ed0cd56cc5b",
+ :page 171,
+ :position {:bounding {:x1 339.95838165283203,
+ :y1 182.0178680419922,
+ :x2 573.7257461547852,
+ :y2 198.5892791748047,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 339.95838165283203,
+ :y1 182.0178680419922,
+ :x2 573.7257461547852,
+ :y2 198.5892791748047,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 171},
+ :content {:text "SOFTWARE-BASED RELOCATION"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fced7-c809-4d1e-bddb-da6474e851b8",
+ :page 172,
+ :position {:bounding {:x1 0,
+ :y1 462.2857360839844,
+ :x2 645.8682518005371,
+ :y2 768.1161193847656,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 0,
+ :y1 462.2857360839844,
+ :x2 0,
+ :y2 481.71429443359375,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 582.5714378356934,
+ :y1 727.2321472167969,
+ :x2 645.8682518005371,
+ :y2 749.5179138183594,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 108.35714340209961,
+ :y1 745.8304138183594,
+ :x2 307.23522567749023,
+ :y2 768.1161193847656,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 108.35714340209961,
+ :y1 748.6875305175781,
+ :x2 307.23522567749023,
+ :y2 765.4286193847656,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 172},
+ :content {:text "memory management unit (MMU)"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fcf85-6cfb-4eb9-aef2-ddcef7027b70",
+ :page 173,
+ :position {:bounding {:x1 594.1667251586914,
+ :y1 801.4464416503906,
+ :x2 631.7198867797852,
+ :y2 818.0178833007812,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 594.1667251586914,
+ :y1 801.4464416503906,
+ :x2 631.7198867797852,
+ :y2 818.0178833007812,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 173},
+ :content {:text "havoc"},
:properties {:color "green"}}
- {:id #uuid "64302ac2-a341-467e-9469-baca1e8aa7f2",
- :page 195,
- :position {:bounding {:x1 0,
- :y1 285,
- :x2 830.3397216796875,
- :y2 779.15625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 0,
- :y1 285,
- :x2 0,
- :y2 307,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 734.25,
- :x2 830.3397216796875,
- :y2 755.25,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 758.15625,
- :x2 335.2363586425781,
- :y2 779.15625,
- :width 1036.8,
- :height 1555.2}),
- :page 195},
- :content {:text "A free list contains a set of elements that describe the free space still remaining in the heap."},
- :properties {:color "yellow"}}
- {:id #uuid "64302b20-f76e-4516-868f-0ecab376328f",
- :page 196,
- :position {:bounding {:x1 697.3678588867188,
- :y1 479.21875,
- :x2 749.7317504882812,
- :y2 500.21875,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 697.3678588867188,
- :y1 479.21875,
- :x2 749.7317504882812,
- :y2 500.21875,
- :width 1036.8,
- :height 1555.2}),
- :page 196},
- :content {:text "intact"},
+ {:id #uuid "642fcf90-3133-4002-b986-4fd8157ab707",
+ :page 173,
+ :position {:bounding {:x1 263.87279510498047,
+ :y1 822.919677734375,
+ :x2 300.8291549682617,
+ :y2 839.4910888671875,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 263.87279510498047,
+ :y1 822.919677734375,
+ :x2 300.8291549682617,
+ :y2 839.4910888671875,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 173},
+ :content {:text "wreak"},
:properties {:color "green"}}
- {:id #uuid "64302b32-b01b-4cb2-b027-5ad59bd7ec11",
- :page 196,
- :position {:bounding {:x1 254.9693603515625,
- :y1 578.34375,
- :x2 355.1087341308594,
- :y2 599.34375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 254.9693603515625,
- :y1 578.34375,
- :x2 355.1087341308594,
- :y2 599.34375,
- :width 1036.8,
- :height 1555.2}),
- :page 196},
- :content {:text "corollary "},
+ {:id #uuid "642fcfa9-c026-4885-9f50-029ca80ce148",
+ :page 174,
+ :position {:bounding {:x1 295.96537590026855,
+ :y1 470.6607437133789,
+ :x2 344.6133556365967,
+ :y2 487.2321548461914,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 295.96537590026855,
+ :y1 470.6607437133789,
+ :x2 344.6133556365967,
+ :y2 487.2321548461914,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 174},
+ :content {:text "ghastly"},
:properties {:color "green"}}
- {:id #uuid "64302da4-d1d5-41df-8ec8-883712d948d5",
- :page 195,
- :position {:bounding {:x1 139.3125,
- :y1 691.859375,
- :x2 408.8620910644531,
- :y2 722.859375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 691.859375,
- :x2 408.8620910644531,
- :y2 722.859375,
- :width 1036.8,
- :height 1555.2}),
- :page 195},
- :content {:text "Splitting and Coalescing"},
- :properties {:color "yellow"}}
- {:id #uuid "64302eab-54b3-4e8c-a105-cc3e8747c0f3",
- :page 197,
- :position {:bounding {:x1 139.3125,
- :y1 814.921875,
- :x2 576.952392578125,
- :y2 845.921875,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 814.921875,
- :x2 576.952392578125,
- :y2 845.921875,
- :width 1036.8,
- :height 1555.2}),
- :page 197},
- :content {:text "Tracking The Size Of Allocated Regions"},
- :properties {:color "yellow"}}
- {:id #uuid "64303176-25c9-4d28-bd6e-b5b00bf74e3a",
- :page 197,
- :position {:bounding {:x1 265.125,
- :y1 733.9375,
- :x2 704.548095703125,
- :y2 762.9375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 381.796875,
- :y1 733.9375,
- :x2 704.548095703125,
- :y2 762.9375,
- :width 1036.8,
- :height 1555.2}
- {:x1 265.125,
- :y1 736.5,
- :x2 381.8045654296875,
- :y2 757.5,
- :width 1036.8,
- :height 1555.2}),
- :page 197},
- :content {:text "Figure 17.2: Specific Contents Of The Header"},
- :properties {:color "yellow"}}
- {:id #uuid "643032f8-4103-4d7c-b471-fae4364ce7b5",
- :page 198,
- :position {:bounding {:x1 206.28125,
- :y1 625.40625,
- :x2 457.9869079589844,
- :y2 656.40625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 206.28125,
- :y1 625.40625,
- :x2 457.9869079589844,
- :y2 656.40625,
- :width 1036.8,
- :height 1555.2}),
- :page 198},
- :content {:text "Embedding A Free List"},
- :properties {:color "yellow"}}
- {:id #uuid "643034f6-efa7-4f59-80a9-3561c52a5218",
- :page 203,
- :position {:bounding {:x1 139.3125,
- :y1 604.0625,
- :x2 317.9329528808594,
- :y2 630.0625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 604.0625,
- :x2 317.9329528808594,
- :y2 630.0625,
- :width 1036.8,
- :height 1555.2}),
- :page 203},
- :content {:text "Basic Strategies"},
- :properties {:color "yellow"}}
- {:id #uuid "6430350b-81b6-44db-a10d-fb0b392e957c",
- :page 203,
- :position {:bounding {:x1 139.3125,
- :y1 943.015625,
- :x2 220.99745178222656,
- :y2 974.015625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 943.015625,
- :x2 220.99745178222656,
- :y2 974.015625,
- :width 1036.8,
- :height 1555.2}),
- :page 203},
- :content {:text "Best Fit"},
- :properties {:color "yellow"}}
- {:id #uuid "6430350e-5d5f-4e5a-9342-7b57874ffda8",
- :page 203,
- :position {:bounding {:x1 139.3125,
- :y1 1228.15625,
- :x2 237.8300018310547,
- :y2 1259.15625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 1228.15625,
- :x2 237.8300018310547,
- :y2 1259.15625,
- :width 1036.8,
- :height 1555.2}),
- :page 203},
- :content {:text "Worst Fit"},
- :properties {:color "yellow"}}
- {:id #uuid "64303512-4b59-4c95-b86d-62a2e1349490",
- :page 204,
- :position {:bounding {:x1 206.265625,
- :y1 339.03125,
- :x2 290.59710693359375,
- :y2 370.03125,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 206.265625,
- :y1 339.03125,
- :x2 290.59710693359375,
- :y2 370.03125,
- :width 1036.8,
- :height 1555.2}),
- :page 204},
- :content {:text "First Fit"},
- :properties {:color "yellow"}}
- {:id #uuid "64303515-c336-4934-987d-4ea4a29a7dfd",
- :page 204,
- :position {:bounding {:x1 206.265625,
- :y1 621.4375,
- :x2 293.2553405761719,
- :y2 652.4375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 206.265625,
- :y1 621.4375,
- :x2 293.2553405761719,
- :y2 652.4375,
- :width 1036.8,
- :height 1555.2}),
- :page 204},
- :content {:text "Next Fit"},
- :properties {:color "yellow"}}
- {:id #uuid "6430382d-9e37-412f-b983-e2a7f624954a",
- :page 204,
- :position {:bounding {:x1 663.82666015625,
- :y1 874.3125,
- :x2 747.8853759765625,
- :y2 895.3125,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 663.82666015625,
- :y1 874.3125,
- :x2 747.8853759765625,
- :y2 895.3125,
- :width 1036.8,
- :height 1555.2}),
- :page 204},
- :content {:text "Envision "},
+ {:id #uuid "642fcff1-ae71-4756-9847-5ab85c41be06",
+ :page 174,
+ :position {:bounding {:x1 563.5171890258789,
+ :y1 819.3750610351562,
+ :x2 622.2142715454102,
+ :y2 835.9464874267578,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 563.5171890258789,
+ :y1 819.3750610351562,
+ :x2 622.2142715454102,
+ :y2 835.9464874267578,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 174},
+ :content {:text "junctures"},
:properties {:color "green"}}
- {:id #uuid "64303831-b777-42c4-a349-d6e95ac91b25",
- :page 204,
- :position {:bounding {:x1 791.7130737304688,
- :y1 735.59375,
- :x2 897.3075561523438,
- :y2 756.59375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 791.7130737304688,
- :y1 735.59375,
- :x2 897.3075561523438,
- :y2 756.59375,
- :width 1036.8,
- :height 1555.2}),
- :page 204},
- :content {:text "splintering"},
+ {:id #uuid "642fd071-db9c-4f0e-886f-b6ba3e5e4f7d",
+ :page 175,
+ :position {:bounding {:x1 263.1218795776367,
+ :y1 857.2053833007812,
+ :x2 331.5805435180664,
+ :y2 873.7768249511719,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 263.1218795776367,
+ :y1 857.2053833007812,
+ :x2 331.5805435180664,
+ :y2 873.7768249511719,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 175},
+ :content {:text "oblivious "},
:properties {:color "green"}}
- {:id #uuid "64303b17-81c8-4d92-ab80-1e48c3598403",
- :page 205,
- :position {:bounding {:x1 139.3125,
- :y1 651,
- :x2 317.9664611816406,
- :y2 682,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 139.3125,
- :y1 651,
- :x2 317.9664611816406,
- :y2 682,
- :width 1036.8,
- :height 1555.2}),
- :page 205},
- :content {:text "Segregated Lists"},
+ {:id #uuid "642fd1ed-22a9-4443-b02f-bc35fe42e50b",
+ :page 174,
+ :position {:bounding {:x1 245.77680206298828,
+ :y1 412.4821662902832,
+ :x2 599.3089981079102,
+ :y2 434.76787185668945,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 245.77680206298828,
+ :y1 412.4821662902832,
+ :x2 599.3089981079102,
+ :y2 434.76787185668945,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 174},
+ :content {:text "Dynamic Relocation: Hardware Requirements"},
:properties {:color "yellow"}}
- {:id #uuid "64303b24-47e4-4016-8111-519c599e6cca",
- :page 205,
+ {:id #uuid "642fd1f4-d573-4dbc-9e48-02adacc69e5e",
+ :page 175,
+ :position {:bounding {:x1 258.5803756713867,
+ :y1 304.2589302062988,
+ :x2 690.6892623901367,
+ :y2 326.5446662902832,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 258.5803756713867,
+ :y1 304.2589302062988,
+ :x2 690.6892623901367,
+ :y2 326.5446662902832,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 175},
+ :content {:text "Dynamic Relocation: Operating System Responsibilities"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fd2f3-e05f-453c-8286-15e7807e8e97",
+ :page 178,
:position {:bounding {:x1 0,
- :y1 269,
- :x2 830.3434448242188,
- :y2 810.703125,
- :width 1036.8,
- :height 1555.2},
+ :y1 190.2857208251953,
+ :x2 645.8295669555664,
+ :y2 413.9375457763672,
+ :width 806.3999999999999,
+ :height 1209.6},
:rects ({:x1 0,
- :y1 269,
+ :y1 190.2857208251953,
:x2 0,
- :y2 291,
- :width 1036.8,
- :height 1555.2}
+ :y2 209.7142791748047,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 624.4375381469727,
+ :y1 373.05357360839844,
+ :x2 645.8295669555664,
+ :y2 395.3392791748047,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 108.35714721679688,
+ :y1 391.6518096923828,
+ :x2 266.05450439453125,
+ :y2 413.9375457763672,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 108.35714721679688,
+ :y1 394.5089569091797,
+ :x2 266.05450439453125,
+ :y2 411.2500457763672,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 178},
+ :content {:text "internal fragmentation"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fd36e-c0a7-4ead-a3a8-f085d6576229",
+ :page 167,
+ :position {:bounding {:x1 261.12808990478516,
+ :y1 205.67858013510704,
+ :x2 533.4398574829102,
+ :y2 227.96430096030235,
+ :width 806.3999999999999,
+ :height 1209.6},
+ :rects ({:x1 261.4018020629883,
+ :y1 205.67858013510704,
+ :x2 533.4398574829102,
+ :y2 227.96430096030235,
+ :width 806.3999999999999,
+ :height 1209.6}
+ {:x1 261.12808990478516,
+ :y1 207.41965374350548,
+ :x2 533.4398574829102,
+ :y2 223.99108013510704,
+ :width 806.3999999999999,
+ :height 1209.6}),
+ :page 167},
+ :content {:text "hardware-based address translation"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fd5c3-30f9-4770-8ec5-09555d21c4ab",
+ :page 181,
+ :position {:bounding {:x1 116.09822082519531,
+ :y1 958.7767944335938,
+ :x2 514.5045623779297,
+ :y2 980.4910888671875,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 116.09822082519531,
+ :y1 958.7767944335938,
+ :x2 514.5045623779297,
+ :y2 980.4910888671875,
+ :width 864,
+ :height 1296}),
+ :page 181},
+ :content {:text "Segmentation: Generalized Base/Bounds"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fda54-4040-4d9b-ab00-13523aeb54c4",
+ :page 185,
+ :position {:bounding {:x1 378.80360412597656,
+ :y1 1097.276840209961,
+ :x2 524.0114593505859,
+ :y2 1120.7054138183594,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 378.80360412597656,
+ :y1 1097.276840209961,
+ :x2 448.84825134277344,
+ :y2 1120.7054138183594,
+ :width 864,
+ :height 1296}
+ {:x1 443.54466247558594,
+ :y1 1100.1339874267578,
+ :x2 524.0114593505859,
+ :y2 1118.0625610351562,
+ :width 864,
+ :height 1296}),
+ :page 185},
+ :content {:text "implicit approach,"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fdca4-df4b-4515-8e96-ef4b05a7bb62",
+ :page 186,
+ :position {:bounding {:x1 566.0081558227539,
+ :y1 391.0178680419922,
+ :x2 707.7133255004883,
+ :y2 408.73216247558594,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 566.0081558227539,
+ :y1 391.0178680419922,
+ :x2 707.7133255004883,
+ :y2 408.73216247558594,
+ :width 864,
+ :height 1296}),
+ :page 186},
+ :content {:text "it grows backwards"},
+ :properties {:color "yellow"}}
+ {:id #uuid "642fe0dc-7d4b-41af-a136-69164ee77ab4",
+ :page 187,
+ :position {:bounding {:x1 116.09822273254395,
+ :y1 179.01787185668945,
+ :x2 308.1895008087158,
+ :y2 200.73215103149414,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 116.09822273254395,
+ :y1 179.01787185668945,
+ :x2 308.1895008087158,
+ :y2 200.73215103149414,
+ :width 864,
+ :height 1296}),
+ :page 187},
+ :content {:text "Support for Sharing"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430bfab-9ff7-44cb-ad64-c422796cad71",
+ :page 213,
+ :position {:bounding {:x1 292.1696472167969,
+ :y1 379.9821734428406,
+ :x2 377.8273162841797,
+ :y2 403.41073179244995,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 292.1696472167969,
+ :y1 379.9821734428406,
+ :x2 377.8273162841797,
+ :y2 403.41073179244995,
+ :width 864,
+ :height 1296}),
+ :page 213},
+ :content {:text "page table"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430c091-bc57-4930-bac1-9e1762b7c3e1",
+ :page 213,
+ :position {:bounding {:x1 0,
+ :y1 270.2857208251953,
+ :x2 691.8273773193359,
+ :y2 538.8392944335938,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 0,
+ :y1 270.2857208251953,
+ :x2 0,
+ :y2 289.71429443359375,
+ :width 864,
+ :height 1296}
+ {:x1 563.7946624755859,
+ :y1 501.1964416503906,
+ :x2 691.8273773193359,
+ :y2 519.1250305175781,
+ :width 864,
+ :height 1296}
+ {:x1 116.08929061889648,
+ :y1 521.1250305175781,
+ :x2 188.8107566833496,
+ :y2 538.8392944335938,
+ :width 864,
+ :height 1296}),
+ :page 213},
+ :content {:text " per-process data structure"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430c0a5-6e88-455c-8a62-ab6e60fca98f",
+ :page 213,
+ :position {:bounding {:x1 0,
+ :y1 494.2857484817505,
+ :x2 691.7999114990234,
+ :y2 836.2143249511719,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 0,
+ :y1 494.2857484817505,
+ :x2 0,
+ :y2 513.7143220901489,
+ :width 864,
+ :height 1296}
+ {:x1 430.75001525878906,
+ :y1 792.8661193847656,
+ :x2 653.0842742919922,
+ :y2 816.294677734375,
+ :width 864,
+ :height 1296}
+ {:x1 263.4424133300781,
+ :y1 794.5268249511719,
+ :x2 691.7999114990234,
+ :y2 812.4554138183594,
+ :width 864,
+ :height 1296}
+ {:x1 145.79464721679688,
+ :y1 812.7857666015625,
+ :x2 192.31140899658203,
+ :y2 836.2143249511719,
+ :width 864,
+ :height 1296}
+ {:x1 116.08929061889648,
+ :y1 814.4554138183594,
+ :x2 192.31140899658203,
+ :y2 832.3839721679688,
+ :width 864,
+ :height 1296}),
+ :page 213},
+ :content {:text "to two components: the virtual page number (VPN), and the offset"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430c173-13a7-4bce-9d60-3f1d2a7fb3f4",
+ :page 214,
+ :position {:bounding {:x1 370.9896926879883,
+ :y1 624.6517944335938,
+ :x2 617.3806228637695,
+ :y2 648.0803833007812,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 371.00894927978516,
+ :y1 624.6517944335938,
+ :x2 609.2644119262695,
+ :y2 648.0803833007812,
+ :width 864,
+ :height 1296}
+ {:x1 370.9896926879883,
+ :y1 626.3125,
+ :x2 617.3806228637695,
+ :y2 644.2410888671875,
+ :width 864,
+ :height 1296}),
+ :page 214},
+ :content {:text "physical frame number (PFN)"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430c18b-cd3f-400d-8414-3b780ed1b4ce",
+ :page 215,
+ :position {:bounding {:x1 336.12825775146484,
+ :y1 768.1964721679688,
+ :x2 414.7227249145508,
+ :y2 785.9107666015625,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 336.12825775146484,
+ :y1 768.1964721679688,
+ :x2 414.7227249145508,
+ :y2 785.9107666015625,
+ :width 864,
+ :height 1296}),
+ :page 215},
+ :content {:text "beguiling "},
+ :properties {:color "green"}}
+ {:id #uuid "6430c51c-591b-4739-921a-ea9e0abbfbaa",
+ :page 216,
+ :position {:bounding {:x1 203.78307342529297,
+ :y1 458.76788330078125,
+ :x2 267.5793685913086,
+ :y2 476.4821472167969,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 203.78307342529297,
+ :y1 458.76788330078125,
+ :x2 267.5793685913086,
+ :y2 476.4821472167969,
+ :width 864,
+ :height 1296}),
+ :page 216},
+ :content {:text "gruesome"},
+ :properties {:color "green"}}
+ {:id #uuid "6430c5f3-3ce3-486d-b7ee-832673fa4d4d",
+ :page 217,
+ :position {:bounding {:x1 182.60790252685547,
+ :y1 1042.7500305175781,
+ :x2 290.69754791259766,
+ :y2 1060.4643249511719,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 182.60790252685547,
+ :y1 1042.7500305175781,
+ :x2 290.69754791259766,
+ :y2 1060.4643249511719,
+ :width 864,
+ :height 1296}),
+ :page 217},
+ :content {:text "judiciousness"},
+ :properties {:color "green"}}
+ {:id #uuid "6430c665-8485-46e6-810a-b2d62b01cf66",
+ :page 215,
+ :position {:bounding {:x1 0,
+ :y1 734.2857513427734,
+ :x2 691.0049819946289,
+ :y2 1056.8929138183594,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 0,
+ :y1 734.2857513427734,
+ :x2 0,
+ :y2 753.7143249511719,
+ :width 864,
+ :height 1296}
+ {:x1 253.03572845458984,
+ :y1 1017.5982666015625,
+ :x2 442.4459915161133,
+ :y2 1041.0268249511719,
+ :width 864,
+ :height 1296}
+ {:x1 437.19644927978516,
+ :y1 1020.4554138183594,
+ :x2 691.0049819946289,
+ :y2 1038.3840026855469,
+ :width 864,
+ :height 1296}
+ {:x1 116.09821891784668,
+ :y1 1039.1786193847656,
+ :x2 330.14942741394043,
+ :y2 1056.8929138183594,
+ :width 864,
+ :height 1296}),
+ :page 215},
+ :content {:text "page table entry (PTE) to hold the physical translation plus any other useful stu"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430cac6-63c8-4ab7-a402-49097ef24154",
+ :page 219,
+ :position {:bounding {:x1 224.4910888671875,
+ :y1 580.5000381469727,
+ :x2 583.5963134765625,
+ :y2 603.928596496582,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 321.7232360839844,
+ :y1 580.5000381469727,
+ :x2 583.5963134765625,
+ :y2 603.928596496582,
+ :width 864,
+ :height 1296}
+ {:x1 224.4910888671875,
+ :y1 582.1607437133789,
+ :x2 321.7139892578125,
+ :y2 599.8750381469727,
+ :width 864,
+ :height 1296}),
+ :page 219},
+ :content {:text "Figure 18.6: Accessing Memory With Paging"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430cb48-d435-4bb4-807e-402ee20d0a98",
+ :page 216,
+ :position {:bounding {:x1 0,
+ :y1 429.14288806915283,
+ :x2 747.7490539550781,
+ :y2 857.169677734375,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 0,
+ :y1 429.14288806915283,
+ :x2 0,
+ :y2 450.2857446670532,
+ :width 864,
+ :height 1296}
{:x1 0,
- :y1 285,
+ :y1 445.14288902282715,
:x2 0,
- :y2 307,
- :width 1036.8,
- :height 1555.2}
+ :y2 466.2857475280762,
+ :width 864,
+ :height 1296}
{:x1 0,
- :y1 301,
+ :y1 461.1428909301758,
:x2 0,
- :y2 323,
- :width 1036.8,
- :height 1555.2}
- {:x1 588.3651123046875,
- :y1 717.96875,
- :x2 830.3397827148438,
- :y2 738.96875,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 741.875,
- :x2 830.3272094726562,
- :y2 763.390625,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 765.796875,
- :x2 830.3434448242188,
- :y2 787.3125,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 789.703125,
- :x2 458.33245849609375,
- :y2 810.703125,
- :width 1036.8,
- :height 1555.2}),
- :page 205},
- :content {:text "f a particular application has one (or a few) popular-sized request that it makes, keep a separate list just to manage objects of that size; all other requests are forwarded to a more general memory allocator."},
+ :y2 482.2857475280762,
+ :width 864,
+ :height 1296}
+ {:x1 656.2946472167969,
+ :y1 778.0357666015625,
+ :x2 747.7490539550781,
+ :y2 801.4643249511719,
+ :width 864,
+ :height 1296}
+ {:x1 651.5446472167969,
+ :y1 779.6964721679688,
+ :x2 747.7490539550781,
+ :y2 797.6250305175781,
+ :width 864,
+ :height 1296}
+ {:x1 171.8928680419922,
+ :y1 797.9554138183594,
+ :x2 212.7416534423828,
+ :y2 821.3839721679688,
+ :width 864,
+ :height 1296}
+ {:x1 171.8928680419922,
+ :y1 800.8125610351562,
+ :x2 746.8775329589844,
+ :y2 818.7411193847656,
+ :width 864,
+ :height 1296}
+ {:x1 171.8928680419922,
+ :y1 819.544677734375,
+ :x2 745.5410003662109,
+ :y2 837.4732666015625,
+ :width 864,
+ :height 1296}
+ {:x1 171.8928680419922,
+ :y1 839.4554138183594,
+ :x2 608.1875457763672,
+ :y2 857.169677734375,
+ :width 864,
+ :height 1296}),
+ :page 216},
+ :content {:text " linear page table, which is just an array. The OS indexes the array by the virtual page number (VPN), and looks up the page-table entry (PTE) at that index in order to find the desired physical frame number (PFN)."},
:properties {:color "yellow"}}
- {:id #uuid "64303d7c-6ac2-462c-98c9-1b61ea58a396",
- :page 205,
+ {:id #uuid "6430cc79-5b7c-4cc3-9d7e-39a44a333c77",
+ :page 226,
+ :position {:bounding {:x1 233.6696548461914,
+ :y1 928.1160888671875,
+ :x2 529.5121078491211,
+ :y2 951.5446472167969,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 233.6696548461914,
+ :y1 928.1160888671875,
+ :x2 464.1027145385742,
+ :y2 951.5446472167969,
+ :width 864,
+ :height 1296}
+ {:x1 494.61608123779297,
+ :y1 928.1160888671875,
+ :x2 529.5121078491211,
+ :y2 951.5446472167969,
+ :width 864,
+ :height 1296}
+ {:x1 464.08931732177734,
+ :y1 929.7767944335938,
+ :x2 494.60372161865234,
+ :y2 947.7053833007812,
+ :width 864,
+ :height 1296}),
+ :page 226},
+ :content {:text "translation-lookaside buffer, or TLB"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430ccdf-09c2-42e2-aa80-7859bb320b91",
+ :page 227,
+ :position {:bounding {:x1 292.38394927978516,
+ :y1 566.0982666015625,
+ :x2 627.2922592163086,
+ :y2 589.5267944335938,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 389.60717010498047,
+ :y1 566.0982666015625,
+ :x2 627.2922592163086,
+ :y2 589.5267944335938,
+ :width 864,
+ :height 1296}
+ {:x1 292.38394927978516,
+ :y1 567.7589721679688,
+ :x2 389.5889205932617,
+ :y2 585.4732666015625,
+ :width 864,
+ :height 1296}),
+ :page 227},
+ :content {:text "Figure 19.1: TLB Control Flow Algorithm"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430d370-e99b-4443-bd55-3aa5b941b2c4",
+ :page 228,
+ :position {:bounding {:x1 479.61145782470703,
+ :y1 182.38394165039062,
+ :x2 544.302864074707,
+ :y2 200.09823608398438,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 479.61145782470703,
+ :y1 182.38394165039062,
+ :x2 544.302864074707,
+ :y2 200.09823608398438,
+ :width 864,
+ :height 1296}),
+ :page 228},
+ :content {:text "premise "},
+ :properties {:color "green"}}
+ {:id #uuid "6430d54f-9837-4f82-b4b0-13ab387c9a7a",
+ :page 231,
+ :position {:bounding {:x1 426.67589569091797,
+ :y1 558.3482360839844,
+ :x2 486.1343307495117,
+ :y2 576.0625305175781,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 426.67589569091797,
+ :y1 558.3482360839844,
+ :x2 486.1343307495117,
+ :y2 576.0625305175781,
+ :width 864,
+ :height 1296}),
+ :page 231},
+ :content {:text "sneaky "},
+ :properties {:color "green"}}
+ {:id #uuid "6430d596-d805-4bc8-a3a7-219d6927a503",
+ :page 231,
+ :position {:bounding {:x1 171.89286041259766,
+ :y1 437.2053680419922,
+ :x2 453.11307525634766,
+ :y2 458.9196548461914,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 171.89286041259766,
+ :y1 437.2053680419922,
+ :x2 453.11307525634766,
+ :y2 458.9196548461914,
+ :width 864,
+ :height 1296}),
+ :page 231},
+ :content {:text "Who Handles The TLB Miss?"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430d5ac-5021-4b2e-a5d7-e3e4988a4a89",
+ :page 231,
+ :position {:bounding {:x1 341.72127532958984,
+ :y1 696.1517944335938,
+ :x2 549.0402755737305,
+ :y2 719.5803833007812,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 341.74108123779297,
+ :y1 696.1517944335938,
+ :x2 549.0402755737305,
+ :y2 719.5803833007812,
+ :width 864,
+ :height 1296}
+ {:x1 341.72127532958984,
+ :y1 697.8125305175781,
+ :x2 549.0402755737305,
+ :y2 715.5267944335938,
+ :width 864,
+ :height 1296}),
+ :page 231},
+ :content {:text "hardware-managed TLBs"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430d5be-7a59-4ef2-9ba3-94e8298f4e47",
+ :page 231,
+ :position {:bounding {:x1 269.5446548461914,
+ :y1 797.0982666015625,
+ :x2 461.39708709716797,
+ :y2 820.5268249511719,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 269.5446548461914,
+ :y1 797.0982666015625,
+ :x2 461.39708709716797,
+ :y2 820.5268249511719,
+ :width 864,
+ :height 1296}),
+ :page 231},
+ :content {:text "software-managed TLB"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430db45-ace1-4bcf-9672-b929c8720bf2",
+ :page 233,
:position {:bounding {:x1 0,
- :y1 509,
- :x2 830.3489379882812,
- :y2 1129.984375,
- :width 1036.8,
- :height 1555.2},
+ :y1 381.14288330078125,
+ :x2 747.7241287231445,
+ :y2 815.0357666015625,
+ :width 864,
+ :height 1296},
:rects ({:x1 0,
- :y1 509,
+ :y1 381.14288330078125,
:x2 0,
- :y2 531,
- :width 1036.8,
- :height 1555.2}
- {:x1 770.578125,
- :y1 1077.078125,
- :x2 830.3489379882812,
- :y2 1106.078125,
- :width 1036.8,
- :height 1555.2}
- {:x1 279.8678283691406,
- :y1 1079.640625,
- :x2 830.3489379882812,
- :y2 1101.15625,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 1100.984375,
- :x2 206.98757934570312,
- :y2 1129.984375,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 1104.984375,
- :x2 750.18896484375,
- :y2 1126.5,
- :width 1036.8,
- :height 1555.2}),
- :page 205},
- :content {:text ", when the kernel boots up, it allocates a number of object caches for kernel objects that are likely to be requested frequently"},
+ :y2 402.2857360839844,
+ :width 864,
+ :height 1296}
+ {:x1 639.6428909301758,
+ :y1 771.6786193847656,
+ :x2 747.7241287231445,
+ :y2 795.107177734375,
+ :width 864,
+ :height 1296}
+ {:x1 171.8928680419922,
+ :y1 791.607177734375,
+ :x2 202.7895965576172,
+ :y2 815.0357666015625,
+ :width 864,
+ :height 1296}),
+ :page 233},
+ :content {:text "fully associative"},
:properties {:color "yellow"}}
- {:id #uuid "64303d8e-54a3-4b7f-a879-7c2533ad8b02",
- :page 205,
+ {:id #uuid "6430e32c-f334-4274-a56f-03a793d05df9",
+ :page 236,
+ :position {:bounding {:x1 176.55016326904297,
+ :y1 179.01786041259766,
+ :x2 368.0005569458008,
+ :y2 200.73214721679688,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 176.55016326904297,
+ :y1 179.01786041259766,
+ :x2 368.0005569458008,
+ :y2 200.73214721679688,
+ :width 864,
+ :height 1296}),
+ :page 236},
+ :content {:text " Replacement Policy"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6430e441-2997-4efb-a6b2-f0bcee885f27",
+ :page 238,
+ :position {:bounding {:x1 454.19637298583984,
+ :y1 242.16073608398438,
+ :x2 497.84362030029297,
+ :y2 259.8750305175781,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 454.19637298583984,
+ :y1 242.16073608398438,
+ :x2 497.84362030029297,
+ :y2 259.8750305175781,
+ :width 864,
+ :height 1296}),
+ :page 238},
+ :content {:text "rosy "},
+ :properties {:color "green"}}
+ {:id #uuid "6430e5e3-d80e-44f2-8cfc-7424b8a8ff92",
+ :page 238,
:position {:bounding {:x1 0,
- :y1 573,
- :x2 830.3426208496094,
- :y2 1225.625,
- :width 1036.8,
- :height 1555.2},
+ :y1 61.14286804199219,
+ :x2 689.8498764038086,
+ :y2 279.80357360839844,
+ :width 864,
+ :height 1296},
:rects ({:x1 0,
- :y1 573,
+ :y1 61.14286804199219,
:x2 0,
- :y2 595,
- :width 1036.8,
- :height 1555.2}
- {:x1 238.18783569335938,
- :y1 1175.28125,
- :x2 830.3426208496094,
- :y2 1196.28125,
- :width 1036.8,
- :height 1555.2}
- {:x1 197.546875,
- :y1 1196.625,
- :x2 254.109375,
- :y2 1225.625,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 1199.1875,
- :x2 757.2152099609375,
- :y2 1220.703125,
- :width 1036.8,
- :height 1555.2}),
- :page 205},
- :content {:text "hen a given cache is running low on free space, it requests some slabs of memory from a more general memory allocator ("},
+ :y2 82.28572082519531,
+ :width 864,
+ :height 1296}
+ {:x1 227.28630828857422,
+ :y1 242.1607208251953,
+ :x2 689.8498764038086,
+ :y2 259.87501525878906,
+ :width 864,
+ :height 1296}
+ {:x1 116.09822082519531,
+ :y1 262.0893096923828,
+ :x2 161.99095916748047,
+ :y2 279.80357360839844,
+ :width 864,
+ :height 1296}),
+ :page 238},
+ :content {:text "LBs do not make the world rosy for every program that exists"},
:properties {:color "yellow"}}
- {:id #uuid "64303da3-9def-447a-9cc8-08942db17f38",
- :page 205,
+ {:id #uuid "6430e720-f62a-4094-9ecf-3a6d47540d34",
+ :page 240,
+ :position {:bounding {:x1 335.6250228881836,
+ :y1 759.4286193847656,
+ :x2 509.79073333740234,
+ :y2 781.7143249511719,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 335.6250228881836,
+ :y1 759.4286193847656,
+ :x2 509.79073333740234,
+ :y2 781.7143249511719,
+ :width 864,
+ :height 1296}),
+ :page 240},
+ :content {:text "TLB Size Measurement"},
+ :properties {:color "yellow"}}
+ {:id #uuid "643106f5-b280-4331-be8e-70f8c34c3c28",
+ :page 242,
+ :position {:bounding {:x1 286.1451416015625,
+ :y1 890.4464416503906,
+ :x2 406.1989440917969,
+ :y2 912.1607360839844,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 286.1451416015625,
+ :y1 890.4464416503906,
+ :x2 406.1989440917969,
+ :y2 912.1607360839844,
+ :width 864,
+ :height 1296}),
+ :page 242},
+ :content {:text "Bigger Pages"},
+ :properties {:color "yellow"}}
+ {:id #uuid "6431070d-a42a-4403-b6c5-bab956d5608f",
+ :page 242,
:position {:bounding {:x1 0,
- :y1 621,
- :x2 830.3461303710938,
- :y2 1315.8125,
- :width 1036.8,
- :height 1555.2},
+ :y1 29.14285659790039,
+ :x2 689.751106262207,
+ :y2 496.28572845458984,
+ :width 864,
+ :height 1296},
:rects ({:x1 0,
- :y1 621,
+ :y1 29.14285659790039,
:x2 0,
- :y2 643,
- :width 1036.8,
- :height 1555.2}
- {:x1 0,
- :y1 637,
- :x2 0,
- :y2 659,
- :width 1036.8,
- :height 1555.2}
- {:x1 366.1932678222656,
- :y1 1247.015625,
- :x2 830.3406982421875,
- :y2 1268.015625,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 1270.921875,
- :x2 830.3461303710938,
- :y2 1292.4375,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 1294.8125,
- :x2 372.8996276855469,
- :y2 1315.8125,
- :width 1036.8,
- :height 1555.2}),
- :page 205},
- :content {:text "when the reference counts of the objects within a given slab all go to zero, the general allocator can reclaim them from the specialized allocato"},
+ :y2 50.28571319580078,
+ :width 864,
+ :height 1296}
+ {:x1 596.9524612426758,
+ :y1 458.42858123779297,
+ :x2 689.751106262207,
+ :y2 476.1428756713867,
+ :width 864,
+ :height 1296}
+ {:x1 116.09822273254395,
+ :y1 478.35717010498047,
+ :x2 520.7247180938721,
+ :y2 496.28572845458984,
+ :width 864,
+ :height 1296}),
+ :page 242},
+ :content {:text "page tables are too big and thus consume too much memory."},
:properties {:color "yellow"}}
- {:id #uuid "64303db7-987f-47ed-84de-c17e421159aa",
- :page 206,
+ {:id #uuid "64310894-f97b-4d29-b477-75d45b1af812",
+ :page 245,
+ :position {:bounding {:x1 276.6483688354492,
+ :y1 282.0089569091797,
+ :x2 414.1182327270508,
+ :y2 299.72325134277344,
+ :width 864,
+ :height 1296},
+ :rects ({:x1 276.6483688354492,
+ :y1 282.0089569091797,
+ :x2 414.1182327270508,
+ :y2 299.72325134277344,
+ :width 864,
+ :height 1296}),
+ :page 245},
+ :content {:text "hybrid approach: "},
+ :properties {:color "yellow"}}
+ {:id #uuid "64310f59-4581-45b8-9b56-9e0ef04ec513",
+ :page 246,
:position {:bounding {:x1 0,
- :y1 237,
- :x2 897.280029296875,
- :y2 679.15625,
- :width 1036.8,
- :height 1555.2},
+ :y1 509.1428909301758,
+ :x2 691.9763946533203,
+ :y2 939.0000305175781,
+ :width 864,
+ :height 1296},
:rects ({:x1 0,
- :y1 237,
+ :y1 509.1428909301758,
:x2 0,
- :y2 259,
- :width 1036.8,
- :height 1555.2}
- {:x1 326.44189453125,
- :y1 634.25,
- :x2 897.280029296875,
- :y2 655.765625,
- :width 1036.8,
- :height 1555.2}
- {:x1 206.265625,
- :y1 658.15625,
- :x2 843.4315795898438,
- :y2 679.15625,
- :width 1036.8,
- :height 1555.2}),
- :page 206},
- :content {:text "ee objects on the lists in a pre-initialized state. Bonwick shows that initialization and destruction of data structures is costly "},
+ :y2 530.2857513427734,
+ :width 864,
+ :height 1296}
+ {:x1 601.3036041259766,
+ :y1 895.6429138183594,
+ :x2 691.9763946533203,
+ :y2 919.0715026855469,
+ :width 864,
+ :height 1296}
+ {:x1 116.09822463989258,
+ :y1 915.5715026855469,
+ :x2 199.5235939025879,
+ :y2 939.0000305175781,
+ :width 864,
+ :height 1296}),
+ :page 246},
+ :content {:text "multi-level page table"},
:properties {:color "yellow"}}
- {:id #uuid "64303dc5-8073-4659-9f39-ec6167683a7d",
- :page 206,
- :position {:bounding {:x1 265.65625,
- :y1 878.625,
- :x2 490.42877197265625,
- :y2 907.625,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 265.65625,
- :y1 878.625,
- :x2 490.42877197265625,
- :y2 907.625,
- :width 1036.8,
- :height 1555.2}),
- :page 206},
- :content {:text "binary buddy allocator"},
+ {:id #uuid "64318f9a-b732-4bab-9a1e-73519fac8059",
+ :page 253,
+ :position {:bounding {:x1 332.21875,
+ :y1 940.15625,
+ :x2 832.685546875,
+ :y2 970.15625,
+ :width 1094.3999999999999,
+ :height 1641.6},
+ :rects ({:x1 455.359375,
+ :y1 940.15625,
+ :x2 832.685546875,
+ :y2 970.15625,
+ :width 1094.3999999999999,
+ :height 1641.6}
+ {:x1 332.21875,
+ :y1 941.640625,
+ :x2 455.35888671875,
+ :y2 964.640625,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 253},
+ :content {:text "Figure 20.6: Multi-level Page Table Control Flow"},
:properties {:color "yellow"}}
- {:id #uuid "64303f3a-2b0f-4106-8ab1-48e4839fe971",
- :page 206,
+ {:id #uuid "64319047-2ffb-4355-9aab-82ea232375aa",
+ :page 254,
+ :position {:bounding {:x1 271.4013977050781,
+ :y1 291.203125,
+ :x2 486.9229736328125,
+ :y2 321.203125,
+ :width 1094.3999999999999,
+ :height 1641.6},
+ :rects ({:x1 271.40625,
+ :y1 291.203125,
+ :x2 486.9229736328125,
+ :y2 321.203125,
+ :width 1094.3999999999999,
+ :height 1641.6}
+ {:x1 271.4013977050781,
+ :y1 292.6875,
+ :x2 486.9229736328125,
+ :y2 315.6875,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 254},
+ :content {:text "inverted page tables"},
+ :properties {:color "yellow"}}
+ {:id #uuid "643196c4-91fa-43c2-832e-7080b0617fe5",
+ :page 257,
+ :position {:bounding {:x1 284.4680480957031,
+ :y1 760.75,
+ :x2 580.4756469726562,
+ :y2 783.75,
+ :width 1094.3999999999999,
+ :height 1641.6},
+ :rects ({:x1 284.4680480957031,
+ :y1 760.75,
+ :x2 580.4756469726562,
+ :y2 783.75,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 257},
+ :content {:text "upport large address spaces,"},
+ :properties {:color "yellow"}}
+ {:id #uuid "64319715-78ae-4efe-bab1-def007ee8e78",
+ :page 258,
+ :position {:bounding {:x1 384.6151123046875,
+ :y1 884.734375,
+ :x2 501.601318359375,
+ :y2 914.734375,
+ :width 1094.3999999999999,
+ :height 1641.6},
+ :rects ({:x1 384.625,
+ :y1 884.734375,
+ :x2 501.601318359375,
+ :y2 914.734375,
+ :width 1094.3999999999999,
+ :height 1641.6}
+ {:x1 384.6151123046875,
+ :y1 886.21875,
+ :x2 384.6233215332031,
+ :y2 909.21875,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 258},
+ :content {:text "swap space"},
+ :properties {:color "yellow"}}
+ {:id #uuid "64319809-1dbe-48dc-a4e4-7e14062d42c5",
+ :page 258,
:position {:bounding {:x1 0,
- :y1 397,
- :x2 897.3008422851562,
- :y2 1002.546875,
- :width 1036.8,
- :height 1555.2},
+ :y1 589,
+ :x2 947.1476440429688,
+ :y2 1338.296875,
+ :width 1094.3999999999999,
+ :height 1641.6},
:rects ({:x1 0,
- :y1 397,
+ :y1 589,
:x2 0,
- :y2 419,
- :width 1036.8,
- :height 1555.2}
- {:x1 0,
- :y1 413,
- :x2 0,
- :y2 435,
- :width 1036.8,
- :height 1555.2}
- {:x1 808.667236328125,
- :y1 933.734375,
- :x2 897.3008422851562,
- :y2 954.734375,
- :width 1036.8,
- :height 1555.2}
- {:x1 206.265625,
- :y1 957.640625,
- :x2 897.2750854492188,
- :y2 979.15625,
- :width 1036.8,
- :height 1555.2}
- {:x1 206.265625,
- :y1 981.546875,
- :x2 551.7743530273438,
- :y2 1002.546875,
- :width 1036.8,
- :height 1555.2}),
- :page 206},
- :content {:text "earch for free space recursively divides free space by two until a block that is big enough to accommodate the request is"},
+ :y2 610,
+ :width 1094.3999999999999,
+ :height 1641.6}
+ {:x1 456.7027587890625,
+ :y1 1290.046875,
+ :x2 947.1476440429688,
+ :y2 1313.046875,
+ :width 1094.3999999999999,
+ :height 1641.6}
+ {:x1 217.734375,
+ :y1 1315.296875,
+ :x2 311.5235900878906,
+ :y2 1338.296875,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 258},
+ :content {:text "swap space is not the only on-disk location for swapping "},
:properties {:color "yellow"}}
- {:id #uuid "64304015-d9ff-408b-bf88-cf37a33e832d",
- :page 206,
- :position {:bounding {:x1 0,
- :y1 621,
- :x2 897.265869140625,
- :y2 1339.734375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 0,
- :y1 621,
- :x2 0,
- :y2 643,
- :width 1036.8,
- :height 1555.2}
- {:x1 0,
- :y1 637,
- :x2 0,
- :y2 659,
- :width 1036.8,
- :height 1555.2}
- {:x1 720.0787353515625,
- :y1 1270.921875,
- :x2 897.265869140625,
- :y2 1291.921875,
- :width 1036.8,
- :height 1555.2}
- {:x1 206.265625,
- :y1 1294.8125,
- :x2 897.259765625,
- :y2 1316.328125,
- :width 1036.8,
- :height 1555.2}
- {:x1 206.265625,
- :y1 1318.734375,
- :x2 662.5130615234375,
- :y2 1339.734375,
- :width 1036.8,
- :height 1555.2}),
- :page 206},
- :content {:text " This recursive coalescing process continues up the tree, either restoring the entire free space or stopping when a buddy is found to be in use."},
- :properties {:color "yellow"}}
- {:id #uuid "643040e1-7784-424c-9096-d3e22fddbf9e",
- :page 207,
- :position {:bounding {:x1 0,
- :y1 141,
- :x2 830.3450317382812,
- :y2 715.359375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 0,
- :y1 141,
- :x2 0,
- :y2 163,
- :width 1036.8,
- :height 1555.2}
- {:x1 372.8900146484375,
- :y1 670.453125,
- :x2 830.3450317382812,
- :y2 691.453125,
- :width 1036.8,
- :height 1555.2}
- {:x1 139.3125,
- :y1 694.359375,
- :x2 243.44570922851562,
- :y2 715.359375,
- :width 1036.8,
- :height 1555.2}),
- :page 207},
- :content {:text " the address of each buddy pair only differs by a single bi"},
- :properties {:color "yellow"}}
- {:id #uuid "643044ff-fd8a-45fe-b564-f93683425ab3",
- :page 211,
- :position {:bounding {:x1 523.1875,
- :y1 793.984375,
- :x2 569.8348388671875,
- :y2 822.984375,
- :width 1036.8,
- :height 1555.2},
- :rects ({:x1 523.1875,
- :y1 793.984375,
- :x2 569.8348388671875,
- :y2 822.984375,
- :width 1036.8,
- :height 1555.2}),
- :page 211},
- :content {:text "page"},
- :properties {:color "yellow"}}],
- :extra {:page 211}}
+ {:id #uuid "64319857-9885-49e0-9e51-c974f0b6b038",
+ :page 259,
+ :position {:bounding {:x1 147.046875,
+ :y1 734.78125,
+ :x2 231.62075805664062,
+ :y2 757.78125,
+ :width 1094.3999999999999,
+ :height 1641.6},
+ :rects ({:x1 147.046875,
+ :y1 734.78125,
+ :x2 231.62075805664062,
+ :y2 757.78125,
+ :width 1094.3999999999999,
+ :height 1641.6}),
+ :page 259},
+ :content {:text "chinery "},
+ :properties {:color "green"}}],
+ :extra {:page 260}}
diff --git a/logseq/bak/pages/hls__ostep_1680491762166_0/2023-04-08T01_01_06.501Z.Desktop.md b/logseq/bak/pages/hls__ostep_1680491762166_0/2023-04-08T01_01_06.501Z.Desktop.md
new file mode 100644
index 0000000..15829ed
--- /dev/null
+++ b/logseq/bak/pages/hls__ostep_1680491762166_0/2023-04-08T01_01_06.501Z.Desktop.md
@@ -0,0 +1,678 @@
+file-path:: ../assets/ostep_1680491762166_0.pdf
+
+- virtualization, concurrency, and persistence
+ ls-type:: annotation
+ hl-page:: 1
+ hl-color:: yellow
+ id:: 642a452b-2dc9-4566-b8a8-95f0caa7b8e3
+- didactic 道德说教的；教诲的；
+ hl-page:: 2
+ ls-type:: annotation
+ id:: 642a7c33-ca04-447a-a357-88236d0b9360
+ hl-color:: green
+- Cramming 填塞；填鸭式用功；考试前临时硬记
+ hl-page:: 3
+ ls-type:: annotation
+ id:: 642a80b7-43a1-40ba-ad01-815cb171572f
+ hl-color:: green
+- fond 喜爱（尤指认识已久的人）；喜爱（尤指长期喜爱的事物）
+ hl-page:: 4
+ ls-type:: annotation
+ id:: 642a80ef-5f31-422a-8227-3842faa4eb8d
+ hl-color:: green
+- the operating system as a virtual machine, standard library and resource manager
+ hl-page:: 25
+ ls-type:: annotation
+ id:: 642bb88b-f481-4af6-afb6-7375d37654ce
+ hl-color:: yellow
+- illusion 错觉，幻象
+ hl-page:: 27
+ ls-type:: annotation
+ id:: 642bb978-1efe-418e-8894-8493bfd4f6bb
+ hl-color:: green
+- virtualizing the CPU: run many programs at the same time
+ hl-page:: 27
+ ls-type:: annotation
+ id:: 642bb9c2-efb8-4960-a7bd-36afe1cc0b1d
+ hl-color:: yellow
+- virtualizing memory: each process accesses its own private virtual address space
+ hl-page:: 29
+ ls-type:: annotation
+ id:: 642bbaae-582b-4b1c-bc60-e709931085e7
+ hl-color:: yellow
+- intricate 错综复杂的
+ ls-type:: annotation
+ hl-page:: 33
+ hl-color:: green
+ id:: 642bbca9-67e2-45d3-a131-968df46c0cef
+- heyday 全盛时期
+ ls-type:: annotation
+ hl-page:: 39
+ hl-color:: green
+ id:: 642bc0e8-ee33-46a6-bf83-407cc1e64737
+- incredulous 不肯相信的；不能相信的；表示怀疑的
+ hl-page:: 45
+ ls-type:: annotation
+ id:: 642bc1b3-459e-4e76-b36c-406daba96726
+ hl-color:: green
+- The definition of a process, informally, is quite simple: it is a running program
+ ls-type:: annotation
+ hl-page:: 47
+ hl-color:: yellow
+ id:: 642bc39c-f56a-488f-a751-1532e413d474
+- To implement virtualization of the CPU, low-level machinery and some high-level intelligence.
+ hl-page:: 47
+ ls-type:: annotation
+ id:: 642bc417-a3af-4132-b4b9-9fec9749fc9b
+ hl-color:: yellow
+ - mechanisms are low-level methods or protocols that implement a needed piece of functionality
+ hl-page:: 47
+ ls-type:: annotation
+ id:: 642bc41d-8b68-46d9-908e-ab14b53a859b
+ hl-color:: yellow
+ - Policies are algorithms for making some kind of decision within the OS
+ ls-type:: annotation
+ hl-page:: 48
+ hl-color:: yellow
+ id:: 642bc579-a1cc-4b67-a8c5-5a33f274c634
+- inventory 库存；财产清单；
+ hl-page:: 48
+ ls-type:: annotation
+ id:: 642bc8a9-1a7d-4236-86ce-65b0498e9e01
+ hl-color:: green
+- three states of a process: Running Ready Blocked
+ hl-page:: 51
+ ls-type:: annotation
+ id:: 642bd104-6b57-44f2-9f10-e5107a926079
+ hl-color:: yellow
+- nitty-gritty 本质；事实真相；实质问题
+ hl-page:: 55
+ ls-type:: annotation
+ id:: 642c279e-0187-4175-abfb-5fcf4e534ae8
+ hl-color:: green
+- KEY PROCESS TERMS
+ ls-type:: annotation
+ hl-page:: 56
+ hl-color:: yellow
+ id:: 642c27e3-d7d6-41d8-9832-73674615a246
+- Interlude: Process API
+ hl-page:: 60
+ ls-type:: annotation
+ id:: 642cc7d2-cd33-4dd6-879f-72f1070ed96d
+ hl-color:: yellow
+ Syscall-fork, wait, exec
+- Get it right. Neither abstraction nor simplicity is a substitute for getting it right
+ ls-type:: annotation
+ hl-page:: 65
+ hl-color:: yellow
+ id:: 642cc975-cf26-431c-8c38-617da01d89ee
+- the separation of fork() and exec() is essential in shell, because it lets the shell run code after the call to fork() but before the call to exec(); this code can alter the environment of the about-to-be-run program
+ hl-page:: 65
+ ls-type:: annotation
+ id:: 642ccc92-baa5-4b54-8525-9a664698c669
+ hl-color:: yellow
+- imperative 必要的，命令的；必要的事
+ hl-page:: 67
+ ls-type:: annotation
+ id:: 642ccf62-0b5a-41db-899e-3e99a69c2eac
+ hl-color:: green
+- control processes through signal subsystem
+ hl-page:: 67
+ ls-type:: annotation
+ id:: 642cd11a-eea5-48f8-b4d1-b225f37ccdb4
+ hl-color:: yellow
+- Limited Direct Execution: Direct execution is to simply run the program directly on the CPU.
+ hl-page:: 74
+ ls-type:: annotation
+ id:: 642cd1eb-c058-484a-ac25-782e37082bc6
+ hl-color:: yellow
+- aspiring 有追求的，有抱负的
+ hl-page:: 75
+ ls-type:: annotation
+ id:: 642cd2f2-c565-4309-951a-1f809da9beff
+ hl-color:: green
+- user mode and kernel mode
+ hl-page:: 76
+ ls-type:: annotation
+ id:: 642cd3e3-3fa6-43a6-a37a-cae62c634654
+ hl-color:: yellow
+ - In user mode, code is restricted in what it can do, otherwise the processor will raise an exception
+ - User code perform system call to do privileged operation.
+ - To execute a system call, use `trap` and `return-from-trap` instruction: jump to/from kernel and change the privilege level.
+- Limited Direct Execution Protocol-interesting figure illustrating how system call is done
+ hl-page:: 78
+ ls-type:: annotation
+ id:: 642cd6be-083b-4ecd-b220-aafef97a8b65
+ hl-color:: yellow
+- wary 谨慎的；考虑周到的
+ hl-page:: 79
+ ls-type:: annotation
+ id:: 642cd6e9-21fc-49c7-b0bb-0c9ba3b7a524
+ hl-color:: green
+- Switching Between Processes: how OS regain control of the CPU
+ hl-page:: 80
+ ls-type:: annotation
+ id:: 642cd90e-ab6b-4d4d-8312-cd8c69efdac8
+ hl-color:: yellow
+ - Cooperative Approach: wait for a system call. 1. The processes are expected to give up the CPU periodically through system call `yield`(which does nothing except to transfer control to the OS). 2. The process does something that causes a trap
+ - Non-Cooperative Approach: timer interrupt.
+ - Context switch: save a few register values for the currently-executing process.
+ Two types of register saves/restores: TI, hardware save state to kernel stack; context switch, OS save kernel registers and restore everything to return from trap
+- malfeasance 渎职；不正当行为
+ hl-page:: 81
+ ls-type:: annotation
+ id:: 642cdc2e-329c-423e-a65a-0a53fb6eaa76
+ hl-color:: green
+- scoff 嘲笑；愚弄；笑柄
+ hl-page:: 83
+ ls-type:: annotation
+ id:: 642ce319-8087-4252-b51d-42f749f7c283
+ hl-color:: green
+- enact 制定(法律)；通过(法案)
+ ls-type:: annotation
+ hl-page:: 83
+ hl-color:: green
+ id:: 642ce357-9914-417b-8036-35ae44ac7283
+- whet 引起,刺激(食欲、欲望、兴趣等)
+ hl-page:: 84
+ ls-type:: annotation
+ id:: 642cef47-0c2f-482f-8b61-9a715e5438e5
+ hl-color:: green
+- analogous 相似的,可比拟的
+ ls-type:: annotation
+ hl-page:: 86
+ hl-color:: green
+ id:: 642cf0c1-59a2-410e-8f45-517f66ef47f9
+- workload assumptions: Each job, runs for the same amount of time, arrives at the same time, runs to completion, uses only CPU, and run-time is known
+ hl-page:: 90
+ ls-type:: annotation
+ id:: 642cf292-4464-4c8f-8639-3a194484d4c0
+ hl-color:: yellow
+ - Quite unrealistic, but modern preemptive scheduling somewhat mimics part of these assumptions
+- scheduling metric: turnaround time, aka `completion - arrival`
+ hl-page:: 91
+ ls-type:: annotation
+ id:: 642cf48d-b312-4af1-a2ff-d55cf9f32e48
+ hl-color:: yellow
+- conundrum 谜,猜不透的难题,难答的问题
+ ls-type:: annotation
+ hl-page:: 91
+ hl-color:: green
+ id:: 642cf4c4-d246-48f2-a6ef-f14c77684ad9
+- First In, First Out (FIFO/FCFS) algorithm
+ hl-page:: 91
+ ls-type:: annotation
+ id:: 642cf4f9-4afd-4240-ac76-5522285fa1eb
+ hl-color:: yellow
+ - Bad average turnaround when long job runs first(The jobs run for **different amount of time**)
+ - Convoy effect: a number of relatively-short potential consumers of a resource get queued behind a heavyweight resource consumer
+- Shortest Job First(SJF)
+ hl-page:: 93
+ ls-type:: annotation
+ id:: 642cf705-4a47-4daa-a542-43c4ae6f239e
+ hl-color:: yellow
+ - assuming that jobs all arriving at the same time, it could be proven that SJF is indeed an optimal scheduling algorithm
+ - Downgrade to the same problem of Convey Effect when jobs **don't arrive at the same time**. For example, short jobs arrive shortly after the long job.
+- Shortest Time-to-Completion First (STCF)
+ ls-type:: annotation
+ hl-page:: 94
+ hl-color:: yellow
+ id:: 642cfce4-67f5-4315-bf81-445922b8ae54
+ - Basically, it is SJF(by our definition is a non-preemptive scheduler) with **preemption**. When a new job enters the system, STCF schedules to the job with the least time left among all present jobs(including the new guy).
+- Metric: Response Time. Defined as `resp = firstrun - arrival`. Compare to ((642cf48d-b312-4af1-a2ff-d55cf9f32e48))
+ hl-page:: 95
+ ls-type:: annotation
+ id:: 642e41ac-3b8f-4fe3-a9ef-e2adeeadfe9d
+ hl-color:: yellow
+ - For this metric, STCF is not that good.
+- Round-Robin (RR)
+ ls-type:: annotation
+ hl-page:: 96
+ hl-color:: yellow
+ id:: 642e435d-7116-4d2c-9ec3-889558ba2dca
+ - Not run jobs to completion But run a job for a time slice and then Switch to the next job in the run queue. Repeat until the jobs are done
+ - Good for Response Time, bad for Turnaround Time.
+ - Length of time slice is critical, in theory the shorter the better performance under response time metric. However, cost of context switching will dominate overall performance. The cost of context switching comes not only from save/restore registers, but also from caches or something alike.
+- amortization 分期偿还；折旧；（均摊）
+ hl-page:: 97
+ ls-type:: annotation
+ id:: 642e4473-4162-4320-91af-fba22e79be25
+ hl-color:: green
+- pessimal 最差的；最坏的
+ ls-type:: annotation
+ hl-page:: 97
+ hl-color:: green
+ id:: 642e4a5d-37c1-4484-b2ac-913e40d8a2dc
+- Incorporating I/O: Overlap. Basic idea is to treat each CPU burst(rather than the whole job) as a job, so that the job is divided into parts. This enables the scheduler to choose another job to run when the job is doing IO
+ hl-page:: 98
+ ls-type:: annotation
+ id:: 642e4ed2-7674-4a5f-bb65-67541b97db95
+ hl-color:: yellow
+- Multi-level Feedback Queue (MLFQ)
+ ls-type:: annotation
+ hl-page:: 103
+ hl-color:: yellow
+ id:: 642e5117-90c3-41db-9f15-45f3ba9edf91
+ - Workload: a mix of interactive jobs that are short-running, and some longer-running “CPU-bound” jobs
+ - Basic rules: each job assigned to a priority level and MLFQ decides which job to run by priority. In this scheme, a job with higher priority runs first, and jobs with the same priority RR. ((642ecc9e-b28b-4951-aaf6-1191e867b34f))
+ - Change priority: set priority based on its observed behavior, for example, keep high priority for interactive jobs which frequently relinquish CPU.
+ collapsed:: true
+ - one of the major goals of the algorithm: It doesn’t know whether a job will be short or job, it first assumes it might be short, thus giving high priority. If it actually is short, it will run quickly and complete; if it is not, it will slowly move down the queues, and thus soon prove itself to be a long-running more batch-like process.
+ hl-page:: 107
+ ls-type:: annotation
+ id:: 642ece05-2fa8-4a24-88e2-f2550cfdd2ed
+ hl-color:: yellow
+ - Approximates SJF
+ - Basic rules for MLFQ:
+ hl-page:: 104
+ ls-type:: annotation
+ id:: 642ecc9e-b28b-4951-aaf6-1191e867b34f
+ hl-color:: yellow
+ collapsed:: true
+ - Rule 1: If Priority(A) > Priority(B), A runs (B doesn’t).
+ - Rule 2: If Priority(A) = Priority(B), A & B run in RR.
+ - Problematic priority adjustment algorithm
+ hl-page:: 105
+ ls-type:: annotation
+ id:: 642ecd09-c81b-4127-8bfa-e1fbb78ba583
+ hl-color:: yellow
+ collapsed:: true
+ - Rule 3: When a job enters the system, it is placed at the highest priority (the topmost queue).
+ - Rule 4a: If a job uses up an entire time slice while running, its priority is reduced.
+ id:: 642ecd25-c824-4dcd-9a6a-43a717dd5b1e
+ Rule 4b: If a job gives up the CPU before the time slice is up, it stays at the same priority level.
+ - Problem 1: starvation.
+ id:: 642ecd3f-c076-42f1-ba24-7f363eba9e14
+ If there are too many interactive jobs *occupying the CPU in combination*, then the long jobs will never get to run
+ - Problem 2: game the scheduler.
+ For example, a CPU-bound job intentionally issue a trivial IO request just before its time slice is over, so that it will not be moved to lower queue although it should be.
+ - Problem 3: program behavior change.
+ id:: 642ed383-c27c-401c-b77f-66e7ec60ba5e
+ - The Priority Boost
+ ls-type:: annotation
+ hl-page:: 109
+ hl-color:: yellow
+ id:: 642ed47c-9ba8-4451-b6b3-6ca6ee1dbdda
+ collapsed:: true
+ - Rule 5: After some time period `S`, move all the jobs in the system to the topmost queue.
+ - This solves the problem of ((642ecd3f-c076-42f1-ba24-7f363eba9e14)) and ((642ed383-c27c-401c-b77f-66e7ec60ba5e)). Since the priorities will get recalculated periodically, the scheduler re-learns the jobs' traits which may have changed.
+ - However, how to choose such `S` is a problem.
+ - voo-doo constants
+ ls-type:: annotation
+ hl-page:: 109
+ hl-color:: yellow
+ id:: 642ed799-d933-441a-a043-06e47877c0d9
+ - Better Accounting
+ ls-type:: annotation
+ hl-page:: 110
+ hl-color:: yellow
+ id:: 642ed5f6-2a74-4a24-9f69-a472cf644fc9
+ collapsed:: true
+ - Rule 4: Once a job uses up its time allotment at a given level (regardless of how many times it has given up the CPU), its priority is reduced.
+ - This substitutes ((642ecd25-c824-4dcd-9a6a-43a717dd5b1e))
+ - parameterized scheduler
+ hl-page:: 110
+ ls-type:: annotation
+ id:: 642ed6a2-c04b-4f03-a86f-1d70933c0d42
+ hl-color:: yellow
+- relinquish 交出，让给；放弃
+ hl-page:: 105
+ ls-type:: annotation
+ id:: 642ec9be-dd64-4a66-ab7a-3f0ee376e055
+ hl-color:: green
+- culprit 犯人，罪犯；被控犯罪的人
+ ls-type:: annotation
+ hl-page:: 110
+ hl-color:: green
+ id:: 642ed5fe-3314-4020-a4fc-b1b75ea987b9
+- Proportional-share(fair-share) scheduler
+ hl-page:: 115
+ ls-type:: annotation
+ id:: 642eda22-bd34-42e4-b7e4-1107636d1fbc
+ hl-color:: yellow
+ - Instead of optimizing for turnaround or response time, the scheduler tries to guarantee that each job obtain a certain percentage of CPU time.
+ - tickets: represent the share of a resource that a process should receive
+ hl-page:: 115
+ ls-type:: annotation
+ id:: 642edaa2-78d2-4fde-8b14-584b7d39fa24
+ hl-color:: yellow
+ - ticket currency: kind of user interface. Users allocate tickets freely to their own processes, and the system converts user tickets to global tickets according to some kind of exchange rate, in order to achieve fairness between users.
+ hl-page:: 117
+ ls-type:: annotation
+ id:: 642edc09-1329-4eca-95ad-7f62b48875e2
+ hl-color:: yellow
+ - ticket transfer: kind of cooperation between processes. A process temporarily hands off its tickets to another process.
+ hl-page:: 117
+ ls-type:: annotation
+ id:: 642edc0f-464d-4616-9313-92b640cecec5
+ hl-color:: yellow
+ - ticket inflation: another kind of cooperation. A process can temporarily raise or lower the number of tickets it owns, to indicate that it needs CPU.
+ hl-page:: 117
+ ls-type:: annotation
+ id:: 642edc14-74d6-4758-a21f-d615d2ee51c9
+ hl-color:: yellow
+ - Lottery scheduling
+ hl-page:: 115
+ ls-type:: annotation
+ id:: 642edb1d-7740-4459-bb42-0c6a84156475
+ hl-color:: yellow
+ - Scheduler **randomly** pick a winning ticket(i.e. number the tickets 1-N, and do a range random), the job which holdes this ticket runs. The more tickets a job holds, the higher chance it is chosen to run. Thus the CPU is shared by proportion, probabilistically.
+ - Lottery Fairness Study: When the job length is not very long, unfairness can be quite severe. Only as the jobs run for a significant number of time slices does the lottery scheduler approach the desired outcome.
+ ls-type:: annotation
+ hl-page:: 119
+ hl-color:: yellow
+ id:: 642eded0-39d0-40aa-8b28-c273d39f90c2
+ - Stride scheduling: a **deterministic** fair-share scheduler.
+ hl-page:: 120
+ ls-type:: annotation
+ id:: 642edf4f-7c7f-477f-acae-0969da13731e
+ hl-color:: yellow
+ - Each job has a *stride*, which is inverse in proportion to the tickets it has (conceptually like reciprocal).
+ Every time a process runs, increase its counter(called its *pass* value) by 1 stride.
+ The scheduler picks the process with lowest pass value to run
+ - Why still lottery scheduling? No global states! Thus much easier to implement.
+ - Problem: How to determine how many tickets to assign to your processes with different purposes and traits? MLFQ does this automatically, but here nobody does this.
+- Completely Fair Scheduler (CFS)
+ ls-type:: annotation
+ hl-page:: 121
+ hl-color:: yellow
+ id:: 642ee1b9-281d-4589-ab90-e776507dd04f
+ - Goal: to fairly divide a CPU evenly among all competing processes.
+ hl-page:: 122
+ ls-type:: annotation
+ id:: 642ee242-d382-4685-86b4-b3169fcc4fcf
+ hl-color:: yellow
+ - virtual runtime: As each process runs, it accumulates `vruntime`. And the scheduler picks the lowest one to run.
+ hl-page:: 122
+ ls-type:: annotation
+ id:: 642ee25b-1f3a-4b7c-a721-fa60f5fa5d2f
+ hl-color:: yellow
+ - For blocked processes: need to alter `vruntime` of a job when it wakes up. Otherwise, its `vruntime` would be too small thus breaking fairness. CFS chooses the minimum `vruntime` in the running process table.
+ hl-page:: 125
+ ls-type:: annotation
+ id:: 642ee7e4-20d2-44d5-8407-288a8a2e1769
+ hl-color:: yellow
+ - Parameters
+ - `sched_latency`: when running, scheduler divides this value by the number of running processes `n`. The result is used as the time slice for each process. This simple approach is adaptive to dynamic change of running processes.
+ hl-page:: 122
+ ls-type:: annotation
+ id:: 642ee303-c289-4e55-a0c5-bc4f534fa882
+ hl-color:: yellow
+ - `min_granularity`: minimum of time slice, to avoid reducing performance too much
+ hl-page:: 122
+ ls-type:: annotation
+ id:: 642ee3d6-827b-4d80-b6c3-9cb8253a16d6
+ hl-color:: yellow
+ - Weighting (Niceness): every process is assigned to a `nice` value ranging from -20 to 19. The smaller nice value, the higher priority. A nice value is mapped to some `weight` through a carefully built table.
+ hl-page:: 123
+ ls-type:: annotation
+ id:: 642ee44f-5fca-4d7d-b688-ff4ac22be23a
+ hl-color:: yellow
+ - Given the weight, the time slice can be calculated, and the calculation for `vruntime` needs adaptation to guarantee the time slice.
+ $$ time\_slice_k = \frac{weight_k}{\sum weight_i}\cdot sched\_latency \\ vruntime_i = vruntime_i + \frac{weight_0}{weight_i} \cdot runtime_i$$
+ -
+- hallmark 特征；特点:
+ ls-type:: annotation
+ hl-page:: 126
+ hl-color:: green
+ id:: 642ee5dd-9183-4122-9dee-06ff7fb9be46
+- panacea 万能药
+ hl-page:: 126
+ ls-type:: annotation
+ id:: 642ee8c2-89fe-4e7b-bf6d-bb0e379f8fe2
+ hl-color:: green
+- remedy 补救方法
+ ls-type:: annotation
+ hl-page:: 129
+ hl-color:: green
+ id:: 642eeb3a-8803-4c73-84a7-cc48c903f10f
+- proliferation 涌现；增殖
+ hl-page:: 129
+ ls-type:: annotation
+ id:: 642eeb44-cf62-4cf6-81cb-f1f6423cb66d
+ hl-color:: green
+- Problems with multiple processors
+ - cache coherence: basically, hardware handles this
+ hl-page:: 132
+ ls-type:: annotation
+ id:: 642eecc1-d07d-4e48-bcd5-b84db831b241
+ hl-color:: yellow
+ - Synchronization: though locks ensure correctness, performance is harmed
+ hl-page:: 132
+ ls-type:: annotation
+ id:: 642f878b-44c2-4485-ae98-448032b588da
+ hl-color:: yellow
+ - Cache Affinity: cache may still keep some of the process's state, so this may be faster if the process runs on the same CPU next time, in that there is no need to load state from memory.
+ hl-page:: 133
+ ls-type:: annotation
+ id:: 642f87d0-2e9a-405c-8fa6-689dc492ef52
+ hl-color:: yellow
+- Single-Queue Multiprocessor Scheduling(SQMS)
+ hl-page:: 134
+ ls-type:: annotation
+ id:: 642f88e3-3f8b-472b-8947-09531409a23b
+ hl-color:: yellow
+ - Simply use the same policy as we do in the single processor condition, and pick maybe more than one best jobs to run.
+ - Problem 1: lack of scalability. Since it is a single global queue, there will be a lot of contention on the same lock, thus greatly reducing the performance.
+ - Problem 2: cache affinity. If the scheduler simply feed processes to CPU by order, the jobs will bounce around from CPU to CPU. Complex affinity mechanism is needed to try to make it more likely that process will continue to run on the same CPU.
+- Multi-Queue Multiprocessor Scheduling (MQMS).
+ hl-page:: 135
+ ls-type:: annotation
+ id:: 642f90ef-6bf0-42be-8056-188682da8901
+ hl-color:: yellow
+ - Consists of multiple independent queues following some particular policy. Avoid problems of sharing and synchronization.
+ - More scalable: when number of CPUs grows, add more queues.
+ - Better cache affinity: jobs in the same queue stay in the same CPU
+ - Problem: load imbalance. The jobs in the queue with fewer jobs get more CPU share than those in the queue with more jobs. Or even worse, some CPUs are IDLE. (一核有难，七核围观)
+ hl-page:: 136
+ ls-type:: annotation
+ id:: 642f934e-0f7b-43de-97a1-fc530b229098
+ hl-color:: yellow
+ - Migration: the obvious solution to load imbalance, is to migrate some jobs from one CPU to another. Sometimes, we need to keep switching jobs, in such case that Q1 has 1 job and Q2 has 2 jobs. You may want to keep moving the third job from one CPU to another, to balance load.
+ hl-page:: 137
+ ls-type:: annotation
+ id:: 642f9564-38b9-4f22-a0af-f4c4f6c8fe76
+ hl-color:: yellow
+ - Work stealing: source queue(low on jobs) occasionally peek at other queues to see whether it is a good idea to move some jobs to help balance load.
+- sinister 危险的, 不吉祥的
+ hl-page:: 136
+ ls-type:: annotation
+ id:: 642f914d-502e-4f9d-8878-cf331e7f3fc3
+ hl-color:: green
+- insidious 隐伏的,潜在的,阴险的
+ hl-page:: 137
+ ls-type:: annotation
+ id:: 642f9458-c07c-4ef3-a1ec-a14e76ea4b2b
+ hl-color:: green
+- dissertation 专题论文, 学位论文
+ ls-type:: annotation
+ hl-page:: 138
+ hl-color:: green
+ id:: 642f96cb-066e-4ab9-975c-a746e3143062
+- daunting 使人畏缩的；使人气馁的；
+ ls-type:: annotation
+ hl-page:: 138
+ hl-color:: green
+ id:: 642f97ac-a4ab-4baf-b039-678c466ea588
+- undertake 承担；从事；负责
+ ls-type:: annotation
+ hl-page:: 138
+ hl-color:: green
+ id:: 642f97b5-d203-4998-84f0-21d66f8424b7
+- Linux Multiprocessor Schedulers: 3 different schedulers. CFS and O(1) are MQMS, while BFS is SQMS based on EEVDF.
+ hl-page:: 138
+ ls-type:: annotation
+ id:: 642f981d-af29-4cc1-a9da-b445cb964674
+ hl-color:: yellow
+- super-linear speedup: Sometimes a speedup of more than A when using A processors is observed in parallel computing. One possible reason for this is that, these CPUs offers larger cache size all together. If properly designed, memory access could even be eliminated, thus greatly improving performance.
+ hl-page:: 141
+ ls-type:: annotation
+ id:: 642faf44-5876-46b3-acb4-b786f390716f
+ hl-color:: yellow
+- paranoid
+ ls-type:: annotation
+ hl-page:: 142
+ hl-color:: green
+ id:: 642fb2f2-b9a4-48f4-b847-2b30d632db32
+- rage
+ ls-type:: annotation
+ hl-page:: 143
+ hl-color:: green
+ id:: 642fb3d2-e51f-4b9b-8a79-dea9d8e6a7b0
+- inundated
+ ls-type:: annotation
+ hl-page:: 144
+ hl-color:: green
+ id:: 642fb4c0-5c56-44e9-aac6-396212698309
+- errant
+ ls-type:: annotation
+ hl-page:: 145
+ hl-color:: green
+ id:: 642fb51d-f82c-40b4-82ad-878ee13a2264
+- darned
+ ls-type:: annotation
+ hl-page:: 146
+ hl-color:: green
+ id:: 642fb54e-23c4-4667-955d-ad09fbbf6268
+- pesky
+ ls-type:: annotation
+ hl-page:: 148
+ hl-color:: green
+ id:: 642fb9df-d4c2-4b75-9341-e9ea53d42dcc
+- Address space: process's view of memory, the abstraction that the OS provides to the running program. When OS does this, we say it is **virtualizing memory**.
+ hl-page:: 148
+ ls-type:: annotation
+ id:: 642fbad1-cda0-4ef4-97f7-38c3519042f4
+ hl-color:: yellow
+ - Goal: transparency, efficiency and protection
+- alas
+ ls-type:: annotation
+ hl-page:: 149
+ hl-color:: green
+ id:: 642fbb24-877c-4c90-9e13-4e613e2e23d3
+- tandem
+ ls-type:: annotation
+ hl-page:: 150
+ hl-color:: green
+ id:: 642fbb6e-9a9a-4ff6-92ea-b36903da1b88
+- stipulate
+ ls-type:: annotation
+ hl-page:: 150
+ hl-color:: green
+ id:: 642fbc3d-d70b-4adb-bb0b-6b7038480589
+- scribble
+ ls-type:: annotation
+ hl-page:: 159
+ hl-color:: green
+ id:: 642fbfcb-7327-44b8-9b25-308728264a81
+- Memory API: this interlude chapter talks about memory allocation interfaces like `malloc` and `free`. Quite trivial for proficient C programmers.
+ hl-page:: 155
+ ls-type:: annotation
+ id:: 642fc139-afc3-4ba4-ad01-4cc33d9e535c
+ hl-color:: yellow
+- hardware-based address translation
+ ls-type:: annotation
+ hl-page:: 167
+ hl-color:: yellow
+ id:: 642fd36e-c0a7-4ead-a3a8-f085d6576229
+- Assumptions
+ ls-type:: annotation
+ hl-page:: 167
+ hl-color:: yellow
+ id:: 642fc48b-e5bf-4043-b042-218445c2b714
+ - Address space mapped to contiguous physical memory
+ - Address space can be totally held in physical memory(no too big)
+ - Each address space is the same size.
+- Dynamic (Hardware-based) Relocation
+ ls-type:: annotation
+ hl-page:: 170
+ hl-color:: yellow
+ id:: 642fc65f-1147-459c-8906-5ffca38b1e66
+ - Software-based(static) relocation: program loader rewrites the to-be-loaded program's addresses according to its target offset in physical memory. The most important problem with this approach is that, protection can hardly be enforced.
+ hl-page:: 171
+ ls-type:: annotation
+ id:: 642fc677-cbd4-47fd-bd90-3ed0cd56cc5b
+ hl-color:: yellow
+ - base-and-bounds: 2 registers for *each* CPU, used for determining the physical location of the address space.
+ - Before running, program is compiled as if it is loaded at address 0x00000000.
+ On startup, OS decide where to put the program and set `base` register.
+ When running, CPU translates process's memory reference(virtual address -> physical address) and issue request to RAM using physical address. `physcal address = virtual address + base`
+ - `bounds` register is there to help with protection, hardware checks whether the translated address exceeds the bound
+ - Dynamic Relocation: Hardware Requirements
+ ls-type:: annotation
+ hl-page:: 174
+ hl-color:: yellow
+ id:: 642fd1ed-22a9-4443-b02f-bc35fe42e50b
+ - Dynamic Relocation: Operating System Responsibilities. In addition to the LDE introduced in CPU virtualization, a little more work needs to be done, like base/bounds register save/restore, memory allocation and deallocation.
+ hl-page:: 175
+ ls-type:: annotation
+ id:: 642fd1f4-d573-4dbc-9e48-02adacc69e5e
+ hl-color:: yellow
+ - The stuff is not difficult to figure out on your own, so, why bother keeping notes on it?
+ - Problem: Internal fragmentation. Since the address space has fixed size in Dynamic Relocation, the used part of memory between stack and heap is wasted.
+ hl-page:: 178
+ ls-type:: annotation
+ id:: 642fd2f3-e05f-453c-8286-15e7807e8e97
+ hl-color:: yellow
+ - Programs may want larger address space(though not fully used)
+- Memory Management Unit (MMU): the part of the processor that helps with address translation.
+ hl-page:: 172
+ ls-type:: annotation
+ id:: 642fced7-c809-4d1e-bddb-da6474e851b8
+ hl-color:: yellow
+- havoc
+ ls-type:: annotation
+ hl-page:: 173
+ hl-color:: green
+ id:: 642fcf85-6cfb-4eb9-aef2-ddcef7027b70
+- wreak
+ ls-type:: annotation
+ hl-page:: 173
+ hl-color:: green
+ id:: 642fcf90-3133-4002-b986-4fd8157ab707
+- ghastly
+ ls-type:: annotation
+ hl-page:: 174
+ hl-color:: green
+ id:: 642fcfa9-c026-4885-9f50-029ca80ce148
+- juncture
+ ls-type:: annotation
+ hl-page:: 174
+ hl-color:: green
+ id:: 642fcff1-ae71-4756-9847-5ab85c41be06
+- oblivious
+ ls-type:: annotation
+ hl-page:: 175
+ hl-color:: green
+ id:: 642fd071-db9c-4f0e-886f-b6ba3e5e4f7d
+- Segmentation: Generalized Base/Bounds
+ ls-type:: annotation
+ hl-page:: 181
+ hl-color:: yellow
+ id:: 642fd5c3-30f9-4770-8ec5-09555d21c4ab
+ - Divide the address space into contiguous segments, and **the address space as a whole is no more contiguous in physical memory**.
+ - A base and bounds pair per logical segment of the address space. Place each one of those segments in different parts of physical memory, and thus avoid filling physical memory with unused virtual address space. Conforming to this, MMU should add some registers.
+ - Selecting segment: which segment does a virtual address refer to?
+ - Explicit method: use the top few bits of the virtual address as segment selector, and the rest as in-segment offset.
+ - Problem 1: bit wasted, for example, we have only 3 segments, but we have to use 2-bits which provides 4.
+ - Problem2: limits the use of the virtual address space. Because the top bits is taken away to represent segments, the maximum of a segment is reduced.
+ - implicit approach, the hardware determines the segment by noticing how the address was formed. For example, PC -> code segment, SP -> stack segment
+ hl-page:: 185
+ ls-type:: annotation
+ id:: 642fda54-4040-4d9b-ab00-13523aeb54c4
+ hl-color:: yellow
+ - Stack segment support: stack grows backwards. First, add a field to hardware to indicate a segment grows positive or not. When proceeding a negative growing segment, the physical address is calculated as `PA = VA[offset] - MAX_SEG_SIZE + base`, signed operation
+ hl-page:: 186
+ ls-type:: annotation
+ id:: 642fdca4-df4b-4515-8e96-ef4b05a7bb62
+ hl-color:: yellow
+ - A real world example for this is the E(Expand-Down) bit in x86's segment descriptor.
+ - The reason why design such a weird mechanism is explained here: [osdev-expand_down](https://wiki.osdev.org/Expand_Down#Expand_Down). In short, programs may require the a segment to grow its size when the initially allocated segment is too small.
+ - Support for Sharing: protection bits.
+ hl-page:: 187
+ ls-type:: annotation
+ id:: 642fe0dc-7d4b-41af-a136-69164ee77ab4
+ hl-color:: yellow
+ - Attach several protection bits to Segment Register. For example, by setting code segment to read-only, you can safely share the segment across processes, thus saving the memory to hold a copy of code when a program creates many processes.
+ - Problem 1: variable-sized segments cause external fragments by chopping free memory into odd-sized pieces
+ - Problem 2: not flexible enough. What if we want a large enough but sparsely-allocated heap(the heap segment could be very large but wastefully used)?
\ No newline at end of file
diff --git a/pages/hls__ostep_1680491762166_0.md b/pages/hls__ostep_1680491762166_0.md
index 5ccf56b..bd76f3b 100644
--- a/pages/hls__ostep_1680491762166_0.md
+++ b/pages/hls__ostep_1680491762166_0.md
@@ -830,9 +830,200 @@ file-path:: ../assets/ostep_1680491762166_0.pdf
ls-type:: annotation
id:: 643040e1-7784-424c-9096-d3e22fddbf9e
hl-color:: yellow
-- Page: fixed-sized memory unit in address space
+- Page: fixed-sized memory unit in address space
hl-page:: 211
ls-type:: annotation
id:: 643044ff-fd8a-45fe-b564-f93683425ab3
hl-color:: yellow
- Page frame: physical memory as an array of fixed-sized slots
\ No newline at end of file
+ Page frame: physical memory as an array of fixed-sized slots
+ - Avoid external fragmentation by dividing fixed-sized units instead of variable-sized segments
+- page table: store address translations for each of the virtual pages of the address space
+ hl-page:: 213
+ ls-type:: annotation
+ id:: 6430bfab-9ff7-44cb-ad64-c422796cad71
+ hl-color:: yellow
+ - per-process data structure
+ ls-type:: annotation
+ hl-page:: 213
+ hl-color:: yellow
+ id:: 6430c091-bc57-4930-bac1-9e1762b7c3e1
+ - Virtual address splits into two components: the virtual page number (VPN), and the offset
+ hl-page:: 213
+ ls-type:: annotation
+ id:: 6430c0a5-6e88-455c-8a62-ab6e60fca98f
+ hl-color:: yellow
+ - physical frame number (PFN)
+ ls-type:: annotation
+ hl-page:: 214
+ hl-color:: yellow
+ id:: 6430c173-13a7-4bce-9d60-3f1d2a7fb3f4
+ - Page table entry (PTE): hold the physical translation plus any other useful stuff like valid bit, protection bits, present bit, dirty bit, accessed bit
+ hl-page:: 215
+ ls-type:: annotation
+ id:: 6430c665-8485-46e6-810a-b2d62b01cf66
+ hl-color:: yellow
+ - Linear Page Table: just an Array. The OS indexes the array by the VPN, and looks up the PTE at that index in order to find the desired PFN.
+ hl-page:: 216
+ ls-type:: annotation
+ id:: 6430cb48-d435-4bb4-807e-402ee20d0a98
+ hl-color:: yellow
+ - Figure 18.6: Accessing Memory With Paging(Initial Version)
+ hl-page:: 219
+ ls-type:: annotation
+ id:: 6430cac6-63c8-4ab7-a402-49097ef24154
+ hl-color:: yellow
+ Extra memory references are costly
+- beguile 哄骗（某人做某事）；诱骗；吸引（某人）；
+ ls-type:: annotation
+ hl-page:: 215
+ hl-color:: green
+ id:: 6430c18b-cd3f-400d-8414-3b780ed1b4ce
+- gruesome 可怕的；阴森的
+ ls-type:: annotation
+ hl-page:: 216
+ hl-color:: green
+ id:: 6430c51c-591b-4739-921a-ea9e0abbfbaa
+- judicious 审慎而明智的
+ hl-page:: 217
+ ls-type:: annotation
+ id:: 6430c5f3-3ce3-486d-b7ee-832673fa4d4d
+ hl-color:: green
+- Translation-Lookaside Buffer(TLB)
+ hl-page:: 226
+ ls-type:: annotation
+ id:: 6430cc79-5b7c-4cc3-9d7e-39a44a333c77
+ hl-color:: yellow
+ - **a hardware cache** of popular virtual-to-physical address translations. Due to temporal and spatial locality, TLB works quite well.
+ - Figure 19.1: TLB Control Flow Algorithm: hit and miss
+ hl-page:: 227
+ ls-type:: annotation
+ id:: 6430ccdf-09c2-42e2-aa80-7859bb320b91
+ hl-color:: yellow
+ - TLB Miss handler
+ hl-page:: 231
+ ls-type:: annotation
+ id:: 6430d596-d805-4bc8-a3a7-219d6927a503
+ hl-color:: yellow
+ - hardware-managed TLBs: transparent to OS, if page table relative stuff is properly set.
+ hl-page:: 231
+ ls-type:: annotation
+ id:: 6430d5ac-5021-4b2e-a5d7-e3e4988a4a89
+ hl-color:: yellow
+ - software-managed TLB: hardware raises an exception and goes to a trap handler.
+ hl-page:: 231
+ ls-type:: annotation
+ id:: 6430d5be-7a59-4ef2-9ba3-94e8298f4e47
+ hl-color:: yellow
+ Then OS takes over, trap handler code looks up page table, and use privileged instructions to update TLB.
+ - Special trap: Syscall resumes to the next instruction(like a procedure call); TLB trap resumes to the instruction caused the trap(retry, this time should have a TLB hit).
+ - Infinite chain of TLB misses: what if the trap handler causes a TLB miss? Reserve some unmapped memory or some always-valid TLB entries to avoid such terrible situation.
+ id:: 6430d9b4-c202-486f-9943-bd5c6d1310a8
+ - Fully-associative TLB: `VPN | PFN | other bits`.
+ hl-page:: 233
+ ls-type:: annotation
+ id:: 6430db45-ace1-4bcf-9672-b929c8720bf2
+ hl-color:: yellow
+ - "Fully-associative" means no limit on the relation between VPN and PFN, and the hardware lookup can be performed in parallel.
+ - Other bits include some bits from PTE, and a valid bit indicating whether the *translation* is valid(not about the page), which has different meaning from the valid bit in PTE.
+ - TLB and Context Switch: page table is ((6430c091-bc57-4930-bac1-9e1762b7c3e1)).
+ Conflicts show up when the same VPN is mapped to different PFNs. This is quite common because all processes' have similar address space layout.
+ - Flush TLB on context switches by some kind of flush instruction(software TLB) or changing the PTBR(hardware TLB, e.g. x86's CR3). Simple but wasteful.
+ - Add an address space identifier(ASID) field to TLB entry, which identifies different processes and allows them to share TLB without flushing on context switch.
+ - Replacement Policy: Random, LRU
+ hl-page:: 236
+ ls-type:: annotation
+ id:: 6430e32c-f334-4274-a56f-03a793d05df9
+ hl-color:: yellow
+ - MIPS R4k TLB Entry Layout
+ - G-global bit, the entry is globally-shared among processes, thus shadowing the ASID field
+ - C-coherence bit, deals with process number that exceeds ASID capability
+ - D-dirty bit; V-valid bit
+ - Page mask, large page support
+ - CP0-wired register: tell the hardware how many slots of the TLB to reserve for the OS to solve this: ((6430d9b4-c202-486f-9943-bd5c6d1310a8))
+ - Problems
+ hl-page:: 238
+ ls-type:: annotation
+ id:: 6430e5e3-d80e-44f2-8cfc-7424b8a8ff92
+ hl-color:: yellow
+ - Exceeding the TLB coverage: too many pages are accessed in a short period of time. Maybe we need some large pages
+ - CPU pipeline bottleneck: physically-indexed cache requires address translation before cache lookup, causing high delay. Solutions like virtually-indexed cache, VIPT
+- premise 前提；假定
+ ls-type:: annotation
+ hl-page:: 228
+ hl-color:: green
+ id:: 6430d370-e99b-4443-bd55-3aa5b941b2c4
+- sneaky 悄悄的；偷偷摸摸的；鬼鬼祟祟的
+ ls-type:: annotation
+ hl-page:: 231
+ hl-color:: green
+ id:: 6430d54f-9837-4f82-b4b0-13ab387c9a7a
+- TLB Size Measurement: loop through an large array and access the elements by page stride. Measure the time cost by repeating this for millions of time.
+ hl-page:: 240
+ ls-type:: annotation
+ id:: 6430e720-f62a-4094-9ecf-3a6d47540d34
+ hl-color:: yellow
+- page tables are too big and thus consume too much memory.
+ ls-type:: annotation
+ hl-page:: 242
+ hl-color:: yellow
+ id:: 6431070d-a42a-4403-b6c5-bab956d5608f
+ - Bigger Pages
+ hl-page:: 242
+ ls-type:: annotation
+ id:: 643106f5-b280-4331-be8e-70f8c34c3c28
+ hl-color:: yellow
+ - Reduce page table size and TLB pressure, though internal fragmentation becomes the major problem.
+ - Suitable for professional software which frequently uses memory-consuming data structures like database.
+ - Hybrid approach: Segments with paging
+ hl-page:: 245
+ ls-type:: annotation
+ id:: 64310894-f97b-4d29-b477-75d45b1af812
+ hl-color:: yellow
+ - Each segment, which is *bounded*, have a page table which stores a few pages that are in use. We don't need to cover the whole address space where many PTEs are just invalid.
+ - The original base register now points to the *physical address of the page table*; and the bounds register indicates the end of the page table for this segment.
+ - Virtual address is accordingly split into 3 parts `Segment | VPN | Offset`. And the lookup procedure also needs adaptation: `PTE_Addr = Base[SegNo] + (VPN * sizeof(PTE))`
+ - Problem: inflexible due to segmentation; external fragmentation because page tables are still variable-sized(though other part of memory is fixed-sized); complexity.
+ - multi-level page table
+ ls-type:: annotation
+ hl-page:: 246
+ hl-color:: yellow
+ id:: 64310f59-4581-45b8-9b56-9e0ef04ec513
+ - turns the linear page table into something like a tree, the detailed working principles are quite easy thus ignored here, or look at the link below as a review
+ - Figure 20.6: Multi-level Page Table Control Flow
+ ls-type:: annotation
+ hl-page:: 253
+ hl-color:: yellow
+ id:: 64318f9a-b732-4bab-9a1e-73519fac8059
+ - Page directory and Page Directory Entry(PDE)
+ - Advantages: Page table size is in proportion to address space usage; Easy to manage, contiguous physical memory is not required for page table(in contrast to Segment + Paging)
+ - Problems: Complexity; More penalty at TLB miss (need to access RAM more than once)
+ - inverted page table
+ hl-page:: 254
+ ls-type:: annotation
+ id:: 64319047-2ffb-4355-9aab-82ea232375aa
+ hl-color:: yellow
+ - A system-wide single page table instead of per-process page table. Inverted page table has an entry for each physical page, which tells us which process is using this page, and which virtual page is mapped to this physical page.
+ - The translation process is to search this table by VA and PID to find the correct entry. Maybe build a hash table to speed up this search.
+- Support large address spaces: stash away portions of address spaces that currently aren't in great demand.
+ hl-page:: 257
+ ls-type:: annotation
+ id:: 643196c4-91fa-43c2-832e-7080b0617fe5
+ hl-color:: yellow
+ - Swap space
+ hl-page:: 258
+ ls-type:: annotation
+ id:: 64319715-78ae-4efe-bab1-def007ee8e78
+ hl-color:: yellow
+ - Reserve some space on disk for moving pages back and forth, and the OS needs to remember the disk address of a given page.
+ - swap space is not the only on-disk location for swapping, e.g. program binary loading, not necessarily load the whole code segment at first
+ hl-page:: 258
+ ls-type:: annotation
+ id:: 64319809-1dbe-48dc-a4e4-7e14062d42c5
+ hl-color:: yellow
+ -
+-
+- chinery
+ ls-type:: annotation
+ hl-page:: 259
+ hl-color:: green
+ id:: 64319857-9885-49e0-9e51-c974f0b6b038
\ No newline at end of file