අන්තර්ගතයට යන්න
mcqdinethlive

OS පාඩමට කලින් fetch-execute cycle එක ඉගෙන ගන්න ඕනේ ඇයි

Fetch-execute cycle එකයි OS පාඩමයි එකම කතාවක් විදිහට. කෑලි ඉගෙන ගන්න ඕනේ පිළිවෙළ සහ ඇයි කියලා, එක program එකක් double-click එකේ ඉඳන් exit වෙනකම්, exam එක මේක අහන හැටි, අද computers වල තියෙන දේ සහ Grade 13 එකේ මේවා ආයෙ එන තැන්.

ඉංග්‍රීසියෙන් කියවන්න

මේ post එකෙන් අපි බලමු Unit 2 වල තියෙන fetch-execute cycle එකයි Unit 5 වල තියෙන operating system පාඩමයි කියන්නේ එකම program එකක් ගැන කියවෙන එකම කතාවක් කියලා. Process states, PCB, paging සහ FAT කියන්නේ අලුත් subjects හතරක් වගේ පේන්න පුළුවන්. හැබැයි එහෙම නෑ. පොත්වල මේ කතාව කෑලි වලට කඩලා තියෙන්නේ, ඒ වගේම ගොඩක් ළමයි මේ OS වචන ඉගෙන ගන්නේ කලින් පාඩම් වල වචන හරියටම ඔලුවට යන්න කලින්.

මේ post එකේ කොටස් හතරක් තියෙනවා:

  • ඉගෙන ගන්න පිළිවෙල: මේ පාඩම් පටලැවෙන්නේ ඇයි කියන එකත්, මේ කොටස් ඉගෙන ගන්න ඕනේ හරි පිළිවෙල සහ ඒ එක් එක් පියවරට හේතුව (කොටස් 1 සහ 2).
  • කතාව: එක program එකක් double-click කරපු වෙලාවේ ඉඳන් exit වෙනකම් යන හැටි (කොටස 3).
  • විභාගය: මේ කතාව paper එකෙන් අහන හැටි, ප්‍රශ්න වර්ග සහ හදපු උදාහරණ දෙකක් (කොටස් 4 සහ 5).
  • පොතෙන් එහාට: අද කාලේ තියෙන ඇත්තම පරිගණක වල මොකද වෙන්නේ කියන එකත්, 13 වසරේදී මේ අදහස් ආයේ එන්නේ කොහෙදිද කියන එකත්, try කරන්න past paper ප්‍රශ්න ටිකකුත් (කොටස් 6 ඉඳන් 8 වෙනකම්).

1. මේ පාඩම් පටලැවෙන්නේ ඇයි

Syllabus එකේ මේ කතාව 12 වසරේ units පහකට කඩලා තියෙනවා. ළමයි computer parts ගැන ඉගෙන ගන්නේ Unit 1 වලදී, CPU එක Unit 2 වලදී, binary Unit 3 වලදී, flip-flops Unit 4 වලදී සහ OS එක Unit 5 වලදී. Syllabus එක මේ units වලට periods 28, 22, 18, 26 සහ 22 ක් දීලා තියෙනවා (Syllabus, page ix) (විෂය නිර්දේශය, පිටුව viii).

සෑම unit එකක්ම ඊට කලින් තියෙන units වල වචන පාවිච්චි කරනවා:

  • Unit 5, Unit 2 වචන පාවිච්චි කරනවා. Process Control Block එක program counter එක තියාගන්නවා, "a pointer to the address of the next instruction to be executed for this process" (Teachers' Guide 5.3, page 136) (ගුරු අත්පොත 5.3, පිටුව 147). ඒක fetch-execute cycle (2.3) එකේ තියෙන program counter එකම තමයි. සිංහල Teachers' Guide එකේ PCB එකට "ක්‍රියායන පාලන ඛණ්ඩය" කියලත් program counter එකට "වැඩසටහන් ගණකය" කියලත් කියනවා.
  • Unit 5, Unit 3 ඉලක්කම් පාවිච්චි කරනවා. Frames වලට තියෙන size එක "is power of 2" (Teachers' Guide 5.4, page 141) (ගුරු අත්පොත 5.4, පිටුව 153). හැම paging ගාණක්ම powers-of-two ගාණක් (3.1).
  • Unit 5, Unit 4 circuits පාවිච්චි කරනවා. Register එකක් හැදිලා තියෙන්නේ flip-flops පේළියකින් (4.4). හැම context switch එකකදිම OS එක registers save කරනවා.

ඉතින් මේකේ ප්‍රශ්නෙ OS පාඩම අමාරු එක නෙවෙයි. ප්‍රශ්නෙ තමයි ළමයෙක් මේ OS වචන ඉගෙන ගන්නේ කලින් පාඩම් වල වචන හරියටම ඔලුවට යන්න කලින්.

2. පියවරෙන් පියවර ඉගෙන ගන්න පිළිවෙල

මේ තියෙන්නේ අපි යෝජනා කරන පිළිවෙල. මේක පොත්වල තියෙන rule එකක් නෙවෙයි. මේක එක test එකක් follow කරනවා: යම් අදහසක් ඉගෙන ගන්න ඕනේ ඒකට පාවිච්චි වෙන හැම වචනයක්ම දැනගත්තට පස්සේ විතරයි.

  1. Hardware, software සහ OS layer (1.4, 5.1). මොනවා තියෙන්නේ කොහෙද කියලා දැනගන්න. OS එක කියන්නේ system software එකක්. ඒක hardware විස්තර හංගලා, resources manage කරලා application software run කරනවා (Teachers' Guide 5.1, page 123) (ගුරු අත්පොත 5.1, පිටුව 133).
  2. Stored program සහ fetch-execute cycle (2.3). Program එක තියෙන්නේ memory එකේ. CPU එක memory එකෙන් එක පාරකට එක instruction එක ගානේ අරගෙන ඒක execute කරනවා (Teachers' Guide 2.3, page 67) (ගුරු අත්පොත 2.3, පිටුව 72). මේ cycle එක fetch, decode, execute විදිහට යනවා (Teachers' Guide 2.3, page 68) (ගුරු අත්පොත 2.3, පිටුව 73). සිංහල Teachers' Guide එකේ මේකට කියන්නේ "සෙවුම්-ඉෂ්ට චක්‍රය". Program counter එක ඉගෙන ගන්න ඕනේ මෙතනදි.
  3. Memory types සහ storage (2.4). Registers, cache සහ RAM කියන්නේ volatile ඒවා. Disks වල current එක නැතුව data තියාගන්න පුළුවන් (Teachers' Guide 2.4, pages 70 and 71) (ගුරු අත්පොත 2.4, පිටු 77 සහ 78). සිංහල Teachers' Guide එක මේවට "නශ්‍ය මතකය" සහ "නශ්‍ය නොවන මතකය" කියලා කියනවා. Program එකක් run වෙන්න කලින් disk එකේ ඉඳන් RAM එකට එන්න ඕනේ ඇයි කියලා මේ පියවරෙන් පෙන්නනවා.
  4. Binary sizes සහ registers (3.1, 4.4). 2 to the power n, සහ bits වල ඉඳන් bytes වලට යන හැටි පුරුදු වෙන්න. Register එකක් හැදිලා තියෙන්නේ flip-flops වලින් කියලා මතක තියාගන්න. හැම paging ප්‍රශ්නෙකටම මේක ඕනේ වෙනවා.
  5. Processes, interrupts සහ context switch (5.3). "A process is basically a program in execution" (Teachers' Guide 5.3, page 134) (ගුරු අත්පොත 5.3, පිටුව 145). සිංහල Teachers' Guide එක process එකකට "ක්‍රියායනය" කියලා කියනවා. දැන් පියවර 2 යි 4 යි වැඩට එනවා. Context switch එකකදි program counter එකත් ඇතුළුව registers ටික PCB එකට save කරනවා (Teachers' Guide 5.3, page 137) (ගුරු අත්පොත 5.3, පිටුව 148).
  6. Memory management සහ paging (5.4). පියවර 3 යි 4 යි වැඩට එනවා. MMU එක කියන්නේ "hardware device that maps virtual to physical address" (Teachers' Guide 5.4, page 141) (ගුරු අත්පොත 5.4, පිටුව 152).
  7. Files සහ disk blocks (5.2). පියවර 3 වැඩට එනවා. File system එකකින් secondary storage එකේ "how data is stored and retrieved" කියන එක පාලනය කරනවා (Teachers' Guide 5.2, page 128) (ගුරු අත්පොත 5.2, පිටුව 139).

Syllabus එකේ files (5.2) දාලා තියෙන්නේ processes (5.3) වලට කලින්. පන්තියේදී ඒ පිළිවෙලට ගියාට කමක් නෑ. හැබැයි revision කරද්දි 5.3 සහ 5.4 කොටස් දෙක fetch-execute cycle එකට පස්සෙම ගන්න, මොකද ඒවයින් cycle එක කෙලින්ම පාවිච්චි කරනවා. Files පාවිච්චි කරන්නේ disk එක මිසක් CPU cycle එක නෙවෙයි නිසා, ඒක අන්තිමට ගන්න පුළුවන්.

3. එක program එකක් double-click කළ මොහොතේ ඉඳන් exit වෙනකම්

අපි එක program එකක් පටන් ගත්ත වෙලාවේ ඉඳන් අන්තිම වෙනකම් බැලුවම, මේ පියවර හතම එක කතාවකට එකතු වෙනවා. මෙතන තියෙන program එක spreadsheet එකක්, user කෙනෙක් ඒක double-click කරපු වෙලාවේ ඉඳන්. මේ හැම stage එකකම ඒ අදාළ level එක දාලා තියෙනවා.

  1. File එක හොයාගන්න (5.2). Program එක කියන්නේ disk එකේ තියෙන file එකක්. FAT file system එකකදි, File Allocation Table එක file එකේ blocks track කරනවා, හැම block එකක්ම ඊළඟ block එකට link වෙනවා (Teachers' Guide 5.2, pages 128 and 130) (ගුරු අත්පොත 5.2, පිටු 139 සහ 141). විභාගයේදී මේකට තව එකතු කරනවා directory entry එකේ පළවෙනි block number එක තියෙනවා කියලා, 2023 (held 2024) Paper II, B, Q10(f) වල වගේ.
  2. Memory එකට load කරන්න (5.4). OS එක මේ program එක pages වලට කඩලා නිදහස් frames වලට දානවා. Logical addresses වලින් physical addresses වලට translate කරන්න ඒක page table එකක් හදනවා (Teachers' Guide 5.4, page 141) (ගුරු අත්පොත 5.4, පිටු 152 සහ 153).
  3. Process එකක් හදන්න (5.3). OS එක process ID එක, state එක, program counter එක, registers සහ memory විස්තර එක්ක PCB එකක් හදනවා (Teachers' Guide 5.3, page 136) (ගුරු අත්පොත 5.3, පිටුව 147). මේ අලුත් process එක Ready කියලා mark කරනවා (Teachers' Guide 5.3, page 136) (ගුරු අත්පොත 5.3, පිටුව 147).
  4. Run කරන්න (2.3, 5.3). Short-term scheduler එක, ඒ කියන්නේ dispatcher එක, process එකට CPU එක දෙනවා (Teachers' Guide 5.3, page 138) (ගුරු අත්පොත 5.3, පිටුව 149). දැන් මේකේ instructions ටික fetch-execute cycle එකෙන් run වෙනවා. ඊළඟට එන්නේ මොන instruction එකද කියලා program counter එකෙන් කියනවා.
  5. Disk එකට wait කරන්න (5.3). Program එක file එකක් read කරන්න අහනවා. Disk එක slow නිසා, process එක Blocked වෙනවා. මේ අතරතුර CPU එක වෙන process එකක් run කරනවා. මේකට multiprogramming කියනවා. Program එකක් I/O වලට wait කරද්දි, "OS switches processor to execute another program in memory" (Teachers' Guide 5.1, page 124) (ගුරු අත්පොත 5.1, පිටුව 135).
  6. Interrupt සහ context switch (5.3). Interrupt එකක් කියන්නේ "is an event that alters the sequence of execution of process". මේක වෙලාව ඉවර වීමක්, service request එකක් හරි I/O සම්පූර්ණ වීමක් හරි වෙන්න පුළුවන් (Teachers' Guide 5.3, page 135) (ගුරු අත්පොත 5.3, පිටුව 145). සිංහල Teachers' Guide එක interrupt එකකට "අතුරුබිඳුම" කියලත් context switch එකකට "සන්දර්භ ස්විචය" කියලත් කියනවා. Switch එකකදි, OS එක පරණ process එකේ "the content of all processor registers" ඒකේ PCB එකේ save කරනවා (Teachers' Guide 5.3, page 137) (ගුරු අත්පොත 5.3, පිටුව 148).
  7. නැවැත්තුව තැනින්ම ආයේ run කරන්න (2.3, 5.3). OS එක save කරපු program counter එක ආයෙත් load කරනවා. කිසි දෙයක් වුණේ නෑ වගේ, fetch-execute cycle එක ඊළඟ instruction එකේ ඉඳන් දිගටම යනවා.
  8. Print කරලා exit වෙන්න (5.4, 5.3). Printout එක device driver එකක් සහ spool එකක් හරහා යනවා, spool එක කියන්නේ "while the slower device catches up" data තියාගන්න buffer එකක් (Teachers' Guide 5.4, page 143) (ගුරු අත්පොත 5.4, පිටුව 154). Exit වෙද්දි, "OS reclaims all resources assigned to the process" (Teachers' Guide 5.3, page 134) (ගුරු අත්පොත 5.3, පිටුව 145).

මේ list එකේ තියෙන levels 2.3, 5.2, 5.3 සහ 5.4 අතරේ නිතරම මාරු වෙනවා. ඒකයි exam එකට මේ ඔක්කොම එක ප්‍රශ්නෙකට එකතු කරලා අහන්න පුළුවන්.

4. Exam එක මේක අහන හැටි

හැම අවුරුද්දකම විභාගයට මේ කතාව එනවා: හැම Paper II එකකම OS ගැන ප්‍රශ්නයක් එනවා, ඒ වගේම Paper I එකේ fetch-execute කොටස් එනවා. මේ ගණන් වලට අදාළ වෙන්නේ 2019 ඉඳන් 2026 වෙනකම් තියෙන අලුත් syllabus papers අටයි. 2022 (held 2023) සහ 2024 වල keys third-party schemes වලින් ආපු ඒවා. 2023 (held 2024) Paper II marks ඇස්තමේන්තු, මොකද ඒ අවුරුද්දේ marking scheme එකක් නෑ.

Paper II වල හැමදාම OS ප්‍රශ්නයක් තියෙනවා

හැම අලුත් syllabus Paper II එකකම OS ගැන structured ප්‍රශ්නයක් තියෙනවා. ඒකේ Unit 5 කොටස් වලට marks 9 ඉඳන් 15 වෙනකම් ලැබෙනවා, ඒ කියන්නේ papers අටේම එකතුව marks 87 ක්.

  • 2019, 2020, 2025 සහ 2026 වලදී, මේක එන්නේ Part A, Q4 විදිහට, ඒ කියන්නේ සම්පූර්ණ ප්‍රශ්නයක්ම OS ගැන.
  • 2021 (held 2022) ඉඳන් 2024 වෙනකම්, මේක තියෙන්නේ Part B, Q10 විදිහට. සමහර අවුරුදු වලදී, මේ ප්‍රශ්නයෙන් ඊට කලින් තියෙන units ගැනත් අහනවා.

අන්න ඒ අන්තිම කාරණාව තමයි ගොඩක්ම වැදගත්. 2024 Paper II, B, Q10 පටන් ගන්නේ එක Python statement එකකට අදාළ CPU instructions වලින් (2.3), ඊට පස්සේ two's complement ගාණක් අහනවා (3.3), ඊළඟට process states සහ context switch එකකදි program counter එක ගැන (5.3), ඊට පස්සේ paging (5.4), අන්තිමට file allocation (5.2). 2023 (held 2024) Paper II, B, Q10 පටන් ගන්නේ පරිගණකය on කරලා තියෙද්දි processor එකක් run කරන "the repeating cycle" එකෙන් (2.3), ඊට පස්සේ අහනවා n-bit register එකකට flip-flops කීයක් ඕනෙද කියලා (4.4), එතනින් පස්සේ PCB, paging සහ FAT වලට යනවා. මේ ප්‍රශ්න යන්නේ කොටස 3 එකේ කතාවෙ පිළිවෙලටමයි.

Paper I යන්නේ syllabus එකේ පිළිවෙලටමයි

Paper I එකේ MCQs දළ වශයෙන් syllabus එකේ පිළිවෙළට එන්නේ. 2026 Paper I එකේ, Q1 සහ Q2 තියෙන්නේ data processing ගැන (1.5), Q3 තියෙන්නේ storage ගැන (2.4), ඒ වගේම Q4 සහ Q5 තියෙන්නේ buses සහ program counter එක ගැන (2.3). Number systems පටන් ගන්නේ Q6 වලින්.

Unit 5 MCQs තියෙන තැන් වෙනස් වෙලා තියෙනවා. 2019 ඉඳන් 2024 වෙනකම් හැම paper එකකම MCQs 3 ඉඳන් 5 වෙනකම් තිබුණා. 2025 සහ 2026 වල මුකුත්ම තිබුණේ නෑ. ඒ අවුරුදු දෙකේදිම, Unit 2 වලට MCQs 6 ක් (2025 දී, ඒක තමයි වැඩිම ගාණ) සහ MCQs 3 ක් (2026 දී) ආවා. ඒ කියන්නේ මෑතකදී ආපු papers වලින් Paper I එකේ fetch-execute කොටසුත් Paper II එකේ OS කොටසුත් test කරනවා. අවුරුදු දෙකක් කියන්නේ කෙටි කාලයක් නිසා, ළමයි OS MCQs දිගටම practice කරන්න.

5. බලාපොරොත්තු වෙන්න පුළුවන් ප්‍රශ්න වර්ග

පහුගිය ප්‍රශ්න ගත්තම ඒවා ප්‍රශ්න වර්ග කීපයකට වෙන් කරන්න පුළුවන්. මේ වර්ග ටික අඳුරගන්න, එතකොට අලුත් ප්‍රශ්නයක් දැක්කම ඒක පුරුදු එකක් වගේ පෙනෙයි.

  1. කොටසේ නම (2.3). Read signal එක ගෙනියන්නේ මොන bus එකෙන්ද? ඊළඟට තියෙන instruction එකේ address එක තියාගන්නේ මොන register එකේද? 2025 Paper I, Q6 සහ Q7, ඒ වගේම 2026 Paper I, Q4 සහ Q5 බලන්න.
  2. Cycle එකේ පියවරවල් (2.3). පියවරවල් list කරන්න, නැත්නම් එක statement එකකට CPU එකකට ඕනේ වෙන instructions ටික ලියන්න. 2020 Paper II, A, Q3(a)(ii) සහ 2024 Paper II, B, Q10(a) බලන්න.
  3. State වෙනස් වීම සහ හේතුව (5.3). Process එකක් web server එකකට හරි disk එකට හරි wait කරනවා. මොන transition එකද වෙන්නේ? 2024 Paper II, B, Q10(c)(i) සහ (ii), ඒ වගේම 2025 Paper II, A, Q4(a) බලන්න.
  4. Context switch (5.3). මොනවද save වෙන්නේ, කොහෙද, ඒ වගේම මේකට යන වෙලාව overhead එකක් වෙන්නේ ඇයි. Guide එක කියනවා "Context switch time is pure overhead" (Teachers' Guide 5.3, page 137) (ගුරු අත්පොත 5.3, පිටුව 148). සිංහල Guide එකේ මේ වෙලාවට කියන්නේ "අමතර වැය කිරීමකි" කියලා. 2026 Paper II, A, Q4(b) බලන්න.
  5. Paging ඉලක්කම් (5.4). Frames ගණන් කරන්න, frame number එකකට ඕනේ bits ගාණ හොයන්න, නැත්නම් virtual address එකක් translate කරන්න. 2026 Paper II, A, Q4(c), 2024 Paper II, B, Q10(d)(i) සහ (ii), ඒ වගේම 2023 (held 2024) Paper II, B, Q10(e) බලන්න.
  6. Page table bits (5.4). Valid bit එක 0 වුණාම ඒකේ තේරුම මොකක්ද, ඒ වගේම modified bit එකක් උදව් වෙන්නේ ඇයි. 2024 Paper II, B, Q10(d)(iii) සහ (iv) බලන්න.
  7. File allocation (5.2). FAT chain එකක් දිගේ යන්න, blocks ගණන් කරන්න, internal fragmentation හොයන්න, නැත්නම් linked හෝ indexed allocation තෝරන්න. 2026 Paper II, A, Q4(a), 2025 Paper II, A, Q4(c) සහ 2023 (held 2024) Paper II, B, Q10(f) බලන්න.
  8. හේතුව පැහැදිලි කරන්න (5.1, 5.4). Printer එකකට driver එකක් ඕනේ ඇයි? RAM එකට වඩා ලොකු program එකක් run වෙන්නේ කොහොමද? එක processor එකක් උඩ programs ගොඩක් run වෙන්නේ කොහොමද? 2026 Paper II, A, Q4(d) සහ 2021 (held 2022) Paper II, B, Q10(c) බලන්න.
  9. Cross-unit links (2.3, 4.4, 5.3). Register එකක තියෙන flip-flops, context switch එකකදි run වෙන්නේ කාගේ instructions ද, නැත්නම් PCB එක memory එකේ කොහෙද තියෙන්නේ. 2023 (held 2024) Paper II, B, Q10(a) සහ (b) බලන්න.

හදපු paging උදාහරණයක්

වර්ගය 5 දැක්කම ගොඩක් ළමයි බය වෙනවා, හැබැයි ඒක Unit 3 වල තියෙන සාමාන්‍ය ගණිතය විතරයි. මේ තියෙන්නේ past paper එකක නැති අපිම හදපු උදාහරණයක්.

පරිගණකයක 16-bit virtual addresses සහ 4 KB page size එකක් පාවිච්චි කරනවා. Page table එකේ තියෙන විදිහට page 1 තියෙන්නේ frame 6 වල. Virtual address 5000 සඳහා physical address එක හොයන්න.

Page size     = 4 KB = 4096 = 2^12 bytes, so the offset uses 12 bits
Page number   = 5000 div 4096 = 1
Offset        = 5000 - 4096   = 904
Frame         = 6, read from the page table
Physical      = 6 x 4096 + 904 = 24576 + 904 = 25480

Offset එක කවදාවත් වෙනස් වෙන්නේ නෑ. Page number එක විතරක් frame number එක බවට පත් වෙනවා. 16-bit addresses සහ 12-bit offset එකක් එක්ක, page number එකට bits 4 ක් ඉතුරු වෙනවා, ඒ නිසා process එකකට pages 2^4 = 16 ක් තියෙන්න පුළුවන්.

හදපු FAT උදාහරණයක්

මේකත් අපේම උදාහරණයක්. File එකක් block 3 න් පටන් ගන්නවා. FAT එකේ entry 3 වල 7 තියෙනවා, entry 7 වල 4 තියෙනවා, සහ entry 4 වල -1 තියෙනවා. ඉතින් මේ file එක අනුපිළිවෙලින් blocks 3, 7 සහ 4 පාවිච්චි කරනවා, ඒ වගේම අන්තිම -1 න් අවසානය සලකුණු කරනවා. 4 KB blocks එක්ක, මේ file එක disk එකෙන් 12 KB ඉඩක් ගන්නවා. File එකේ තියෙන්නේ 9 KB data විතරක් නම්, අන්තිම block එකේ 3 KB අපතේ යනවා. Block එකක් ඇතුළේ එහෙම ඉඩ අපතේ යන එකට කියන්නේ internal fragmentation කියලා.

6. ඇත්ත ලෝකයේ අද වෙන්නේ මොකක්ද

2026 වෙද්දිත් ඇත්ත පරිගණක මේ පොත්වල තියෙන අදහස්ම පාවිච්චි කරනවා, හැබැයි පොඩි පොඩි වෙනස්කම් එක්ක. විභාගයේදී සමහර වෙලාවට අද කාලේ තියෙන ඉලක්කම් එක්ක ප්‍රශ්න හදන නිසා, ළමයි මේ දෙකම දැනගන්න ඕනේ.

  • Cores ගොඩක්, අදහස එකයි. Multi-core processor එකක "two or more independent actual processing units" තියෙනවා (Teachers' Guide 2.3, page 68) (ගුරු අත්පොත 2.3, පිටුව 74). හැම core එකක්ම ඒකටම අදාළ fetch-execute cycle එකක් run කරනවා. OS scheduler එක දැන් එක CPU එකකට විතරක් නෙවෙයි, හැම core එකකටම process එකක් හරි thread එකක් හරි තෝරනවා. Process states එහෙම්මමයි.
  • ලොකු addresses, ඒ paging එකමයි. 2026 Paper II, A, Q4(c) වල 48-bit virtual addresses සහ 4 KB pages පාවිච්චි කරනවා. මේ ඉලක්කම් ඇවිත් තියෙන්නේ ඇත්තම machines වලින්. දැන් තියෙන x86-64 processors පාවිච්චි කරන්නේ 48-bit virtual addresses, ඒ වගේම අලුත් ඒවට 57 bits පාවිච්චි කරන්න පුළුවන් (x86-64). 4 KB page එක කියන්නේ තාමත් ගොඩක්ම පාවිච්චි වෙන size එක (Page). Guide එකේ frame sizes දීලා තියෙන්නේ "between 512 bytes and 8192 bytes" කියලා (Teachers' Guide 5.4, page 141) (ගුරු අත්පොත 5.4, පිටුව 153), ඉතින් 4 KB කියන්නේ ඒ පරාසය ඇතුළේ තියෙන අගයක්.
  • Defragmentation තියෙන්නේ කැරකෙන disks වලට. Defragmentation එකෙන් කරන්නේ disk එකක තියෙන file කෑලි ටික පිළිවෙලකට හදන එක (Teachers' Guide 5.2, page 129) (ගුරු අත්පොත 5.2, පිටුව 140). මේකෙන් hard disk එකක් fast වෙනවා, මොකද ඒකේ head එක එහෙ මෙහෙ යනවා අඩුයි. හැබැයි solid-state drive එකක head එකක් නෑ. SSD එකකදි, OS එක TRIM commands යවලා drive එකට කියනවා මොන blocks ද නිදහස් කියලා (Trim).
  • FAT තාමත් පාවිච්චි වෙනවා. Guide එක FAT වලට කියන්නේ MS-DOS වල file system එක කියලා (Teachers' Guide 5.2, page 128) (ගුරු අත්පොත 5.2, පිටුව 139). ඒකෙන් පස්සේ ආපු FAT32 සහ exFAT තාමත් memory cards සහ USB drives වල ගොඩක් පාවිච්චි වෙනවා (exFAT). ඒ නිසා Paper II එකේ එන FAT chain එක ඉතිහාසය විතරක්ම නෙවෙයි.
  • Real-time systems හැමතැනම තියෙනවා. Real-time OS එකකින් "quick and predictable response to events" දෙනවා, ඒ ප්‍රමාදයක් වුණොත් "could cause a safety hazard" වෙන අවස්ථා වලදි (Teachers' Guide 5.1, page 125) (ගුරු අත්පොත 5.1, පිටුව 136). මේක කෙලින්ම සම්බන්ධ වෙන්නේ Unit 11 වල තියෙන embedded systems වලට.

7. මේ අදහස් පස්සේ කාලෙක ආයේ එන්නේ කොහෙදිද

Fetch-execute cycle එකයි OS එකයි 12 වසරෙන් ඉවර වෙන්නේ නෑ. ඒවා 13 වසරේ units වලදි ආයෙත් එනවා, ගොඩක් වෙලාවට ඒ නම් නැතුව.

  • Program translators (9.5). Syllabus එකේ source program, object program, interpreters සහ compilers ගැන තියෙනවා (Syllabus 9.5, pages 37 and 38) (විෂය නිර්දේශය 9.5, පිටුව 35). Object program කියන්නේ fetch-execute cycle එකෙන් run කරන machine instructions ටික.
  • Programs ඇතුළේ file handling (9.11). Python program එකකින් file එකක් open කරද්දි, ඒක ඒ file එක ඉල්ලන්නේ OS එකෙන් (Syllabus 9.11, page 40) (විෂය නිර්දේශය 9.11, පිටුව 37). ඊට පස්සේ OS එක අර 5.2 වල තියෙන file system එක පාවිච්චි කරනවා.
  • Parallel සහ grid computing (2.2). Syllabus එකෙන් "the need for parallel and grid computing" අහනවා (Syllabus 2.2, pages 7 and 8) (විෂය නිර්දේශය 2.2, පිටුව 8). ඒ කියන්නේ අර multi-core අදහසම, machines ගොඩක් හරහා පැතිරිලා තියෙන එක.
  • Embedded systems (11.1). Syllabus එකෙන් Arduino වගේ boards සාමාන්‍ය computer systems එක්ක සසඳනවා (Syllabus 11.1, pages 45 and 46) (විෂය නිර්දේශය 11.1, පිටු 42 සහ 43). සරල board එකක් එක program එකක් loop එකක දිගටම run කරනවා, ඒක hardware වලට ගොඩක් කිට්ටුයි. මේකත් fetch-execute cycle එකම තමයි, හැබැයි පොඩි OS එකක් එක්ක හරි OS එකක් ඇත්තෙම නැතුව හරි.
  • Von Neumann වලින් එහාට (13.3). Syllabus එකෙන් අහනවා "beyond von-Neumann" computing ගැන (Syllabus 13.3, page 49) (විෂය නිර්දේශය 13.3, පිටුව 47). එතනින් එහාට තියෙන්නේ මොකක්ද කියලා තේරුම් ගන්න ළමයි මේ stored program එකයි fetch-execute cycle එකයි හරියටම දැනගන්න ඕනේ.

Bottleneck එක සහ අලුත් models එක්ක සම්පූර්ණ von Neumann කතාව Von Neumann architecture from stored program to bottleneck වල තියෙනවා. Adders වල ඉඳන් flip-flops හරහා memory එකට යන circuit පැත්ත Binary to memory through adders and flip-flops වල තියෙනවා.

8. Try කරන්න past paper ප්‍රශ්න

උත්තර බලන්න කලින් මේ හැම ප්‍රශ්නයක්ම තනියම try කරන්න. වරහන් ඇතුළේ තියෙන්නේ මේ ප්‍රශ්නෙට උදව් වෙන මේ post එකේ අදාළ කොටස. මේ ප්‍රශ්න වල උත්තර මේ post එකේ නෑ.

සම්පූර්ණ කතාවම අහන ප්‍රශ්න, මේවා අන්තිමට කරන්න:

  • 2024 Paper II, B, Q10: එක program එකක් CPU instructions වල ඉඳන් file allocation වෙනකම් (කොටස් 3 සහ 5).
  • 2023 (held 2024) Paper II, B, Q10: cycle එක, flip-flops, PCB, paging සහ FAT (කොටස් 3 සහ 5).
  • 2021 (held 2022) Paper II, B, Q10: multi-core, volatile memory, time sharing, virtual memory සහ linked allocation (කොටස් 2 සහ 6).

එක stage එකක් ගැන විතරක් අහන ප්‍රශ්න:

  • 2025 Paper I, Q6 සහ Q7, 2026 Paper I, Q4 සහ Q5: buses, registers සහ program counter එක (කොටස 2).
  • 2021 (held 2022) Paper I, Q4: program එකක් load කරන හැටි සහ fetch-decode-execute cycle එක (කොටස 3).
  • 2025 Paper II, A, Q4(a) සහ 2026 Paper II, A, Q4(b): process states, PCB සහ context switch එක (කොටස් 3 සහ 5).
  • 2022 (held 2023) Paper II, B, Q10(a) ඉඳන් (d) වෙනකම්: context switch, කෙටි time slice එකක් සහ paging (කොටස් 3 සහ 5).
  • 2026 Paper II, A, Q4(c) සහ 2025 Paper II, A, Q4(b): paging සහ page faults (කොටස 5).
  • 2026 Paper II, A, Q4(a) සහ 2025 Paper II, A, Q4(c): FAT chains සහ block size (කොටස 5).
  • 2026 Paper II, A, Q4(d) සහ 2024 Paper I, Q6: device drivers සහ booting (කොටස් 3 සහ 5).

පරණ syllabus, extra practice වලට විතරයි:

  • 2013 Paper II, A, Q2(c) සහ 2015 Paper II, A, Q4(b): states හතේ diagram එක (කොටස 3).
  • 2018 Paper II, A, Q4(d): frames සහ page table එක (කොටස 5).

Syllabus එකෙන් පිට sources

මාධ්‍ය දෙකේම syllabus එකේ සහ Teachers' Guide එකේ පිටු post එකේ text එකේම දාලා තියෙනවා. මෙතන තියෙන past papers කියන්නේ ශ්‍රී ලංකා විභාග දෙපාර්තමේන්තුවේ අ.පො.ස. (උ/පෙ) ICT ප්‍රශ්න පත්‍ර. අනිත් sources මේවා:

  • x86-64, virtual address size එක. Wikipedia.
  • Page (computer memory), සාමාන්‍ය page sizes. Wikipedia.
  • Trim (computing), SSD free-block commands. Wikipedia.
  • exFAT, flash media වල තියෙන FAT family එක. Wikipedia.

මේ Explained එක බෙදාගන්න

A/L ICT කරන යාළුවෙකුට යවන්න.

මේ ලිපියට link කරන ලිපි

  1. සිංහල

    Paper II OS ගණන් FAT chain එකෙන් සහ page table එකෙන් හදන හැටි

    හැම A/L ICT Paper II එකකම එන operating system calculations. FAT chains, blocks සහ wasted space, allocation method එක තෝරන හැටි, page සහ frame bits, සහ address translation, හැම එකක්ම ඇත්ත past paper ප්‍රශ්න වලින් හදලා.

  2. සිංහල

    OS පාඩමට කලින් fetch-execute

    Fetch-execute cycle එක පැහැදිලි නැති වුණාම OS පාඩම වචන ගොඩක් වගේ දැනෙනවා. Unit 5 ලේසියෙන් තේරුම් ගන්න පුළුවන් පිළිවෙලක් තියෙනවා. මේක Paper II එකටත් වැදගත්.

තවත් Explained

  1. Layer 2 සහ Layer 3 switch වල වෙනස්කම් සහ ඇත්තටම පාවිච්චි වෙන තැන්

    Layer 2 සහ Layer 3 switch එකක් වෙනස් වෙන්නේ කොහොමද, ඒවගේ වැඩ මොනවද, network වල දැන් සහ ඉස්සරහට ඒවා පාවිච්චි වෙන්නේ කොහෙද, ඒ වගේම මේවා අහන A/L ICT past paper ප්‍රශ්න උත්තර එක්කම.

    සිංහලපියවර 7ක්
  2. A/L ICT 2027 දෙවැනි පාර ලියන අයට past papers සහ unit weights අනුව හදපු study plan එක

    2027 දී A/L ICT ආයෙත් ලියන ළමයින්ට හදපු study plan එකක්. 2026 results, වැඩිම ලකුණු තියෙන units, past papers එක්ක පාඩම් කරන විදිහ, මාසෙන් මාසෙට යන timeline එකක් සහ මේ site එකේ තියෙන free papers ගැන මේකෙන් පැහැදිලි කරනවා.

    සිංහලපියවර 7ක්
  3. 2026 Paper II Q9 හි lists of tuples එක්ක Python functions සහ sequential search

    2026 Paper II Q9 පියවරෙන් පියවර. Fine rule එකේ තේරුම් දෙක, if සහ elif එක්ක function එකක්, loop එකකින් හදන list of tuples, -1 දෙන sequential search එක සහ මේ දේවල් Paper I එකේ එන හැටි.

    සිංහලපියවර 7ක්
All Explained