Key To Fast Crash Recovery: Statelessness.

ಶೀಘ್ರ ಕ್ರ್ಯಾಶ್ ಚೇತರಿಕೆಗೆ ಪ್ರಮುಖ ಅಂಶ: ಸ್ಥಿತಿರಹಿತತೆ.


NFSv2 ಪ್ರೋಟೋಕಾಲ್.


From Protocol to Distributed File System.

ಪ್ರೋಟೋಕಾಲ್‌ನಿಂದ ವಿತರಣಾ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ.


Handling Server Failure with Idempotent Operations.

ಐಡೆಂಪೋಟೆಂಟ್ ಕಾರ್ಯಾಚರಣೆಗಳೊಂದಿಗೆ ಸರ್ವರ್ ವೈಫಲ್ಯವನ್ನು ನಿರ್ವಹಿಸುವುದು.


Improving Performance: Client-side Caching.

ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುವುದು: ಕ್ಲೈಂಟ್-ಸೈಡ್ ಸಂಗ್ರಹ.


ಸಂಗ್ರಹ ಸ್ಥಿರತೆಯ ಸಮಸ್ಯೆ.


NFS ಸಂಗ್ರಹ ಸ್ಥಿರತೆಯನ್ನು ನಿರ್ಣಯಿಸುವುದು.


Implications on Server-Side Write Buffering.

ಸರ್ವರ್-ಸೈಡ್ ಬರೆಯುವ ಬಫರಿಂಗ್‌ನ ಮೇಲಿನ ಪರಿಣಾಮಗಳು.


ಆಂಡ್ರ್ಯೂ ಫೈಲ್ ಸಿಸ್ಟಮ್ (AFS)


AFS ಆವೃತ್ತಿ 1.


ಆವೃತ್ತಿ 1 ರೊಂದಿಗಿನ ಸಮಸ್ಯೆಗಳು.


ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಸುಧಾರಿಸುವುದು.


AFS ಆವೃತ್ತಿ 2.


ಸಂಗ್ರಹ ಸ್ಥಿರತೆ.


ಕ್ರ್ಯಾಶ್ ಚೇತರಿಕೆ.


AFSv2 ನ ಪ್ರಮಾಣ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ.


AFS: ಇತರ ಸುಧಾರಣೆಗಳು.


ವಿತರಣೆಯ ಕುರಿತು ಸಾರಾಂಶ ಸಂವಾದ


ಮೆಮೊರಿಯನ್ನು ಪ್ರವೇಶಿಸುವ ಒಂದು ಪ್ರೋಗ್ರಾಂ.


ಅಡ್ಡಿಗಳನ್ನು ನಿಯಂತ್ರಿಸುವುದು.


ಕೆಲಸ ಮಾಡುವ ಸ್ಪಿನ್ ಲಾಕ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು.


ಹೋಲಿಕೆ ಮತ್ತು ವಿನಿಮಯ.


ಒಂದು ಸರಳ ವಿಧಾನ: ಸುಮ್ಮನೆ ಇಳಿಸಿ, ಮಗು.


Using Queues: Sleeping Instead Of Spinning.

ಸಾಲನ್ನು ಬಳಸುವುದು: ಸ್ಪಿನ್ ಮಾಡುವ ಬದಲು ನಿದ್ರಿಸುವುದು.


ವಿವಿಧ OS, ವಿಭಿನ್ನ ಬೆಂಬಲ.


ಎರಡು-ಹಂತದ ಬೀಗಗಳು.


ಸಮಕಾಲೀನ ಕೌಂಟರ್‌ಗಳು.


ಸಮಕಾಲೀನ ಲಿಂಕ್ಡ್ ಪಟ್ಟಿಗಳು.


ಸಮಕಾಲೀನ ಸರತಿ ಸಾಲುಗಳು.


ಸಮಕಾಲೀನ ಹ್ಯಾಶ್ ಟೇಬಲ್.


ವ್ಯಾಖ್ಯಾನ ಮತ್ತು ದಿನಚರಿಗಳು.


The Producer/Consumer (Bound Buffer) Problem.

ಉತ್ಪಾದಕ/ಗ್ರಾಹಕ (ಬೌಂಡ್ ಬಫರ್) ಸಮಸ್ಯೆ.


ಷರತ್ತುಗಳನ್ನು ಒಳಗೊಳ್ಳುವುದು.


ಸೆಮಾಫೋರ್‌ಗಳು: ಒಂದು ವ್ಯಾಖ್ಯಾನ.


ಬೈನರಿ ಸೆಮಾಫೋರ್‌ಗಳು (ಲಾಕ್‌ಗಳು).


ಷರತ್ತುಬದ್ಧ ಅಸ್ಥಿರಗಳಂತೆ ಸೆಮಾಫೋರ್‌ಗಳು.


ಊಟದ ತತ್ವಜ್ಞಾನಿಗಳು.


ಯಾವ ರೀತಿಯ ದೋಷಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ?


ಮೂಲ ಕಲ್ಪನೆ: ಈವೆಂಟ್ ಲೂಪ್.


The operating system manages the computer's resources.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


Scheduling algorithms determine the order in which processes are executed.

ಯಾವ ಕ್ರಮದಲ್ಲಿ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು ಎಂಬುದನ್ನು ಶೆಡ್ಯೂಲಿಂಗ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ನಿರ್ಧರಿಸುತ್ತವೆ.


Memory management is crucial for efficient system performance.

ಸಮರ್ಥ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ ಅತ್ಯಗತ್ಯ.


CPU ಕಂಪ್ಯೂಟರ್‌ನ ಮೆದುಳು.


Virtual memory allows the system to run programs larger than physical RAM.

ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಸಿಸ್ಟಮ್ ಭೌತಿಕ RAM ಗಿಂತ ದೊಡ್ಡ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.


Concurrency and parallelism are important concepts in modern operating systems.

ಆಧುನಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಸಮಕಾಲೀನತೆ ಮತ್ತು ಸಮಾನಾಂತರತೆ ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳಾಗಿವೆ.


ಥ್ರೆಡ್‌ಗಳು ಒಂದೇ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ.


Locks are used to protect shared resources from race conditions.

ರೇಸ್ ಪರಿಸ್ಥಿತಿಗಳಿಂದ ಹಂಚಿದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಕ್ಷಿಸಲು ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


Condition variables help threads coordinate their actions.

ಥ್ರೆಡ್‌ಗಳು ತಮ್ಮ ಕ್ರಿಯೆಗಳನ್ನು ಸಂಯೋಜಿಸಲು ಕಂಡಿಷನ್ ವೇರಿಯೇಬಲ್‌ಗಳು ಸಹಾಯ ಮಾಡುತ್ತವೆ.


The operating system provides an abstraction of the hardware.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಹಾರ್ಡ್‌ವೇರ್‌ನ ಒಂದು ಅಮೂರ್ತತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.


File systems organize data on storage devices.

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಸಂಗ್ರಹ ಸಾಧನಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಘಟಿಸುತ್ತವೆ.


ನಾನು ಶುಕ್ರವಾರದೊಳಗೆ ನನ್ನ ಹೋಮ್‌ವರ್ಕ್ ಸಲ್ಲಿಸಬೇಕು.


Can you explain the concept of virtual memory?

ನೀವು ವರ್ಚುವಲ್ ಮೆಮೊರಿಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸಬಹುದೇ?


ಉಪನ್ಯಾಸವು ಬಹಳ ಮಾಹಿತಿಯುಕ್ತವಾಗಿತ್ತು.


I am having trouble understanding the material.

ವಸ್ತುವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನನಗೆ ತೊಂದರೆಯಾಗುತ್ತಿದೆ.


The professor assigned a lot of reading for this week.

ಈ ವಾರಕ್ಕಾಗಿ ಪ್ರಾಧ್ಯಾಪಕರು ಬಹಳಷ್ಟು ಓದುವಿಕೆಯನ್ನು ನಿಯೋಜಿಸಿದ್ದಾರೆ.


ಯೋಜನೆಯ ಅವಶ್ಯಕತೆಗಳನ್ನು ಚರ್ಚಿಸೋಣ.


The deadline for the assignment is approaching.

ಅಸೈನ್‌ಮೆಂಟ್‌ನ ಗಡುವು ಸಮೀಪಿಸುತ್ತಿದೆ.


ಕೋಡ್‌ನೊಂದಿಗೆ ನನಗೆ ಸಹಾಯ ಬೇಕು.


The system crashed due to a memory leak.

ಮೆಮೊರಿ ಸೋರಿಕೆಯಿಂದಾಗಿ ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ ಆಯಿತು.


The program is designed to run on multiple platforms.

ಈ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅನೇಕ ವೇದಿಕೆಗಳಲ್ಲಿ ಚಲಾಯಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


Please provide the necessary details for the project.

ಯೋಜನೆಗಾಗಿ ಅಗತ್ಯವಿರುವ ವಿವರಗಳನ್ನು ದಯವಿಟ್ಟು ಒದಗಿಸಿ.


The company announced a new product launch next month.

ಕಂಪನಿಯು ಮುಂದಿನ ತಿಂಗಳು ಹೊಸ ಉತ್ಪನ್ನವನ್ನು ಬಿಡುಗಡೆ ಮಾಡುವುದಾಗಿ ಘೋಷಿಸಿತು.


He is a very knowledgeable person in the field of computer science.

ಅವರು ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನ ಕ್ಷೇತ್ರದಲ್ಲಿ ಬಹಳ ಜ್ಞಾನವುಳ್ಳ ವ್ಯಕ್ತಿ.


The operating system manages the computer's resources efficiently.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸುತ್ತದೆ.


Despite the challenges, the team completed the project on time.

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ತಂಡವು ಸಮಯಕ್ಕೆ ಸರಿಯಾಗಿ ಯೋಜನೆಯನ್ನು ಪೂರ್ಣಗೊಳಿಸಿತು.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಸಮರ್ಥವಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


The government is implementing new policies to boost the economy.

ಆರ್ಥಿಕತೆಯನ್ನು ಹೆಚ್ಚಿಸಲು ಸರ್ಕಾರ ಹೊಸ ನೀತಿಗಳನ್ನು ಜಾರಿಗೆ ತರುತ್ತಿದೆ.


The software update includes several bug fixes and performance improvements.

ಸಾಫ್ಟ್‌ವೇರ್ ನವೀಕರಣವು ಹಲವಾರು ದೋಷ ಪರಿಹಾರಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


The research paper explores the impact of climate change on agriculture.

ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ಕೃಷಿಯ ಮೇಲೆ ಹವಾಮಾನ ಬದಲಾವಣೆಯ ಪ್ರಭಾವವನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ.


The complex system requires careful planning and execution.

ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗೆ ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಅಗತ್ಯವಿದೆ.


The company's innovative approach revolutionized the industry.

ಕಂಪನಿಯ ನವೀನ ವಿಧಾನವು ಉದ್ಯಮದಲ್ಲಿ ಕ್ರಾಂತಿಯನ್ನುಂಟುಮಾಡಿತು.


The philosophical debate centered on the nature of consciousness.

ತತ್ವಶಾಸ್ತ್ರದ ಚರ್ಚೆಯು ಪ್ರಜ್ಞೆಯ ಸ್ವರೂಪದ ಮೇಲೆ ಕೇಂದ್ರೀಕೃತವಾಗಿತ್ತು.


The intricate details of the experiment were meticulously documented.

ಪ್ರಯೋಗದ ಜಟಿಲ ವಿವರಗಳನ್ನು ನಿಖರವಾಗಿ ದಾಖಲಿಸಲಾಗಿದೆ.


The economic forecast predicts a period of sustained growth.

ಆರ್ಥಿಕ ಮುನ್ಸೂಚನೆಯು ಸ್ಥಿರ ಬೆಳವಣಿಗೆಯ ಅವಧಿಯನ್ನು ಊಹಿಸುತ್ತದೆ.


The implications of the new policy are far-reaching and complex.

ಹೊಸ ನೀತಿಯ ಪರಿಣಾಮಗಳು ದೂರಗಾಮಿ ಮತ್ತು ಸಂಕೀರ್ಣವಾಗಿವೆ.


The artist's work reflects a deep understanding of human emotions.

ಕಲಾವಿದನ ಕೆಲಸವು ಮಾನವ ಭಾವನೆಗಳ ಬಗ್ಗೆ ಆಳವಾದ ತಿಳುವಳಿಕೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ.


The development of artificial intelligence has raised ethical concerns.

ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯ ಅಭಿವೃದ್ಧಿಯು ನೈತಿಕ ಕಾಳಜಿಗಳನ್ನು ಹೆಚ್ಚಿಸಿದೆ.


The intricate network of relationships within the organization was difficult to navigate.

ಸಂಸ್ಥೆಯೊಳಗಿನ ಸಂಬಂಧಗಳ ಜಟಿಲ ಜಾಲವನ್ನು ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವುದು ಕಷ್ಟಕರವಾಗಿತ್ತು.


The scientific community is actively researching potential cures for the disease.

ವೈಜ್ಞಾನಿಕ ಸಮುದಾಯವು ರೋಗಕ್ಕೆ ಸಂಭಾವ್ಯ ಪರಿಹಾರಗಳ ಬಗ್ಗೆ ಸಕ್ರಿಯವಾಗಿ ಸಂಶೋಧನೆ ನಡೆಸುತ್ತಿದೆ.


The book is called Operating Systems: Three Easy Pieces.

ಪುಸ್ತಕದ ಹೆಸರು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ಸ್: ತ್ರೀ ಈಸಿ ಪೀಸಸ್.


We hope you’ll enjoy reading it as much as we enjoyed writing it.

ನೀವು ಇದನ್ನು ಓದುವುದನ್ನು ನಾವು ಬರೆದಷ್ಟೇ ಆನಂದಿಸುವಿರಿ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.


The three easy pieces refer to the three major thematic elements the book is organized around: virtualization, concurrency, and persistence.

ಮೂರು ಸುಲಭ ತುಣುಕುಗಳು ಪುಸ್ತಕವನ್ನು ಆಯೋಜಿಸಿರುವ ಮೂರು ಪ್ರಮುಖ ವಿಷಯಾಧಾರಿತ ಅಂಶಗಳನ್ನು ಸೂಚಿಸುತ್ತವೆ: ವರ್ಚುವಲೈಸೇಶನ್, ಸಮಕಾಲೀನತೆ ಮತ್ತು ನಿರಂತರತೆ.


ಹೊಸ ವಿಷಯಗಳನ್ನು ಕಲಿಯುವುದು ಖುಷಿಯಲ್ಲವೇ?


Each major concept is divided into a set of chapters, most of which present a particular problem and then show how to solve it.

ಪ್ರತಿಯೊಂದು ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಯನ್ನು ಅಧ್ಯಾಯಗಳ ಗುಂಪಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ, ಅವುಗಳಲ್ಲಿ ಹೆಚ್ಚಿನವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತವೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಬೇಕೆಂದು ತೋರಿಸುತ್ತವೆ.


One of our goals in writing this book is to make the paths of history as clear as possible.

ಈ ಪುಸ್ತಕವನ್ನು ಬರೆಯುವ ನಮ್ಮ ಗುರಿಗಳಲ್ಲಿ ಒಂದು ಇತಿಹಾಸದ ಹಾದಿಗಳನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಸ್ಪಷ್ಟಪಡಿಸುವುದು.


There are a couple devices we use throughout the book which are probably worth introducing here.

ನಾವು ಪುಸ್ತಕದ ಉದ್ದಕ್ಕೂ ಬಳಸುವ ಕೆಲವು ಸಾಧನಗಳಿವೆ, ಅದನ್ನು ಇಲ್ಲಿ ಪರಿಚಯಿಸುವುದು ಯೋಗ್ಯವಾಗಿದೆ.


ಮೊದಲನೆಯದು ಸಮಸ್ಯೆಯ ತಿರುಳು.


Asides tend to discuss something relevant (but perhaps not essential) to the main text.

ಪಕ್ಕದ ವಿಷಯಗಳು ಮುಖ್ಯ ಪಠ್ಯಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ವಿಷಯವನ್ನು ಚರ್ಚಿಸುತ್ತವೆ (ಆದರೆ ಬಹುಶಃ ಅಗತ್ಯವಿಲ್ಲ).


An index at the end of the book lists all of these tips and asides for your convenience.

ಪುಸ್ತಕದ ಕೊನೆಯಲ್ಲಿರುವ ಸೂಚ್ಯಂಕವು ನಿಮ್ಮ ಅನುಕೂಲಕ್ಕಾಗಿ ಈ ಎಲ್ಲಾ ಸಲಹೆಗಳು ಮತ್ತು ಪಕ್ಕದ ವಿಷಯಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ.


We use one of the oldest didactic methods, the dialogue, throughout the book.

ನಾವು ಪುಸ್ತಕದ ಉದ್ದಕ್ಕೂ ಅತ್ಯಂತ ಹಳೆಯ ಬೋಧನಾ ವಿಧಾನಗಳಲ್ಲಿ ಒಂದನ್ನು ಬಳಸುತ್ತೇವೆ, ಸಂವಾದ.


At the beginning of each major section, we’ll first present an abstraction that an operating system provides.

ಪ್ರತಿ ಪ್ರಮುಖ ವಿಭಾಗದ ಆರಂಭದಲ್ಲಿ, ನಾವು ಮೊದಲು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಒದಗಿಸುವ ಒಂದು ಅಮೂರ್ತತೆಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ.


Throughout the chapters, we try to use real code (not pseudocode) where possible.

ಅಧ್ಯಾಯಗಳ ಉದ್ದಕ್ಕೂ, ಸಾಧ್ಯವಾದಲ್ಲೆಲ್ಲಾ ನಾವು ನಿಜವಾದ ಕೋಡ್ ಅನ್ನು ಬಳಸಲು ಪ್ರಯತ್ನಿಸುತ್ತೇವೆ (ಸೂಡೋಕೋಡ್ ಅಲ್ಲ).


Running real code on real systems is the best way to learn about operating systems.

ನಿಜವಾದ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ನಿಜವಾದ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳ ಬಗ್ಗೆ ಕಲಿಯಲು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.


In various parts of the text, we have sprinkled in a few homeworks to ensure that you are understanding what is going on.

ಪಠ್ಯದ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ, ನೀವು ಏನು ನಡೆಯುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಾವು ಕೆಲವು ಹೋಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಸೇರಿಸಿದ್ದೇವೆ.


The most important addendum to this book is a set of projects in which you learn about how real systems work.

ಈ ಪುಸ್ತಕಕ್ಕೆ ಅತ್ಯಂತ ಮುಖ್ಯವಾದ ಅನುಬಂಧವೆಂದರೆ ನೀವು ಹೇಗೆ ನಿಜವಾದ ವ್ಯವಸ್ಥೆಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದರ ಬಗ್ಗೆ ಕಲಿಯುವ ಯೋಜನೆಗಳ ಒಂದು ಗುಂಪಾಗಿದೆ.


All projects (as well as the code examples, mentioned above) are in the C programming language.

ಎಲ್ಲಾ ಯೋಜನೆಗಳು (ಮೇಲೆ ತಿಳಿಸಿದ ಕೋಡ್ ಉದಾಹರಣೆಗಳ ಜೊತೆಗೆ) ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಲ್ಲಿವೆ.


If you are an instructor or professor who wishes to use this book, please feel free to do so.

ನೀವು ಈ ಪುಸ್ತಕವನ್ನು ಬಳಸಲು ಬಯಸುವ ಬೋಧಕ ಅಥವಾ ಪ್ರಾಧ್ಯಾಪಕರಾಗಿದ್ದರೆ, ದಯವಿಟ್ಟು ಹಾಗೆ ಮಾಡಲು ಮುಕ್ತರಾಗಿರಿ.


The course divides fairly well across a 15-week semester.

ಈ ಕೋರ್ಸ್ 15 ವಾರಗಳ ಅವಧಿಯಲ್ಲಿ ಉತ್ತಮವಾಗಿ ವಿಂಗಡಿಸಲ್ಪಟ್ಟಿದೆ.


You may have noticed this book is free and available online.

ಈ ಪುಸ್ತಕವು ಉಚಿತವಾಗಿದೆ ಮತ್ತು ಆನ್‌ಲೈನ್‌ನಲ್ಲಿ ಲಭ್ಯವಿದೆ ಎಂಬುದನ್ನು ನೀವು ಗಮನಿಸಿರಬಹುದು.


The program creates a file named '/tmp/file'.

ಪ್ರೋಗ್ರಾಂ '/tmp/file' ಎಂಬ ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ.


Data in system memory can be easily lost.

ಸಿಸ್ಟಮ್ ಮೆಮೊರಿಯಲ್ಲಿನ ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ಕಳೆದುಕೊಳ್ಳಬಹುದು.


The file system manages files on the disk.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


Users often want to share information in files.

ಬಳಕೆದಾರರು ಸಾಮಾನ್ಯವಾಗಿ ಫೈಲ್‌ಗಳಲ್ಲಿ ಮಾಹಿತಿಯನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಬಯಸುತ್ತಾರೆ.


The compiler turns source code into an executable.

ಕಂಪೈಲರ್ ಮೂಲ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಕೋಡ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.


The program writes 'hello world' to the file.

ಪ್ರೋಗ್ರಾಂ ಫೈಲ್‌ಗೆ 'hello world' ಅನ್ನು ಬರೆಯುತ್ತದೆ.


The file system is responsible for storing files.

ಫೈಲ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಹೊಂದಿದೆ.


The OS provides a standard way to access devices.

OS ಸಾಧನಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಮಾಣಿತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ.


File systems delay writes for performance reasons.

ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಬರವಣಿಗೆಯನ್ನು ವಿಳಂಬಗೊಳಿಸುತ್ತವೆ.


Operating systems virtualize resources like CPU and memory.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು CPU ಮತ್ತು ಮೆಮೊರಿಯಂತಹ ಸಂಪನ್ಮೂಲಗಳನ್ನು ವರ್ಚುವಲೈಸ್ ಮಾಡುತ್ತವೆ.


Abstraction makes it possible to write large programs.

ಅಮೂರ್ತತೆಯು ದೊಡ್ಡ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬರೆಯಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ.


The OS must provide protection between applications.

OS ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಡುವೆ ರಕ್ಷಣೆಯನ್ನು ಒದಗಿಸಬೇಕು.


Operating systems strive to provide a high degree of reliability.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು ಹೆಚ್ಚಿನ ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಒದಗಿಸಲು ಶ್ರಮಿಸುತ್ತವೆ.


Early operating systems were just libraries of functions.

ಆರಂಭಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು ಕೇವಲ ಕಾರ್ಯಗಳ ಗ್ರಂಥಾಲಯಗಳಾಗಿದ್ದವು.


The system call was invented to manage machines.

ಯಂತ್ರಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಿಸ್ಟಮ್ ಕರೆ ಕಂಡುಹಿಡಿಯಲಾಯಿತು.


ಬಳಕೆದಾರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಬಳಕೆದಾರ ಮೋಡ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತವೆ.


The hardware privilege level is raised in kernel mode.

ಕರ್ನಲ್ ಮೋಡ್‌ನಲ್ಲಿ ಹಾರ್ಡ್‌ವೇರ್ ಸವಲತ್ತು ಮಟ್ಟವನ್ನು ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ.


Multiprogramming became commonplace to improve CPU utilization.

CPU ಬಳಕೆಯನ್ನು ಸುಧಾರಿಸಲು ಮಲ್ಟಿಪ್ರೋಗ್ರಾಮಿಂಗ್ ಸಾಮಾನ್ಯವಾಯಿತು.


UNIX took many good ideas from different operating systems.

UNIX ವಿವಿಧ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಿಂದ ಅನೇಕ ಉತ್ತಮ ಆಲೋಚನೆಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು.


The modern era brought the personal computer.

ಆಧುನಿಕ ಯುಗವು ವೈಯಕ್ತಿಕ ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ತಂದಿತು.


A classic text on software engineering; well worth the read.

ಸಾಫ್ಟ್‌ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್‌ನ ಮೇರುಕೃತಿ; ಓದಲು ಯೋಗ್ಯವಾಗಿದೆ.


Another great intro to how computer systems work.

ಕಂಪ್ಯೂಟರ್ ವ್ಯವಸ್ಥೆಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದಕ್ಕೆ ಮತ್ತೊಂದು ಉತ್ತಮ ಪರಿಚಯ.


After all, one good way to build up your own knowledge is to hear as many other perspectives as possible, and then develop your own opinion and thoughts on the matter.

ಎಲ್ಲಾ ನಂತರ, ನಿಮ್ಮ ಸ್ವಂತ ಜ್ಞಾನವನ್ನು ಬೆಳೆಸಿಕೊಳ್ಳಲು ಒಂದು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ ಇತರ ಹಲವು ದೃಷ್ಟಿಕೋನಗಳನ್ನು ಕೇಳುವುದು, ತದನಂತರ ವಿಷಯದ ಬಗ್ಗೆ ನಿಮ್ಮದೇ ಆದ ಅಭಿಪ್ರಾಯ ಮತ್ತು ಆಲೋಚನೆಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುವುದು.


The Atlas pioneered much of what you see in modern systems.

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ನೀವು ನೋಡುವುದನ್ನು ಅಟ್ಲಾಸ್ ಬಹಳವಾಗಿ ಪ್ರವರ್ತಿಸಿತು.


A nice piece of history on the early development of computer systems and the pioneering efforts of the Atlas.

ಕಂಪ್ಯೂಟರ್ ವ್ಯವಸ್ಥೆಗಳ ಆರಂಭಿಕ ಅಭಿವೃದ್ಧಿ ಮತ್ತು ಅಟ್ಲಾಸ್‌ನ ಪ್ರವರ್ತಕ ಪ್ರಯತ್ನಗಳ ಬಗ್ಗೆ ಒಂದು ಉತ್ತಮ ಐತಿಹಾಸಿಕ ತುಣುಕು.


ಮಲ್ಟಿಕ್ಸ್‌ನ ಉತ್ತಮ ಅವಲೋಕನ.


One of our favorite intro to computing systems books.

ಕಂಪ್ಯೂಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ನಮ್ಮ ನೆಚ್ಚಿನ ಪರಿಚಯ ಪುಸ್ತಕಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.


A great summary of UNIX written as it was taking over the world of computing, by the people who wrote it.

ಯುನಿಕ್ಸ್‌ನ ಉತ್ತಮ ಸಾರಾಂಶವನ್ನು ಕಂಪ್ಯೂಟಿಂಗ್ ಜಗತ್ತನ್ನು ವಶಪಡಿಸಿಕೊಳ್ಳುತ್ತಿರುವಾಗ ಬರೆಯಲಾಗಿದೆ, ಅದನ್ನು ಬರೆದ ಜನರು ಇದನ್ನು ಬರೆದಿದ್ದಾರೆ.


Yes, a technical manual was the best we could find.

ಹೌದು, ನಾವು ಕಂಡುಕೊಳ್ಳಬಹುದಾದ ಅತ್ಯುತ್ತಮ ವಿಷಯವೆಂದರೆ ತಾಂತ್ರಿಕ ಕೈಪಿಡಿಯಾಗಿದೆ.


But it is fascinating to read these old system documents, and see how much was already in place in the late 1960’s.

ಆದರೆ ಈ ಹಳೆಯ ಸಿಸ್ಟಮ್ ದಾಖಲೆಗಳನ್ನು ಓದುವುದು ಮತ್ತು 1960 ರ ದಶಕದ ಉತ್ತರಾರ್ಧದಲ್ಲಿ ಎಷ್ಟು ಈಗಾಗಲೇ ಜಾರಿಯಲ್ಲಿತ್ತು ಎಂಬುದನ್ನು ನೋಡುವುದು ಆಕರ್ಷಕವಾಗಿದೆ.


The great thing about writing your own class notes: you can advertise your own research.

ನಿಮ್ಮ ಸ್ವಂತ ತರಗತಿ ಟಿಪ್ಪಣಿಗಳನ್ನು ಬರೆಯುವ ದೊಡ್ಡ ವಿಷಯವೆಂದರೆ: ನಿಮ್ಮ ಸ್ವಂತ ಸಂಶೋಧನೆಯನ್ನು ನೀವು ಜಾಹೀರಾತು ಮಾಡಬಹುದು.


ನಾವು ಒಂದು ಪೀಚ್ ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಊಹಿಸಿ.


What we would like to present to each eater is their own peach, so that they can be happy.

ಪ್ರತಿಯೊಬ್ಬ ತಿನ್ನುವವರಿಗೆ ನಾವು ಏನು ಪ್ರಸ್ತುತಪಡಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದರೆ ಅವರ ಸ್ವಂತ ಪೀಚ್, ಇದರಿಂದ ಅವರು ಸಂತೋಷಪಡಬಹುದು.


ಇದು ಕೆಟ್ಟ ಪ್ರಚಾರದ ಘೋಷಣೆಯಂತೆ ಧ್ವನಿಸುತ್ತದೆ.


Assume there is one physical CPU in a system.

ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಒಂದು ಭೌತಿಕ CPU ಇದೆ ಎಂದು ಭಾವಿಸೋಣ.


What virtualization does is take that single CPU and make it look like many virtual CPUs to the applications running on the system.

ವರ್ಚುವಲೈಸೇಶನ್ ಮಾಡುವುದೇನೆಂದರೆ ಆ ಒಂದೇ CPU ಅನ್ನು ತೆಗೆದುಕೊಂಡು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಅನೇಕ ವರ್ಚುವಲ್ CPU ಗಳಂತೆ ಕಾಣುವಂತೆ ಮಾಡುವುದು.


ಇನ್ನಷ್ಟು ಹೇಳಿ!


In this note, we discuss one of the most fundamental abstractions that the OS provides to users: the process.

ಈ ಟಿಪ್ಪಣಿಯಲ್ಲಿ, OS ಬಳಕೆದಾರರಿಗೆ ಒದಗಿಸುವ ಅತ್ಯಂತ ಮೂಲಭೂತ ಅಮೂರ್ತತೆಗಳಲ್ಲಿ ಒಂದನ್ನು ನಾವು ಚರ್ಚಿಸುತ್ತೇವೆ: ಪ್ರಕ್ರಿಯೆ.


The OS creates this illusion by virtualizing the CPU.

OS CPU ಅನ್ನು ವರ್ಚುವಲೈಜ್ ಮಾಡುವ ಮೂಲಕ ಈ ಭ್ರಮೆಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.


By allowing the resource to be used for a little while by one entity, and then a little while by another, and so forth, the resource in question (e.g., the CPU, or a network link) can be shared by many.

ಒಂದು ಘಟಕದಿಂದ ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ ಸಂಪನ್ಮೂಲವನ್ನು ಬಳಸಲು ಅನುಮತಿಸುವ ಮೂಲಕ, ಮತ್ತು ನಂತರ ಇನ್ನೊಂದರಿಂದ ಸ್ವಲ್ಪ ಸಮಯದವರೆಗೆ, ಪ್ರಶ್ನೆಯಲ್ಲಿರುವ ಸಂಪನ್ಮೂಲವನ್ನು (ಉದಾಹರಣೆಗೆ, CPU, ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಲಿಂಕ್) ಅನೇಕರು ಹಂಚಿಕೊಳ್ಳಬಹುದು.


The program creates a new process using the fork() system call.

ಫೋರ್ಕ್() ಸಿಸ್ಟಮ್ ಕಾಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರೋಗ್ರಾಂ ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸುತ್ತದೆ.


The child process is an almost exact copy of the parent process.

ಶಿಶು ಪ್ರಕ್ರಿಯೆಯು ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯ ಬಹುತೇಕ ನಿಖರವಾದ ಪ್ರತಿಯಾಗಿದೆ.


The operating system provides the fork() system call to create a new process.

ಹೊಸ ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಲು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಫೋರ್ಕ್() ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.


The parent process waits for the child process to complete using the wait() system call.

ಪೋಷಕ ಪ್ರಕ್ರಿಯೆಯು ಕಾಯುವ() ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಶಿಶು ಪ್ರಕ್ರಿಯೆಯು ಪೂರ್ಣಗೊಳ್ಳಲು ಕಾಯುತ್ತದೆ.


The exec() system call is used to run a different program.

ವಿಭಿನ್ನ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಲು ಎಕ್ಸೆಕ್() ಸಿಸ್ಟಮ್ ಕರೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


The shell uses fork() and exec() to run commands.

ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಶೆಲ್ ಫೋರ್ಕ್() ಮತ್ತು ಎಕ್ಸೆಕ್() ಅನ್ನು ಬಳಸುತ್ತದೆ.


The program prints a 'hello world' message.

ಪ್ರೋಗ್ರಾಂ 'ಹಲೋ ವರ್ಲ್ಡ್' ಸಂದೇಶವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.


The CPU scheduler determines which process runs at a given time.

CPU ಶೆಡ್ಯೂಲರ್ ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಯಾವ ಪ್ರಕ್ರಿಯೆ ಚಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.


The output of one process can be used as input to another.

ಒಂದು ಪ್ರಕ್ರಿಯೆಯ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಇನ್ನೊಂದಕ್ಕೆ ಇನ್‌ಪುಟ್ ಆಗಿ ಬಳಸಬಹುದು.


ಶೆಲ್ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.


The operating system manages file descriptors.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಫೈಲ್ ವಿವರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


The program p4.c redirects standard output to a file.

p4.c ಪ್ರೋಗ್ರಾಂ ಪ್ರಮಾಣಿತ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಫೈಲ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ.


The fork() and exec() combination is powerful for process manipulation.

ಪ್ರಕ್ರಿಯೆ ನಿರ್ವಹಣೆಗಾಗಿ ಫೋರ್ಕ್() ಮತ್ತು ಎಕ್ಸೆಕ್() ಸಂಯೋಜನೆಯು ಶಕ್ತಿಯುತವಾಗಿದೆ.


The OS needs to share the CPU among many jobs.

OS ಅನೇಕ ಕೆಲಸಗಳ ನಡುವೆ CPU ಅನ್ನು ಹಂಚಿಕೊಳ್ಳಬೇಕು.


Direct execution is fast, but introduces problems.

ನೇರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ವೇಗವಾಗಿದೆ, ಆದರೆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.


A process may need to perform restricted operations.

ಪ್ರಕ್ರಿಯೆಯು ನಿರ್ಬಂಧಿತ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗಬಹುದು.


User mode restricts what a process can do.

ಬಳಕೆದಾರರ ಮೋಡ್ ಪ್ರಕ್ರಿಯೆಯು ಏನು ಮಾಡಬಹುದು ಎಂಬುದನ್ನು ನಿರ್ಬಂಧಿಸುತ್ತದೆ.


Kernel mode allows privileged operations.

ಕರ್ನಲ್ ಮೋಡ್ ಸವಲತ್ತು ಪಡೆದ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅನುಮತಿಸುತ್ತದೆ.


The OS must virtualize the CPU efficiently.

OS CPU ಅನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವರ್ಚುವಲೈಸ್ ಮಾಡಬೇಕು.


ಪ್ರೋಗ್ರಾಂ CPU ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿದೆ.


The operating system manages the computer's resources.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


System calls allow user programs to access kernel functionality.

ಸಿಸ್ಟಮ್ ಕರೆಗಳು ಬಳಕೆದಾರ ಕಾರ್ಯಕ್ರಮಗಳಿಗೆ ಕರ್ನಲ್ ಕಾರ್ಯಚಟುವಟಿಕೆಯನ್ನು ಪ್ರವೇಶಿಸಲು ಅವಕಾಶ ನೀಡುತ್ತವೆ.


The hardware saves the caller’s register state.

ಹಾರ್ಡ್‌ವೇರ್ ಕರೆ ಮಾಡುವವರ ರಿಜಿಸ್ಟರ್ ಸ್ಥಿತಿಯನ್ನು ಉಳಿಸುತ್ತದೆ.


The kernel initializes the trap table at boot time.

ಕರ್ನಲ್ ಬೂಟ್ ಸಮಯದಲ್ಲಿ ಟ್ರಾಪ್ ಟೇಬಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ.


The OS must inform the hardware of the locations of these trap handlers.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಈ ಟ್ರಾಪ್ ಹ್ಯಾಂಡ್ಲರ್‌ಗಳ ಸ್ಥಳಗಳ ಬಗ್ಗೆ ಹಾರ್ಡ್‌ವೇರ್‌ಗೆ ತಿಳಿಸಬೇಕು.


The timer interrupt gives the OS the ability to run again.

ಟೈಮರ್ ಅಡಚಣೆಯು ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗೆ ಮತ್ತೆ ಚಲಾಯಿಸಲು ಸಾಮರ್ಥ್ಯವನ್ನು ನೀಡುತ್ತದೆ.


The OS decides to stop one process and start another.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸಲು ಮತ್ತು ಇನ್ನೊಂದನ್ನು ಪ್ರಾರಂಭಿಸಲು ನಿರ್ಧರಿಸುತ್ತದೆ.


How can the operating system regain control of the CPU?

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಸಿಪಿಯುನ ನಿಯಂತ್ರಣವನ್ನು ಹೇಗೆ ಮರಳಿ ಪಡೆಯಬಹುದು?


Applications transfer control to the OS when they do something illegal.

ಅಕ್ರಮವಾದ ಏನನ್ನಾದರೂ ಮಾಡಿದಾಗ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ನಿಯಂತ್ರಣವನ್ನು ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಗೆ ವರ್ಗಾಯಿಸುತ್ತವೆ.


The OS can't do much at all when a process refuses to make system calls.

ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಮಾಡಲು ಪ್ರಕ್ರಿಯೆಯು ನಿರಾಕರಿಸಿದಾಗ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಹೆಚ್ಚು ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ.


ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಸಿಪಿಯುನನ್ನು “ಶಿಶು ನಿರೋಧಕ” ವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.


The basic idea is straightforward: just run the program you want to run on the CPU.

ಮೂಲ ಕಲ್ಪನೆಯು ನೇರವಾಗಿದೆ: ನೀವು ಸಿಪಿಯುನಲ್ಲಿ ಚಲಾಯಿಸಲು ಬಯಸುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸಿ.


The OS is not running, how can it do anything at all?

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಚಾಲನೆಯಲ್ಲಿಲ್ಲದಿದ್ದರೆ, ಅದು ಹೇಗೆ ಏನನ್ನಾದರೂ ಮಾಡಬಹುದು?


The OS has to be careful in doing so; disabling interrupts for too long could lead to lost interrupts.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಹಾಗೆ ಮಾಡುವಲ್ಲಿ ಜಾಗರೂಕತೆಯಿಂದಿರಬೇಕು; ಅಡಚಣೆಗಳನ್ನು ಬಹಳ ಸಮಯದವರೆಗೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವುದರಿಂದ ಅಡಚಣೆಗಳು ಕಳೆದುಹೋಗಬಹುದು.


The OS will then have control of the CPU again.

ನಂತರ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಮತ್ತೆ ಸಿಪಿಯುನ ನಿಯಂತ್ರಣವನ್ನು ಹೊಂದಿರುತ್ತದೆ.


The hardware needs to save enough of the caller’s register state.

ಕರೆ ಮಾಡುವವರ ರಿಜಿಸ್ಟರ್ ಸ್ಥಿತಿಯನ್ನು ಹಾರ್ಡ್‌ವೇರ್ ಉಳಿಸಬೇಕಾಗುತ್ತದೆ.


The kernel must carefully control what code executes upon a trap.

ಟ್ರಾಪ್‌ನಲ್ಲಿ ಯಾವ ಕೋಡ್ ಕಾರ್ಯಗತಗೊಳ್ಳುತ್ತದೆ ಎಂಬುದನ್ನು ಕರ್ನಲ್ ಎಚ್ಚರಿಕೆಯಿಂದ ನಿಯಂತ್ರಿಸಬೇಕು.


ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಬಳಕೆದಾರ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಚಲಾಯಿಸಲು ಮುಕ್ತವಾಗಿದೆ.


The scheduler must answer which process should we run at a given time.

ಯಾವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಚಲಾಯಿಸಬೇಕು ಎಂಬುದಕ್ಕೆ ಶೆಡ್ಯೂಲರ್ ಉತ್ತರಿಸಬೇಕು.


Reboots also reclaim stale or leaked resources.

ಮರುಪ್ರಾರಂಭಗಳು ಹಳೆಯ ಅಥವಾ ಸೋರಿಕೆಯಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಮರುಪಡೆಯುತ್ತವೆ.


The operating system decides whether to remove the current user.

ಕಾರ್ಯನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯು ಪ್ರಸ್ತುತ ಬಳಕೆದಾರರನ್ನು ತೆಗೆದುಹಾಕಬೇಕೆ ಎಂದು ನಿರ್ಧರಿಸುತ್ತದೆ.


lmbench ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿ.


This is hard and painful to read, so probably avoid it if you can.

ಇದು ಓದಲು ಕಷ್ಟಕರ ಮತ್ತು ನೋವಿನಿಂದ ಕೂಡಿದೆ, ಆದ್ದರಿಂದ ನಿಮಗೆ ಸಾಧ್ಯವಾದರೆ ಇದನ್ನು ತಪ್ಪಿಸಿ.


The technique makes it even harder to defend against malicious attacks, alas.

ಈ ತಂತ್ರವು ದುರುದ್ದೇಶಪೂರಿತ ದಾಳಿಗಳ ವಿರುದ್ಧ ರಕ್ಷಿಸಿಕೊಳ್ಳುವುದನ್ನು ಇನ್ನಷ್ಟು ಕಷ್ಟಕರವಾಗಿಸುತ್ತದೆ, ಅಯ್ಯೋ.


In this homework, you’ll measure the costs of a system call and context switch.

ಈ ಹೋಮ್‌ವರ್ಕ್‌ನಲ್ಲಿ, ನೀವು ಸಿಸ್ಟಮ್ ಕರೆ ಮತ್ತು ಸಂದರ್ಭ ಸ್ವಿಚ್‌ನ ವೆಚ್ಚವನ್ನು ಅಳೆಯುತ್ತೀರಿ.


Measuring the cost of a system call is relatively easy.

ಸಿಸ್ಟಮ್ ಕರೆಯ ವೆಚ್ಚವನ್ನು ಅಳೆಯುವುದು ತುಲನಾತ್ಮಕವಾಗಿ ಸುಲಭ.


A typical timer that you can use is gettimeofday(); read the man page for details.

ನೀವು ಬಳಸಬಹುದಾದ ವಿಶಿಷ್ಟ ಟೈಮರ್ ಎಂದರೆ gettimeofday(); ವಿವರಗಳಿಗಾಗಿ ಮ್ಯಾನ್ ಪುಟವನ್ನು ಓದಿ.


Measuring the cost of a context switch is a little trickier.

ಸಂದರ್ಭ ಸ್ವಿಚ್‌ನ ವೆಚ್ಚವನ್ನು ಅಳೆಯುವುದು ಸ್ವಲ್ಪ ಟ್ರಿಕಿ ಆಗಿದೆ.


You can try to re-create something similar here, using pipes, or perhaps some other communication mechanism such as UNIX sockets.

ನೀವು ಇಲ್ಲಿ ಪೈಪ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಥವಾ UNIX ಸಾಕೆಟ್‌ಗಳಂತಹ ಕೆಲವು ಇತರ ಸಂವಹನ ಕಾರ್ಯವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಇದೇ ರೀತಿಯದನ್ನು ಮರು-ರಚಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು.


By ensuring both processes are on the same processor, you are making sure to measure the cost of the OS stopping one process and restoring another on the same CPU.

ಎರಡೂ ಪ್ರಕ್ರಿಯೆಗಳು ಒಂದೇ ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ, OS ಒಂದು ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಿಲ್ಲಿಸುವುದು ಮತ್ತು ಅದೇ CPU ನಲ್ಲಿ ಇನ್ನೊಂದನ್ನು ಮರುಸ್ಥಾಪಿಸುವ ವೆಚ್ಚವನ್ನು ಅಳೆಯಲು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುತ್ತಿದ್ದೀರಿ.


By now low-level mechanisms of running processes (e.g., context switching) should be clear.

ಈಗ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಚಲಾಯಿಸುವ ಕಡಿಮೆ-ಮಟ್ಟದ ಕಾರ್ಯವಿಧಾನಗಳು (ಉದಾಹರಣೆಗೆ, ಸಂದರ್ಭ ಸ್ವಿಚಿಂಗ್) ಸ್ಪಷ್ಟವಾಗಿರಬೇಕು.


We will now do just that, presenting a series of scheduling policies that various smart and hard-working people have developed over the years.

ನಾವು ಈಗಷ್ಟೇ ಮಾಡುತ್ತೇವೆ, ವರ್ಷಗಳಲ್ಲಿ ವಿವಿಧ ಬುದ್ಧಿವಂತ ಮತ್ತು ಶ್ರಮಶೀಲ ಜನರು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ವೇಳಾಪಟ್ಟಿ ನೀತಿಗಳ ಸರಣಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇವೆ.


The origins of scheduling, in fact, predate computer systems.

ವಾಸ್ತವವಾಗಿ, ವೇಳಾಪಟ್ಟಿಯ ಮೂಲಗಳು ಕಂಪ್ಯೂಟರ್ ವ್ಯವಸ್ಥೆಗಳಿಗಿಂತ ಹಿಂದಿನವು.


Determining the workload is a critical part of building policies.

ಕೆಲಸದ ಹೊರೆಯನ್ನು ನಿರ್ಧರಿಸುವುದು ನೀತಿಗಳನ್ನು ನಿರ್ಮಿಸುವ ಒಂದು ನಿರ್ಣಾಯಕ ಭಾಗವಾಗಿದೆ.


We will make the following assumptions about the processes, sometimes called jobs, that are running in the system:

ನಾವು ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗಳ ಬಗ್ಗೆ ಈ ಕೆಳಗಿನ ಊಹೆಗಳನ್ನು ಮಾಡುತ್ತೇವೆ, ಕೆಲವೊಮ್ಮೆ ಕೆಲಸಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ:


Each job runs for the same amount of time.

ಪ್ರತಿಯೊಂದು ಕೆಲಸವು ಒಂದೇ ಸಮಯದವರೆಗೆ ಚಲಿಸುತ್ತದೆ.


What will the average turnaround time be for these jobs?

ಈ ಕೆಲಸಗಳಿಗೆ ಸರಾಸರಿ ತಿರುವು ಸಮಯ ಎಷ್ಟು?


This problem is generally referred to as the convoy effect.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಕನ್ವಾಯ್ ಪರಿಣಾಮ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Shortest Job First represents a general scheduling principle.

ಶಾರ್ಟೆಸ್ಟ್ ಜಾಬ್ ಫಸ್ಟ್ ಒಂದು ಸಾಮಾನ್ಯ ವೇಳಾಪಟ್ಟಿ ತತ್ವವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ.


Let’s take our example above but with SJF as our scheduling policy.

ನಮ್ಮ ವೇಳಾಪಟ್ಟಿ ನೀತಿಯಾಗಿ SJF ನೊಂದಿಗೆ ಮೇಲಿನ ನಮ್ಮ ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.


When possible, overlap operations to maximize the utilization of systems.

ಸಾಧ್ಯವಾದಾಗ, ಸಿಸ್ಟಮ್‌ಗಳ ಬಳಕೆಯನ್ನು ಗರಿಷ್ಠಗೊಳಿಸಲು ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಅತಿಕ್ರಮಿಸಿ.


ಆದ್ದರಿಂದ, ಸಿಸ್ಟಮ್ ಅನ್ನು ಉತ್ತಮವಾಗಿ ಬಳಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.


By treating each CPU burst as a job, the scheduler makes sure processes that are interactive get run frequently.

ಪ್ರತಿ CPU ಸ್ಫೋಟವನ್ನು ಒಂದು ಕೆಲಸವೆಂದು ಪರಿಗಣಿಸುವ ಮೂಲಕ, ಶೆಡ್ಯೂಲರ್ ಸಂವಾದಾತ್ಮಕವಾಗಿರುವ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಆಗಾಗ್ಗೆ ಚಲಾಯಿಸುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ.


We have introduced the basic ideas behind scheduling.

ನಾವು ಶೆಡ್ಯೂಲಿಂಗ್‌ನ ಹಿಂದಿನ ಮೂಲಭೂತ ವಿಚಾರಗಳನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ.


The first runs the shortest job remaining and thus optimizes turnaround time.

ಮೊದಲನೆಯದು ಉಳಿದಿರುವ ಚಿಕ್ಕ ಕೆಲಸವನ್ನು ಚಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗೆ ತಿರುಗುವ ಸಮಯವನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.


The second alternates between all jobs and thus optimizes response time.

ಎರಡನೆಯದು ಎಲ್ಲಾ ಕೆಲಸಗಳ ನಡುವೆ ಪರ್ಯಾಯವಾಗಿ ಚಲಿಸುತ್ತದೆ ಮತ್ತು ಹೀಗೆ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವನ್ನು ಉತ್ತಮಗೊಳಿಸುತ್ತದೆ.


We have also seen how we might incorporate I/O into the picture.

ನಾವು I/O ಅನ್ನು ಚಿತ್ರಕ್ಕೆ ಹೇಗೆ ಸೇರಿಸಬಹುದು ಎಂಬುದನ್ನು ಸಹ ನೋಡಿದ್ದೇವೆ.


The scheduler knows the length of each job.

ಶೆಡ್ಯೂಲರ್ ಪ್ರತಿ ಕೆಲಸದ ಉದ್ದವನ್ನು ತಿಳಿದಿದೆ.


The OS usually knows very little about the length of each job.

OS ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತಿ ಕೆಲಸದ ಉದ್ದದ ಬಗ್ಗೆ ಬಹಳ ಕಡಿಮೆ ತಿಳಿದಿರುತ್ತದೆ.


How can we build an approach that behaves like SJF/STCF without such a priori knowledge?

ಅಂತಹ ಪೂರ್ವ ಜ್ಞಾನವಿಲ್ಲದೆ SJF/STCF ನಂತೆ ವರ್ತಿಸುವ ವಿಧಾನವನ್ನು ನಾವು ಹೇಗೆ ನಿರ್ಮಿಸಬಹುದು?


How can we incorporate some of the ideas we have seen with the RR scheduler so that response time is also quite good?

ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯವು ಸಹ ಉತ್ತಮವಾಗಿರುವಂತೆ RR ಶೆಡ್ಯೂಲರ್‌ನೊಂದಿಗೆ ನಾವು ನೋಡಿದ ಕೆಲವು ವಿಚಾರಗಳನ್ನು ನಾವು ಹೇಗೆ ಸೇರಿಸಬಹುದು?


We will see how to overcome this problem, by building a scheduler that uses the recent past to predict the future.

ಭವಿಷ್ಯವನ್ನು ಊಹಿಸಲು ಇತ್ತೀಚಿನ ಭೂತಕಾಲವನ್ನು ಬಳಸುವ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಮೂಲಕ ಈ ಸಮಸ್ಯೆಯನ್ನು ಹೇಗೆ ನಿವಾರಿಸಬೇಕೆಂದು ನಾವು ನೋಡುತ್ತೇವೆ.


This scheduler is known as the multi-level feedback queue.

ಈ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಬಹು-ಹಂತದ ಪ್ರತಿಕ್ರಿಯೆ ಸರತಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Compute the response time and turnaround time when running three jobs of length 200 with the SJF and FIFO schedulers.

SJF ಮತ್ತು FIFO ಶೆಡ್ಯೂಲರ್‌ಗಳೊಂದಿಗೆ 200 ಉದ್ದದ ಮೂರು ಕೆಲಸಗಳನ್ನು ಚಲಾಯಿಸುವಾಗ ಪ್ರತಿಕ್ರಿಯೆ ಸಮಯ ಮತ್ತು ತಿರುಗುವ ಸಮಯವನ್ನು ಲೆಕ್ಕಹಾಕಿ.


The fundamental problem MLFQ tries to address is two-fold.

MLFQ ಪರಿಹರಿಸಲು ಪ್ರಯತ್ನಿಸುವ ಮೂಲಭೂತ ಸಮಸ್ಯೆಯು ದ್ವಿಮುಖವಾಗಿದೆ.


First, it would like to optimize turnaround time.

ಮೊದಲನೆಯದಾಗಿ, ಇದು ತಿರುಗುವ ಸಮಯವನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಬಯಸುತ್ತದೆ.


Second, MLFQ would like to make a system feel responsive to interactive users.

ಎರಡನೆಯದಾಗಿ, MLFQ ಸಂವಾದಾತ್ಮಕ ಬಳಕೆದಾರರಿಗೆ ಸಿಸ್ಟಮ್ ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕವಾಗಿರಲು ಬಯಸುತ್ತದೆ.


How can the scheduler learn, as the system runs, the characteristics of the jobs it is running, and thus make better scheduling decisions?

ಸಿಸ್ಟಮ್ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ, ಶೆಡ್ಯೂಲರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಕೆಲಸದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೇಗೆ ಕಲಿಯಬಹುದು ಮತ್ತು ಉತ್ತಮ ಶೆಡ್ಯೂಲಿಂಗ್ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು?


The multi-level feedback queue is an excellent example of a system that learns from the past to predict the future.

ಬಹು-ಹಂತದ ಪ್ರತಿಕ್ರಿಯೆ ಸರತಿಯು ಭವಿಷ್ಯವನ್ನು ಊಹಿಸಲು ಭೂತಕಾಲದಿಂದ ಕಲಿಯುವ ಸಿಸ್ಟಮ್‌ನ ಅತ್ಯುತ್ತಮ ಉದಾಹರಣೆಯಾಗಿದೆ.


MLFQ uses priorities to decide which job should run at a given time.

ನಿರ್ದಿಷ್ಟ ಸಮಯದಲ್ಲಿ ಯಾವ ಕೆಲಸವನ್ನು ಚಲಾಯಿಸಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲು MLFQ ಆದ್ಯತೆಗಳನ್ನು ಬಳಸುತ್ತದೆ.


ಈ ಲೇಖನವು ಲಾಟರಿ ವೇಳಾಪಟ್ಟಿಯನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.


Lottery scheduling is a simple randomized algorithm.

ಲಾಟರಿ ವೇಳಾಪಟ್ಟಿ ಒಂದು ಸರಳ ಯಾದೃಚ್ಛಿಕ ಕ್ರಮಾವಳಿಯಾಗಿದೆ.


This thesis outlines lottery and stride scheduling.

ಈ ಪ್ರಬಂಧವು ಲಾಟರಿ ಮತ್ತು ಸ್ಟ್ರೈಡ್ ವೇಳಾಪಟ್ಟಿಯನ್ನು ವಿವರಿಸುತ್ತದೆ.


The paper is about memory resource management.

ಈ ಲೇಖನವು ಮೆಮೊರಿ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಯ ಬಗ್ಗೆ ಇದೆ.


3 ಕೆಲಸಗಳೊಂದಿಗೆ ಅನುಕರಣೆಗಳನ್ನು ಪರಿಗಣಿಸಿ.


What happens when the number of tickets is imbalanced?

ಟಿಕೆಟ್‌ಗಳ ಸಂಖ್ಯೆ ಅಸಮತೋಲನಗೊಂಡಾಗ ಏನಾಗುತ್ತದೆ?


ವೇಳಾಪಟ್ಟಿ ಎಷ್ಟು ಅನ್ಯಾಯವಾಗಿದೆ?


This chapter introduces multiprocessor scheduling.

ಈ ಅಧ್ಯಾಯವು ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ವೇಳಾಪಟ್ಟಿಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.


Multiprocessor systems are increasingly commonplace.

ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ವ್ಯವಸ್ಥೆಗಳು ಹೆಚ್ಚಾಗಿ ಸಾಮಾನ್ಯವಾಗುತ್ತಿವೆ.


Multi-threaded applications can spread work across multiple CPUs.

ಬಹು-ಥ್ರೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಅನೇಕ CPU ಗಳಲ್ಲಿ ಕೆಲಸವನ್ನು ಹರಡಬಹುದು.


A primary problem is that a typical application only uses a single CPU.

ಒಂದು ಮುಖ್ಯ ಸಮಸ್ಯೆಯೆಂದರೆ ಒಂದು ವಿಶಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್ ಒಂದೇ CPU ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ.


We have to understand a fundamental difference between single-CPU and multi-CPU hardware.

ಏಕ-CPU ಮತ್ತು ಬಹು-CPU ಹಾರ್ಡ್‌ವೇರ್ ನಡುವಿನ ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸವನ್ನು ನಾವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.


ಕ್ಯಾಶ್‌ಗಳು ಚಿಕ್ಕದಾಗಿರುತ್ತವೆ, ವೇಗದ ಮೆಮೊರಿಗಳಾಗಿವೆ.


The system can make the large, slow memory appear to be a fast one.

ವ್ಯವಸ್ಥೆಯು ದೊಡ್ಡ, ನಿಧಾನ ಮೆಮೊರಿಯನ್ನು ವೇಗವಾಗಿ ಕಾಣುವಂತೆ ಮಾಡಬಹುದು.


Caches are thus based on the notion of locality.

ಕ್ಯಾಶ್‌ಗಳು ಸ್ಥಳೀಯತೆಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ಆಧರಿಸಿವೆ.


What happens when you have multiple processors in a single system?

ಒಂದೇ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ನೀವು ಅನೇಕ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಏನಾಗುತ್ತದೆ?


This general problem is called the problem of cache coherence.

ಈ ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಯನ್ನು ಕ್ಯಾಶ್ ಕೋಹೆರೆನ್ಸ್ ಸಮಸ್ಯೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


When accessing shared data items, mutual exclusion primitives should be used.

ಹಂಚಿದ ಡೇಟಾ ಐಟಂಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ, ಪರಸ್ಪರ ಹೊರಗಿಡುವ ಆದಿಮಗಳನ್ನು ಬಳಸಬೇಕು.


A multiprocessor scheduler should consider cache affinity.

ಮಲ್ಟಿಪ್ರೊಸೆಸರ್ ವೇಳಾಪಟ್ಟಿಯು ಕ್ಯಾಶ್ ಅಫಿನಿಟಿಯನ್ನು ಪರಿಗಣಿಸಬೇಕು.


SQMS ಸ್ಪಷ್ಟ ನ್ಯೂನತೆಗಳನ್ನು ಹೊಂದಿದೆ.


The operating system rarely knows what is best for each process.

ಕಾರ್ಯನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯು ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಗೆ ಯಾವುದು ಉತ್ತಮ ಎಂದು ತಿಳಿದಿರುವುದಿಲ್ಲ.


Such hints are useful in many parts of the OS, including the scheduler.

ಅಂತಹ ಸುಳಿವುಗಳು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂನ ಅನೇಕ ಭಾಗಗಳಲ್ಲಿ ಉಪಯುಕ್ತವಾಗಿವೆ, ಇದರಲ್ಲಿ ಶೆಡ್ಯೂಲರ್ ಕೂಡ ಸೇರಿದೆ.


Rule 1: If Priority(A) > Priority(B), A runs (B doesn’t).

ನಿಯಮ 1: ಆದ್ಯತೆ(A) > ಆದ್ಯತೆ(B) ಆಗಿದ್ದರೆ, A ಚಲಿಸುತ್ತದೆ (B ಅಲ್ಲ).


MLFQ is interesting because it observes the execution of a job.

MLFQ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಕೆಲಸದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಗಮನಿಸುತ್ತದೆ.


Many systems use a form of MLFQ as their base scheduler.

ಅನೇಕ ವ್ಯವಸ್ಥೆಗಳು ತಮ್ಮ ಮೂಲ ಶೆಡ್ಯೂಲರ್ ಆಗಿ MLFQ ರೂಪವನ್ನು ಬಳಸುತ್ತವೆ.


Proportional-share is based around a simple concept.

ಅನುಪಾತ-ಹಂಚಿಕೆಯು ಸರಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ಆಧರಿಸಿದೆ.


Processes that should run more often should be given more chances.

ಹೆಚ್ಚು ಬಾರಿ ಚಲಾಯಿಸಬೇಕಾದ ಪ್ರಕ್ರಿಯೆಗಳಿಗೆ ಹೆಚ್ಚಿನ ಅವಕಾಶಗಳನ್ನು ನೀಡಬೇಕು.


The scheduler must know how many total tickets there are.

ಶೆಡ್ಯೂಲರ್ ಒಟ್ಟು ಎಷ್ಟು ಟಿಕೆಟ್‌ಗಳಿವೆ ಎಂದು ತಿಳಿದಿರಬೇಕು.


Imagine two processes, A and B, and further that A has 75 tickets while B has only 25.

ಎರಡು ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ, A ಮತ್ತು B, ಮತ್ತು A 75 ಟಿಕೆಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ B ಕೇವಲ 25 ಅನ್ನು ಹೊಂದಿದೆ.


The longer these two jobs compete, the more likely they are to achieve the desired percentages.

ಈ ಎರಡು ಕೆಲಸಗಳು ಎಷ್ಟು ಸಮಯದವರೆಗೆ ಸ್ಪರ್ಧಿಸುತ್ತವೆಯೋ ಅಷ್ಟು ಸಮಯ ಅವು ಅಪೇಕ್ಷಿತ ಶೇಕಡಾವಾರುಗಳನ್ನು ಸಾಧಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ.


One of the most beautiful aspects of lottery scheduling is its use of randomness.

ಲಾಟರಿ ವೇಳಾಪಟ್ಟಿಯ ಅತ್ಯಂತ ಸುಂದರವಾದ ಅಂಶವೆಂದರೆ ಯಾದೃಚ್ಛಿಕತೆಯ ಬಳಕೆ.


Random often avoids strange corner-case behaviors.

ಯಾದೃಚ್ಛಿಕತೆಯು ಸಾಮಾನ್ಯವಾಗಿ ವಿಚಿತ್ರವಾದ ಮೂಲೆಯ-ಪ್ರಕರಣದ ನಡವಳಿಕೆಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.


Random also is lightweight, requiring little state to track alternatives.

ಯಾದೃಚ್ಛಿಕತೆಯು ಕಡಿಮೆ ತೂಕವನ್ನು ಹೊಂದಿದೆ, ಪರ್ಯಾಯಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಕಡಿಮೆ ಸ್ಥಿತಿಯನ್ನು ಬಯಸುತ್ತದೆ.


As long as generating a random number is quick, making the decision is also.

ಯಾದೃಚ್ಛಿಕ ಸಂಖ್ಯೆಯನ್ನು ಉತ್ಪಾದಿಸುವುದು ಎಷ್ಟು ಬೇಗನೆ ಇದೆಯೋ ಅಷ್ಟೇ ಬೇಗ ನಿರ್ಧಾರ ತೆಗೆದುಕೊಳ್ಳುವುದು ಸಹ.


The ticket is used to represent a process’s share of the CPU.

ಟಿಕೆಟ್ ಅನ್ನು ಪ್ರಕ್ರಿಯೆಯ CPU ಯ ಪಾಲನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.


Currency allows a user to allocate tickets among their own jobs.

ಕರೆನ್ಸಿ ಬಳಕೆದಾರರಿಗೆ ತಮ್ಮದೇ ಆದ ಕೆಲಸಗಳಲ್ಲಿ ಟಿಕೆಟ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.


With transfers, a process can temporarily hand off its tickets to another process.

ವರ್ಗಾವಣೆಗಳೊಂದಿಗೆ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯು ತಾತ್ಕಾಲಿಕವಾಗಿ ತನ್ನ ಟಿಕೆಟ್‌ಗಳನ್ನು ಇನ್ನೊಂದು ಪ್ರಕ್ರಿಯೆಗೆ ವರ್ಗಾಯಿಸಬಹುದು.


Ticket inflation can sometimes be a useful technique.

ಟಿಕೆಟ್ ಹಣದುಬ್ಬರವು ಕೆಲವೊಮ್ಮೆ ಉಪಯುಕ್ತ ತಂತ್ರವಾಗಬಹುದು.


The code walks the list of processes, adding each ticket value to counter.

ಕೋಡ್ ಪ್ರಕ್ರಿಯೆಗಳ ಪಟ್ಟಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ, ಪ್ರತಿ ಟಿಕೆಟ್ ಮೌಲ್ಯವನ್ನು ಕೌಂಟರ್‌ಗೆ ಸೇರಿಸುತ್ತದೆ.


To make this process most efficient, it might generally be best to organize the list in sorted order.

ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಲು, ಪಟ್ಟಿಯನ್ನು ವಿಂಗಡಿಸಲಾದ ಕ್ರಮದಲ್ಲಿ ಆಯೋಜಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಉತ್ತಮವಾಗಿರುತ್ತದೆ.


ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ CPU ಅನ್ನು ವರ್ಚುವಲೈಸ್ ಮಾಡುತ್ತದೆ.


I learned a little about how the OS virtualizes the CPU.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ CPU ಅನ್ನು ಹೇಗೆ ವರ್ಚುವಲೈಸ್ ಮಾಡುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನಾನು ಸ್ವಲ್ಪ ಕಲಿತಿದ್ದೇನೆ.


The OS wants to make sure it stays in charge of the machine.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಯಂತ್ರದ ಮೇಲೆ ತನ್ನ ನಿಯಂತ್ರಣವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಬಯಸುತ್ತದೆ.


ಪ್ಯಾರನೋಯಾ ದಿನವನ್ನು ಆಳುತ್ತದೆ.


ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಒಂದು ಸಂಪನ್ಮೂಲ ವ್ಯವಸ್ಥಾಪಕವಾಗಿದೆ.


Building up a real scheduler seems difficult.

ನಿಜವಾದ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು ಕಷ್ಟಕರವೆಂದು ತೋರುತ್ತದೆ.


There is still controversy to this day over which scheduler to use.

ಯಾವ ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಬಳಸಬೇಕೆಂಬುದರ ಬಗ್ಗೆ ಇಂದಿಗೂ ವಿವಾದವಿದೆ.


ಒಳ್ಳೆಯ ಎಂಜಿನಿಯರಿಂಗ್ ಆ ರೀತಿಯಲ್ಲಿರಬಹುದು.


It’s just your perspective on it, really.

ಇದು ನಿಜವಾಗಿಯೂ ಅದರ ಬಗ್ಗೆ ನಿಮ್ಮ ದೃಷ್ಟಿಕೋನವಾಗಿದೆ.


I really liked the notion of gaming the scheduler.

ನಾನು ಶೆಡ್ಯೂಲರ್ ಅನ್ನು ಗೇಮಿಂಗ್ ಮಾಡುವ ಪರಿಕಲ್ಪನೆಯನ್ನು ನಿಜವಾಗಿಯೂ ಇಷ್ಟಪಟ್ಟೆ.


We are not nearly done with virtualization!

ನಾವು ವರ್ಚುವಲೈಸೇಶನ್‌ನೊಂದಿಗೆ ಇನ್ನೂ ಮುಗಿದಿಲ್ಲ!


ಮೆಮೊರಿಯನ್ನು ವರ್ಚುವಲೈಸ್ ಮಾಡುವುದು ಜಟಿಲವಾಗಿದೆ.


Every address generated by a user program is a virtual address.

ಬಳಕೆದಾರರ ಪ್ರೋಗ್ರಾಂನಿಂದ ರಚಿಸಲಾದ ಪ್ರತಿಯೊಂದು ವಿಳಾಸವು ವರ್ಚುವಲ್ ವಿಳಾಸವಾಗಿದೆ.


The OS is just providing an illusion to each process.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರತಿ ಪ್ರಕ್ರಿಯೆಗೆ ಒಂದು ಭ್ರಮೆಯನ್ನು ಒದಗಿಸುತ್ತಿದೆ.


The OS will turn these pretend virtual addresses into real physical addresses.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಈ ನಟನೆಯ ವರ್ಚುವಲ್ ವಿಳಾಸಗಳನ್ನು ನಿಜವಾದ ಭೌತಿಕ ವಿಳಾಸಗಳಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.


The OS will give each program the view that it has its own large contiguous address space.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರತಿ ಪ್ರೋಗ್ರಾಂಗೆ ತನ್ನದೇ ಆದ ದೊಡ್ಡ ನಿರಂತರ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಹೊಂದಿದೆ ಎಂಬ ನೋಟವನ್ನು ನೀಡುತ್ತದೆ.


We don’t want one errant program to be able to read, or worse, overwrite, some other program’s memory, do we?

ಒಂದು ದೋಷಪೂರಿತ ಪ್ರೋಗ್ರಾಂ ಇನ್ನೊಂದು ಪ್ರೋಗ್ರಾಂನ ಮೆಮೊರಿಯನ್ನು ಓದಲು ಅಥವಾ ಕೆಟ್ಟದಾಗಿ ಓವರ್‌ರೈಟ್ ಮಾಡಲು ನಾವು ಬಯಸುವುದಿಲ್ಲ, ಅಲ್ಲವೇ?


The OS should implement virtual memory in a way that is invisible to the running program.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರೋಗ್ರಾಂಗೆ ಅಗೋಚರವಾಗಿರುವ ರೀತಿಯಲ್ಲಿ ವರ್ಚುವಲ್ ಮೆಮೊರಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು.


The OS should strive to make the virtualization as efficient as possible.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ವರ್ಚುವಲೈಸೇಶನ್ ಅನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಲು ಶ್ರಮಿಸಬೇಕು.


The OS should make sure to protect processes from one another as well as the OS itself from processes.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಪರಸ್ಪರ ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ರಕ್ಷಿಸಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು.


In UNIX/C programs, understanding how to allocate and manage memory is critical in building robust and reliable software.

UNIX/C ಪ್ರೋಗ್ರಾಮ್‌ಗಳಲ್ಲಿ, ದೃಢವಾದ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ಹಂಚಿಕೆ ಮಾಡುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


The main problem we address is this: CRUX: HOW TO ALLOCATE AND MANAGE MEMORY.

ನಾವು ಪರಿಹರಿಸಬೇಕಾದ ಮುಖ್ಯ ಸಮಸ್ಯೆ ಎಂದರೆ ಇದು: CRUX: ಮೆಮೊರಿಯನ್ನು ಹೇಗೆ ಹಂಚಿಕೆ ಮಾಡುವುದು ಮತ್ತು ನಿರ್ವಹಿಸುವುದು.


In running a C program, there are two types of memory that are allocated.

C ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಚಲಾಯಿಸುವಾಗ, ಎರಡು ವಿಧದ ಮೆಮೊರಿಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡಲಾಗುತ್ತದೆ.


The first is called stack memory, and allocations and deallocations of it are managed implicitly by the compiler.

ಮೊದಲನೆಯದನ್ನು ಸ್ಟಾಕ್ ಮೆಮೊರಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ, ಮತ್ತು ಅದರ ಹಂಚಿಕೆ ಮತ್ತು ವಿಘಟನೆಗಳನ್ನು ಕಂಪೈಲರ್‌ನಿಂದ ಸೂಚ್ಯವಾಗಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ.


Declaring memory on the stack in C is easy.

C ಯಲ್ಲಿ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಮೆಮೊರಿಯನ್ನು ಘೋಷಿಸುವುದು ಸುಲಭ.


For example, let’s say you need some space in a function func() for an integer, called x.

ಉದಾಹರಣೆಗೆ, ನೀವು x ಎಂಬ ಪೂರ್ಣಾಂಕಕ್ಕಾಗಿ func() ಎಂಬ ಫಂಕ್ಷನ್‌ನಲ್ಲಿ ಕೆಲವು ಸ್ಥಳಾವಕಾಶದ ಅಗತ್ಯವಿದೆ ಎಂದು ಹೇಳೋಣ.


The compiler does the rest, making sure to make space on the stack when you call into func().

ನೀವು func() ಗೆ ಕರೆ ಮಾಡಿದಾಗ ಸ್ಟಾಕ್‌ನಲ್ಲಿ ಸ್ಥಳಾವಕಾಶವನ್ನು ಮಾಡಲು ಕಂಪೈಲರ್ ಉಳಿದದ್ದನ್ನು ಮಾಡುತ್ತದೆ.


When your return from the function, the compiler deallocates the memory for you.

ನೀವು ಫಂಕ್ಷನ್‌ನಿಂದ ಹಿಂದಿರುಗಿದಾಗ, ಕಂಪೈಲರ್ ನಿಮಗಾಗಿ ಮೆಮೊರಿಯನ್ನು ವಿಘಟಿಸುತ್ತದೆ.


It is this need for long-lived memory that gets us to the second type of memory, called heap memory.

ದೀರ್ಘಕಾಲೀನ ಮೆಮೊರಿಯ ಈ ಅಗತ್ಯತೆಯು ನಮ್ಮನ್ನು ಎರಡನೇ ವಿಧದ ಮೆಮೊರಿಗೆ ಕರೆದೊಯ್ಯುತ್ತದೆ, ಇದನ್ನು ಹೀಪ್ ಮೆಮೊರಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Here is an example of how one might allocate a pointer to an integer on the heap:

ಹೀಪ್‌ನಲ್ಲಿ ಪೂರ್ಣಾಂಕಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ಹೇಗೆ ಹಂಚಿಕೆ ಮಾಡಬಹುದು ಎಂಬುದಕ್ಕೆ ಇಲ್ಲೊಂದು ಉದಾಹರಣೆ:


First, you might notice that both stack and heap allocation occur on this line.

ಮೊದಲಿಗೆ, ಈ ಸಾಲಿನಲ್ಲಿ ಸ್ಟಾಕ್ ಮತ್ತು ಹೀಪ್ ಎರಡೂ ಹಂಚಿಕೆಗಳು ಸಂಭವಿಸುವುದನ್ನು ನೀವು ಗಮನಿಸಬಹುದು.


Because of its explicit nature, and because of its more varied usage, heap memory presents more challenges.

ಅದರ ಸ್ಪಷ್ಟ ಸ್ವರೂಪದಿಂದಾಗಿ ಮತ್ತು ಅದರ ಹೆಚ್ಚು ವೈವಿಧ್ಯಮಯ ಬಳಕೆಯಿಂದಾಗಿ, ಹೀಪ್ ಮೆಮೊರಿ ಹೆಚ್ಚು ಸವಾಲುಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.


The malloc() call is quite simple: you pass it a size asking for some room on the heap.

malloc() ಕರೆ ತುಂಬಾ ಸರಳವಾಗಿದೆ: ನೀವು ಅದಕ್ಕೆ ಗಾತ್ರವನ್ನು ರವಾನಿಸುತ್ತೀರಿ, ಹೀಪ್‌ನಲ್ಲಿ ಕೆಲವು ಸ್ಥಳಾವಕಾಶವನ್ನು ಕೇಳುತ್ತೀರಿ.


The manual page shows what you need to do to use malloc.

malloc ಅನ್ನು ಬಳಸಲು ನೀವು ಏನು ಮಾಡಬೇಕು ಎಂಬುದನ್ನು ಕೈಪಿಡಿ ಪುಟ ತೋರಿಸುತ್ತದೆ.


From this information, you can see that all you need to do is include the header file stdlib.h to use malloc.

ಈ ಮಾಹಿತಿಯಿಂದ, malloc ಅನ್ನು ಬಳಸಲು ನೀವು ಮಾಡಬೇಕಾಗಿರುವುದು ಹೆಡರ್ ಫೈಲ್ stdlib.h ಅನ್ನು ಸೇರಿಸುವುದು ಎಂದು ನೀವು ನೋಡಬಹುದು.


The single parameter malloc() takes is of type size_t which simply describes how many bytes you need.

malloc() ತೆಗೆದುಕೊಳ್ಳುವ ಏಕೈಕ ಪ್ಯಾರಾಮೀಟರ್ size_t ಪ್ರಕಾರದ್ದಾಗಿದೆ, ಇದು ನಿಮಗೆ ಎಷ್ಟು ಬೈಟ್‌ಗಳು ಬೇಕು ಎಂಬುದನ್ನು ಸರಳವಾಗಿ ವಿವರಿಸುತ್ತದೆ.


For example, to allocate space for a double-precision floating point value, you simply do this:

ಉದಾಹರಣೆಗೆ, ಡಬಲ್-ಪ್ರೆಸಿಷನ್ ಫ್ಲೋಟಿಂಗ್ ಪಾಯಿಂಟ್ ಮೌಲ್ಯಕ್ಕಾಗಿ ಸ್ಥಳಾವಕಾಶವನ್ನು ಹಂಚಿಕೆ ಮಾಡಲು, ನೀವು ಇದನ್ನು ಸರಳವಾಗಿ ಮಾಡಿ:


If you aren’t sure how some routine or operator you are using behaves, there is no substitute for simply trying it out.

ನೀವು ಬಳಸುತ್ತಿರುವ ಕೆಲವು ರೂಟಿನ್ ಅಥವಾ ಆಪರೇಟರ್ ಹೇಗೆ ವರ್ತಿಸುತ್ತದೆ ಎಂದು ನಿಮಗೆ ಖಚಿತವಿಲ್ಲದಿದ್ದರೆ, ಅದನ್ನು ಸರಳವಾಗಿ ಪ್ರಯತ್ನಿಸುವುದಕ್ಕೆ ಯಾವುದೇ ಬದಲಿ ಇಲ್ಲ.


In the first line, we’ve declared space for an array of 10 integers, which is fine and dandy.

ಮೊದಲ ಸಾಲಿನಲ್ಲಿ, ನಾವು 10 ಪೂರ್ಣಾಂಕಗಳ ಶ್ರೇಣಿಗಾಗಿ ಸ್ಥಳಾವಕಾಶವನ್ನು ಘೋಷಿಸಿದ್ದೇವೆ, ಇದು ಉತ್ತಮವಾಗಿದೆ.


With address translation, the hardware transforms each memory access, changing the virtual address provided by the instruction to a physical address.

ವಿಳಾಸ ಅನುವಾದದೊಂದಿಗೆ, ಹಾರ್ಡ್‌ವೇರ್ ಪ್ರತಿ ಮೆಮೊರಿ ಪ್ರವೇಶವನ್ನು ಪರಿವರ್ತಿಸುತ್ತದೆ, ಸೂಚನೆಯಿಂದ ಒದಗಿಸಲಾದ ವರ್ಚುವಲ್ ವಿಳಾಸವನ್ನು ಭೌತಿಕ ವಿಳಾಸಕ್ಕೆ ಬದಲಾಯಿಸುತ್ತದೆ.


The OS must manage memory, keeping track of which locations are free and which are in use.

OS ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸಬೇಕು, ಯಾವ ಸ್ಥಳಗಳು ಉಚಿತವಾಗಿವೆ ಮತ್ತು ಯಾವುವು ಬಳಕೆಯಲ್ಲಿವೆ ಎಂಬುದನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಬೇಕು.


Through virtualization, the OS turns the ugly machine reality into something that is a useful, powerful, and easy to use abstraction.

ವರ್ಚುವಲೈಸೇಶನ್ ಮೂಲಕ, OS ಕೆಟ್ಟ ಯಂತ್ರದ ವಾಸ್ತವತೆಯನ್ನು ಉಪಯುಕ್ತ, ಶಕ್ತಿಯುತ ಮತ್ತು ಬಳಸಲು ಸುಲಭವಾದ ಅಮೂರ್ತತೆಯನ್ನಾಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ.


We will assume for now that the user’s address space must be placed contiguously in physical memory.

ಈಗ ನಾವು ಬಳಕೆದಾರರ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಭೌತಿಕ ಮೆಮೊರಿಯಲ್ಲಿ ಸತತವಾಗಿ ಇರಿಸಬೇಕು ಎಂದು ಭಾವಿಸುತ್ತೇವೆ.


To understand better what we need to do to implement address translation, let’s look at a simple example.

ವಿಳಾಸ ಅನುವಾದವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಾವು ಏನು ಮಾಡಬೇಕೆಂದು ಚೆನ್ನಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಸರಳ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.


The compiler turns this line of code into assembly.

ಕಂಪೈಲರ್ ಈ ಕೋಡ್‌ನ ಸಾಲನ್ನು ಅಸೆಂಬ್ಲಿಗೆ ತಿರುಗಿಸುತ್ತದೆ.


This code snippet is relatively straightforward.

ಈ ಕೋಡ್ ತುಣುಕು ತುಲನಾತ್ಮಕವಾಗಿ ನೇರವಾಗಿದೆ.


From the program’s perspective, its address space starts at address 0.

ಪ್ರೋಗ್ರಾಂನ ದೃಷ್ಟಿಕೋನದಿಂದ, ಅದರ ವಿಳಾಸ ಸ್ಥಳವು ವಿಳಾಸ 0 ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.


How can we relocate this process in memory in a way that is transparent to the process?

ಪ್ರಕ್ರಿಯೆಗೆ ಪಾರದರ್ಶಕ ರೀತಿಯಲ್ಲಿ ನಾವು ಈ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಹೇಗೆ ಮರುಸ್ಥಾಪಿಸಬಹುದು?


In the figure, you can see the OS using the first slot of physical memory for itself.

ಚಿತ್ರದಲ್ಲಿ, OS ತನ್ನ ಮೊದಲ ಭೌತಿಕ ಮೆಮೊರಿಯನ್ನು ಬಳಸುವುದನ್ನು ನೀವು ನೋಡಬಹುದು.


Each memory reference generated by the process is a virtual address.

ಪ್ರಕ್ರಿಯೆಯಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಪ್ರತಿಯೊಂದು ಮೆಮೊರಿ ಉಲ್ಲೇಖವು ವರ್ಚುವಲ್ ವಿಳಾಸವಾಗಿದೆ.


Transforming a virtual address into a physical address is exactly the technique we refer to as address translation.

ವರ್ಚುವಲ್ ವಿಳಾಸವನ್ನು ಭೌತಿಕ ವಿಳಾಸವಾಗಿ ಪರಿವರ್ತಿಸುವುದು ನಾವು ವಿಳಾಸ ಅನುವಾದ ಎಂದು ಉಲ್ಲೇಖಿಸುವ ತಂತ್ರವಾಗಿದೆ.


With dynamic relocation, we can see how a little hardware goes a long way.

ಡೈನಾಮಿಕ್ ಮರುಸ್ಥಾಪನೆಯೊಂದಿಗೆ, ಸ್ವಲ್ಪ ಹಾರ್ಡ್‌ವೇರ್ ಹೇಗೆ ಬಹಳ ದೂರ ಹೋಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ನೋಡಬಹುದು.


The point of the bounds is thus to make sure that all addresses generated by the process are legal.

ಪ್ರಕ್ರಿಯೆಯಿಂದ ಉತ್ಪತ್ತಿಯಾಗುವ ಎಲ್ಲಾ ವಿಳಾಸಗಳು ಕಾನೂನುಬದ್ಧವಾಗಿವೆ ಎಂದು ಖಚಿತಪಡಿಸುವುದು ಗಡಿಗಳ ಉದ್ದೇಶವಾಗಿದೆ.


The OS must take action when a process is created, finding space for its address space in memory.

ಪ್ರಕ್ರಿಯೆಯನ್ನು ರಚಿಸಿದಾಗ OS ಕ್ರಮ ತೆಗೆದುಕೊಳ್ಳಬೇಕು, ಮೆಮೊರಿಯಲ್ಲಿ ಅದರ ವಿಳಾಸ ಸ್ಥಳಕ್ಕಾಗಿ ಸ್ಥಳವನ್ನು ಹುಡುಕಬೇಕು.


The OS must also take action when a context switch occurs.

ಸಂದರ್ಭ ಸ್ವಿಚ್ ಸಂಭವಿಸಿದಾಗ OS ಸಹ ಕ್ರಮ ತೆಗೆದುಕೊಳ್ಳಬೇಕು.


When the OS resumes a running process, it must set the values of the base and bounds on the CPU.

OS ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪುನರಾರಂಭಿಸಿದಾಗ, ಅದು CPU ನಲ್ಲಿ ಬೇಸ್ ಮತ್ತು ಬೌಂಡ್ಸ್‌ನ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಬೇಕು.


We have extended the concept of limited direct execution with a specific mechanism used in virtual memory, known as address translation.

ವಿಳಾಸ ಅನುವಾದ ಎಂದು ಕರೆಯಲ್ಪಡುವ ವರ್ಚುವಲ್ ಮೆಮೊರಿಯಲ್ಲಿ ಬಳಸಲಾಗುವ ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವಿಧಾನದೊಂದಿಗೆ ನಾವು ಸೀಮಿತ ನೇರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ವಿಸ್ತರಿಸಿದ್ದೇವೆ.


Key to the efficiency of this technique is hardware support.

ಈ ತಂತ್ರದ ದಕ್ಷತೆಗೆ ಪ್ರಮುಖವಾದದ್ದು ಹಾರ್ಡ್‌ವೇರ್ ಬೆಂಬಲವಾಗಿದೆ.


ಬೇಸ್-ಮತ್ತು-ಬೌಂಡ್ಸ್ ರಕ್ಷಣೆಯನ್ನು ಸಹ ನೀಡುತ್ತದೆ.


In our current approach, internal fragmentation can arise.

ನಮ್ಮ ಪ್ರಸ್ತುತ ವಿಧಾನದಲ್ಲಿ, ಆಂತರಿಕ ತುಣುಕುಗಳು ಉದ್ಭವಿಸಬಹುದು.


The figure shows an example of this problem.

ಚಿತ್ರವು ಈ ಸಮಸ್ಯೆಗೆ ಒಂದು ಉದಾಹರಣೆಯನ್ನು ತೋರಿಸುತ್ತದೆ.


In this case, the total free space available is 20 bytes.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಲಭ್ಯವಿರುವ ಒಟ್ಟು ಉಚಿತ ಸ್ಥಳವು 20 ಬೈಟ್‌ಗಳು.


A request for 15 bytes will fail even though there are 20 bytes free.

15 ಬೈಟ್‌ಗಳ ವಿನಂತಿಯು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ, ಆದರೂ 20 ಬೈಟ್‌ಗಳು ಉಚಿತವಾಗಿವೆ.


How should free space be managed, when satisfying variable-sized requests?

ಬದಲಾಗುವ ಗಾತ್ರದ ವಿನಂತಿಗಳನ್ನು ಪೂರೈಸುವಾಗ ಉಚಿತ ಸ್ಥಳವನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು?


What strategies can be used to minimize fragmentation?

ವಿಘಟನೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಯಾವ ತಂತ್ರಗಳನ್ನು ಬಳಸಬಹುದು?


We assume a basic interface such as that provided by malloc() and free().

ನಾವು malloc() ಮತ್ತು free() ಒದಗಿಸಿದಂತಹ ಮೂಲ ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಊಹಿಸುತ್ತೇವೆ.


The user, when freeing the space, does not inform the library of its size.

ಬಳಕೆದಾರರು ಜಾಗವನ್ನು ಮುಕ್ತಗೊಳಿಸುವಾಗ, ಅದರ ಗಾತ್ರದ ಬಗ್ಗೆ ಲೈಬ್ರರಿಗೆ ತಿಳಿಸುವುದಿಲ್ಲ.


The space that this library manages is known historically as the heap.

ಈ ಲೈಬ್ರರಿ ನಿರ್ವಹಿಸುವ ಸ್ಥಳವನ್ನು ಐತಿಹಾಸಿಕವಾಗಿ ರಾಶಿ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


We are concerned with external fragmentation, as described above.

ಮೇಲೆ ವಿವರಿಸಿದಂತೆ ನಾವು ಬಾಹ್ಯ ವಿಘಟನೆಯ ಬಗ್ಗೆ ಕಾಳಜಿ ವಹಿಸುತ್ತೇವೆ.


Allocators could of course also have the problem of internal fragmentation.

ಹಂಚಿಕೆದಾರರು ಆಂತರಿಕ ವಿಘಟನೆಯ ಸಮಸ್ಯೆಯನ್ನು ಸಹ ಹೊಂದಿರಬಹುದು.


We’ll mostly focus on external fragmentation.

ನಾವು ಹೆಚ್ಚಾಗಿ ಬಾಹ್ಯ ವಿಘಟನೆಯ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತೇವೆ.


We’ll also assume that once memory is handed out to a client, it cannot be relocated.

ಒಮ್ಮೆ ಮೆಮೊರಿಯನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ನೀಡಿದರೆ, ಅದನ್ನು ಬೇರೆಡೆಗೆ ಸ್ಥಳಾಂತರಿಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.


Compaction could, however, be used in the OS to deal with fragmentation.

ಆದಾಗ್ಯೂ, ವಿಘಟನೆಯನ್ನು ನಿಭಾಯಿಸಲು OS ನಲ್ಲಿ ಕಾಂಪ್ಯಾಕ್ಷನ್ ಅನ್ನು ಬಳಸಬಹುದು.


We’ll assume that the allocator manages a contiguous region of bytes.

ಹಂಚಿಕೆದಾರರು ಬೈಟ್‌ಗಳ ನಿರಂತರ ಪ್ರದೇಶವನ್ನು ನಿರ್ವಹಿಸುತ್ತಾರೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.


First, we’ll discuss the basics of splitting and coalescing.

ಮೊದಲಿಗೆ, ನಾವು ವಿಭಜನೆ ಮತ್ತು ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.


A request for anything greater than 10 bytes will fail.

10 ಬೈಟ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚಿನ ಯಾವುದಕ್ಕೂ ವಿನಂತಿಯು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.


The allocator will perform an action known as splitting.

ಹಂಚಿಕೆದಾರರು ವಿಭಜನೆ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತಾರೆ.


A corollary mechanism found in many allocators is known as coalescing of free space.

ಅನೇಕ ಹಂಚಿಕೆದಾರರಲ್ಲಿ ಕಂಡುಬರುವ ಒಂದು ಪರಿಣಾಮವೆಂದರೆ ಉಚಿತ ಸ್ಥಳದ ಒಟ್ಟುಗೂಡಿಸುವಿಕೆ.


The idea is simple: when returning a free chunk in memory, look carefully.

ಕಲ್ಪನೆ ಸರಳವಾಗಿದೆ: ಮೆಮೊರಿಯಲ್ಲಿ ಉಚಿತ ತುಣುಕನ್ನು ಹಿಂದಿರುಗಿಸುವಾಗ, ಎಚ್ಚರಿಕೆಯಿಂದ ನೋಡಿ.


With coalescing, an allocator can better ensure that large free extents are available.

ಒಟ್ಟುಗೂಡಿಸುವಿಕೆಯೊಂದಿಗೆ, ದೊಡ್ಡ ಉಚಿತ ವಿಸ್ತರಣೆಗಳು ಲಭ್ಯವಿವೆ ಎಂದು ಹಂಚಿಕೆದಾರರು ಉತ್ತಮವಾಗಿ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.


The idea is simple: instead of having just one base and bounds pair in our MMU, why not have a base and bounds pair per logical segment of the address space?

ವಿಚಾರ ಸರಳವಾಗಿದೆ: ನಮ್ಮ MMU ನಲ್ಲಿ ಒಂದೇ ಬೇಸ್ ಮತ್ತು ಬೌಂಡ್ಸ್ ಜೋಡಿಯನ್ನು ಹೊಂದಿರುವ ಬದಲು, ವಿಳಾಸ ಜಾಗದ ಪ್ರತಿ ತಾರ್ಕಿಕ ವಿಭಾಗಕ್ಕೆ ಒಂದು ಬೇಸ್ ಮತ್ತು ಬೌಂಡ್ಸ್ ಜೋಡಿಯನ್ನು ಏಕೆ ಹೊಂದಬಾರದು?


A segment is just a contiguous portion of the address space of a particular length.

ಒಂದು ವಿಭಾಗವು ನಿರ್ದಿಷ್ಟ ಉದ್ದದ ವಿಳಾಸ ಜಾಗದ ಪಕ್ಕದ ಭಾಗವಾಗಿದೆ.


What segmentation allows the OS to do is to place each one of those segments in different parts of physical memory.

ವಿಭಾಗೀಕರಣವು OS ಗೆ ಏನು ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ ಎಂದರೆ ಆ ವಿಭಾಗಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದನ್ನು ಭೌತಿಕ ಮೆಮೊರಿಯ ವಿವಿಧ ಭಾಗಗಳಲ್ಲಿ ಇರಿಸುವುದು.


Assume we want to place the address space from Figure 16.1 into physical memory.

ನಾವು ಚಿತ್ರ 16.1 ರಿಂದ ವಿಳಾಸ ಜಾಗವನ್ನು ಭೌತಿಕ ಮೆಮೊರಿಗೆ ಇರಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸೋಣ.


With a base and bounds pair per segment, we can place each segment independently in physical memory.

ಪ್ರತಿ ವಿಭಾಗಕ್ಕೆ ಒಂದು ಬೇಸ್ ಮತ್ತು ಬೌಂಡ್ಸ್ ಜೋಡಿಯೊಂದಿಗೆ, ನಾವು ಪ್ರತಿ ವಿಭಾಗವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಭೌತಿಕ ಮೆಮೊರಿಯಲ್ಲಿ ಇರಿಸಬಹುದು.


As you can see in the diagram, only used memory is allocated space in physical memory.

ನೀವು ರೇಖಾಚಿತ್ರದಲ್ಲಿ ನೋಡುವಂತೆ, ಬಳಸಿದ ಮೆಮೊರಿಯನ್ನು ಮಾತ್ರ ಭೌತಿಕ ಮೆಮೊರಿಯಲ್ಲಿ ಜಾಗವನ್ನು ಹಂಚಲಾಗುತ್ತದೆ.


The hardware structure in our MMU required to support segmentation is just what you’d expect.

ವಿಭಾಗೀಕರಣವನ್ನು ಬೆಂಬಲಿಸಲು ಅಗತ್ಯವಿರುವ ನಮ್ಮ MMU ನಲ್ಲಿನ ಹಾರ್ಡ್‌ವೇರ್ ರಚನೆಯು ನೀವು ನಿರೀಕ್ಷಿಸುವಂತೆಯೇ ಇದೆ.


You can see from the table that the code segment is placed at physical address 32KB and has a size of 2KB.

ಕೋಡ್ ವಿಭಾಗವನ್ನು ಭೌತಿಕ ವಿಳಾಸ 32KB ನಲ್ಲಿ ಇರಿಸಲಾಗಿದೆ ಮತ್ತು 2KB ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ ಎಂದು ನೀವು ಕೋಷ್ಟಕದಿಂದ ನೋಡಬಹುದು.


Let’s do an example translation, using the address space in Figure 16.1.

ಚಿತ್ರ 16.1 ರಲ್ಲಿನ ವಿಳಾಸ ಜಾಗವನ್ನು ಬಳಸಿಕೊಂಡು, ಒಂದು ಉದಾಹರಣೆ ಅನುವಾದವನ್ನು ಮಾಡೋಣ.


Assume a reference is made to virtual address 100 (which is in the code segment).

ವರ್ಚುವಲ್ ವಿಳಾಸ 100 (ಇದು ಕೋಡ್ ವಿಭಾಗದಲ್ಲಿದೆ) ಗೆ ಉಲ್ಲೇಖಿಸಲಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ.


When the reference takes place (say, on an instruction fetch), the hardware will add the base value to the offset into this segment.

ಉಲ್ಲೇಖವು ನಡೆದಾಗ (ಉದಾಹರಣೆಗೆ, ಸೂಚನಾ ಫೆಚ್‌ನಲ್ಲಿ), ಹಾರ್ಡ್‌ವೇರ್ ಬೇಸ್ ಮೌಲ್ಯವನ್ನು ಈ ವಿಭಾಗಕ್ಕೆ ಆಫ್‌ಸೆಟ್‌ಗೆ ಸೇರಿಸುತ್ತದೆ.


The term segmentation fault or violation arises from a memory access on a segmented machine to an illegal address.

ವಿಭಾಗೀಕರಣ ದೋಷ ಅಥವಾ ಉಲ್ಲಂಘನೆ ಎಂಬ ಪದವು ವಿಭಾಗಿತ ಯಂತ್ರದಲ್ಲಿ ಅಕ್ರಮ ವಿಳಾಸಕ್ಕೆ ಮೆಮೊರಿ ಪ್ರವೇಶದಿಂದ ಉದ್ಭವಿಸುತ್ತದೆ.


What we need to first do is extract the offset into the heap, i.e., which byte(s) in this segment the address refers to.

ನಾವು ಮೊದಲು ಮಾಡಬೇಕಾಗಿರುವುದು ಹೀಪ್‌ಗೆ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಹೊರತೆಗೆಯುವುದು, ಅಂದರೆ, ಈ ವಿಭಾಗದಲ್ಲಿ ಯಾವ ಬೈಟ್(ಗಳು) ವಿಳಾಸವನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತದೆ.


Because the heap starts at virtual address 4KB (4096), the offset of 4200 is actually 4200 – 4096 or 104.

ಹೀಪ್ ವರ್ಚುವಲ್ ವಿಳಾಸ 4KB (4096) ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುವುದರಿಂದ, 4200 ರ ಆಫ್‌ಸೆಟ್ ವಾಸ್ತವವಾಗಿ 4200 – 4096 ಅಥವಾ 104 ಆಗಿದೆ.


What if we tried to refer to an illegal address, such as 7KB which is beyond the end of the heap?

ನಾವು 7KB ನಂತಹ ಅಕ್ರಮ ವಿಳಾಸವನ್ನು ಉಲ್ಲೇಖಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ ಏನಾಗುತ್ತದೆ, ಇದು ಹೀಪ್‌ನ ಕೊನೆಯ ಭಾಗವನ್ನು ಮೀರಿದೆ?


The hardware uses segment registers during translation.

ಅನುವಾದದ ಸಮಯದಲ್ಲಿ ಹಾರ್ಡ್‌ವೇರ್ ವಿಭಾಗದ ರೆಜಿಸ್ಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


One common approach, sometimes referred to as an explicit approach, is to chop up the address space into segments based on the top few bits of the virtual address.

ಒಂದು ಸಾಮಾನ್ಯ ವಿಧಾನವೆಂದರೆ, ಕೆಲವೊಮ್ಮೆ ಸ್ಪಷ್ಟವಾದ ವಿಧಾನ ಎಂದು ಉಲ್ಲೇಖಿಸಲಾಗುತ್ತದೆ, ವರ್ಚುವಲ್ ವಿಳಾಸದ ಕೆಲವು ಉನ್ನತ ಬಿಟ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ವಿಳಾಸ ಜಾಗವನ್ನು ವಿಭಾಗಗಳಾಗಿ ಕತ್ತರಿಸುವುದು.


In our example, then, if the top two bits are 00, the hardware knows the virtual address is in the code segment.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಉನ್ನತ ಎರಡು ಬಿಟ್‌ಗಳು 00 ಆಗಿದ್ದರೆ, ಹಾರ್ಡ್‌ವೇರ್ ವರ್ಚುವಲ್ ವಿಳಾಸವು ಕೋಡ್ ವಿಭಾಗದಲ್ಲಿದೆ ಎಂದು ತಿಳಿದಿದೆ.


The stack has been relocated to physical address 28KB in the diagram above, but with one critical difference: it grows backwards.

ಮೇಲಿನ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ಸ್ಟಾಕ್ ಅನ್ನು ಭೌತಿಕ ವಿಳಾಸ 28KB ಗೆ ಸ್ಥಳಾಂತರಿಸಲಾಗಿದೆ, ಆದರೆ ಒಂದು ನಿರ್ಣಾಯಕ ವ್ಯತ್ಯಾಸವಿದೆ: ಇದು ಹಿಮ್ಮುಖವಾಗಿ ಬೆಳೆಯುತ್ತದೆ.


To support sharing, we need a little extra support from the hardware, in the form of protection bits.

ಹಂಚಿಕೆಯನ್ನು ಬೆಂಬಲಿಸಲು, ನಮಗೆ ಹಾರ್ಡ್‌ವೇರ್‌ನಿಂದ ಸ್ವಲ್ಪ ಹೆಚ್ಚುವರಿ ಬೆಂಬಲ ಬೇಕು, ರಕ್ಷಣಾ ಬಿಟ್‌ಗಳ ರೂಪದಲ್ಲಿ.


Engineers like Jeff Bonwick are the heart of Silicon Valley.

ಜೆಫ್ ಬೊನ್ವಿಕ್ ಅವರಂತಹ ಎಂಜಿನಿಯರ್‌ಗಳು ಸಿಲಿಕಾನ್ ವ್ಯಾಲಿಯ ಹೃದಯವಾಗಿದ್ದಾರೆ.


Behind almost any great product or technology is a human who is way above average.

ಯಾವುದೇ ಉತ್ತಮ ಉತ್ಪನ್ನ ಅಥವಾ ತಂತ್ರಜ್ಞಾನದ ಹಿಂದೆ ಸರಾಸರಿಗಿಂತ ಹೆಚ್ಚಿನ ವ್ಯಕ್ತಿ ಇರುತ್ತಾನೆ.


Work hard and you might become such a “100x” person as well.

ಕಠಿಣ ಪರಿಶ್ರಮ ವಹಿಸಿ ಮತ್ತು ನೀವೂ ಸಹ ಅಂತಹ “100x” ವ್ಯಕ್ತಿಯಾಗಬಹುದು.


The slab allocator also goes beyond most segregated list approaches.

ಸ್ಲ್ಯಾಬ್ ಅಲೋಕೇಟರ್ ಹೆಚ್ಚಿನ ಪ್ರತ್ಯೇಕ ಪಟ್ಟಿ ವಿಧಾನಗಳನ್ನು ಮೀರಿ ಹೋಗುತ್ತದೆ.


By keeping freed objects in a particular list in their initialized state, the slab allocator thus avoids frequent initialization and destruction cycles.

ಬಿಡುಗಡೆಗೊಂಡ ವಸ್ತುಗಳನ್ನು ಅವುಗಳ ಆರಂಭಿಕ ಸ್ಥಿತಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಪಟ್ಟಿಯಲ್ಲಿ ಇರಿಸುವ ಮೂಲಕ, ಸ್ಲ್ಯಾಬ್ ಅಲೋಕೇಟರ್ ಆಗಾಗ್ಗೆ ಪ್ರಾರಂಭ ಮತ್ತು ವಿನಾಶ ಚಕ್ರಗಳನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.


In such a system, free memory is first conceptually thought of as one big space.

ಅಂತಹ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಉಚಿತ ಮೆಮೊರಿಯನ್ನು ಮೊದಲು ಒಂದು ದೊಡ್ಡ ಸ್ಥಳವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.


At this point, the requested block is returned to the user.

ಈ ಹಂತದಲ್ಲಿ, ವಿನಂತಿಸಿದ ಬ್ಲಾಕ್ ಅನ್ನು ಬಳಕೆದಾರರಿಗೆ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ.


The beauty of buddy allocation is found in what happens when that block is freed.

ಬಡ್ಡಿ ಹಂಚಿಕೆಯ ಸೌಂದರ್ಯವು ಆ ಬ್ಲಾಕ್ ಅನ್ನು ಮುಕ್ತಗೊಳಿಸಿದಾಗ ಏನಾಗುತ್ತದೆ ಎಂಬುದರಲ್ಲಿ ಕಂಡುಬರುತ್ತದೆ.


When returning the 8KB block to the free list, the allocator checks whether the “buddy” 8KB is free.

8KB ಬ್ಲಾಕ್ ಅನ್ನು ಉಚಿತ ಪಟ್ಟಿಗೆ ಹಿಂದಿರುಗಿಸುವಾಗ, ಅಲೋಕೇಟರ್ “ಬಡ್ಡಿ” 8KB ಉಚಿತವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.


The reason buddy allocation works so well is that it is simple to determine the buddy of a particular block.

ಬಡ್ಡಿ ಹಂಚಿಕೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಕಾರಣವೆಂದರೆ ನಿರ್ದಿಷ್ಟ ಬ್ಲಾಕ್‌ನ ಬಡ್ಡಿಯನ್ನು ನಿರ್ಧರಿಸುವುದು ಸರಳವಾಗಿದೆ.


Given that modern systems often have multiple processors and run multi-threaded workloads.

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಅನೇಕ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ಹೊಂದಿವೆ ಮತ್ತು ಬಹು-ಥ್ರೆಡ್ ಕೆಲಸದ ಹೊರೆಗಳನ್ನು ನಡೆಸುತ್ತವೆ.


In this chapter, we’ve discussed the most rudimentary forms of memory allocators.

ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ನಾವು ಮೆಮೊರಿ ಅಲೋಕೇಟರ್‌ಗಳ ಅತ್ಯಂತ ಮೂಲಭೂತ ರೂಪಗಳನ್ನು ಚರ್ಚಿಸಿದ್ದೇವೆ.


Such allocators exist everywhere, linked into every C program you write.

ನೀವು ಬರೆಯುವ ಪ್ರತಿಯೊಂದು ಸಿ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿಯೂ ಅಂತಹ ಅಲೋಕೇಟರ್‌ಗಳು ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ.


Making a fast, space-efficient, scalable allocator that works well for a broad range of workloads remains an on-going challenge.

ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಕೆಲಸದ ಹೊರೆಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ವೇಗದ, ಸ್ಥಳ-ಸಮರ್ಥ, ಸ್ಕೇಲೆಬಲ್ ಅಲೋಕೇಟರ್ ಅನ್ನು ತಯಾರಿಸುವುದು ಒಂದು ನಡೆಯುತ್ತಿರುವ ಸವಾಲಾಗಿದೆ.


Segmentation helped us do this, but has some problems.

ವಿಭಾಗೀಕರಣವು ಇದನ್ನು ಮಾಡಲು ನಮಗೆ ಸಹಾಯ ಮಾಡಿತು, ಆದರೆ ಕೆಲವು ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ.


ಉತ್ತಮ ಪರಿಹಾರವಿದೆಯೇ?


Instead of splitting up our address space into three logical segments, we split up our address space into fixed-sized units we call a page.

ನಮ್ಮ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಮೂರು ತಾರ್ಕಿಕ ವಿಭಾಗಗಳಾಗಿ ವಿಭಜಿಸುವ ಬದಲು, ನಾವು ನಮ್ಮ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಸ್ಥಿರ ಗಾತ್ರದ ಘಟಕಗಳಾಗಿ ವಿಭಜಿಸುತ್ತೇವೆ, ನಾವು ಪುಟ ಎಂದು ಕರೆಯುತ್ತೇವೆ.


With paging, physical memory is also split into some number of pages as well.

ಪುಟ ಮಾಡುವಿಕೆಯೊಂದಿಗೆ, ಭೌತಿಕ ಸ್ಮರಣೆಯನ್ನು ಸಹ ಕೆಲವು ಸಂಖ್ಯೆಯ ಪುಟಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ.


Another advantage is the simplicity of free-space management that paging affords.

ಮತ್ತೊಂದು ಪ್ರಯೋಜನವೆಂದರೆ ಪುಟ ಮಾಡುವಿಕೆಯು ನೀಡುವ ಉಚಿತ-ಸ್ಥಳ ನಿರ್ವಹಣೆಯ ಸರಳತೆ.


The major role of the page table is to store address translations for each of the virtual pages of the address space.

ಪುಟ ಕೋಷ್ಟಕದ ಪ್ರಮುಖ ಪಾತ್ರವೆಂದರೆ ವಿಳಾಸ ಸ್ಥಳದ ಪ್ರತಿಯೊಂದು ವರ್ಚುವಲ್ ಪುಟಗಳಿಗೆ ವಿಳಾಸ ಅನುವಾದಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು.


The first instruction moves the value zero into the virtual memory address.

ಮೊದಲ ಸೂಚನೆಯು ಶೂನ್ಯ ಮೌಲ್ಯವನ್ನು ವರ್ಚುವಲ್ ಮೆಮೊರಿ ವಿಳಾಸಕ್ಕೆ ಸರಿಸುತ್ತದೆ.


The array is an array of integers, each size four bytes.

ಅರೇ ಎಂದರೆ ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಅರೇ, ಪ್ರತಿಯೊಂದೂ ನಾಲ್ಕು ಬೈಟ್‌ಗಳ ಗಾತ್ರವನ್ನು ಹೊಂದಿದೆ.


The second instruction increments the array index held in %eax.

ಎರಡನೆಯ ಸೂಚನೆಯು %eax ನಲ್ಲಿರುವ ಅರೇ ಸೂಚಿಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.


If the comparison shows that that two values are not yet equal, the fourth instruction jumps back to the top of the loop.

ಹೋಲಿಕೆಯು ಎರಡು ಮೌಲ್ಯಗಳು ಇನ್ನೂ ಸಮಾನವಾಗಿಲ್ಲ ಎಂದು ತೋರಿಸಿದರೆ, ನಾಲ್ಕನೇ ಸೂಚನೆಯು ಲೂಪ್‌ನ ಮೇಲ್ಭಾಗಕ್ಕೆ ಹಿಂತಿರುಗುತ್ತದೆ.


We assume a virtual address space of size 64KB.

ನಾವು 64KB ಗಾತ್ರದ ವರ್ಚುವಲ್ ವಿಳಾಸ ಸ್ಥಳವನ್ನು ಊಹಿಸುತ್ತೇವೆ.


The virtual pages for this decimal range is VPN=39 ... VPN=42.

ಈ ದಶಮಾಂಶ ಶ್ರೇಣಿಗಾಗಿ ವರ್ಚುವಲ್ ಪುಟಗಳು VPN=39 ... VPN=42 ಆಗಿದೆ.


When it runs, each instruction fetch will generate two memory references.

ಇದು ಚಲಿಸಿದಾಗ, ಪ್ರತಿ ಸೂಚನಾ ಫೆಚ್ ಎರಡು ಮೆಮೊರಿ ಉಲ್ಲೇಖಗಳನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.


The bottom most graph shows the instruction memory references on the y-axis in black.

ಕೆಳಗಿನ ಗ್ರಾಫ್ ಸೂಚನಾ ಮೆಮೊರಿ ಉಲ್ಲೇಖಗಳನ್ನು y-ಅಕ್ಷದ ಮೇಲೆ ಕಪ್ಪು ಬಣ್ಣದಲ್ಲಿ ತೋರಿಸುತ್ತದೆ.


Paging has many advantages over previous approaches.

ಪುಟೀಕರಣವು ಹಿಂದಿನ ವಿಧಾನಗಳಿಗಿಂತ ಅನೇಕ ಪ್ರಯೋಜನಗಳನ್ನು ಹೊಂದಿದೆ.


It does not lead to external fragmentation, as paging divides memory into fixed-sized units.

ಪುಟೀಕರಣವು ಮೆಮೊರಿಯನ್ನು ಸ್ಥಿರ ಗಾತ್ರದ ಘಟಕಗಳಾಗಿ ವಿಂಗಡಿಸುವುದರಿಂದ ಇದು ಬಾಹ್ಯ ತುಣುಕುಗಳಿಗೆ ಕಾರಣವಾಗುವುದಿಲ್ಲ.


Implementing paging support without care will lead to a slower machine.

ಯಾವುದೇ ಕಾಳಜಿಯಿಲ್ಲದೆ ಪುಟೀಕರಣ ಬೆಂಬಲವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ನಿಧಾನ ಯಂತ್ರಕ್ಕೆ ಕಾರಣವಾಗುತ್ತದೆ.


We have introduced the concept of paging as a solution to our challenge of virtualizing memory.

ವರ್ಚುವಲ್ ಮೆಮೊರಿಯ ನಮ್ಮ ಸವಾಲಿಗೆ ಪರಿಹಾರವಾಗಿ ನಾವು ಪುಟೀಕರಣದ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸಿದ್ದೇವೆ.


How can we speed up address translation?

ವಿಳಾಸ ಅನುವಾದವನ್ನು ನಾವು ಹೇಗೆ ವೇಗಗೊಳಿಸಬಹುದು?


To speed address translation, we are going to add what is called a translation-lookaside buffer, or TLB.

ವಿಳಾಸ ಅನುವಾದವನ್ನು ವೇಗಗೊಳಿಸಲು, ನಾವು ಅನುವಾದ-ಲುಕ್ಸೈಡ್ ಬಫರ್ ಅಥವಾ TLB ಎಂದು ಕರೆಯಲ್ಪಡುವದನ್ನು ಸೇರಿಸಲಿದ್ದೇವೆ.


A TLB is part of the chip’s memory-management unit (MMU).

ಟಿಎಲ್‌ಬಿ ಚಿಪ್‌ನ ಮೆಮೊರಿ-ನಿರ್ವಹಣಾ ಘಟಕದ (ಎಂಎಂಯು) ಭಾಗವಾಗಿದೆ.


Upon each virtual memory reference, the hardware first checks the TLB.

ಪ್ರತಿ ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಉಲ್ಲೇಖದ ಮೇಲೆ, ಹಾರ್ಡ್‌ವೇರ್ ಮೊದಲು ಟಿಎಲ್‌ಬಿಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.


If it does, we have a TLB hit, which means the TLB holds the translation.

ಹಾಗಿದ್ದಲ್ಲಿ, ನಾವು ಟಿಎಲ್‌ಬಿ ಹಿಟ್ ಹೊಂದಿದ್ದೇವೆ, ಅಂದರೆ ಟಿಎಲ್‌ಬಿ ಅನುವಾದವನ್ನು ಹೊಂದಿದೆ.


If the CPU does not find the translation in the TLB (a TLB miss), we have some more work to do.

ಸಿಪಿಯು ಟಿಎಲ್‌ಬಿಯಲ್ಲಿ ಅನುವಾದವನ್ನು ಕಂಡುಹಿಡಿಯದಿದ್ದರೆ (ಟಿಎಲ್‌ಬಿ ಮಿಸ್), ನಾವು ಇನ್ನೂ ಕೆಲವು ಕೆಲಸಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ.


The TLB, like all caches, is built on the premise that in the common case, translations are found in the cache.

ಟಿಎಲ್‌ಬಿ, ಎಲ್ಲಾ ಸಂಗ್ರಹಗಳಂತೆ, ಸಾಮಾನ್ಯ ಸಂದರ್ಭದಲ್ಲಿ, ಅನುವಾದಗಳನ್ನು ಸಂಗ್ರಹದಲ್ಲಿ ಕಾಣಬಹುದು ಎಂಬ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಮಿಸಲಾಗಿದೆ.


Even though this is the first time the program accesses the array, TLB performance gains benefit from spatial locality.

ಪ್ರೋಗ್ರಾಂ ಮೊದಲ ಬಾರಿಗೆ ಅರೇ ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೂ ಸಹ, ಟಿಎಲ್‌ಬಿ ಕಾರ್ಯಕ್ಷಮತೆಯ ಲಾಭಗಳು ಪ್ರಾದೇಶಿಕ ಸ್ಥಳೀಯತೆಯಿಂದ ಪ್ರಯೋಜನ ಪಡೆಯುತ್ತವೆ.


The operating system manages the computer's resources.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


Memory management is a crucial function of the OS.

ಮೆಮೊರಿ ನಿರ್ವಹಣೆ OS ನ ಒಂದು ಮುಖ್ಯ ಕಾರ್ಯವಾಗಿದೆ.


The program ran 10,000 times slower due to the page faults.

ಪುಟ ದೋಷಗಳಿಂದಾಗಿ ಪ್ರೋಗ್ರಾಂ 10,000 ಪಟ್ಟು ನಿಧಾನವಾಗಿ ಚಲಿಸಿತು.


The hardware handles the translation of virtual addresses.

ಹಾರ್ಡ್‌ವೇರ್ ವರ್ಚುವಲ್ ವಿಳಾಸಗಳ ಅನುವಾದವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


ಟಿಎಲ್‌ಬಿ ಲುಕಪ್ ಒಂದು ವೇಗದ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ.


If the TLB lookup fails, a page table walk is initiated.

ಟಿಎಲ್‌ಬಿ ಲುಕಪ್ ವಿಫಲವಾದರೆ, ಪುಟ ಕೋಷ್ಟಕ ನಡಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.


The OS must find a physical frame for the page.

OS ಪುಟಕ್ಕಾಗಿ ಭೌತಿಕ ಚೌಕಟ್ಟನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು.


The replacement algorithm decides which page to evict.

ಬದಲಿ ಅಲ್ಗಾರಿದಮ್ ಯಾವ ಪುಟವನ್ನು ಹೊರಹಾಕಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತದೆ.


The system uses a high watermark and a low watermark.

ಸಿಸ್ಟಮ್ ಒಂದು ಹೆಚ್ಚಿನ ವಾಟರ್‌ಮಾರ್ಕ್ ಮತ್ತು ಕಡಿಮೆ ವಾಟರ್‌ಮಾರ್ಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


ಹಿನ್ನೆಲೆ ಥ್ರೆಡ್‌ಗಳು ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತವೆ.


ಡಿಸ್ಕ್ ಪ್ರವೇಶದ ವೆಚ್ಚವು ತುಂಬಾ ಹೆಚ್ಚಾಗಿದೆ.


The optimal replacement policy minimizes misses.

ಆಪ್ಟಿಮಲ್ ಬದಲಿ ನೀತಿಯು ಮಿಸ್‌ಗಳನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.


FIFO ಒಂದು ಸರಳ ಬದಲಿ ನೀತಿಯಾಗಿದೆ.


Random replacement is also easy to implement.

ಯಾದೃಚ್ಛಿಕ ಬದಲಿ ಸಹ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸುಲಭವಾಗಿದೆ.


LRU uses history to make better decisions.

ಉತ್ತಮ ನಿರ್ಧಾರಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು LRU ಇತಿಹಾಸವನ್ನು ಬಳಸುತ್ತದೆ.


ಪ್ರೋಗ್ರಾಂ ನಿಧಾನವಾಗಿ ಚಲಿಸುತ್ತಿದೆ.


The system is experiencing memory pressure.

ಸಿಸ್ಟಮ್ ಮೆಮೊರಿ ಒತ್ತಡವನ್ನು ಅನುಭವಿಸುತ್ತಿದೆ.


The OS is responsible for managing virtual memory.

ವರ್ಚುವಲ್ ಮೆಮೊರಿಯನ್ನು ನಿರ್ವಹಿಸುವ ಜವಾಬ್ದಾರಿ OS ನ ಮೇಲಿದೆ.


Understanding page faults is crucial for performance tuning.

ಕಾರ್ಯಕ್ಷಮತೆ ಟ್ಯೂನಿಂಗ್‌ಗಾಗಿ ಪುಟ ದೋಷಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


The operating system's design impacts overall system performance.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ನ ವಿನ್ಯಾಸವು ಒಟ್ಟಾರೆ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.


The system can then form our desired physical address and request the memory system.

ಸಿಸ್ಟಮ್ ನಂತರ ನಮ್ಮ ಅಪೇಕ್ಷಿತ ಭೌತಿಕ ವಿಳಾಸವನ್ನು ರೂಪಿಸಬಹುದು ಮತ್ತು ಮೆಮೊರಿ ಸಿಸ್ಟಮ್ಗೆ ವಿನಂತಿಯನ್ನು ನೀಡಬಹುದು.


You should now understand how to construct a two-level page table.

ನೀವು ಈಗ ಎರಡು-ಹಂತದ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.


In some cases, a deeper tree is possible and indeed needed.

ಕೆಲವು ಸಂದರ್ಭಗಳಲ್ಲಿ, ಆಳವಾದ ಮರ ಸಾಧ್ಯ ಮತ್ತು ಅಗತ್ಯವಿದೆ.


Let's take a simple example to show why a deeper multi-level table can be useful.

ಆಳವಾದ ಬಹು-ಹಂತದ ಕೋಷ್ಟಕ ಏಕೆ ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು ಸರಳ ಉದಾಹರಣೆಯನ್ನು ತೆಗೆದುಕೊಳ್ಳೋಣ.


Remember our goal in constructing a multi-level page table: to make each piece of the page table fit within a single page.

ಬಹು-ಹಂತದ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ನಿರ್ಮಿಸುವಲ್ಲಿ ನಮ್ಮ ಗುರಿಯನ್ನು ನೆನಪಿಡಿ: ಪುಟ ಕೋಷ್ಟಕದ ಪ್ರತಿಯೊಂದು ಭಾಗವನ್ನು ಒಂದೇ ಪುಟದಲ್ಲಿ ಹೊಂದಿಸಲು.


What if the page directory gets too big?

ಪುಟ ಡೈರೆಕ್ಟರಿ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದ್ದರೆ ಏನು?


To remedy this problem, we build a further level of the tree.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಮರದ ಮತ್ತಷ್ಟು ಮಟ್ಟವನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ.


Now, when indexing the upper-level page directory, we use the very top bits of the virtual address.

ಈಗ, ಮೇಲಿನ ಹಂತದ ಪುಟ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸೂಚಿಸುವಾಗ, ನಾವು ವರ್ಚುವಲ್ ವಿಳಾಸದ ಅತ್ಯಂತ ಮೇಲಿನ ಬಿಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತೇವೆ.


The figure shows what happens in hardware upon every memory reference.

ಪ್ರತಿ ಮೆಮೊರಿ ಉಲ್ಲೇಖದ ಮೇಲೆ ಹಾರ್ಡ್ವೇರ್ನಲ್ಲಿ ಏನಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಈ ಅಂಕಿ ತೋರಿಸುತ್ತದೆ.


Only upon a TLB miss does the hardware need to perform the full multi-level lookup.

TLB ಮಿಸ್ ಆದಾಗ ಮಾತ್ರ ಹಾರ್ಡ್ವೇರ್ ಸಂಪೂರ್ಣ ಬಹು-ಹಂತದ ಹುಡುಕಾಟವನ್ನು ನಿರ್ವಹಿಸಬೇಕಾಗುತ್ತದೆ.


Here, instead of having many page tables, we keep a single page table.

ಇಲ್ಲಿ, ಅನೇಕ ಪುಟ ಕೋಷ್ಟಕಗಳನ್ನು ಹೊಂದಿರುವ ಬದಲು, ನಾವು ಒಂದೇ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಇರಿಸಿಕೊಳ್ಳುತ್ತೇವೆ.


Multi-level and inverted page tables are just two examples of the many things one could do.

ಬಹು-ಹಂತದ ಮತ್ತು ವಿಲೋಮ ಪುಟ ಕೋಷ್ಟಕಗಳು ಒಬ್ಬರು ಮಾಡಬಹುದಾದ ಹಲವು ವಿಷಯಗಳಿಗೆ ಎರಡು ಉದಾಹರಣೆಗಳಾಗಿವೆ.


We have assumed that page tables reside in kernel-owned physical memory.

ಪುಟ ಕೋಷ್ಟಕಗಳು ಕರ್ನಲ್-ಮಾಲೀಕತ್ವದ ಭೌತಿಕ ಮೆಮೊರಿಯಲ್ಲಿ ನೆಲೆಗೊಂಡಿವೆ ಎಂದು ನಾವು ಭಾವಿಸಿದ್ದೇವೆ.


It is still possible that they may be too big to fit into memory all at once.

ಅವುಗಳು ಒಮ್ಮೆಲೆ ಮೆಮೊರಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು ತುಂಬಾ ದೊಡ್ಡದಾಗಿರಬಹುದು.


We will now relax these big assumptions, and assume that we wish to support many concurrently-running large address spaces.

ನಾವು ಈಗ ಈ ದೊಡ್ಡ ಊಹೆಗಳನ್ನು ಸಡಿಲಿಸುತ್ತೇವೆ ಮತ್ತು ನಾವು ಅನೇಕ ಏಕಕಾಲದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ದೊಡ್ಡ ವಿಳಾಸ ಸ್ಥಳಗಳನ್ನು ಬೆಂಬಲಿಸಲು ಬಯಸುತ್ತೇವೆ ಎಂದು ಭಾವಿಸುತ್ತೇವೆ.


To do so, we require an additional level in the memory hierarchy.

ಇದನ್ನು ಮಾಡಲು, ನಮಗೆ ಮೆಮೊರಿ ಶ್ರೇಣಿಯಲ್ಲಿ ಹೆಚ್ಚುವರಿ ಮಟ್ಟದ ಅಗತ್ಯವಿದೆ.


In modern systems, this role is usually served by a hard disk drive.

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಈ ಪಾತ್ರವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹಾರ್ಡ್ ಡಿಸ್ಕ್ ಡ್ರೈವ್ ನಿರ್ವಹಿಸುತ್ತದೆ.


How can the OS make use of a larger, slower device to transparently provide the illusion of a large virtual address space?

ದೊಡ್ಡ, ನಿಧಾನವಾದ ಸಾಧನವನ್ನು ಬಳಸಿಕೊಂಡು ದೊಡ್ಡ ವರ್ಚುವಲ್ ವಿಳಾಸ ಸ್ಥಳದ ಭ್ರಮೆಯನ್ನು ಪಾರದರ್ಶಕವಾಗಿ ಒದಗಿಸಲು OS ಹೇಗೆ ಬಳಸಬಹುದು?


The answer is convenience and ease of use.

ಉತ್ತರವೆಂದರೆ ಅನುಕೂಲತೆ ಮತ್ತು ಬಳಕೆಯ ಸುಲಭತೆ.


We will need to reserve some space on the disk for moving pages back and forth.

ಪುಟಗಳನ್ನು ಹಿಂದಕ್ಕೆ ಮತ್ತು ಮುಂದಕ್ಕೆ ಸರಿಸಲು ನಾವು ಡಿಸ್ಕ್ನಲ್ಲಿ ಸ್ವಲ್ಪ ಸ್ಥಳವನ್ನು ಕಾಯ್ದಿರಿಸಬೇಕಾಗುತ್ತದೆ.


Will this affect your code and its timing?

ಇದು ನಿಮ್ಮ ಕೋಡ್ ಮತ್ತು ಅದರ ಸಮಯದ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆಯೇ?


What can you do to counterbalance these potential costs?

ಈ ಸಂಭಾವ್ಯ ವೆಚ್ಚಗಳನ್ನು ಸರಿದೂಗಿಸಲು ನೀವು ಏನು ಮಾಡಬಹುದು?


Assume again a 32-bit address space (2^32 bytes), with 4KB (2^12 byte) pages and a 4-byte page-table entry.

ಮತ್ತೆ 32-ಬಿಟ್ ವಿಳಾಸ ಸ್ಥಳವನ್ನು (2^32 ಬೈಟ್‌ಗಳು), 4KB (2^12 ಬೈಟ್) ಪುಟಗಳು ಮತ್ತು 4-ಬೈಟ್ ಪುಟ-ಕೋಷ್ಟಕದ ಪ್ರವೇಶವನ್ನು ಊಹಿಸಿ.


With a hundred active processes (not uncommon on a modern system), we will be allocating hundreds of megabytes of memory just for page tables!

ನೂರಾರು ಸಕ್ರಿಯ ಪ್ರಕ್ರಿಯೆಗಳೊಂದಿಗೆ (ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಅಸಾಮಾನ್ಯವಲ್ಲ), ನಾವು ಪುಟ ಕೋಷ್ಟಕಗಳಿಗಾಗಿ ನೂರಾರು ಮೆಗಾಬೈಟ್‌ಗಳ ಮೆಮೊರಿಯನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ!


ಪುಟ ಕೋಷ್ಟಕಗಳನ್ನು ನಾವು ಹೇಗೆ ಚಿಕ್ಕದಾಗಿಸಬಹುದು?


ಪ್ರಮುಖ ಆಲೋಚನೆಗಳು ಯಾವುವು?


What inefficiencies arise as a result of these new data structures?

ಈ ಹೊಸ ದತ್ತಾಂಶ ರಚನೆಗಳ ಪರಿಣಾಮವಾಗಿ ಯಾವ ಅಸಮರ್ಥತೆಗಳು ಉದ್ಭವಿಸುತ್ತವೆ?


We could reduce the size of the page table in one simple way: use bigger pages.

ನಾವು ಒಂದು ಸರಳ ರೀತಿಯಲ್ಲಿ ಪುಟ ಕೋಷ್ಟಕದ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಬಹುದು: ದೊಡ್ಡ ಪುಟಗಳನ್ನು ಬಳಸಿ.


The major problem with this approach, however, is that big pages lead to waste within each page, a problem known as internal fragmentation.

ಆದಾಗ್ಯೂ, ಈ ವಿಧಾನದ ಮುಖ್ಯ ಸಮಸ್ಯೆಯೆಂದರೆ ದೊಡ್ಡ ಪುಟಗಳು ಪ್ರತಿ ಪುಟದೊಳಗೆ ತ್ಯಾಜ್ಯಕ್ಕೆ ಕಾರಣವಾಗುತ್ತವೆ, ಇದನ್ನು ಆಂತರಿಕ ತುಣುಕು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Applications thus end up allocating pages but only using little bits and pieces of each, and memory quickly fills up with these overly-large pages.

ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಪುಟಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತವೆ ಆದರೆ ಪ್ರತಿಯೊಂದರ ಸಣ್ಣ ಬಿಟ್‌ಗಳು ಮತ್ತು ತುಣುಕುಗಳನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತವೆ ಮತ್ತು ಮೆಮೊರಿಯು ಈ ಅತಿಯಾದ ದೊಡ್ಡ ಪುಟಗಳಿಂದ ತ್ವರಿತವಾಗಿ ತುಂಬಿಹೋಗುತ್ತದೆ.


Thus, most systems use relatively small page sizes in the common case: 4KB (as in x86) or 8KB (as in SPARCv9).

ಆದ್ದರಿಂದ, ಹೆಚ್ಚಿನ ಸಿಸ್ಟಮ್‌ಗಳು ಸಾಮಾನ್ಯ ಸಂದರ್ಭದಲ್ಲಿ ತುಲನಾತ್ಮಕವಾಗಿ ಸಣ್ಣ ಪುಟ ಗಾತ್ರಗಳನ್ನು ಬಳಸುತ್ತವೆ: 4KB (x86 ನಲ್ಲಿರುವಂತೆ) ಅಥವಾ 8KB (SPARCv9 ನಲ್ಲಿರುವಂತೆ).


Whenever you have two reasonable but different approaches to something in life, you should always examine the combination of the two to see if you can obtain the best of both worlds.

ಜೀವನದಲ್ಲಿ ನೀವು ಯಾವುದಕ್ಕಾದರೂ ಎರಡು ಸಮಂಜಸವಾದ ಆದರೆ ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಹೊಂದಿರುವಾಗ, ಎರಡರ ಸಂಯೋಜನೆಯನ್ನು ನೀವು ಯಾವಾಗಲೂ ಪರೀಕ್ಷಿಸಬೇಕು ಮತ್ತು ಎರಡೂ ಪ್ರಪಂಚದ ಅತ್ಯುತ್ತಮತೆಯನ್ನು ನೀವು ಪಡೆಯಬಹುದೇ ಎಂದು ನೋಡಬೇಕು.


ನಾವು ಅಂತಹ ಸಂಯೋಜನೆಯನ್ನು ಒಂದು ಮಿಶ್ರತಳಿ ಎಂದು ಕರೆಯುತ್ತೇವೆ.


For example, why eat just chocolate or plain peanut butter when you can instead combine the two in a lovely hybrid known as the Reese’s Peanut Butter Cup?

ಉದಾಹರಣೆಗೆ, ನೀವು ಚಾಕೊಲೇಟ್ ಅಥವಾ ಸಿಂಪಲ್ ಕಡಲೆಕಾಯಿ ಬೆಣ್ಣೆಯನ್ನು ಏಕೆ ತಿನ್ನಬೇಕು, ಬದಲಿಗೆ ನೀವು ಎರಡನ್ನೂ ರೀಸಸ್ ಪೀನಟ್ ಬಟರ್ ಕಪ್ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಸುಂದರವಾದ ಮಿಶ್ರತಳಿಯಲ್ಲಿ ಸಂಯೋಜಿಸಬಹುದು?


Specifically, Dennis had the idea of combining paging and segmentation in order to reduce the memory overhead of page tables.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಡೆನ್ನಿಸ್ ಪುಟ ಕೋಷ್ಟಕಗಳ ಮೆಮೊರಿ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಪೇಜಿಂಗ್ ಮತ್ತು ವಿಭಾಗೀಕರಣವನ್ನು ಸಂಯೋಜಿಸುವ ಕಲ್ಪನೆಯನ್ನು ಹೊಂದಿದ್ದರು.


As you can see from the picture, most of the page table is unused, full of invalid entries.

ಚಿತ್ರದಿಂದ ನೀವು ನೋಡುವಂತೆ, ಹೆಚ್ಚಿನ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ, ಅಮಾನ್ಯ ನಮೂದುಗಳಿಂದ ತುಂಬಿದೆ.


ಏನೊಂದು ವ್ಯರ್ಥ!


Imagine the page table of a 32-bit address space and all the potential wasted space in there!

32-ಬಿಟ್ ವಿಳಾಸ ಸ್ಥಳದ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಮತ್ತು ಅಲ್ಲಿನ ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ವ್ಯರ್ಥ ಸ್ಥಳವನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ!


Thus, our hybrid approach: instead of having a single page table for the entire address space of the process, why not have one per logical segment?

ಆದ್ದರಿಂದ, ನಮ್ಮ ಮಿಶ್ರ ವಿಧಾನ: ಪ್ರಕ್ರಿಯೆಯ ಸಂಪೂರ್ಣ ವಿಳಾಸ ಸ್ಥಳಕ್ಕಾಗಿ ಒಂದೇ ಪುಟ ಕೋಷ್ಟಕವನ್ನು ಹೊಂದುವ ಬದಲು, ಪ್ರತಿ ತಾರ್ಕಿಕ ವಿಭಾಗಕ್ಕೆ ಒಂದನ್ನು ಏಕೆ ಹೊಂದಬಾರದು?


In this example, we might thus have three page tables, one for the code, heap, and stack parts of the address space.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಮೂರು ಪುಟ ಕೋಷ್ಟಕಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಒಂದು ಕೋಡ್‌ಗಾಗಿ, ಒಂದು ರಾಶಿಗಾಗಿ ಮತ್ತು ಒಂದು ವಿಳಾಸ ಸ್ಥಳದ ಸ್ಟಾಕ್ ಭಾಗಗಳಿಗಾಗಿ.


The RISC side was spear-headed by David Patterson at Berkeley and John Hennessy at Stanford.

ಬರ್ಕ್ಲಿಯಲ್ಲಿ ಡೇವಿಡ್ ಪ್ಯಾಟರ್ಸನ್ ಮತ್ತು ಸ್ಟಾನ್ಫೋರ್ಡ್‌ನಲ್ಲಿ ಜಾನ್ ಹೆನ್ನೆಸ್ಸಿ ಅವರು RISC ವಿಭಾಗಕ್ಕೆ ನೇತೃತ್ವ ವಹಿಸಿದ್ದರು.


CISC instruction sets tend to have a lot of instructions in them, and each instruction is relatively powerful.

CISC ಸೂಚನಾ ಸೆಟ್‌ಗಳು ಬಹಳಷ್ಟು ಸೂಚನೆಗಳನ್ನು ಹೊಂದಿವೆ, ಮತ್ತು ಪ್ರತಿಯೊಂದು ಸೂಚನೆಯು ತುಲನಾತ್ಮಕವಾಗಿ ಶಕ್ತಿಯುತವಾಗಿದೆ.


For example, you might see a string copy, which takes two pointers and a length and copies bytes from source to destination.

ಉದಾಹರಣೆಗೆ, ನೀವು ಸ್ಟ್ರಿಂಗ್ ನಕಲನ್ನು ನೋಡಬಹುದು, ಇದು ಎರಡು ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ಉದ್ದವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಮೂಲದಿಂದ ಗಮ್ಯಸ್ಥಾನಕ್ಕೆ ಬೈಟ್‌ಗಳನ್ನು ನಕಲಿಸುತ್ತದೆ.


The idea behind CISC was that instructions should be high-level primitives, to make the assembly language itself easier to use, and to make code more compact.

CISC ಯ ಹಿಂದಿನ ಕಲ್ಪನೆಯೆಂದರೆ ಸೂಚನೆಗಳು ಉನ್ನತ ಮಟ್ಟದ ಪ್ರಿಮಿಟಿವ್‌ಗಳಾಗಿರಬೇಕು, ಅಸೆಂಬ್ಲಿ ಭಾಷೆಯನ್ನು ಬಳಸಲು ಸುಲಭವಾಗುವಂತೆ ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಕಾಂಪ್ಯಾಕ್ಟ್ ಮಾಡಲು.


A key observation behind RISC is that instruction sets are really compiler targets, and all compilers really want are a few simple primitives that they can use to generate high-performance code.

RISC ಯ ಹಿಂದಿನ ಒಂದು ಪ್ರಮುಖ ಅವಲೋಕನವೆಂದರೆ ಸೂಚನಾ ಸೆಟ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಕಂಪೈಲರ್ ಗುರಿಗಳಾಗಿವೆ, ಮತ್ತು ಎಲ್ಲಾ ಕಂಪೈಲರ್‌ಗಳು ನಿಜವಾಗಿಯೂ ಬಯಸುವುದು ಕೆಲವು ಸರಳ ಪ್ರಿಮಿಟಿವ್‌ಗಳಾಗಿವೆ, ಅದು ಹೆಚ್ಚಿನ ಕಾರ್ಯಕ್ಷಮತೆಯ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಬಳಸಬಹುದು.


In the early days, RISC chips made a huge impact, as they were noticeably faster.

ಆರಂಭಿಕ ದಿನಗಳಲ್ಲಿ, RISC ಚಿಪ್‌ಗಳು ದೊಡ್ಡ ಪರಿಣಾಮ ಬೀರಿದವು, ಏಕೆಂದರೆ ಅವು ಗಮನಾರ್ಹವಾಗಿ ವೇಗವಾಗಿದ್ದವು.


However, as time progressed, CISC manufacturers such as Intel incorporated many RISC techniques into the core of their processors.

ಆದಾಗ್ಯೂ, ಸಮಯ ಕಳೆದಂತೆ, ಇಂಟೆಲ್‌ನಂತಹ CISC ತಯಾರಕರು ತಮ್ಮ ಪ್ರೊಸೆಸರ್‌ಗಳ ಕೋರ್‌ನಲ್ಲಿ ಅನೇಕ RISC ತಂತ್ರಗಳನ್ನು ಸೇರಿಸಿಕೊಂಡರು.


The end result is that the debate died down, and today both types of processors can be made to run fast.

ಅಂತಿಮ ಫಲಿತಾಂಶವೆಂದರೆ ಚರ್ಚೆ ಕಡಿಮೆಯಾಯಿತು, ಮತ್ತು ಇಂದು ಎರಡೂ ರೀತಿಯ ಪ್ರೊಸೆಸರ್‌ಗಳನ್ನು ವೇಗವಾಗಿ ಚಲಾಯಿಸಬಹುದು.


A typical TLB might have 32, 64, or 128 entries and be what is called fully associative.

ವಿಶಿಷ್ಟವಾದ TLB 32, 64, ಅಥವಾ 128 ನಮೂದುಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಸಂಪೂರ್ಣವಾಗಿ ಸಹಾಯಕವಾಗಿದೆ ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತದೆ.


Basically, this just means that any given translation can be anywhere in the TLB, and that the hardware will search the entire TLB in parallel to find the desired translation.

ಮೂಲಭೂತವಾಗಿ, ಇದರರ್ಥ ಯಾವುದೇ ನಿರ್ದಿಷ್ಟ ಅನುವಾದವು TLB ಯಲ್ಲಿ ಎಲ್ಲಿಯಾದರೂ ಇರಬಹುದು ಮತ್ತು ಅಪೇಕ್ಷಿತ ಅನುವಾದವನ್ನು ಹುಡುಕಲು ಹಾರ್ಡ್‌ವೇರ್ ಸಂಪೂರ್ಣ TLB ಅನ್ನು ಸಮಾನಾಂತರವಾಗಿ ಹುಡುಕುತ್ತದೆ.


A common mistake is to confuse the valid bits found in a TLB with those found in a page table.

TLB ಯಲ್ಲಿ ಕಂಡುಬರುವ ಮಾನ್ಯ ಬಿಟ್‌ಗಳನ್ನು ಪುಟ ಕೋಷ್ಟಕದಲ್ಲಿ ಕಂಡುಬರುವ ಬಿಟ್‌ಗಳೊಂದಿಗೆ ಗೊಂದಲಗೊಳಿಸುವುದು ಒಂದು ಸಾಮಾನ್ಯ ತಪ್ಪು.


When a system boots, for example, a common initial state for each TLB entry is to be set to invalid, because no address translations are yet cached there.

ಉದಾಹರಣೆಗೆ, ಸಿಸ್ಟಮ್ ಬೂಟ್ ಆದಾಗ, ಪ್ರತಿ TLB ನಮೂದಿಗೆ ಸಾಮಾನ್ಯ ಆರಂಭಿಕ ಸ್ಥಿತಿಯನ್ನು ಅಮಾನ್ಯವೆಂದು ಹೊಂದಿಸಬೇಕು, ಏಕೆಂದರೆ ಯಾವುದೇ ವಿಳಾಸ ಅನುವಾದಗಳನ್ನು ಇನ್ನೂ ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿಲ್ಲ.


By setting all TLB entries to invalid, the system can ensure that the about-to-be-run process does not accidentally use a virtual-to-physical translation from a previous process.

ಎಲ್ಲಾ TLB ನಮೂದುಗಳನ್ನು ಅಮಾನ್ಯವೆಂದು ಹೊಂದಿಸುವ ಮೂಲಕ, ಸಿಸ್ಟಮ್, ರನ್ ಆಗಲಿರುವ ಪ್ರಕ್ರಿಯೆಯು ಹಿಂದಿನ ಪ್ರಕ್ರಿಯೆಯಿಂದ ವರ್ಚುವಲ್-ಟು-ಭೌತಿಕ ಅನುವಾದವನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಬಳಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು.


ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ “ಇತರ ಬಿಟ್‌ಗಳು”.


For example, the TLB commonly has a valid bit, which says whether the entry has a valid translation or not.

ಉದಾಹರಣೆಗೆ, TLB ಸಾಮಾನ್ಯವಾಗಿ ಮಾನ್ಯ ಬಿಟ್ ಅನ್ನು ಹೊಂದಿದೆ, ಇದು ನಮೂದಿನಲ್ಲಿ ಮಾನ್ಯ ಅನುವಾದವಿದೆಯೇ ಅಥವಾ ಇಲ್ಲವೇ ಎಂದು ಹೇಳುತ್ತದೆ.


With TLBs, some new issues arise when switching between processes (and hence address spaces).

TLB ಗಳೊಂದಿಗೆ, ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಬದಲಾಯಿಸುವಾಗ (ಮತ್ತು ಆದ್ದರಿಂದ ವಿಳಾಸ ಸ್ಥಳಗಳು) ಕೆಲವು ಹೊಸ ಸಮಸ್ಯೆಗಳು ಉದ್ಭವಿಸುತ್ತವೆ.


Specifically, the TLB contains virtual-to-physical translations that are only valid for the currently running process.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, TLB ವರ್ಚುವಲ್-ಟು-ಭೌತಿಕ ಅನುವಾದಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಅದು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಪ್ರಕ್ರಿಯೆಗೆ ಮಾತ್ರ ಮಾನ್ಯವಾಗಿದೆ.


As a result, when switching from one process to another, the hardware or OS (or both) must be careful to ensure that the about-to-be-run process does not accidentally use translations from some previously run process.

ಪರಿಣಾಮವಾಗಿ, ಒಂದು ಪ್ರಕ್ರಿಯೆಯಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಬದಲಾಯಿಸುವಾಗ, ಹಾರ್ಡ್‌ವೇರ್ ಅಥವಾ OS (ಅಥವಾ ಎರಡೂ) ರನ್ ಆಗಲಿರುವ ಪ್ರಕ್ರಿಯೆಯು ಹಿಂದೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಕೆಲವು ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ಅನುವಾದಗಳನ್ನು ಆಕಸ್ಮಿಕವಾಗಿ ಬಳಸುವುದಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಜಾಗರೂಕರಾಗಿರಬೇಕು.


When context-switching between processes, the translations in the TLB for the last process are not meaningful to the about-to-be-run process.

ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಸಂದರ್ಭವನ್ನು ಬದಲಾಯಿಸುವಾಗ, ಕೊನೆಯ ಪ್ರಕ್ರಿಯೆಗಾಗಿ TLB ಯಲ್ಲಿನ ಅನುವಾದಗಳು ರನ್ ಆಗಲಿರುವ ಪ್ರಕ್ರಿಯೆಗೆ ಅರ್ಥಪೂರ್ಣವಲ್ಲ.


One approach is to simply flush the TLB on context switches, thus emptying it before running the next process.

ಒಂದು ವಿಧಾನವೆಂದರೆ ಸಂದರ್ಭ ಬದಲಾವಣೆಗಳಲ್ಲಿ TLB ಅನ್ನು ಸರಳವಾಗಿ ಫ್ಲಶ್ ಮಾಡುವುದು, ಹೀಗಾಗಿ ಮುಂದಿನ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು ಅದನ್ನು ಖಾಲಿ ಮಾಡುವುದು.


The principle of locality suggests that recently accessed pages are likely to be accessed again soon.

ಸ್ಥಳೀಯತೆಯ ತತ್ವವು ಇತ್ತೀಚೆಗೆ ಪ್ರವೇಶಿಸಿದ ಪುಟಗಳನ್ನು ಶೀಘ್ರದಲ್ಲೇ ಮತ್ತೆ ಪ್ರವೇಶಿಸುವ ಸಾಧ್ಯತೆಯಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.


LRU (Least Recently Used) is a page replacement algorithm.

ಎಲ್‌ಆರ್‌ಯು (ಕಡಿಮೆ ಬಾರಿ ಬಳಸಿದ) ಪುಟ ಬದಲಿ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ.


Programs often exhibit two types of locality: spatial and temporal.

ಪ್ರೋಗ್ರಾಂಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಎರಡು ರೀತಿಯ ಸ್ಥಳೀಯತೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತವೆ: ಪ್ರಾದೇಶಿಕ ಮತ್ತು ತಾತ್ಕಾಲಿಕ.


The 80-20 workload demonstrates locality, with 80% of references to 20% of pages.

80-20 ಕೆಲಸದ ಹೊರೆ ಸ್ಥಳೀಯತೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, 20% ಪುಟಗಳಿಗೆ 80% ಉಲ್ಲೇಖಗಳೊಂದಿಗೆ.


In a looping-sequential workload, LRU and FIFO perform poorly.

ಲೂಪಿಂಗ್-ಸೀಕ್ವೆನ್ಷಿಯಲ್ ಕೆಲಸದ ಹೊರೆಗಳಲ್ಲಿ, ಎಲ್‌ಆರ್‌ಯು ಮತ್ತು ಎಫ್‌ಐಎಫ್‌ಒ ಕಳಪೆಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.


Approximating LRU is more feasible than implementing perfect LRU.

ಪರಿಪೂರ್ಣ ಎಲ್‌ಆರ್‌ಯುನನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಕ್ಕಿಂತ ಎಲ್‌ಆರ್‌ಯುನನ್ನು ಅಂದಾಜು ಮಾಡುವುದು ಹೆಚ್ಚು ಕಾರ್ಯಸಾಧ್ಯವಾಗಿದೆ.


The clock algorithm is a method to approximate LRU.

ಗಡಿಯಾರ ಅಲ್ಗಾರಿದಮ್ ಎಲ್‌ಆರ್‌ಯುನನ್ನು ಅಂದಾಜು ಮಾಡುವ ಒಂದು ವಿಧಾನವಾಗಿದೆ.


Hardware support, like the use bit, aids in approximating LRU.

ಬಳಕೆ ಬಿಟ್‌ನಂತಹ ಹಾರ್ಡ್‌ವೇರ್ ಬೆಂಬಲವು ಎಲ್‌ಆರ್‌ಯುನನ್ನು ಅಂದಾಜು ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Dirty pages need to be written back to disk before eviction.

ಹೊರಹಾಕುವ ಮೊದಲು ಕೊಳಕು ಪುಟಗಳನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಹಿಂತಿರುಗಿಸಬೇಕಾಗುತ್ತದೆ.


The OS also decides when to bring a page into memory.

ಒಎಸ್ ಯಾವಾಗ ಪುಟವನ್ನು ಮೆಮೊರಿಗೆ ತರಬೇಕೆಂದು ನಿರ್ಧರಿಸುತ್ತದೆ.


Demand paging brings pages into memory when accessed.

ಪ್ರವೇಶಿಸಿದಾಗ ಬೇಡಿಕೆ ಪುಟವು ಪುಟಗಳನ್ನು ಮೆಮೊರಿಗೆ ತರುತ್ತದೆ.


Prefetching can improve performance by bringing pages in advance.

ಮುಂಚಿತವಾಗಿ ಪುಟಗಳನ್ನು ತರುವ ಮೂಲಕ ಪೂರ್ವ ಲೋಡಿಂಗ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.


Clustering writes improves disk efficiency.

ಕ್ಲಸ್ಟರಿಂಗ್ ಬರವಣಿಗೆಯು ಡಿಸ್ಕ್ ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.


Thrashing occurs when memory is oversubscribed.

ಮೆಮೊರಿಯನ್ನು ಅತಿಯಾಗಿ ಚಂದಾದಾರರಾದಾಗ ಥ್ರ್ಯಾಶಿಂಗ್ ಸಂಭವಿಸುತ್ತದೆ.


Admission control can mitigate thrashing.

ಪ್ರವೇಶ ನಿಯಂತ್ರಣವು ಥ್ರ್ಯಾಶಿಂಗ್ ಅನ್ನು ತಗ್ಗಿಸಬಹುದು.


Modern systems use scan-resistant algorithms.

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ಸ್ಕ್ಯಾನ್-ನಿರೋಧಕ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.


The VAX/VMS operating system is a well-designed virtual memory manager.

VAX/VMS ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಉತ್ತಮವಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ವರ್ಚುವಲ್ ಮೆಮೊರಿ ವ್ಯವಸ್ಥಾಪಕವಾಗಿದೆ.


Dave Cutler was a primary architect of VMS.

ಡೇವ್ ಕಟ್ಲರ್ ವಿಎಂಎಸ್‌ನ ಪ್ರಮುಖ ವಾಸ್ತುಶಿಲ್ಪಿಗಳಲ್ಲಿ ಒಬ್ಬರಾಗಿದ್ದರು.


The best solution to excessive paging is often to buy more memory.

ಅತಿಯಾದ ಪುಟಕ್ಕೆ ಉತ್ತಮ ಪರಿಹಾರವೆಂದರೆ ಹೆಚ್ಚು ಮೆಮೊರಿಯನ್ನು ಖರೀದಿಸುವುದು.


Understanding page replacement policies is crucial for system performance.

ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ ಪುಟ ಬದಲಿ ನೀತಿಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


The operating system manages the computer's resources.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


Virtual memory allows a system to use more memory than is physically available.

ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಸಿಸ್ಟಮ್‌ಗೆ ಭೌತಿಕವಾಗಿ ಲಭ್ಯವಿರುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ.


The kernel is the core of the operating system.

ಕರ್ನಲ್ ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯ ತಿರುಳಾಗಿದೆ.


Page tables are used to translate virtual addresses to physical addresses.

ವರ್ಚುವಲ್ ವಿಳಾಸಗಳನ್ನು ಭೌತಿಕ ವಿಳಾಸಗಳಿಗೆ ಭಾಷಾಂತರಿಸಲು ಪುಟ ಕೋಷ್ಟಕಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


Context switching is the process of changing from one process to another.

ಸಂದರ್ಭ ಬದಲಾವಣೆ ಎಂದರೆ ಒಂದು ಪ್ರಕ್ರಿಯೆಯಿಂದ ಇನ್ನೊಂದಕ್ಕೆ ಬದಲಾಗುವ ಪ್ರಕ್ರಿಯೆ.


ಸಿಪಿಯು ಸೂಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.


A file system organizes data on a storage device.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸಂಗ್ರಹ ಸಾಧನದಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಘಟಿಸುತ್ತದೆ.


Multitasking allows a computer to run multiple programs at the same time.

ಬಹುಕಾರ್ಯಕತೆಯು ಕಂಪ್ಯೂಟರ್ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಅನೇಕ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಚಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.


The operating system provides an interface for users to interact with the hardware.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಬಳಕೆದಾರರು ಹಾರ್ಡ್‌ವೇರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಒಂದು ಇಂಟರ್‌ಫೇಸ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.


Memory management is a crucial function of the OS.

ಮೆಮೊರಿ ನಿರ್ವಹಣೆ OS ನ ಒಂದು ನಿರ್ಣಾಯಕ ಕಾರ್ಯವಾಗಿದೆ.


The system uses a TLB to speed up address translation.

ವಿಳಾಸ ಅನುವಾದವನ್ನು ವೇಗಗೊಳಿಸಲು ಸಿಸ್ಟಮ್ TLB ಅನ್ನು ಬಳಸುತ್ತದೆ.


Demand paging is a memory management technique.

ಬೇಡಿಕೆ ಪುಟೀಕರಣವು ಮೆಮೊರಿ ನಿರ್ವಹಣಾ ತಂತ್ರವಾಗಿದೆ.


Copy-on-write is an optimization technique used in operating systems.

ಕಾಪಿ-ಆನ್-ರೈಟ್ ಎಂಬುದು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ ಬಳಸಲಾಗುವ ಒಂದು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರವಾಗಿದೆ.


The VAX/VMS operating system was known for its advanced memory management.

VAX/VMS ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ತನ್ನ ಸುಧಾರಿತ ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗೆ ಹೆಸರುವಾಸಿಯಾಗಿತ್ತು.


Understanding how virtual memory works is key to understanding system performance.

ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮುಖ್ಯವಾಗಿದೆ.


The OS must handle page faults efficiently.

OS ಪುಟ ದೋಷಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ನಿರ್ವಹಿಸಬೇಕು.


The kernel protects itself from user-level processes.

ಕರ್ನಲ್ ಬಳಕೆದಾರ-ಮಟ್ಟದ ಪ್ರಕ್ರಿಯೆಗಳಿಂದ ತನ್ನನ್ನು ತಾನು ರಕ್ಷಿಸಿಕೊಳ್ಳುತ್ತದೆ.


Modern operating systems use multi-level page tables.

ಆಧುನಿಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳು ಬಹು-ಹಂತದ ಪುಟ ಕೋಷ್ಟಕಗಳನ್ನು ಬಳಸುತ್ತವೆ.


The design of an OS involves many trade-offs.

ಒಂದು OS ನ ವಿನ್ಯಾಸವು ಅನೇಕ ರಾಜಿಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.


The goal is to create a stable and efficient system.

ಸ್ಥಿರ ಮತ್ತು ಸಮರ್ಥ ವ್ಯವಸ್ಥೆಯನ್ನು ರಚಿಸುವುದು ಗುರಿಯಾಗಿದೆ.


ಒಂದು ಸ್ಥಿತಿಯ ವೇರಿಯೇಬಲ್ ಲಾಕ್ ಅನ್ನು ಬಯಸುತ್ತದೆ.


The thread goes to sleep when pthread_cond_wait() is called.

pthread_cond_wait() ಅನ್ನು ಕರೆದಾಗ ಥ್ರೆಡ್ ನಿದ್ರೆಗೆ ಹೋಗುತ್ತದೆ.


The lock is released when the thread sleeps.

ಥ್ರೆಡ್ ನಿದ್ರಿಸಿದಾಗ ಲಾಕ್ ಬಿಡುಗಡೆಯಾಗುತ್ತದೆ.


Another thread signals the waiting thread.

ಇನ್ನೊಂದು ಥ್ರೆಡ್ ಕಾಯುತ್ತಿರುವ ಥ್ರೆಡ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ.


Always hold the lock when modifying the global variable.

ಜಾಗತಿಕ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಮಾರ್ಪಡಿಸುವಾಗ ಯಾವಾಗಲೂ ಲಾಕ್ ಅನ್ನು ಹಿಡಿದುಕೊಳ್ಳಿ.


ವೈಲ್ ಲೂಪ್ ಸ್ಥಿತಿಯನ್ನು ಮರು-ಪರಿಶೀಲಿಸುತ್ತದೆ.


ಸರಳ ಧ್ವಜವನ್ನು ಬಳಸುವುದು ದೋಷಪೂರಿತವಾಗಬಹುದು.


Condition variables are preferred over simple flags.

ಸರಳ ಧ್ವಜಗಳಿಗಿಂತ ಸ್ಥಿತಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಆದ್ಯತೆ ನೀಡಲಾಗುತ್ತದೆ.


-pthread ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ಕಂಪೈಲ್ ಮಾಡಿ.


The pthread library provides tools for multi-threaded code.

pthread ಲೈಬ್ರರಿ ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಕೋಡ್‌ಗಾಗಿ ಪರಿಕರಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.


ಥ್ರೆಡ್ ಪರಸ್ಪರ ಕ್ರಿಯೆಗಳನ್ನು ಸರಳವಾಗಿ ಇರಿಸಿ.


Initialize locks and condition variables properly.

ಲಾಕ್‌ಗಳು ಮತ್ತು ಸ್ಥಿತಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ಪ್ರಾರಂಭಿಸಿ.


ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ರಿಟರ್ನ್ ಕೋಡ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.


ಪ್ರತಿಯೊಂದು ಥ್ರೆಡ್ ತನ್ನದೇ ಆದ ಸ್ಟ್ಯಾಕ್ ಅನ್ನು ಹೊಂದಿದೆ.


Use condition variables to signal between threads.

ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಸಿಗ್ನಲ್ ಮಾಡಲು ಸ್ಥಿತಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಬಳಸಿ.


The manual pages are highly informative.

ಕೈಪಿಡಿ ಪುಟಗಳು ಹೆಚ್ಚು ಮಾಹಿತಿಯುಕ್ತವಾಗಿವೆ.


Locks are used to protect critical sections.

ನಿರ್ಣಾಯಕ ವಿಭಾಗಗಳನ್ನು ರಕ್ಷಿಸಲು ಲಾಕ್‌ಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


A lock variable holds the state of the lock.

ಲಾಕ್ ವೇರಿಯೇಬಲ್ ಲಾಕ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುತ್ತದೆ.


The lock is either available or acquired.

ಲಾಕ್ ಲಭ್ಯವಿದೆ ಅಥವಾ ಸ್ವಾಧೀನಪಡಿಸಿಕೊಂಡಿದೆ.


ಲಾಕ್‌ಗಳು ವೇಳಾಪಟ್ಟಿಯ ಮೇಲೆ ನಿಯಂತ್ರಣವನ್ನು ಒದಗಿಸುತ್ತವೆ.


ಮೂಲ ನೀತಿಗಳು ಸ್ವಲ್ಪ ಸ್ಪಷ್ಟವಾಗಿವೆ.


Building a real virtual memory system seems more interesting.

ನಿಜವಾದ ವರ್ಚುವಲ್ ಮೆಮೊರಿ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವುದು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ.


The mechanisms are more interesting, and the policies less so.

ವಿಧಾನಗಳು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿವೆ, ಮತ್ತು ನೀತಿಗಳು ಕಡಿಮೆ.


My machine is running a little slowly these days.

ಇತ್ತೀಚೆಗೆ ನನ್ನ ಯಂತ್ರ ಸ್ವಲ್ಪ ನಿಧಾನವಾಗಿ ಚಲಿಸುತ್ತಿದೆ.


Go and get yourself some DRAM, cheapskate.

ಹೋಗಿ ಸ್ವಲ್ಪ DRAM ಅನ್ನು ಪಡೆದುಕೊಳ್ಳಿ, ಲೋಭಿ.


ನಾನು ಮತ್ತೆಂದೂ ಡಿಸ್ಕ್‌ಗೆ ವಿನಿಮಯ ಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ.


We reach the second of our three pillars of operating systems: concurrency.

ನಾವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳ ನಮ್ಮ ಮೂರು ಸ್ತಂಭಗಳಲ್ಲಿ ಎರಡನೆಯದನ್ನು ತಲುಪುತ್ತೇವೆ: ಸಮಕಾಲೀನತೆ.


ನಾವು ಒಂದು ಪೀಚ್ ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಊಹಿಸಿ.


ನಿಮಗೂ ಪೀಚ್‌ಗಳಿಗೂ ಏನು ಸಂಬಂಧ?


Imagine there are a lot of peaches on a table, and a lot of people who wish to eat them.

ಒಂದು ಟೇಬಲ್ ಮೇಲೆ ಬಹಳಷ್ಟು ಪೀಚ್‌ಗಳಿವೆ ಮತ್ತು ಅವುಗಳನ್ನು ತಿನ್ನಲು ಬಯಸುವ ಅನೇಕ ಜನರಿದ್ದಾರೆ ಎಂದು ಊಹಿಸಿ.


Each eater first identifies a peach visually, and then tries to grab it and eat it.

ಪ್ರತಿಯೊಬ್ಬ ತಿನ್ನುವವನು ಮೊದಲು ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಪೀಚ್ ಅನ್ನು ಗುರುತಿಸುತ್ತಾನೆ, ತದನಂತರ ಅದನ್ನು ಹಿಡಿಯಲು ಮತ್ತು ತಿನ್ನಲು ಪ್ರಯತ್ನಿಸುತ್ತಾನೆ.


Hmmm... seems like you might see a peach that somebody else also sees.

ಹ್ಮ್... ಬೇರೆಯವರು ನೋಡುವ ಪೀಚ್ ಅನ್ನು ನೀವು ನೋಡಬಹುದು ಎಂದು ತೋರುತ್ತದೆ.


ಆದ್ದರಿಂದ ನಾವು ಏನು ಮಾಡಬೇಕು?


Well, probably develop a better way of going about this.

ಸರಿ, ಬಹುಶಃ ಇದನ್ನು ಮಾಡಲು ಉತ್ತಮ ಮಾರ್ಗವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿ.


The best kind of approach would be fast and correct, probably.

ಅತ್ಯುತ್ತಮ ರೀತಿಯ ವಿಧಾನವು ವೇಗವಾಗಿ ಮತ್ತು ಸರಿಯಾಗಿರುತ್ತದೆ, ಬಹುಶಃ.


ನೀವು ನಿಜವಾಗಿಯೂ ಪ್ರಭಾವ ಬೀರಲು ಪ್ರಾರಂಭಿಸಿದ್ದೀರಿ.


In fact, you just told us everything we need to know about concurrency!

ವಾಸ್ತವವಾಗಿ, ಸಮಕಾಲೀನತೆಯ ಬಗ್ಗೆ ನಾವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ನೀವು ಈಗಷ್ಟೇ ಹೇಳಿದ್ದೀರಿ!


ಯಾವತ್ತೂ ವಾಸ್ತವವನ್ನು ಮರೆಯಬಾರದು.


There are certain types of programs that we call multi-threaded applications.

ನಾವು ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಎಂದು ಕರೆಯುವ ಕೆಲವು ರೀತಿಯ ಪ್ರೋಗ್ರಾಂಗಳಿವೆ.


The OS must support multi-threaded applications with primitives such as locks and condition variables.

ಲಾಕ್‌ಗಳು ಮತ್ತು ಕಂಡಿಷನ್ ವೇರಿಯೇಬಲ್‌ಗಳಂತಹ ಪ್ರಿಮಿಟಿವ್‌ಗಳೊಂದಿಗೆ OS ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸಬೇಕು.


The operating system manages computer hardware and software resources.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಕಂಪ್ಯೂಟರ್ ಹಾರ್ಡ್‌ವೇರ್ ಮತ್ತು ಸಾಫ್ಟ್‌ವೇರ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


Concurrency allows multiple tasks to appear to run simultaneously.

ಏಕಕಾಲಿಕತೆಯು ಅನೇಕ ಕಾರ್ಯಗಳು ಏಕಕಾಲದಲ್ಲಿ ಚಲಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.


Threads share the same address space, making communication efficient.

ಥ್ರೆಡ್‌ಗಳು ಒಂದೇ ವಿಳಾಸದ ಜಾಗವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ, ಇದು ಸಂವಹನವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡುತ್ತದೆ.


Synchronization primitives are essential for managing shared resources.

ಹಂಚಿದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಪ್ರಿಮಿಟಿವ್ಸ್ ಅತ್ಯಗತ್ಯ.


Locks prevent race conditions by ensuring exclusive access to critical sections.

ನಿರ್ಣಾಯಕ ವಿಭಾಗಗಳಿಗೆ ಪ್ರತ್ಯೇಕ ಪ್ರವೇಶವನ್ನು ಖಚಿತಪಡಿಸುವ ಮೂಲಕ ಲಾಕ್‌ಗಳು ರೇಸ್ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ತಡೆಯುತ್ತವೆ.


Condition variables enable threads to wait for specific conditions to become true.

ನಿರ್ದಿಷ್ಟ ಷರತ್ತುಗಳು ನಿಜವಾಗಲು ಥ್ರೆಡ್‌ಗಳು ಕಾಯಲು ಕಂಡಿಷನ್ ವೇರಿಯೇಬಲ್‌ಗಳು ಅನುಮತಿಸುತ್ತವೆ.


The operating system provides an API for thread creation and management.

ಕಾರ್ಯಾಚರಣಾ ವ್ಯವಸ್ಥೆಯು ಥ್ರೆಡ್ ರಚನೆ ಮತ್ತು ನಿರ್ವಹಣೆಗಾಗಿ API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ.


Understanding concurrency is crucial for writing efficient multi-threaded programs.

ಸಮರ್ಥ ಮಲ್ಟಿ-ಥ್ರೆಡೆಡ್ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಬರೆಯಲು ಏಕಕಾಲಿಕತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


Atomic operations guarantee that a series of actions either all succeed or all fail.

ಅಣು ಕಾರ್ಯಾಚರಣೆಗಳು ಕ್ರಿಯೆಗಳ ಸರಣಿಯು ಒಂದೇ ಬಾರಿಗೆ ಯಶಸ್ವಿಯಾಗುವುದು ಅಥವಾ ವಿಫಲಗೊಳ್ಳುವುದನ್ನು ಖಾತರಿಪಡಿಸುತ್ತದೆ.


File systems use techniques like journaling to ensure data consistency.

ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಜರ್ನಲಿಂಗ್‌ನಂತಹ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತವೆ.


The program uses locks to protect shared data from corruption.

ಹಂಚಿದ ಡೇಟಾವನ್ನು ಭ್ರಷ್ಟಾಚಾರದಿಂದ ರಕ್ಷಿಸಲು ಪ್ರೋಗ್ರಾಂ ಲಾಕ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


Multiple threads can access the same file concurrently.

ಬಹು ಥ್ರೆಡ್‌ಗಳು ಒಂದೇ ಫೈಲ್ ಅನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರವೇಶಿಸಬಹುದು.


The interrupt interval affects the interleaving of threads.

ಅಡ್ಡಿ ಮಧ್ಯಂತರವು ಥ್ರೆಡ್‌ಗಳ ಇಂಟರ್‌ಲೀವಿಂಗ್ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.


Careful synchronization is needed to avoid race conditions.

ರೇಸ್ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ತಪ್ಪಿಸಲು ಎಚ್ಚರಿಕೆಯ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅಗತ್ಯವಿದೆ.


The final value of the shared variable depends on the thread interleaving.

ಹಂಚಿದ ವೇರಿಯೇಬಲ್‌ನ ಅಂತಿಮ ಮೌಲ್ಯವು ಥ್ರೆಡ್ ಇಂಟರ್‌ಲೀವಿಂಗ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುತ್ತದೆ.


The program demonstrates the use of mutexes for mutual exclusion.

ಪರಸ್ಪರ ಹೊರಗಿಡುವಿಕೆಗಾಗಿ ಮ್ಯೂಟೆಕ್ಸ್‌ಗಳ ಬಳಕೆಯನ್ನು ಪ್ರೋಗ್ರಾಂ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.


Understanding how threads interact is key to debugging.

ಥ್ರೆಡ್‌ಗಳು ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಡೀಬಗ್ ಮಾಡಲು ಮುಖ್ಯವಾಗಿದೆ.


The code uses condition variables to signal between threads.

ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಸಿಗ್ನಲ್ ಮಾಡಲು ಕೋಡ್ ಕಂಡಿಷನ್ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


The program's behavior changes with different interrupt intervals.

ಪ್ರೋಗ್ರಾಂನ ನಡವಳಿಕೆಯು ವಿಭಿನ್ನ ಅಡ್ಡಿ ಮಧ್ಯಂತರಗಳೊಂದಿಗೆ ಬದಲಾಗುತ್ತದೆ.


The example illustrates the challenges of concurrent programming.

ಏಕಕಾಲಿಕ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನ ಸವಾಲುಗಳನ್ನು ಉದಾಹರಣೆ ವಿವರಿಸುತ್ತದೆ.


The code uses a spin lock, which can be inefficient on a single processor.

ಕೋಡ್ ಸ್ಪಿನ್ ಲಾಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ, ಇದು ಒಂದೇ ಪ್ರೊಸೆಸರ್‌ನಲ್ಲಿ ಅಸಮರ್ಥವಾಗಬಹುದು.


Test-and-set instructions are used to build a simple spin lock.

ಟೆಸ್ಟ್-ಆಂಡ್-ಸೆಟ್ ಸೂಚನೆಗಳನ್ನು ಸರಳ ಸ್ಪಿನ್ ಲಾಕ್ ನಿರ್ಮಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.


Spin locks can lead to starvation if not implemented carefully.

ಎಚ್ಚರಿಕೆಯಿಂದ ಅಳವಡಿಸದಿದ್ದರೆ ಸ್ಪಿನ್ ಲಾಕ್‌ಗಳು ಹಸಿವಿಗೆ ಕಾರಣವಾಗಬಹುದು.


Compare-and-swap is another hardware primitive for building locks.

ಲಾಕ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಹೋಲಿಕೆ-ಮತ್ತು-ಸ್ವಾಪ್ ಮತ್ತೊಂದು ಹಾರ್ಡ್‌ವೇರ್ ಮೂಲವಾಗಿದೆ.


Load-linked and store-conditional instructions can also be used.

ಲೋಡ್-ಲಿಂಕ್ಡ್ ಮತ್ತು ಸ್ಟೋರ್-ಷರತ್ತುಬದ್ಧ ಸೂಚನೆಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು.


Fetch-and-add is an atomic operation that increments a value.

ಫೆಚ್-ಆಂಡ್-ಆಡ್ ಒಂದು ಪರಮಾಣು ಕಾರ್ಯಾಚರಣೆಯಾಗಿದ್ದು ಅದು ಮೌಲ್ಯವನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ.


Ticket locks ensure progress for all threads.

ಟಿಕೆಟ್ ಲಾಕ್‌ಗಳು ಎಲ್ಲಾ ಥ್ರೆಡ್‌ಗಳಿಗೆ ಪ್ರಗತಿಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ.


Spinning wastes CPU cycles when a thread is waiting for a lock.

ಥ್ರೆಡ್ ಲಾಕ್‌ಗಾಗಿ ಕಾಯುತ್ತಿರುವಾಗ ಸ್ಪಿನ್ನಿಂಗ್ CPU ಚಕ್ರಗಳನ್ನು ವ್ಯರ್ಥ ಮಾಡುತ್ತದೆ.


Yielding the CPU can be a better approach than spinning.

ಸ್ಪಿನ್ನಿಂಗ್‌ಗಿಂತ CPU ಅನ್ನು ಇಳಿಸುವುದು ಉತ್ತಮ ವಿಧಾನವಾಗಿದೆ.


Using queues and sleeping is a more efficient way to handle locks.

очередях и спящем режиме - более эффективный способ работы с блокировками.


The operating system provides primitives like park and unpark.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪಾರ್ಕ್ ಮತ್ತು ಅನ್‌ಪಾರ್ಕ್‌ನಂತಹ ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.


Futexes in Linux provide similar functionality to Solaris's park/unpark.

ಲಿನಕ್ಸ್‌ನಲ್ಲಿನ ಫ್ಯೂಟೆಕ್ಸ್ ಸೋಲಾರಿಸ್‌ನ ಪಾರ್ಕ್/ಅನ್‌ಪಾರ್ಕ್‌ಗೆ ಹೋಲುವ ಕಾರ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ.


The code is designed to avoid spinning as much as possible.

ಕೋಡ್ ಸಾಧ್ಯವಾದಷ್ಟು ಸ್ಪಿನ್ನಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


A thread can be in one of three states: running, ready, or blocked.

ಥ್ರೆಡ್ ಮೂರು ಸ್ಥಿತಿಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿರಬಹುದು: ಚಾಲನೆಯಲ್ಲಿರುವ, ಸಿದ್ಧ ಅಥವಾ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ.


The goal is to build a working mutual exclusion primitive.

ಕೆಲಸ ಮಾಡುವ ಪರಸ್ಪರ ಹೊರಗಿಡುವ ಮೂಲವನ್ನು ನಿರ್ಮಿಸುವುದು ಗುರಿಯಾಗಿದೆ.


Short, concise code is always preferred.

ಸಣ್ಣ, ಸಂಕ್ಷಿಪ್ತ ಕೋಡ್ ಯಾವಾಗಲೂ ಆದ್ಯತೆಯಾಗಿದೆ.


This approach doesn't avoid spin-waiting entirely.

ಈ ವಿಧಾನವು ಸಂಪೂರ್ಣವಾಗಿ ಸ್ಪಿನ್-ಕಾಯುವಿಕೆಯನ್ನು ತಪ್ಪಿಸುವುದಿಲ್ಲ.


The scheduler determines which thread runs next.

ಯಾವ ಥ್ರೆಡ್ ಮುಂದಿನದಾಗಿ ಚಲಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಶೆಡ್ಯೂಲರ್ ನಿರ್ಧರಿಸುತ್ತದೆ.


We need to exert some control over who gets the lock next.

ಮುಂದೆ ಯಾರು ಲಾಕ್ ಪಡೆಯುತ್ತಾರೆ ಎಂಬುದರ ಮೇಲೆ ನಾವು ಕೆಲವು ನಿಯಂತ್ರಣವನ್ನು ಚಲಾಯಿಸಬೇಕಾಗಿದೆ.


The code uses a guard lock around flag and queue manipulations.

ಕೋಡ್ ಧ್ವಜ ಮತ್ತು ಸರತಿ ಸಾಲು ಕುಶಲತೆಗಳ ಸುತ್ತಲೂ ಗಾರ್ಡ್ ಲಾಕ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


ಪ್ರೋಗ್ರಾಂ ಯಶಸ್ವಿಯಾಗಿ ಕಂಪೈಲ್ ಆಗಿದೆ.


ದಯವಿಟ್ಟು ನಿಮ್ಮ ಬಳಕೆದಾರ ಹೆಸರನ್ನು ನಮೂದಿಸಿ.


ಇಂದು ಹವಾಮಾನವು ಆಹ್ಲಾದಕರವಾಗಿದೆ.


ಅವಳು ಗ್ರಂಥಾಲಯದಲ್ಲಿ ಪುಸ್ತಕವನ್ನು ಓದುತ್ತಿದ್ದಾಳೆ.


The company announced its quarterly results.

ಕಂಪನಿಯು ತನ್ನ ತ್ರೈಮಾಸಿಕ ಫಲಿತಾಂಶಗಳನ್ನು ಘೋಷಿಸಿತು.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಸಮರ್ಥವಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


He decided to invest in the stock market.

ಅವರು ಷೇರು ಮಾರುಕಟ್ಟೆಯಲ್ಲಿ ಹೂಡಿಕೆ ಮಾಡಲು ನಿರ್ಧರಿಸಿದರು.


The government implemented new policies.

ಸರ್ಕಾರವು ಹೊಸ ನೀತಿಗಳನ್ನು ಜಾರಿಗೆ ತಂದಿತು.


The research paper explores various aspects of climate change.

ಸಂಶೋಧನಾ ಪ್ರಬಂಧವು ಹವಾಮಾನ ಬದಲಾವಣೆಯ ವಿವಿಧ ಅಂಶಗಳನ್ನು ಪರಿಶೋಧಿಸುತ್ತದೆ.


Despite the challenges, they persevered and succeeded.

ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಅವರು ಪ್ರಯತ್ನಿಸಿದರು ಮತ್ತು ಯಶಸ್ವಿಯಾದರು.


The complex system requires careful analysis and design.

ಸಂಕೀರ್ಣ ವ್ಯವಸ್ಥೆಗೆ ಎಚ್ಚರಿಕೆಯ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ವಿನ್ಯಾಸದ ಅಗತ್ಯವಿದೆ.


The economic forecast predicts a period of growth.

ಆರ್ಥಿಕ ಮುನ್ಸೂಚನೆಯು ಬೆಳವಣಿಗೆಯ ಅವಧಿಯನ್ನು ಊಹಿಸುತ್ತದೆ.


The artist's innovative techniques revolutionized the art world.

ಕಲಾವಿದನ ನವೀನ ತಂತ್ರಗಳು ಕಲಾ ಜಗತ್ತನ್ನು ಕ್ರಾಂತಿಗೊಳಿಸಿದವು.


The company's strategic plan outlines its future goals.

ಕಂಪನಿಯ ಕಾರ್ಯತಂತ್ರದ ಯೋಜನೆಯು ಅದರ ಭವಿಷ್ಯದ ಗುರಿಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ.


The judge delivered a verdict after a lengthy trial.

ದೀರ್ಘ ವಿಚಾರಣೆಯ ನಂತರ ನ್ಯಾಯಾಧೀಶರು ತೀರ್ಪು ನೀಡಿದರು.


The software update includes several bug fixes and performance improvements.

ಸಾಫ್ಟ್‌ವೇರ್ ನವೀಕರಣವು ಹಲವಾರು ದೋಷ ಪರಿಹಾರಗಳು ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆ ಸುಧಾರಣೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


The negotiations between the two countries are ongoing.

ಎರಡೂ ದೇಶಗಳ ನಡುವಿನ ಮಾತುಕತೆಗಳು ನಡೆಯುತ್ತಿವೆ.


The intricate design of the building is a marvel of engineering.

ಕಟ್ಟಡದ ಸಂಕೀರ್ಣ ವಿನ್ಯಾಸವು ಎಂಜಿನಿಯರಿಂಗ್‌ನ ಅದ್ಭುತವಾಗಿದೆ.


The impact of globalization on local cultures is a subject of debate.

ಸ್ಥಳೀಯ ಸಂಸ್ಕೃತಿಗಳ ಮೇಲೆ ಜಾಗತೀಕರಣದ ಪ್ರಭಾವವು ಚರ್ಚೆಯ ವಿಷಯವಾಗಿದೆ.


The scientific community is working to find a cure for the disease.

ವೈಜ್ಞಾನಿಕ ಸಮುದಾಯವು ರೋಗಕ್ಕೆ ಚಿಕಿತ್ಸೆ ಕಂಡುಹಿಡಿಯಲು ಶ್ರಮಿಸುತ್ತಿದೆ.


The code uses locks to protect shared data structures.

ಕೋಡ್ ಹಂಚಿಕೆಯಾದ ಡೇಟಾ ರಚನೆಗಳನ್ನು ರಕ್ಷಿಸಲು ಲಾಕ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


Two-phase locks can improve performance in certain scenarios.

ಎರಡು-ಹಂತದ ಲಾಕ್‌ಗಳು ಕೆಲವು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.


The operating system provides support for locking mechanisms.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಲಾಕಿಂಗ್ ಕಾರ್ಯವಿಧಾನಗಳಿಗೆ ಬೆಂಬಲವನ್ನು ಒದಗಿಸುತ್ತದೆ.


Understanding concurrency is crucial for building robust systems.

ದೃಢವಾದ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಮಕಾಲೀನತೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮುಖ್ಯವಾಗಿದೆ.


The example demonstrates how to use mutex locks.

ಉದಾಹರಣೆಯು ಮ್ಯೂಟೆಕ್ಸ್ ಲಾಕ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ.


Sloppy counters offer a trade-off between accuracy and performance.

ಸರಿಯಾದ ಕೌಂಟರ್‌ಗಳು ನಿಖರತೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯ ನಡುವೆ ವ್ಯಾಪಾರವನ್ನು ನೀಡುತ್ತವೆ.


Hand-over-hand locking is a technique for concurrent linked lists.

ಹ್ಯಾಂಡ್-ಓವರ್-ಹ್ಯಾಂಡ್ ಲಾಕಿಂಗ್ ಸಮಕಾಲೀನ ಲಿಂಕ್ಡ್ ಪಟ್ಟಿಗಳ ತಂತ್ರವಾಗಿದೆ.


The code includes functions for initializing and updating counters.

ಕೋಡ್ ಕೌಂಟರ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಮತ್ತು ನವೀಕರಿಸಲು ಕಾರ್ಯಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.


Concurrent data structures require careful design to avoid race conditions.

ರೇಸ್ ಪರಿಸ್ಥಿತಿಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಮಕಾಲೀನ ಡೇಟಾ ರಚನೆಗಳು ಎಚ್ಚರಿಕೆಯ ವಿನ್ಯಾಸದ ಅಗತ್ಯವಿದೆ.


The performance of a system can be affected by the choice of locking strategy.

ಲಾಕಿಂಗ್ ತಂತ್ರದ ಆಯ್ಕೆಯಿಂದ ಸಿಸ್ಟಮ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆಯು ಪ್ರಭಾವಿತವಾಗಬಹುದು.


The article discusses different approaches to building concurrent data structures.

ಲೇಖನವು ಸಮಕಾಲೀನ ಡೇಟಾ ರಚನೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ವಿಭಿನ್ನ ವಿಧಾನಗಳನ್ನು ಚರ್ಚಿಸುತ್ತದೆ.


Adding locks to a data structure makes it thread-safe.

ಡೇಟಾ ರಚನೆಗೆ ಲಾಕ್‌ಗಳನ್ನು ಸೇರಿಸುವುದರಿಂದ ಅದು ಥ್ರೆಡ್-ಸುರಕ್ಷಿತವಾಗುತ್ತದೆ.


The sloppy counter implementation uses local and global counters.

ಸರಿಯಾದ ಕೌಂಟರ್ ಅನುಷ್ಠಾನವು ಸ್ಥಳೀಯ ಮತ್ತು ಜಾಗತಿಕ ಕೌಂಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


The threshold value influences the performance of sloppy counters.

ಸರಿಯಾದ ಕೌಂಟರ್‌ಗಳ ಕಾರ್ಯಕ್ಷಮತೆಯ ಮೇಲೆ ಮಿತಿ ಮೌಲ್ಯವು ಪ್ರಭಾವ ಬೀರುತ್ತದೆ.


The example code shows how to enqueue and dequeue items from a queue.

ಉದಾಹರಣೆ ಕೋಡ್ ಸರದಿಯಿಂದ ಐಟಂಗಳನ್ನು ಹೇಗೆ ಎನ್‌ಕ್ಯೂ ಮತ್ತು ಡಿಕ್ಯೂ ಮಾಡುವುದು ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ.


Concurrent hash tables are useful for managing data in multi-threaded applications.

ಬಹು-ಥ್ರೆಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಸಮಕಾಲೀನ ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ.


The design of concurrent data structures involves trade-offs.

ಸಮಕಾಲೀನ ಡೇಟಾ ರಚನೆಗಳ ವಿನ್ಯಾಸವು ವ್ಯಾಪಾರ ವಹಿವಾಟುಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ.


Careful consideration of control flow is important in concurrent programming.

ಸಮಕಾಲೀನ ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ನಿಯಂತ್ರಣ ಹರಿವಿನ ಎಚ್ಚರಿಕೆಯ ಪರಿಗಣನೆ ಮುಖ್ಯವಾಗಿದೆ.


Performance testing is crucial to evaluate the effectiveness of different locking strategies.

ವಿವಿಧ ಲಾಕಿಂಗ್ ತಂತ್ರಗಳ ಪರಿಣಾಮಕಾರಿತ್ವವನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡಲು ಕಾರ್ಯಕ್ಷಮತೆ ಪರೀಕ್ಷೆಯು ಮುಖ್ಯವಾಗಿದೆ.


The choice of data structure can significantly impact the scalability of a system.

ಡೇಟಾ ರಚನೆಯ ಆಯ್ಕೆಯು ಸಿಸ್ಟಮ್‌ನ ಸ್ಕೇಲೆಬಿಲಿಟಿಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಪ್ರಭಾವಿಸುತ್ತದೆ.


ಗ್ರಾಹಕ ಸರಳವಾಗಿ ಮತ್ತೆ ನಿದ್ರೆಗೆ ಹೋಗುತ್ತಾನೆ.


Thanks to Mesa semantics, a simple rule to remember with condition variables is to always use while loops.

ಮೆಸಾ ಅರ್ಥಶಾಸ್ತ್ರಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಷರತ್ತುಬದ್ಧ ಅಸ್ಥಿರಗಳೊಂದಿಗೆ ನೆನಪಿಡುವ ಸರಳ ನಿಯಮವೆಂದರೆ ಯಾವಾಗಲೂ ವೈಲ್ ಲೂಪ್‌ಗಳನ್ನು ಬಳಸುವುದು.


The problem occurs when two consumers run first.

ಸಮಸ್ಯೆ ಎದುರಾಗುವುದು ಇಬ್ಬರು ಗ್ರಾಹಕರು ಮೊದಲು ಚಲಿಸಿದಾಗ.


A consumer should not wake other consumers, only producers, and vice-versa.

ಗ್ರಾಹಕರು ಇತರ ಗ್ರಾಹಕರನ್ನು ಎಚ್ಚರಿಸಬಾರದು, ಉತ್ಪಾದಕರನ್ನು ಮಾತ್ರ, ಮತ್ತು ಪ್ರತಿಯಾಗಿ.


The solution here is once again a small one: use two condition variables, instead of one.

ಇಲ್ಲಿ ಪರಿಹಾರವು ಮತ್ತೆ ಚಿಕ್ಕದಾಗಿದೆ: ಒಂದರ ಬದಲು ಎರಡು ಷರತ್ತುಬದ್ಧ ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಿ.


A producer only sleeps if all buffers are currently filled.

ಎಲ್ಲಾ ಬಫರ್‌ಗಳು ಪ್ರಸ್ತುತ ತುಂಬಿದ್ದರೆ ಮಾತ್ರ ಉತ್ಪಾದಕ ನಿದ್ರಿಸುತ್ತಾನೆ.


When checking for a condition in a multi-threaded program, using a while loop is always correct.

ಬಹು-ಥ್ರೆಡ್ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸುವಾಗ, ವೈಲ್ ಲೂಪ್ ಬಳಸುವುದು ಯಾವಾಗಲೂ ಸರಿಯಾಗಿರುತ್ತದೆ.


The cost, as we’ve discussed, is that too many threads might be woken.

ನಾವು ಚರ್ಚಿಸಿದಂತೆ, ವೆಚ್ಚವೆಂದರೆ ಹೆಚ್ಚಿನ ಥ್ರೆಡ್‌ಗಳನ್ನು ಎಚ್ಚರಿಸಬಹುದು.


We have seen the introduction of another important synchronization primitive beyond locks: condition variables.

ನಾವು ಲಾಕ್‌ಗಳನ್ನು ಮೀರಿ ಮತ್ತೊಂದು ಪ್ರಮುಖ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಪ್ರಿಮಿಟಿವ್‌ನ ಪರಿಚಯವನ್ನು ನೋಡಿದ್ದೇವೆ: ಷರತ್ತುಬದ್ಧ ಅಸ್ಥಿರಗಳು.


A semaphore is as an object with an integer value that we can manipulate with two routines.

ಸೆಮಾಫೋರ್ ಎನ್ನುವುದು ಎರಡು ರೂಟಿನ್‌ಗಳೊಂದಿಗೆ ನಾವು ಕುಶಲತೆಯಿಂದ ನಿರ್ವಹಿಸಬಹುದಾದ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿರುವ ವಸ್ತುವಾಗಿದೆ.


Because the initial value of the semaphore determines its behavior, before calling any other routine to interact with the semaphore, we must first initialize it to some value.

ಸೆಮಾಫೋರ್‌ನ ಆರಂಭಿಕ ಮೌಲ್ಯವು ಅದರ ನಡವಳಿಕೆಯನ್ನು ನಿರ್ಧರಿಸುವುದರಿಂದ, ಸೆಮಾಫೋರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಯಾವುದೇ ಇತರ ರೂಟಿನ್ ಅನ್ನು ಕರೆಯುವ ಮೊದಲು, ನಾವು ಮೊದಲು ಅದನ್ನು ಕೆಲವು ಮೌಲ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸಬೇಕು.


After a semaphore is initialized, we can call one of two functions to interact with it.

ಸೆಮಾಫೋರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಾವು ಅದರೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಎರಡು ಕಾರ್ಯಗಳಲ್ಲಿ ಒಂದನ್ನು ಕರೆಯಬಹುದು.


The behavior of these two functions is seen in Figure 31.2.

ಈ ಎರಡು ಕಾರ್ಯಗಳ ನಡವಳಿಕೆಯನ್ನು ಚಿತ್ರ 31.2 ರಲ್ಲಿ ಕಾಣಬಹುದು.


We will now focus on how to use these primitives; later we may discuss how they are built.

ಈ ಪ್ರಿಮಿಟಿವ್‌ಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಮೇಲೆ ನಾವು ಈಗ ಗಮನಹರಿಸುತ್ತೇವೆ; ನಂತರ ಅವುಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನಾವು ಚರ್ಚಿಸಬಹುದು.


First, we can see that sem_wait() will either return right away.

ಮೊದಲಿಗೆ, ಸೆಮ್_ವೇಟ್() ತಕ್ಷಣವೇ ಹಿಂತಿರುಗುತ್ತದೆ ಎಂದು ನಾವು ನೋಡಬಹುದು.


Second, we can see that sem_post() does not wait for some particular condition to hold.

ಎರಡನೆಯದಾಗಿ, ಸೆಮ್_ಪೋಸ್ಟ್() ಕೆಲವು ನಿರ್ದಿಷ್ಟ ಸ್ಥಿತಿಯನ್ನು ಹಿಡಿದಿಡಲು ಕಾಯುವುದಿಲ್ಲ ಎಂದು ನಾವು ನೋಡಬಹುದು.


Though the value generally isn’t seen by users of the semaphores, this invariant is worth knowing.

ಸಾಮಾನ್ಯವಾಗಿ ಸೆಮಾಫೋರ್‌ಗಳ ಬಳಕೆದಾರರು ಮೌಲ್ಯವನ್ನು ನೋಡುವುದಿಲ್ಲವಾದರೂ, ಈ ಇನ್ವೇರಿಯಂಟ್ ತಿಳಿದುಕೊಳ್ಳುವುದು ಯೋಗ್ಯವಾಗಿದೆ.


ನಾವು ಈಗ ಸೆಮಾಫೋರ್ ಅನ್ನು ಬಳಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ.


Critical to making this work, though, is the initial value of the semaphore.

ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿರ್ಣಾಯಕವಾದುದು ಸೆಮಾಫೋರ್‌ನ ಆರಂಭಿಕ ಮೌಲ್ಯವಾಗಿದೆ.


Semaphores are also useful when a thread wants to halt its progress waiting for a condition to become true.

ಒಂದು ಥ್ರೆಡ್ ಸ್ಥಿತಿಯು ನಿಜವಾಗಲು ಕಾಯುತ್ತಿರುವಾಗ ತನ್ನ ಪ್ರಗತಿಯನ್ನು ನಿಲ್ಲಿಸಲು ಬಯಸಿದಾಗ ಸೆಮಾಫೋರ್‌ಗಳು ಸಹ ಉಪಯುಕ್ತವಾಗಿವೆ.


The consumer waits for a buffer to become filled before using it.

ಬಳಸುವ ಮೊದಲು ಬಫರ್ ತುಂಬುವವರೆಗೆ ಗ್ರಾಹಕ ಕಾಯುತ್ತಾನೆ.


Imagine there are two threads, a producer and a consumer.

ಇಬ್ಬರು ಥ್ರೆಡ್‌ಗಳು, ನಿರ್ಮಾಪಕ ಮತ್ತು ಗ್ರಾಹಕರು ಇದ್ದಾರೆ ಎಂದು ಊಹಿಸಿ.


The producer will put a data value into the first entry of buffer.

ಉತ್ಪಾದಕರು ಬಫರ್‌ನ ಮೊದಲ ಪ್ರವೇಶಕ್ಕೆ ಡೇಟಾ ಮೌಲ್ಯವನ್ನು ಹಾಕುತ್ತಾರೆ.


This is a no-no; we don’t want any data from the producer to be lost.

ಇದು ಮಾಡಬಾರದು; ಉತ್ಪಾದಕರಿಂದ ಯಾವುದೇ ಡೇಟಾ ಕಳೆದುಹೋಗಬಾರದು ಎಂದು ನಾವು ಬಯಸುವುದಿಲ್ಲ.


The filling of a buffer and incrementing of the index into the buffer is a critical section.

ಬಫರ್ ಅನ್ನು ತುಂಬುವುದು ಮತ್ತು ಬಫರ್‌ಗೆ ಸೂಚ್ಯಂಕವನ್ನು ಹೆಚ್ಚಿಸುವುದು ಒಂದು ನಿರ್ಣಾಯಕ ವಿಭಾಗವಾಗಿದೆ.


The consumer acquires the mutex and is waiting for the someone to signal full.

ಗ್ರಾಹಕನು ಮ್ಯೂಟೆಕ್ಸ್ ಅನ್ನು ಪಡೆದುಕೊಳ್ಳುತ್ತಾನೆ ಮತ್ತು ಯಾರಾದರೂ ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂದು ಸೂಚಿಸುವವರೆಗೆ ಕಾಯುತ್ತಿದ್ದಾನೆ.


The producer could signal full but is waiting for the mutex.

ಉತ್ಪಾದಕರು ಪೂರ್ಣಗೊಂಡಿದೆ ಎಂದು ಸೂಚಿಸಬಹುದು ಆದರೆ ಮ್ಯೂಟೆಕ್ಸ್ಗಾಗಿ ಕಾಯುತ್ತಿದ್ದಾರೆ.


To solve this problem, we simply must reduce the scope of the lock.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು, ನಾವು ಸರಳವಾಗಿ ಲಾಕ್‌ನ ವ್ಯಾಪ್ತಿಯನ್ನು ಕಡಿಮೆ ಮಾಡಬೇಕು.


Understand it now; use it later. You will thank us for years to come.

ಈಗ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಿ; ನಂತರ ಬಳಸಿ. ನೀವು ವರ್ಷಗಳವರೆಗೆ ನಮಗೆ ಧನ್ಯವಾದ ಹೇಳುತ್ತೀರಿ.


Reader-writer locks should be used with some caution.

ರೀಡರ್-ರೈಟರ್ ಲಾಕ್‌ಗಳನ್ನು ಸ್ವಲ್ಪ ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸಬೇಕು.


The basic setup for the problem is this: assume there are five “philosophers” sitting around a table.

ಸಮಸ್ಯೆಗೆ ಮೂಲಭೂತ ಸೆಟಪ್ ಹೀಗಿದೆ: ಒಂದು ಟೇಬಲ್ ಸುತ್ತಲೂ ಕುಳಿತಿರುವ ಐದು “ತತ್ವಜ್ಞಾನಿಗಳು” ಇದ್ದಾರೆ ಎಂದು ಭಾವಿಸೋಣ.


In order to eat, a philosopher needs two forks, both the one on their left and the one on their right.

ತಿನ್ನಲು, ತತ್ವಜ್ಞಾನಿಗೆ ಎರಡು ಫೋರ್ಕ್‌ಗಳು ಬೇಕಾಗುತ್ತವೆ, ಎಡಭಾಗದಲ್ಲಿರುವ ಮತ್ತು ಬಲಭಾಗದಲ್ಲಿರುವ ಫೋರ್ಕ್‌ಗಳು.


The key challenge, then, is to write the routines getforks() and putforks() such that there is no deadlock.

ಪ್ರಮುಖ ಸವಾಲೆಂದರೆ, ಡೆಡ್‌ಲಾಕ್ ಇಲ್ಲದ ರೀತಿಯಲ್ಲಿ getforks() ಮತ್ತು putforks() ಕಾರ್ಯವಿಧಾನಗಳನ್ನು ಬರೆಯುವುದು.


If each philosopher happens to grab the fork on their left before any philosopher can grab the fork on their right, each will be stuck.

ಪ್ರತಿಯೊಬ್ಬ ತತ್ವಜ್ಞಾನಿಯು ತಮ್ಮ ಬಲಕ್ಕೆ ಫೋರ್ಕ್ ಅನ್ನು ಹಿಡಿಯುವ ಮೊದಲು ತಮ್ಮ ಎಡಭಾಗದಲ್ಲಿರುವ ಫೋರ್ಕ್ ಅನ್ನು ಪಡೆದರೆ, ಪ್ರತಿಯೊಬ್ಬರೂ ಸಿಲುಕಿಕೊಳ್ಳುತ್ತಾರೆ.


The simplest way to attack this problem is to change how forks are acquired by at least one of the philosophers.

ಈ ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಲು ಸುಲಭವಾದ ಮಾರ್ಗವೆಂದರೆ ಕನಿಷ್ಠ ಒಬ್ಬ ತತ್ವಜ್ಞಾನಿಯಿಂದ ಫೋರ್ಕ್‌ಗಳನ್ನು ಹೇಗೆ ಪಡೆಯಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಬದಲಾಯಿಸುವುದು.


There are other “famous” problems like this one, e.g., the cigarette smoker’s problem or the sleeping barber problem.

ಈ ರೀತಿಯ ಇತರ “ಪ್ರಸಿದ್ಧ” ಸಮಸ್ಯೆಗಳಿವೆ, ಉದಾಹರಣೆಗೆ, ಸಿಗರೇಟ್ ಧೂಮಪಾನಿಗಳ ಸಮಸ್ಯೆ ಅಥವಾ ಮಲಗುವ ಕ್ಷೌರಿಕನ ಸಮಸ್ಯೆ.


Finally, let’s use our low-level synchronization primitives, locks and condition variables, to build our own version of semaphores.

ಅಂತಿಮವಾಗಿ, ನಮ್ಮ ಕಡಿಮೆ-ಮಟ್ಟದ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಪ್ರಿಮಿಟಿವ್‌ಗಳು, ಲಾಕ್‌ಗಳು ಮತ್ತು ಸ್ಥಿತಿ ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಮ್ಮದೇ ಆದ ಸೆಮಾಫೋರ್‌ಗಳ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ಮಿಸೋಣ.


One subtle difference between our Zemaphore and pure semaphores as defined by Dijkstra is that we don’t maintain the invariant.

ನಮ್ಮ ಜೆಮಾಫೋರ್ ಮತ್ತು ಡಿಜ್ಕ್‌ಸ್ಟ್ರಾದಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಶುದ್ಧ ಸೆಮಾಫೋರ್‌ಗಳ ನಡುವಿನ ಒಂದು ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸವೆಂದರೆ ನಾವು ಸ್ಥಿರತೆಯನ್ನು ನಿರ್ವಹಿಸುವುದಿಲ್ಲ.


Semaphores are a powerful and flexible primitive for writing concurrent programs.

ಸೆಮಾಫೋರ್‌ಗಳು ಸಮಕಾಲೀನ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಬರೆಯಲು ಶಕ್ತಿಯುತ ಮತ್ತು ಹೊಂದಿಕೊಳ್ಳುವ ಪ್ರಿಮಿಟಿವ್ ಆಗಿದೆ.


In this chapter, we have presented just a few classic problems and solutions.

ಈ ಅಧ್ಯಾಯದಲ್ಲಿ, ನಾವು ಕೆಲವು ಕ್ಲಾಸಿಕ್ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಪರಿಹಾರಗಳನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಿದ್ದೇವೆ.


The study focuses on four major and important open-source applications.

ಅಧ್ಯಯನವು ನಾಲ್ಕು ಪ್ರಮುಖ ಮತ್ತು ಮುಖ್ಯವಾದ ಮುಕ್ತ-ಮೂಲ ಅನ್ವಯಿಕೆಗಳ ಮೇಲೆ ಗಮನಹರಿಸುತ್ತದೆ.


MySQL is a popular database management system.

MySQL ಒಂದು ಜನಪ್ರಿಯ ಡೇಟಾಬೇಸ್ ನಿರ್ವಹಣಾ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ.


Apache ಒಂದು ಸುಪ್ರಸಿದ್ಧ ವೆಬ್ ಸರ್ವರ್ ಆಗಿದೆ.


Mozilla ಪ್ರಸಿದ್ಧ ವೆಬ್ ಬ್ರೌಸರ್ ಆಗಿದೆ.


OpenOffice is a free version of the MS Office suite.

OpenOffice MS ಆಫೀಸ್ ಸೂಟ್‌ನ ಉಚಿತ ಆವೃತ್ತಿಯಾಗಿದೆ.


The authors examine concurrency bugs that have been found and fixed.

ಲೇಖಕರು ಕಂಡುಹಿಡಿದು ಸರಿಪಡಿಸಿದ ಸಮಕಾಲೀನ ದೋಷಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತಾರೆ.


Understanding these results can help you understand what types of problems actually occur.

ಈ ಫಲಿತಾಂಶಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಯಾವ ರೀತಿಯ ಸಮಸ್ಯೆಗಳು ನಿಜವಾಗಿ ಸಂಭವಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತದೆ.


Table 32.1 shows a summary of the bugs Lu and colleagues studied.

ಕೋಷ್ಟಕ 32.1 ಲು ಮತ್ತು ಸಹೋದ್ಯೋಗಿಗಳು ಅಧ್ಯಯನ ಮಾಡಿದ ದೋಷಗಳ ಸಾರಾಂಶವನ್ನು ತೋರಿಸುತ್ತದೆ.


ಹೆಚ್ಚಿನ ದೋಷಗಳು ಡೆಡ್‌ಲಾಕ್ ಆಗಿರಲಿಲ್ಲ.


We now dive into these different classes of bugs a bit more deeply.

ನಾವು ಈಗ ಈ ವಿಭಿನ್ನ ವರ್ಗದ ದೋಷಗಳನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಳವಾಗಿ ಪರಿಶೀಲಿಸೋಣ.


Non-deadlock bugs make up a majority of concurrency bugs.

ಡೆಡ್‌ಲಾಕ್ ಅಲ್ಲದ ದೋಷಗಳು ಸಮಕಾಲೀನ ದೋಷಗಳಲ್ಲಿ ಹೆಚ್ಚಿನದನ್ನು ಹೊಂದಿವೆ.


ಅವು ಹೇಗೆ ಉದ್ಭವಿಸುತ್ತವೆ?


We now discuss the two major types of non-deadlock bugs.

ನಾವು ಈಗ ಡೆಡ್‌ಲಾಕ್ ಅಲ್ಲದ ಎರಡು ಪ್ರಮುಖ ವಿಧದ ದೋಷಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.


The first type of problem encountered is referred to as an atomicity violation.

ಮೊದಲ ವಿಧದ ಸಮಸ್ಯೆಯನ್ನು ಪರಮಾಣು ಉಲ್ಲಂಘನೆ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


Here is a simple example, found in MySQL.

ಇದು MySQL ನಲ್ಲಿ ಕಂಡುಬರುವ ಒಂದು ಸರಳ ಉದಾಹರಣೆಯಾಗಿದೆ.


ಕೋಡ್ ಪರಮಾಣುತ್ವದ ಊಹೆಯನ್ನು ಹೊಂದಿದೆ.


Finding a fix for this type of problem is often straightforward.

ಈ ರೀತಿಯ ಸಮಸ್ಯೆಗೆ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಸಾಮಾನ್ಯವಾಗಿ ನೇರವಾಗಿರುತ್ತದೆ.


Another common type of non-deadlock bug found is known as an order violation.

ಕಂಡುಬರುವ ಮತ್ತೊಂದು ಸಾಮಾನ್ಯ ವಿಧದ ಡೆಡ್‌ಲಾಕ್ ಅಲ್ಲದ ದೋಷವೆಂದರೆ ಆರ್ಡರ್ ಉಲ್ಲಂಘನೆ.


The fix to this type of bug is generally to enforce ordering.

ಈ ರೀತಿಯ ದೋಷಕ್ಕೆ ಪರಿಹಾರವೆಂದರೆ ಸಾಮಾನ್ಯವಾಗಿ ಕ್ರಮವನ್ನು ಜಾರಿಗೊಳಿಸುವುದು.


When ordering matters between threads, condition variables can come to the rescue.

ಥ್ರೆಡ್‌ಗಳ ನಡುವೆ ಆದೇಶವು ಮುಖ್ಯವಾದಾಗ, ಸ್ಥಿತಿ ಅಸ್ಥಿರಗಳು ಸಹಾಯಕ್ಕೆ ಬರಬಹುದು.


ನಮಸ್ಕಾರ, ಹೇಗಿದ್ದೀರಿ?


ಇಂದು ಹವಾಮಾನ ಸುಂದರವಾಗಿದೆ.


ನಾನು ಮಾರುಕಟ್ಟೆಗೆ ಹೋಗುತ್ತಿದ್ದೇನೆ.


ದಯವಿಟ್ಟು ನನಗೆ ಉಪ್ಪು ಕೊಡಿ.


ನಿಮ್ಮ ಹೆಸರೇನು?


ಕಂಪನಿಯು ಹೊಸ ಉತ್ಪನ್ನವನ್ನು ಘೋಷಿಸಿತು.