ਘਰ ਦਾ ਕੰਮ (ਮਾਪ)।


ਅਨੁਸੂਚੀ ਮਾਪਦੰਡ।


ਪਹਿਲਾਂ ਅੰਦਰ, ਪਹਿਲਾਂ ਬਾਹਰ (FIFO)।


ਸਭ ਤੋਂ ਛੋਟਾ ਕੰਮ ਪਹਿਲਾਂ (SJF)।


ਰਾਊਂਡ ਰੋਬਿਨ।


I/O ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ।


ਹੋਰ ਓਰੇਕਲ ਨਹੀਂ।


MLFQ: ਮੁੱਢਲੇ ਨਿਯਮ।


ਪ੍ਰਾਥਮਿਕਤਾ ਨੂੰ ਕਿਵੇਂ ਬਦਲਿਆ ਜਾਵੇ।


ਪ੍ਰਾਥਮਿਕਤਾ ਵਾਧਾ।


ਬਿਹਤਰ ਲੇਖਾਕਾਰੀ।


Basic Concept: Tickets Represent Your Share.

ਮੁੱਢਲਾ ਸੰਕਲਪ: ਟਿਕਟਾਂ ਤੁਹਾਡੇ ਹਿੱਸੇ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ।


ਟਿਕਟਾਂ ਕਿਵੇਂ ਸੌਂਪੀਆਂ ਜਾਣ?


ਸਮਕਾਲੀਕਰਨ ਨੂੰ ਨਾ ਭੁੱਲੋ।


ਇੱਕ ਆਖਰੀ ਮੁੱਦਾ: ਕੈਸ਼ ਅਫਿਨਿਟੀ।


ਐਡਰੈੱਸ ਸਪੇਸ।


ਮਲਟੀਪ੍ਰੋਗਰਾਮਿੰਗ ਅਤੇ ਟਾਈਮ ਸ਼ੇਅਰਿੰਗ।


ਮੈਮੋਰੀ ਦੀਆਂ ਕਿਸਮਾਂ।


ਮੈਲੋਕ() ਕਾਲ।


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.

ਸਰਵਰ-ਸਾਈਡ ਲਿਖਣ ਬਫਰਿੰਗ 'ਤੇ ਪ੍ਰਭਾਵ।


ਵਰਜਨ 1 ਨਾਲ ਸਮੱਸਿਆਵਾਂ।


ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ।


ਕੈਸ਼ ਇਕਸਾਰਤਾ।


ਕਰੈਸ਼ ਰਿਕਵਰੀ।


AFSv2 ਦਾ ਪੈਮਾਨਾ ਅਤੇ ਪ੍ਰਦਰਸ਼ਨ।


AFS: ਹੋਰ ਸੁਧਾਰ।


Simple Example: Code That Loops and Prints.

ਸਧਾਰਨ ਉਦਾਹਰਨ: ਕੋਡ ਜੋ ਲੂਪ ਕਰਦਾ ਹੈ ਅਤੇ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ।


ਇੱਕੋ ਸਮੇਂ ਬਹੁਤ ਸਾਰੇ ਪ੍ਰੋਗਰਾਮ ਚਲਾਉਣਾ।


ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਜੋ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ ਕਰਦਾ ਹੈ।


Running The Memory Program Multiple Times.

ਮੈਮੋਰੀ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਈ ਵਾਰ ਚਲਾਉਣਾ।


ਇੰਟਰੱਪਟਸ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨਾ।


ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ ਸਪਿਨ ਲੌਕ ਬਣਾਉਣਾ।


ਤੁਲਨਾ ਕਰੋ ਅਤੇ ਬਦਲੋ।


ਇੱਕ ਸਧਾਰਨ ਪਹੁੰਚ: ਬੱਸ ਯੀਲਡ ਕਰੋ, ਬੇਬੀ।


Using Queues: Sleeping Instead Of Spinning.

ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ: ਸਪਿਨਿੰਗ ਦੀ ਬਜਾਏ ਸੌਣਾ।


ਵੱਖ-ਵੱਖ OS, ਵੱਖ-ਵੱਖ ਸਹਾਇਤਾ।


ਦੋ-ਪੜਾਅ ਲਾਕ।


ਸਮਕਾਲੀ ਕਾਊਂਟਰ।


ਸਮਕਾਲੀ ਲਿੰਕਡ ਸੂਚੀਆਂ।


ਸਮਕਾਲੀ ਕਤਾਰਾਂ।


ਪਰਿਭਾਸ਼ਾ ਅਤੇ ਰੁਟੀਨ।


The Producer/Consumer (Bound Buffer) Problem.

ਉਤਪਾਦਕ/ਖਪਤਕਾਰ (ਬਾਉਂਡ ਬਫਰ) ਸਮੱਸਿਆ।


ਸੈਮਾਫੋਰ: ਇੱਕ ਪਰਿਭਾਸ਼ਾ।


ਬਾਈਨਰੀ ਸੈਮਾਫੋਰ (ਲਾਕ)।


ਸ਼ਰਤ ਵੇਰੀਏਬਲ ਦੇ ਤੌਰ 'ਤੇ ਸੈਮਾਫੋਰ।


ਡਾਇਨਿੰਗ ਫਿਲਾਸਫਰ।


ਕਿਸ ਕਿਸਮ ਦੇ ਬੱਗ ਮੌਜੂਦ ਹਨ?


ਮੁੱਢਲਾ ਵਿਚਾਰ: ਇੱਕ ਇਵੈਂਟ ਲੂਪ।


ਸਿਸਟਮ ਆਰਕੀਟੈਕਚਰ।


ਇੱਕ ਕੈਨੋਨੀਕਲ ਡਿਵਾਈਸ।


The operating system virtualizes resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸਰੋਤਾਂ ਨੂੰ ਵਰਚੁਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ।


ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹਦਾਇਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ।


ਓਐਸ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕੁਸ਼ਲਤਾ ਨਾਲ ਕਰਦਾ ਹੈ।


Virtualization makes the system easier to use.

ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਸਿਸਟਮ ਨੂੰ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।


The professor teaches operating systems.

ਪ੍ਰੋਫੈਸਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਪੜ੍ਹਾਉਂਦੇ ਹਨ।


ਵਿਦਿਆਰਥੀ ਸਿੱਖਣ ਲਈ ਤਿਆਰ ਹਨ।


The book is called 'Operating Systems in Three Easy Pieces'.

ਕਿਤਾਬ ਦਾ ਨਾਮ 'ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਇਨ ਥ੍ਰੀ ਈਜ਼ੀ ਪੀਸਿਜ਼' ਹੈ।


The OS provides system calls to applications.

ਓਐਸ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਸਿਸਟਮ ਕਾਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


ਓਐਸ ਇੱਕ ਸਰੋਤ ਪ੍ਰਬੰਧਕ ਹੈ।


Concurrency is a key concept in operating systems.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਸਮਕਾਲੀਤਾ ਇੱਕ ਮੁੱਖ ਸੰਕਲਪ ਹੈ।


The program allocates memory using malloc().

ਪ੍ਰੋਗਰਾਮ malloc() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੈਮੋਰੀ ਅਲਾਟ ਕਰਦਾ ਹੈ।


Each process has its own virtual address space.

ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਦਾ ਆਪਣਾ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਸਪੇਸ ਹੁੰਦਾ ਹੈ।


ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸੀਪੀਯੂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


Understanding virtualization is crucial for OS design.

ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਨੂੰ ਸਮਝਣਾ ਓਐਸ ਡਿਜ਼ਾਈਨ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The OS transforms physical resources into virtual ones.

ਓਐਸ ਭੌਤਿਕ ਸਰੋਤਾਂ ਨੂੰ ਵਰਚੁਅਲ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।


Concurrency problems arise in multi-threaded programs.

ਸਮਕਾਲੀਤਾ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ।


The system provides an illusion of many virtual CPUs.

ਸਿਸਟਮ ਬਹੁਤ ਸਾਰੇ ਵਰਚੁਅਲ ਸੀਪੀਯੂ ਦਾ ਭੁਲੇਖਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


The OS ensures that programs run correctly and efficiently.

ਓਐਸ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਹੀ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਚੱਲਦੇ ਹਨ।


The primary goal is to make the system easy to use.

ਮੁੱਖ ਟੀਚਾ ਸਿਸਟਮ ਨੂੰ ਵਰਤਣ ਵਿੱਚ ਆਸਾਨ ਬਣਾਉਣਾ ਹੈ।


The operating system is responsible for resource management.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸਰੋਤ ਪ੍ਰਬੰਧਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।


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.

ਹਰੇਕ ਮੁੱਖ ਸੰਕਲਪ ਨੂੰ ਅਧਿਆਵਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ।


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.

ਅਸਾਈਡਸ ਮੁੱਖ ਟੈਕਸਟ ਨਾਲ ਸੰਬੰਧਿਤ (ਪਰ ਸ਼ਾਇਦ ਜ਼ਰੂਰੀ ਨਹੀਂ) ਕਿਸੇ ਚੀਜ਼ 'ਤੇ ਚਰਚਾ ਕਰਦੇ ਹਨ।


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.

ਅਸਲ ਪ੍ਰਣਾਲੀਆਂ 'ਤੇ ਅਸਲ ਕੋਡ ਚਲਾਉਣਾ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਬਾਰੇ ਸਿੱਖਣ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਹੈ।


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.

ਇਸ ਕਿਤਾਬ ਵਿੱਚ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਜੋੜ ਪ੍ਰੋਜੈਕਟਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੈ।


All projects 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-ਹਫ਼ਤਿਆਂ ਦੇ ਸਮੈਸਟਰ ਵਿੱਚ ਕਾਫ਼ੀ ਵਧੀਆ ਢੰਗ ਨਾਲ ਵੰਡਿਆ ਗਿਆ ਹੈ।


One slightly unusual aspect of the book is that concurrency, a topic at the front of many OS books, is pushed off herein until the student has built an understanding of virtualization.

ਕਿਤਾਬ ਦਾ ਇੱਕ ਥੋੜ੍ਹਾ ਅਸਾਧਾਰਨ ਪਹਿਲੂ ਇਹ ਹੈ ਕਿ ਸਮਕਾਲੀਤਾ, ਬਹੁਤ ਸਾਰੀਆਂ OS ਕਿਤਾਬਾਂ ਦੇ ਅੱਗੇ ਇੱਕ ਵਿਸ਼ਾ, ਨੂੰ ਇੱਥੇ ਉਦੋਂ ਤੱਕ ਅੱਗੇ ਧੱਕਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਵਿਦਿਆਰਥੀ ਨੇ ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਦੀ ਸਮਝ ਨਹੀਂ ਬਣਾ ਲਈ।


We created these notes to spark your interest in operating systems.

ਅਸੀਂ ਇਹ ਨੋਟਸ ਤੁਹਾਡੀ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਦਿਲਚਸਪੀ ਜਗਾਉਣ ਲਈ ਬਣਾਏ ਹਨ।


The program prints a 'hello world' message.

ਪ੍ਰੋਗਰਾਮ 'ਹੈਲੋ ਵਰਲਡ' ਦਾ ਸੁਨੇਹਾ ਛਾਪਦਾ ਹੈ।


The operating system manages the computer's resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਦੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


I am learning about process creation in UNIX systems.

ਮੈਂ ਯੂਨਿਕਸ ਸਿਸਟਮ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਣ ਬਾਰੇ ਸਿੱਖ ਰਿਹਾ ਹਾਂ।


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

ਬੱਚਾ ਪ੍ਰਕਿਰਿਆ ਮਾਤਾ-ਪਿਤਾ ਦੀ ਲਗਭਗ ਸਹੀ ਕਾਪੀ ਹੈ।


The fork() system call creates a new process.

ਫੋਰਕ() ਸਿਸਟਮ ਕਾਲ ਇੱਕ ਨਵੀਂ ਪ੍ਰਕਿਰਿਆ ਬਣਾਉਂਦੀ ਹੈ।


The shell is a user program that interacts with the user.

ਸ਼ੈੱਲ ਇੱਕ ਉਪਭੋਗਤਾ ਪ੍ਰੋਗਰਾਮ ਹੈ ਜੋ ਉਪਭੋਗਤਾ ਨਾਲ ਗੱਲਬਾਤ ਕਰਦਾ ਹੈ।


The program uses the execvp() system call to run another program.

ਪ੍ਰੋਗਰਾਮ ਦੂਜੇ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਚਲਾਉਣ ਲਈ execvp() ਸਿਸਟਮ ਕਾਲ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Understanding how processes are created and managed is crucial.

ਇਹ ਸਮਝਣਾ ਕਿ ਪ੍ਰਕਿਰਿਆਵਾਂ ਕਿਵੇਂ ਬਣਾਈਆਂ ਅਤੇ ਪ੍ਰਬੰਧਿਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ।


The operating system provides an interface for process control.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਪ੍ਰਕਿਰਿਆ ਨਿਯੰਤਰਣ ਲਈ ਇੱਕ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


CPU ਨੂੰ ਸਮਾਂ-ਸਾਂਝਾ ਕਰਨ ਦੁਆਰਾ ਵਰਚੁਅਲਾਈਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The parent process waits for the child to complete.

ਮਾਤਾ-ਪਿਤਾ ਪ੍ਰਕਿਰਿਆ ਬੱਚੇ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦੀ ਹੈ।


ਸ਼ੈੱਲ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਰੀਡਾਇਰੈਕਟ ਕਰਦਾ ਹੈ।


The program's output is not deterministic.

ਪ੍ਰੋਗਰਾਮ ਦਾ ਆਉਟਪੁੱਟ ਨਿਰਧਾਰਤ ਨਹੀਂ ਹੈ।


The system call wait() is used to wait for a child process.

ਸਿਸਟਮ ਕਾਲ wait() ਦੀ ਵਰਤੋਂ ਬੱਚੇ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੀ ਉਡੀਕ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The exec() system call replaces the current program.

exec() ਸਿਸਟਮ ਕਾਲ ਮੌਜੂਦਾ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਬਦਲ ਦਿੰਦੀ ਹੈ।


The separation of fork() and exec() is essential for building a UNIX shell.

ਫੋਰਕ() ਅਤੇ exec() ਦਾ ਵੱਖ ਹੋਣਾ ਇੱਕ UNIX ਸ਼ੈੱਲ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।


The OS must virtualize the CPU efficiently.

ਓਐਸ ਨੂੰ CPU ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਵਰਚੁਅਲਾਈਜ਼ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਉਪਭੋਗਤਾ ਮੋਡ ਵਿੱਚ ਚੱਲ ਰਿਹਾ ਹੈ।


The hardware assists the OS by providing different modes of execution.

ਹਾਰਡਵੇਅਰ ਵੱਖ-ਵੱਖ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਮੋਡ ਪ੍ਰਦਾਨ ਕਰਕੇ OS ਦੀ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ।


The OS uses hardware support to accomplish its work effectively.

ਓਐਸ ਆਪਣੇ ਕੰਮ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਪੂਰਾ ਕਰਨ ਲਈ ਹਾਰਡਵੇਅਰ ਸਹਾਇਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The program is a lifeless thing: it just sits there on the disk.

ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਬੇਜਾਨ ਚੀਜ਼ ਹੈ: ਇਹ ਸਿਰਫ਼ ਡਿਸਕ 'ਤੇ ਪਿਆ ਰਹਿੰਦਾ ਹੈ।


The OS creates this illusion by virtualizing the CPU.

ਓਐਸ ਸੀਪੀਯੂ ਨੂੰ ਵਰਚੁਅਲਾਈਜ਼ ਕਰਕੇ ਇਹ ਭੁਲੇਖਾ ਪੈਦਾ ਕਰਦਾ ਹੈ।


ਕਲਪਨਾ ਕਰੋ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਆੜੂ ਹੈ।


The OS will also likely initialize the stack with arguments.

ਓਐਸ ਆਰਗੂਮੈਂਟਾਂ ਨਾਲ ਸਟੈਕ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਵੀ ਸੰਭਾਵਨਾ ਹੈ।


One good way to build up your own knowledge is to hear as many other perspectives as possible.

ਆਪਣੇ ਗਿਆਨ ਨੂੰ ਵਧਾਉਣ ਦਾ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਹੈ ਕਿ ਵੱਧ ਤੋਂ ਵੱਧ ਹੋਰ ਦ੍ਰਿਸ਼ਟੀਕੋਣਾਂ ਨੂੰ ਸੁਣਿਆ ਜਾਵੇ।


The OS has created a beautiful illusion: it has virtualized the CPU.

ਓਐਸ ਨੇ ਇੱਕ ਸੁੰਦਰ ਭੁਲੇਖਾ ਪੈਦਾ ਕੀਤਾ ਹੈ: ਇਸਨੇ ਸੀਪੀਯੂ ਨੂੰ ਵਰਚੁਅਲਾਈਜ਼ ਕੀਤਾ ਹੈ।


The abstraction provided by the OS of a running program is something we will call a process.

ਇੱਕ ਚੱਲ ਰਹੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਓਐਸ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਐਬਸਟਰੈਕਸ਼ਨ ਉਹ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕਹਾਂਗੇ।


ਸ਼ੁਰੂ ਵਿੱਚ ਹੀਪ ਛੋਟਾ ਹੋਵੇਗਾ।


The OS will need both some low-level machinery as well as some high-level intelligence.

ਓਐਸ ਨੂੰ ਕੁਝ ਘੱਟ-ਪੱਧਰੀ ਮਸ਼ੀਨਰੀ ਦੇ ਨਾਲ-ਨਾਲ ਕੁਝ ਉੱਚ-ਪੱਧਰੀ ਬੁੱਧੀ ਦੀ ਵੀ ਲੋੜ ਹੋਵੇਗੀ।


ਪ੍ਰੋਗਰਾਮ ਆਪਣਾ ਕਾਰਜ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।


The OS is a program, and like any program, it has some key data structures.

ਓਐਸ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਅਤੇ ਕਿਸੇ ਵੀ ਪ੍ਰੋਗਰਾਮ ਵਾਂਗ, ਇਸ ਵਿੱਚ ਕੁਝ ਮੁੱਖ ਡਾਟਾ ਢਾਂਚੇ ਹਨ।


The Manchester Mark I and Atlas: A Historical Perspective.

ਮੈਨਚੈਸਟਰ ਮਾਰਕ I ਅਤੇ ਐਟਲਸ: ਇੱਕ ਇਤਿਹਾਸਕ ਦ੍ਰਿਸ਼ਟੀਕੋਣ।


After all, one good way to build up your own knowledge is to hear as many other perspectives as possible.

ਆਖ਼ਰਕਾਰ, ਆਪਣੇ ਗਿਆਨ ਨੂੰ ਵਧਾਉਣ ਦਾ ਇੱਕ ਵਧੀਆ ਤਰੀਕਾ ਹੈ ਕਿ ਵੱਧ ਤੋਂ ਵੱਧ ਹੋਰ ਦ੍ਰਿਸ਼ਟੀਕੋਣਾਂ ਨੂੰ ਸੁਣਿਆ ਜਾਵੇ।


The OS has now (finally) set the stage for program execution.

ਓਐਸ ਨੇ ਹੁਣ (ਅੰਤ ਵਿੱਚ) ਪ੍ਰੋਗਰਾਮ ਦੇ ਕਾਰਜ ਲਈ ਮੰਚ ਤਿਆਰ ਕਰ ਦਿੱਤਾ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਬੇਜਾਨ ਚੀਜ਼ ਹੈ।


To execute a system call, a program must execute a special trap instruction.

ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਚਲਾਉਣ ਲਈ, ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਟ੍ਰੈਪ ਹਦਾਇਤ ਚਲਾਉਣੀ ਚਾਹੀਦੀ ਹੈ।


Most operating systems provide a few hundred calls.

ਜ਼ਿਆਦਾਤਰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੁਝ ਸੌ ਕਾਲਾਂ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।


The hardware needs to be a bit careful when executing a trap.

ਹਾਰਡਵੇਅਰ ਨੂੰ ਇੱਕ ਟ੍ਰੈਪ ਚਲਾਉਂਦੇ ਸਮੇਂ ਥੋੜਾ ਜਿਹਾ ਸਾਵਧਾਨ ਰਹਿਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


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

ਕਰਨਲ ਨੂੰ ਧਿਆਨ ਨਾਲ ਕੰਟਰੋਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਇੱਕ ਟ੍ਰੈਪ 'ਤੇ ਕਿਹੜਾ ਕੋਡ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ।


The OS informs the hardware of the locations of these trap handlers.

ਓ.ਐੱਸ. ਇਨ੍ਹਾਂ ਟ੍ਰੈਪ ਹੈਂਡਲਰਾਂ ਦੇ ਸਥਾਨਾਂ ਬਾਰੇ ਹਾਰਡਵੇਅਰ ਨੂੰ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।


ਕਰਨਲ ਟ੍ਰੈਪ ਟੇਬਲ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।


Switching between processes should be simple, right?

ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਵਿਚਕਾਰ ਬਦਲਣਾ ਸੌਖਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਠੀਕ?


The OS should just decide to stop one process and start another.

ਓ.ਐੱਸ. ਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਰੋਕਣ ਅਤੇ ਦੂਜੀ ਸ਼ੁਰੂ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


How can the operating system regain control of the CPU so that it can switch between processes?

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸੀ.ਪੀ.ਯੂ. ਦਾ ਕੰਟਰੋਲ ਕਿਵੇਂ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਇਹ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦੇ ਵਿਚਕਾਰ ਬਦਲ ਸਕੇ?


Most processes transfer control of the CPU to the OS quite frequently by making system calls.

ਜ਼ਿਆਦਾਤਰ ਪ੍ਰਕਿਰਿਆਵਾਂ ਸਿਸਟਮ ਕਾਲਾਂ ਕਰਕੇ ਅਕਸਰ ਸੀ.ਪੀ.ਯੂ. ਦਾ ਕੰਟਰੋਲ ਓ.ਐੱਸ. ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕਰਦੀਆਂ ਹਨ।


If an application divides by zero, it will generate a trap to the OS.

ਜੇਕਰ ਕੋਈ ਐਪਲੀਕੇਸ਼ਨ ਜ਼ੀਰੋ ਨਾਲ ਵੰਡਦੀ ਹੈ, ਤਾਂ ਇਹ ਓ.ਐੱਸ. ਨੂੰ ਇੱਕ ਟ੍ਰੈਪ ਤਿਆਰ ਕਰੇਗੀ।


The OS regains control of the CPU by waiting for a system call.

ਓ.ਐੱਸ. ਇੱਕ ਸਿਸਟਮ ਕਾਲ ਦੀ ਉਡੀਕ ਕਰਕੇ ਸੀ.ਪੀ.ਯੂ. ਦਾ ਕੰਟਰੋਲ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।


How can the OS gain control of the CPU even if processes are not being cooperative?

ਓ.ਐੱਸ. ਸੀ.ਪੀ.ਯੂ. ਦਾ ਕੰਟਰੋਲ ਕਿਵੇਂ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ ਭਾਵੇਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਸਹਿਕਾਰੀ ਨਹੀਂ ਹਨ?


A timer device can be programmed to raise an interrupt every so many milliseconds.

ਇੱਕ ਟਾਈਮਰ ਡਿਵਾਈਸ ਨੂੰ ਹਰ ਕੁਝ ਮਿਲੀਸਕਿੰਟਾਂ ਵਿੱਚ ਇੱਕ ਇੰਟਰੱਪਟ ਪੈਦਾ ਕਰਨ ਲਈ ਪ੍ਰੋਗਰਾਮ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


The OS must inform the hardware of which code to run when the timer interrupt occurs.

ਓ.ਐੱਸ. ਨੂੰ ਹਾਰਡਵੇਅਰ ਨੂੰ ਸੂਚਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਟਾਈਮਰ ਇੰਟਰੱਪਟ ਹੋਣ 'ਤੇ ਕਿਹੜਾ ਕੋਡ ਚਲਾਉਣਾ ਹੈ।


The OS can feel safe in that control will eventually be returned to it.

ਓ.ਐੱਸ. ਮਹਿਸੂਸ ਕਰ ਸਕਦਾ ਹੈ ਕਿ ਕੰਟਰੋਲ ਆਖਰਕਾਰ ਇਸਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ।


The OS will execute some low-level assembly code to save the general purpose registers.

ਓ.ਐੱਸ. ਆਮ ਉਦੇਸ਼ ਰਜਿਸਟਰਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਕੁਝ ਘੱਟ-ਪੱਧਰੀ ਅਸੈਂਬਲੀ ਕੋਡ ਚਲਾਏਗਾ।


A context switch is conceptually simple.

ਇੱਕ ਸੰਦਰਭ ਸਵਿੱਚ ਸੰਕਲਪ ਰੂਪ ਵਿੱਚ ਸਧਾਰਨ ਹੈ।


The OS decides to switch from running Process A to Process B.

ਓ.ਐੱਸ. ਪ੍ਰਕਿਰਿਆ A ਤੋਂ ਪ੍ਰਕਿਰਿਆ B 'ਤੇ ਜਾਣ ਦਾ ਫੈਸਲਾ ਕਰਦਾ ਹੈ।


We have described some key low-level mechanisms to implement CPU virtualization.

ਅਸੀਂ ਸੀ.ਪੀ.ਯੂ. ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਕੁਝ ਮੁੱਖ ਘੱਟ-ਪੱਧਰੀ ਵਿਧੀਆਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ।


In this run, when we gave an input value of 100,000, instead of getting a final value of 200,000, we instead first get 143,012.

ਇਸ ਦੌੜ ਵਿੱਚ, ਜਦੋਂ ਅਸੀਂ 100,000 ਦਾ ਇਨਪੁਟ ਮੁੱਲ ਦਿੱਤਾ, 200,000 ਦਾ ਅੰਤਮ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਬਜਾਏ, ਸਾਨੂੰ ਪਹਿਲਾਂ 143,012 ਮਿਲਿਆ।


Then, when we run the program a second time, we not only again get the wrong value, but also a different value than the last time.

ਫਿਰ, ਜਦੋਂ ਅਸੀਂ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਦੂਜੀ ਵਾਰ ਚਲਾਉਂਦੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਨਾ ਸਿਰਫ਼ ਗਲਤ ਮੁੱਲ ਮਿਲਦਾ ਹੈ, ਸਗੋਂ ਪਿਛਲੀ ਵਾਰ ਨਾਲੋਂ ਇੱਕ ਵੱਖਰਾ ਮੁੱਲ ਵੀ ਮਿਲਦਾ ਹੈ।


In fact, if you run the program over and over with high values of loops, you may find that sometimes you even get the right answer!

ਅਸਲ ਵਿੱਚ, ਜੇਕਰ ਤੁਸੀਂ ਲੂਪਸ ਦੇ ਉੱਚ ਮੁੱਲਾਂ ਨਾਲ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਵਾਰ-ਵਾਰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਕਈ ਵਾਰ ਤੁਹਾਨੂੰ ਸਹੀ ਜਵਾਬ ਵੀ ਮਿਲ ਜਾਂਦਾ ਹੈ!


ਇਸ ਲਈ ਇਹ ਕਿਉਂ ਹੋ ਰਿਹਾ ਹੈ?


As it turns out, the reason for these odd and unusual outcomes relate to how instructions are executed, which is one at a time.

ਜਿਵੇਂ ਕਿ ਇਹ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ, ਇਹਨਾਂ ਅਜੀਬ ਅਤੇ ਅਸਧਾਰਨ ਨਤੀਜਿਆਂ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਹਦਾਇਤਾਂ ਨੂੰ ਕਿਵੇਂ ਚਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਹੈ।


Unfortunately, a key part of the program above, where the shared counter is incremented, takes three instructions: one to load the value of the counter from memory into a register, one to increment it, and one to store it back into memory.

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਉਪਰੋਕਤ ਪ੍ਰੋਗਰਾਮ ਦਾ ਇੱਕ ਮੁੱਖ ਹਿੱਸਾ, ਜਿੱਥੇ ਸਾਂਝਾ ਕਾਊਂਟਰ ਵਧਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਿੰਨ ਹਦਾਇਤਾਂ ਲੈਂਦਾ ਹੈ: ਇੱਕ ਕਾਊਂਟਰ ਦੇ ਮੁੱਲ ਨੂੰ ਮੈਮੋਰੀ ਤੋਂ ਇੱਕ ਰਜਿਸਟਰ ਵਿੱਚ ਲੋਡ ਕਰਨ ਲਈ, ਇੱਕ ਇਸਨੂੰ ਵਧਾਉਣ ਲਈ, ਅਤੇ ਇੱਕ ਇਸਨੂੰ ਵਾਪਸ ਮੈਮੋਰੀ ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਲਈ।


Because these three instructions do not execute atomically (all at once), strange things can happen.

ਕਿਉਂਕਿ ਇਹ ਤਿੰਨ ਹਦਾਇਤਾਂ ਪਰਮਾਣੂ ਰੂਪ ਵਿੱਚ (ਇੱਕੋ ਵਾਰ) ਨਹੀਂ ਚੱਲਦੀਆਂ, ਅਜੀਬ ਗੱਲਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ।


It is this problem of concurrency that we will address in great detail in the second part of this book.

ਇਹ ਸਮਕਾਲੀਤਾ ਦੀ ਸਮੱਸਿਆ ਹੈ ਜਿਸਨੂੰ ਅਸੀਂ ਇਸ ਕਿਤਾਬ ਦੇ ਦੂਜੇ ਭਾਗ ਵਿੱਚ ਵਿਸਥਾਰ ਵਿੱਚ ਹੱਲ ਕਰਾਂਗੇ।


The third major theme of the course is persistence.

ਕੋਰਸ ਦਾ ਤੀਜਾ ਮੁੱਖ ਵਿਸ਼ਾ ਸਥਿਰਤਾ ਹੈ।


In system memory, data can be easily lost, as devices such as DRAM store values in a volatile manner; when power goes away or the system crashes, any data in memory is lost.

ਸਿਸਟਮ ਮੈਮੋਰੀ ਵਿੱਚ, ਡਾਟਾ ਆਸਾਨੀ ਨਾਲ ਗੁਆਚ ਸਕਦਾ ਹੈ, ਕਿਉਂਕਿ ਡੀਆਰਏਐਮ ਵਰਗੇ ਉਪਕਰਣ ਅਸਥਿਰ ਤਰੀਕੇ ਨਾਲ ਮੁੱਲਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦੇ ਹਨ; ਜਦੋਂ ਪਾਵਰ ਚਲੀ ਜਾਂਦੀ ਹੈ ਜਾਂ ਸਿਸਟਮ ਕਰੈਸ਼ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਮੈਮੋਰੀ ਵਿੱਚ ਕੋਈ ਵੀ ਡਾਟਾ ਗੁੰਮ ਜਾਂਦਾ ਹੈ।


Thus, we need hardware and software to be able to store data persistently; such storage is thus critical to any system as users care a great deal about their data.

ਇਸ ਤਰ੍ਹਾਂ, ਸਾਨੂੰ ਡਾਟਾ ਨੂੰ ਸਥਾਈ ਤੌਰ 'ਤੇ ਸਟੋਰ ਕਰਨ ਦੇ ਯੋਗ ਹੋਣ ਲਈ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸਾਫਟਵੇਅਰ ਦੀ ਲੋੜ ਹੈ; ਅਜਿਹਾ ਸਟੋਰੇਜ ਇਸ ਤਰ੍ਹਾਂ ਕਿਸੇ ਵੀ ਸਿਸਟਮ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਉਪਭੋਗਤਾ ਆਪਣੇ ਡੇਟਾ ਬਾਰੇ ਬਹੁਤ ਜ਼ਿਆਦਾ ਪਰਵਾਹ ਕਰਦੇ ਹਨ।


The hardware comes in the form of some kind of input/output or I/O device; in modern systems, a hard drive is a common repository for long-lived information, although solid-state drives (SSDs) are making headway in this arena as well.

ਹਾਰਡਵੇਅਰ ਕੁਝ ਕਿਸਮ ਦੇ ਇਨਪੁਟ/ਆਉਟਪੁੱਟ ਜਾਂ I/O ਡਿਵਾਈਸ ਦੇ ਰੂਪ ਵਿੱਚ ਆਉਂਦਾ ਹੈ; ਆਧੁਨਿਕ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ, ਇੱਕ ਹਾਰਡ ਡਰਾਈਵ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੀ ਜਾਣਕਾਰੀ ਲਈ ਇੱਕ ਆਮ ਰਿਪੋਜ਼ਟਰੀ ਹੈ, ਹਾਲਾਂਕਿ ਸਾਲਿਡ-ਸਟੇਟ ਡਰਾਈਵ (SSDs) ਵੀ ਇਸ ਖੇਤਰ ਵਿੱਚ ਅੱਗੇ ਵੱਧ ਰਹੇ ਹਨ।


The software in the operating system that usually manages the disk is called the file system; it is thus responsible for storing any files the user creates in a reliable and efficient manner on the disks of the system.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਸਾਫਟਵੇਅਰ ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਡਿਸਕ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ, ਨੂੰ ਫਾਈਲ ਸਿਸਟਮ ਕਿਹਾ ਜਾਂਦਾ ਹੈ; ਇਸ ਤਰ੍ਹਾਂ ਇਹ ਸਿਸਟਮ ਦੀਆਂ ਡਿਸਕਾਂ 'ਤੇ ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਬਣਾਈਆਂ ਗਈਆਂ ਕਿਸੇ ਵੀ ਫਾਈਲਾਂ ਨੂੰ ਭਰੋਸੇਮੰਦ ਅਤੇ ਕੁਸ਼ਲ ਤਰੀਕੇ ਨਾਲ ਸਟੋਰ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ।


Unlike the abstractions provided by the OS for the CPU and memory, the OS does not create a private, virtualized disk for each application.

CPU ਅਤੇ ਮੈਮੋਰੀ ਲਈ OS ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਐਬਸਟਰੈਕਸ਼ਨਾਂ ਦੇ ਉਲਟ, OS ਹਰੇਕ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਇੱਕ ਨਿੱਜੀ, ਵਰਚੁਅਲਾਈਜ਼ਡ ਡਿਸਕ ਨਹੀਂ ਬਣਾਉਂਦਾ ਹੈ।


Rather, it is assumed that often times, users will want to share information that is in files.

ਇਸ ਦੀ ਬਜਾਏ, ਇਹ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ ਕਿ ਅਕਸਰ, ਉਪਭੋਗਤਾ ਉਹ ਜਾਣਕਾਰੀ ਸਾਂਝੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ ਜੋ ਫਾਈਲਾਂ ਵਿੱਚ ਹੈ।


For example, when writing a C program, you might first use an editor (e.g., Emacs) to create and edit the C file (emacs -nw main.c).

ਉਦਾਹਰਨ ਲਈ, ਜਦੋਂ ਇੱਕ C ਪ੍ਰੋਗਰਾਮ ਲਿਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪਹਿਲਾਂ ਇੱਕ ਸੰਪਾਦਕ (ਜਿਵੇਂ ਕਿ, Emacs) ਦੀ ਵਰਤੋਂ C ਫਾਈਲ (emacs -nw main.c) ਬਣਾਉਣ ਅਤੇ ਸੰਪਾਦਿਤ ਕਰਨ ਲਈ ਕਰ ਸਕਦੇ ਹੋ।


Once done, you might use the compiler to turn the source code into an executable (e.g., gcc -o main main.c).

ਇੱਕ ਵਾਰ ਹੋ ਜਾਣ 'ਤੇ, ਤੁਸੀਂ ਸਰੋਤ ਕੋਡ ਨੂੰ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਵਿੱਚ ਬਦਲਣ ਲਈ ਕੰਪਾਈਲਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ, gcc -o main main.c)।


When you’re finished, you might run the new executable (e.g., ./main).

ਜਦੋਂ ਤੁਸੀਂ ਪੂਰਾ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਨਵੇਂ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਨੂੰ ਚਲਾ ਸਕਦੇ ਹੋ (ਜਿਵੇਂ ਕਿ, ./main)।


Thus, you can see how files are shared across different processes.

ਇਸ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਵੱਖ-ਵੱਖ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਫਾਈਲਾਂ ਨੂੰ ਕਿਵੇਂ ਸਾਂਝਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The file system is the part of the OS in charge of managing persistent data.

ਫਾਈਲ ਸਿਸਟਮ OS ਦਾ ਉਹ ਹਿੱਸਾ ਹੈ ਜੋ ਸਥਾਈ ਡੇਟਾ ਦੇ ਪ੍ਰਬੰਧਨ ਦਾ ਇੰਚਾਰਜ ਹੁੰਦਾ ਹੈ।


The operating system manages computer hardware and software resources.

ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸਾਫਟਵੇਅਰ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


Please download the software from the official website.

ਕਿਰਪਾ ਕਰਕੇ ਅਧਿਕਾਰਤ ਵੈੱਬਸਾਈਟ ਤੋਂ ਸਾਫਟਵੇਅਰ ਡਾਊਨਲੋਡ ਕਰੋ।


The system call allows a program to request a service from the kernel.

ਸਿਸਟਮ ਕਾਲ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਕਰਨਲ ਤੋਂ ਇੱਕ ਸੇਵਾ ਦੀ ਬੇਨਤੀ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।


Context switching is essential for multitasking in an operating system.

ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਮਲਟੀਟਾਸਕਿੰਗ ਲਈ ਸੰਦਰਭ ਸਵਿਚਿੰਗ ਜ਼ਰੂਰੀ ਹੈ।


The scheduler determines which process gets access to the CPU.

ਸ਼ਡਿਊਲਰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ CPU ਤੱਕ ਪਹੁੰਚ ਮਿਲਦੀ ਹੈ।


I am reading a book about operating systems.

ਮੈਂ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਬਾਰੇ ਇੱਕ ਕਿਤਾਬ ਪੜ੍ਹ ਰਿਹਾ ਹਾਂ।


The conference will discuss the latest advancements in computer science.

ਕਾਨਫਰੰਸ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਵਿੱਚ ਨਵੀਨਤਮ ਤਰੱਕੀ 'ਤੇ ਚਰਚਾ ਕਰੇਗੀ।


Can you explain the concept of virtual memory?

ਕੀ ਤੁਸੀਂ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੀ ਧਾਰਨਾ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦੇ ਹੋ?


The professor gave a lecture on process synchronization.

ਪ੍ਰੋਫੈਸਰ ਨੇ ਪ੍ਰਕਿਰਿਆ ਸਿੰਕ੍ਰੋਨਾਈਜ਼ੇਸ਼ਨ 'ਤੇ ਇੱਕ ਲੈਕਚਰ ਦਿੱਤਾ।


The operating system's kernel is the core of the system.

ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦਾ ਕਰਨਲ ਸਿਸਟਮ ਦਾ ਕੋਰ ਹੈ।


The user interface should be intuitive and easy to use.

ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਅਨੁਭਵੀ ਅਤੇ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।


The system crashed due to a memory leak.

ਮੈਮੋਰੀ ਲੀਕ ਹੋਣ ਕਾਰਨ ਸਿਸਟਮ ਕਰੈਸ਼ ਹੋ ਗਿਆ।


The company is developing a new operating system.

ਕੰਪਨੀ ਇੱਕ ਨਵਾਂ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿਕਸਤ ਕਰ ਰਹੀ ਹੈ।


The performance of the system is critical for its success.

ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਇਸਦੀ ਸਫਲਤਾ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The research paper explores different scheduling algorithms.

ਖੋਜ ਪੇਪਰ ਵੱਖ-ਵੱਖ ਸ਼ਡਿਊਲਿੰਗ ਐਲਗੋਰਿਦਮ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ।


Understanding the intricacies of operating systems is crucial for software developers.

ਸਾਫਟਵੇਅਰ ਡਿਵੈਲਪਰਾਂ ਲਈ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀਆਂ ਗੁੰਝਲਾਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ।


The design of the file system impacts the overall system performance.

ਫਾਈਲ ਸਿਸਟਮ ਦਾ ਡਿਜ਼ਾਈਨ ਸਮੁੱਚੀ ਸਿਸਟਮ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।


The security of the operating system is paramount to protect user data.

ਉਪਭੋਗਤਾ ਡੇਟਾ ਦੀ ਸੁਰੱਖਿਆ ਲਈ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੀ ਸੁਰੱਖਿਆ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The implementation of a real-time operating system requires careful consideration of timing constraints.

ਇੱਕ ਰੀਅਲ-ਟਾਈਮ ਆਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਮਾਂ ਪਾਬੰਦੀਆਂ 'ਤੇ ਧਿਆਨ ਨਾਲ ਵਿਚਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


The study analyzes the impact of different scheduling policies on system throughput and response time.

ਅਧਿਐਨ ਸਿਸਟਮ ਥ੍ਰੂਪੁੱਟ ਅਤੇ ਜਵਾਬ ਦੇ ਸਮੇਂ 'ਤੇ ਵੱਖ-ਵੱਖ ਸ਼ਡਿਊਲਿੰਗ ਨੀਤੀਆਂ ਦੇ ਪ੍ਰਭਾਵ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦਾ ਹੈ।


The scheduler decides which process gets to use the CPU.

ਸਕੈਡਿਊਲਰ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜਾ ਪ੍ਰੋਸੈਸਰ CPU ਦੀ ਵਰਤੋਂ ਕਰੇਗਾ।


Overlapping operations can maximize system utilization.

ਓਵਰਲੈਪਿੰਗ ਓਪਰੇਸ਼ਨ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਨੂੰ ਵੱਧ ਤੋਂ ਵੱਧ ਕਰ ਸਕਦੇ ਹਨ।


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

ਆਮ ਤੌਰ 'ਤੇ, OS ਨੂੰ ਹਰੇਕ ਕੰਮ ਦੀ ਲੰਬਾਈ ਬਾਰੇ ਬਹੁਤ ਘੱਟ ਪਤਾ ਹੁੰਦਾ ਹੈ।


The scheduler incorporates I/O to ensure interactive processes run frequently.

ਸਕੈਡਿਊਲਰ ਇਹ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ I/O ਨੂੰ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ ਕਿ ਇੰਟਰਐਕਟਿਵ ਪ੍ਰਕਿਰਿਆਵਾਂ ਅਕਸਰ ਚੱਲਦੀਆਂ ਹਨ।


The multi-level feedback queue is a well-known approach to scheduling.

ਮਲਟੀ-ਲੈਵਲ ਫੀਡਬੈਕ ਕਤਾਰ ਸਕੈਡਿਊਲਿੰਗ ਦਾ ਇੱਕ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਤਰੀਕਾ ਹੈ।


MLFQ ਟਰਨਅਰਾਊਂਡ ਸਮੇਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।


The OS doesn't generally know how long a job will run for.

ਆਮ ਤੌਰ 'ਤੇ, OS ਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਹੁੰਦਾ ਕਿ ਕੋਈ ਕੰਮ ਕਿੰਨਾ ਸਮਾਂ ਚੱਲੇਗਾ।


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

MLFQ ਇੱਕ ਸਿਸਟਮ ਨੂੰ ਇੰਟਰਐਕਟਿਵ ਉਪਭੋਗਤਾਵਾਂ ਲਈ ਜਵਾਬਦੇਹ ਮਹਿਸੂਸ ਕਰਵਾਉਣਾ ਚਾਹੁੰਦਾ ਹੈ।


The scheduler learns the characteristics of the jobs it is running.

ਸਕੈਡਿਊਲਰ ਉਹਨਾਂ ਕੰਮਾਂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਿੱਖਦਾ ਹੈ ਜੋ ਇਹ ਚਲਾ ਰਿਹਾ ਹੈ।


MLFQ varies the priority of a job based on its observed behavior.

MLFQ ਇੱਕ ਕੰਮ ਦੀ ਤਰਜੀਹ ਨੂੰ ਇਸਦੇ ਦੇਖੇ ਗਏ ਵਿਵਹਾਰ ਦੇ ਅਧਾਰ 'ਤੇ ਬਦਲਦਾ ਹੈ।


If a job uses up an entire time slice, its priority is reduced.

ਜੇਕਰ ਕੋਈ ਕੰਮ ਪੂਰੇ ਟਾਈਮ ਸਲਾਈਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਤਾਂ ਇਸਦੀ ਤਰਜੀਹ ਘਟਾ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।


If a job gives up the CPU before the time slice is up, it stays at the same priority level.

ਜੇਕਰ ਕੋਈ ਕੰਮ ਟਾਈਮ ਸਲਾਈਸ ਖਤਮ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ CPU ਛੱਡ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਉਸੇ ਤਰਜੀਹ ਪੱਧਰ 'ਤੇ ਰਹਿੰਦਾ ਹੈ।


ਇਸ ਨਿਯਮ ਦਾ ਇਰਾਦਾ ਸਧਾਰਨ ਹੈ।


Gaming the scheduler refers to tricking the scheduler.

ਸਕੈਡਿਊਲਰ ਨੂੰ ਗੇਮਿੰਗ ਕਰਨ ਦਾ ਮਤਲਬ ਹੈ ਸਕੈਡਿਊਲਰ ਨੂੰ ਧੋਖਾ ਦੇਣਾ।


A program may change its behavior over time.

ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਸਮੇਂ ਦੇ ਨਾਲ ਆਪਣਾ ਵਿਵਹਾਰ ਬਦਲ ਸਕਦਾ ਹੈ।


ਸਾਨੂੰ ਭੁੱਖਮਰੀ ਨੂੰ ਰੋਕਣ ਦੀ ਲੋੜ ਹੈ।


The priority boost solves two problems at once.

ਤਰਜੀਹ ਵਾਧਾ ਇੱਕੋ ਸਮੇਂ ਦੋ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ।


The addition of the time period S leads to the obvious question.

ਸਮੇਂ ਦੀ ਮਿਆਦ S ਦੇ ਜੋੜ ਨਾਲ ਸਪੱਸ਼ਟ ਸਵਾਲ ਪੈਦਾ ਹੁੰਦਾ ਹੈ।


The scheduler should keep track of CPU time.

ਸਕੈਡਿਊਲਰ ਨੂੰ CPU ਸਮੇਂ ਦਾ ਧਿਆਨ ਰੱਖਣਾ ਚਾਹੀਦਾ ਹੈ।


MLFQ variants allow for varying time-slice length.

MLFQ ਰੂਪ ਵੱਖ-ਵੱਖ ਟਾਈਮ-ਸਲਾਈਸ ਲੰਬਾਈ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ।


The operating system manages computer hardware and software resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸਾਫਟਵੇਅਰ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


Please provide more details about the problem.

ਕਿਰਪਾ ਕਰਕੇ ਸਮੱਸਿਆ ਬਾਰੇ ਹੋਰ ਵੇਰਵੇ ਪ੍ਰਦਾਨ ਕਰੋ।


The scheduler determines which process gets the CPU.

ਸ਼ਡਿਊਲਰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਪ੍ਰਕਿਰਿਆ CPU ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ।


The news reported a significant increase in unemployment.

ਖ਼ਬਰਾਂ ਵਿੱਚ ਬੇਰੁਜ਼ਗਾਰੀ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਵਾਧੇ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


I need to install the latest version of the software.

ਮੈਨੂੰ ਸੌਫਟਵੇਅਰ ਦਾ ਨਵੀਨਤਮ ਸੰਸਕਰਣ ਸਥਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


The company announced a new product launch next month.

ਕੰਪਨੀ ਨੇ ਅਗਲੇ ਮਹੀਨੇ ਇੱਕ ਨਵੇਂ ਉਤਪਾਦ ਲਾਂਚ ਦੀ ਘੋਸ਼ਣਾ ਕੀਤੀ।


The MLFQ algorithm uses multiple queues and feedback.

MLFQ ਐਲਗੋਰਿਦਮ ਕਈ ਕਤਾਰਾਂ ਅਤੇ ਫੀਡਬੈਕ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Can you explain the concept of proportional-share scheduling?

ਕੀ ਤੁਸੀਂ ਅਨੁਪਾਤਕ-ਸ਼ੇਅਰ ਸ਼ਡਿਊਲਿੰਗ ਦੀ ਧਾਰਨਾ ਨੂੰ ਸਮਝਾ ਸਕਦੇ ਹੋ?


The government is implementing new policies to boost the economy.

ਸਰਕਾਰ ਅਰਥਵਿਵਸਥਾ ਨੂੰ ਹੁਲਾਰਾ ਦੇਣ ਲਈ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ।


The lottery scheduling algorithm uses randomness to allocate CPU time.

ਲਾਟਰੀ ਸ਼ਡਿਊਲਿੰਗ ਐਲਗੋਰਿਦਮ CPU ਸਮਾਂ ਅਲਾਟ ਕਰਨ ਲਈ ਬੇਤਰਤੀਬਤਾ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The details of the implementation are quite complex.

ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦੇ ਵੇਰਵੇ ਕਾਫ਼ੀ ਗੁੰਝਲਦਾਰ ਹਨ।


The stock market experienced a sudden downturn.

ਸ਼ੇਅਰ ਬਾਜ਼ਾਰ ਵਿੱਚ ਅਚਾਨਕ ਗਿਰਾਵਟ ਆਈ।


The professor explained the nuances of the algorithm.

ਪ੍ਰੋਫੈਸਰ ਨੇ ਐਲਗੋਰਿਦਮ ਦੀਆਂ ਬਾਰੀਕੀਆਂ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ।


The company's profits increased significantly this quarter.

ਕੰਪਨੀ ਦਾ ਮੁਨਾਫਾ ਇਸ ਤਿਮਾਹੀ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਵਧਿਆ।


The system administrator needs to optimize the performance.

ਸਿਸਟਮ ਪ੍ਰਸ਼ਾਸਕ ਨੂੰ ਪ੍ਰਦਰਸ਼ਨ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ।


The research paper explores the challenges of multi-level feedback queues.

ਖੋਜ ਪੇਪਰ ਮਲਟੀ-ਲੈਵਲ ਫੀਡਬੈਕ ਕਤਾਰਾਂ ਦੀਆਂ ਚੁਣੌਤੀਆਂ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ।


The economic forecast predicts a period of slow growth.

ਆਰਥਿਕ ਪੂਰਵ ਅਨੁਮਾਨ ਹੌਲੀ ਵਿਕਾਸ ਦੀ ਮਿਆਦ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ।


The algorithm's efficiency depends on the input data.

ਐਲਗੋਰਿਦਮ ਦੀ ਕੁਸ਼ਲਤਾ ਇਨਪੁਟ ਡੇਟਾ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।


The government is taking measures to address climate change.

ਸਰਕਾਰ ਜਲਵਾਯੂ ਪਰਿਵਰਤਨ ਨਾਲ ਨਜਿੱਠਣ ਲਈ ਉਪਾਅ ਕਰ ਰਹੀ ਹੈ।


The complexity of the system requires careful consideration.

ਸਿਸਟਮ ਦੀ ਗੁੰਝਲਤਾ ਲਈ ਧਿਆਨ ਨਾਲ ਵਿਚਾਰ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


ਇਹ ਪੇਪਰ ਲਾਟਰੀ ਸ਼ਡਿਊਲਿੰਗ ਬਾਰੇ ਚਰਚਾ ਕਰਦਾ ਹੈ।


Lottery scheduling is a simple randomized algorithm.

ਲਾਟਰੀ ਸ਼ਡਿਊਲਿੰਗ ਇੱਕ ਸਧਾਰਨ ਰੈਂਡਮਾਈਜ਼ਡ ਐਲਗੋਰਿਦਮ ਹੈ।


This thesis outlines lottery and stride scheduling.

ਇਹ ਥੀਸਿਸ ਲਾਟਰੀ ਅਤੇ ਸਟ੍ਰਾਈਡ ਸ਼ਡਿਊਲਿੰਗ ਦਾ ਵਰਣਨ ਕਰਦੀ ਹੈ।


The paper is about memory resource management.

ਇਹ ਪੇਪਰ ਮੈਮੋਰੀ ਸਰੋਤ ਪ੍ਰਬੰਧਨ ਬਾਰੇ ਹੈ।


This program allows you to see how a lottery scheduler works.

ਇਹ ਪ੍ਰੋਗਰਾਮ ਤੁਹਾਨੂੰ ਦੇਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ ਕਿ ਲਾਟਰੀ ਸ਼ਡਿਊਲਰ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।


Compute the solutions for simulations with 3 jobs.

3 ਕੰਮਾਂ ਦੇ ਨਾਲ ਸਿਮੂਲੇਸ਼ਨਾਂ ਲਈ ਹੱਲ ਕੱਢੋ।


What happens when the number of tickets is so imbalanced?

ਜਦੋਂ ਟਿਕਟਾਂ ਦੀ ਗਿਣਤੀ ਇੰਨੀ ਅਸੰਤੁਲਿਤ ਹੁੰਦੀ ਹੈ ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?


Multi-threaded applications can spread work across multiple CPUs.

ਮਲਟੀ-ਥ੍ਰੈਡਡ ਐਪਲੀਕੇਸ਼ਨ ਕਈ CPU ਵਿੱਚ ਕੰਮ ਵੰਡ ਸਕਦੀਆਂ ਹਨ।


Multiprocessor systems are increasingly commonplace.

ਮਲਟੀਪ੍ਰੋਸੈਸਰ ਸਿਸਟਮ ਵੱਧ ਤੋਂ ਵੱਧ ਆਮ ਹੁੰਦੇ ਜਾ ਰਹੇ ਹਨ।


This chapter will introduce the basics of multiprocessor scheduling.

ਇਹ ਅਧਿਆਇ ਮਲਟੀਪ੍ਰੋਸੈਸਰ ਸ਼ਡਿਊਲਿੰਗ ਦੀਆਂ ਮੁਢਲੀਆਂ ਗੱਲਾਂ ਪੇਸ਼ ਕਰੇਗਾ।


How should the OS schedule jobs on multiple CPUs?

OS ਨੂੰ ਕਈ 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.

ਇਸ ਆਮ ਸਮੱਸਿਆ ਨੂੰ ਕੈਸ਼ ਕੋਹਰੈਂਸ ਦੀ ਸਮੱਸਿਆ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


Do programs have to worry about anything when they access shared data?

ਕੀ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਸਾਂਝੇ ਕੀਤੇ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਵੇਲੇ ਕਿਸੇ ਵੀ ਚੀਜ਼ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨੀ ਪੈਂਦੀ ਹੈ?


Mutual exclusion primitives should likely be used.

ਪਰਸਪਰ ਨਿਵੇਕਲੇ ਪ੍ਰਾਇਮਿਟਿਵਜ਼ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।


A multiprocessor scheduler should consider cache affinity.

ਇੱਕ ਮਲਟੀਪ੍ਰੋਸੈਸਰ ਸ਼ਡਿਊਲਰ ਨੂੰ ਕੈਸ਼ ਅਫਿਨਿਟੀ 'ਤੇ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


SQMS ਦੀਆਂ ਸਪੱਸ਼ਟ ਕਮੀਆਂ ਹਨ।


ਸਤ ਸ੍ਰੀ ਅਕਾਲ, ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?


ਅੱਜ ਮੌਸਮ ਬਹੁਤ ਸੋਹਣਾ ਹੈ।


ਮੈਂ ਬਾਜ਼ਾਰ ਜਾ ਰਿਹਾ ਹਾਂ।


ਕਿਰਪਾ ਕਰਕੇ ਮੈਨੂੰ ਨਮਕ ਦਿਓ।


ਤੁਹਾਡਾ ਨਾਮ ਕੀ ਹੈ?


The company's profits increased significantly this quarter.

ਕੰਪਨੀ ਦਾ ਲਾਭ ਇਸ ਤਿਮਾਹੀ ਵਿੱਚ ਕਾਫ਼ੀ ਵਧਿਆ ਹੈ।


The government announced new economic policies.

ਸਰਕਾਰ ਨੇ ਨਵੀਂ ਆਰਥਿਕ ਨੀਤੀਆਂ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The research team is working on a new vaccine.

ਖੋਜ ਟੀਮ ਇੱਕ ਨਵੀਂ ਵੈਕਸੀਨ 'ਤੇ ਕੰਮ ਕਰ ਰਹੀ ਹੈ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


The CPU scheduling algorithm is complex.

CPU ਸ਼ਡਿਊਲਿੰਗ ਐਲਗੋਰਿਦਮ ਗੁੰਝਲਦਾਰ ਹੈ।


Despite the challenges, the project was completed on time.

ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਪ੍ਰੋਜੈਕਟ ਸਮੇਂ ਸਿਰ ਪੂਰਾ ਹੋ ਗਿਆ।


The implications of the new technology are far-reaching.

ਨਵੀਂ ਤਕਨਾਲੋਜੀ ਦੇ ਪ੍ਰਭਾਵ ਦੂਰ ਤੱਕ ਫੈਲੇ ਹੋਏ ਹਨ।


The philosophical underpinnings of the theory are debated.

ਸਿਧਾਂਤ ਦੀਆਂ ਦਾਰਸ਼ਨਿਕ ਬੁਨਿਆਦਾਂ 'ਤੇ ਬਹਿਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


The intricacies of the legal system are often misunderstood.

ਕਾਨੂੰਨੀ ਪ੍ਰਣਾਲੀ ਦੀਆਂ ਗੁੰਝਲਾਂ ਨੂੰ ਅਕਸਰ ਗਲਤ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ।


The company's strategic plan involves significant restructuring.

ਕੰਪਨੀ ਦੀ ਰਣਨੀਤਕ ਯੋਜਨਾ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਪੁਨਰਗਠਨ ਸ਼ਾਮਲ ਹੈ।


The quantum entanglement phenomenon remains a mystery.

ਕੁਆਂਟਮ ਉਲਝਣ ਦੀ ਘਟਨਾ ਇੱਕ ਰਹੱਸ ਬਣੀ ਹੋਈ ਹੈ।


The OS virtualizes memory, providing an illusion of a large address space.

ਓਐਸ ਮੈਮੋਰੀ ਨੂੰ ਵਰਚੁਅਲਾਈਜ਼ ਕਰਦਾ ਹੈ, ਇੱਕ ਵੱਡੇ ਐਡਰੈੱਸ ਸਪੇਸ ਦਾ ਭੁਲੇਖਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


The principle of isolation is key in building reliable systems.

ਭਰੋਸੇਯੋਗ ਸਿਸਟਮ ਬਣਾਉਣ ਵਿੱਚ ਅਲੱਗ-ਥਲੱਗਤਾ ਦਾ ਸਿਧਾਂਤ ਮੁੱਖ ਹੈ।


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

ਓਐਸ ਨੂੰ ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਨੂੰ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਕੁਸ਼ਲ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ।


The program's code resides at the top of the address space.

ਪ੍ਰੋਗਰਾਮ ਦਾ ਕੋਡ ਐਡਰੈੱਸ ਸਪੇਸ ਦੇ ਸਿਖਰ 'ਤੇ ਰਹਿੰਦਾ ਹੈ।


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

ਯੂਨਿਕਸ/ਸੀ ਪ੍ਰੋਗਰਾਮਾਂ ਵਿੱਚ, ਮੈਮੋਰੀ ਨੂੰ ਕਿਵੇਂ ਅਲਾਟ ਕਰਨਾ ਅਤੇ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ ਹੈ, ਇਸ ਨੂੰ ਸਮਝਣਾ ਮਜ਼ਬੂਤ ਅਤੇ ਭਰੋਸੇਮੰਦ ਸਾਫਟਵੇਅਰ ਬਣਾਉਣ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ।


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.

ਇਹ ਲੰਬੇ ਸਮੇਂ ਤੱਕ ਚੱਲਣ ਵਾਲੀ ਮੈਮੋਰੀ ਦੀ ਲੋੜ ਹੈ ਜੋ ਸਾਨੂੰ ਦੂਜੀ ਕਿਸਮ ਦੀ ਮੈਮੋਰੀ, ਜਿਸਨੂੰ ਹੀਪ ਮੈਮੋਰੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਵੱਲ ਲੈ ਜਾਂਦੀ ਹੈ।


A heavy responsibility, no doubt! And certainly the cause of many bugs.

ਇੱਕ ਵੱਡੀ ਜ਼ਿੰਮੇਵਾਰੀ, ਕੋਈ ਸ਼ੱਕ ਨਹੀਂ! ਅਤੇ ਬੇਸ਼ੱਕ ਬਹੁਤ ਸਾਰੇ ਬੱਗਾਂ ਦਾ ਕਾਰਨ।


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.

ਪਹਿਲਾਂ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਇਸ ਲਾਈਨ 'ਤੇ ਸਟੈਕ ਅਤੇ ਹੀਪ ਅਲਾਟਮੈਂਟ ਦੋਵੇਂ ਹੁੰਦੇ ਹਨ।


The programmer further helps out by using what is called a cast.

ਪ੍ਰੋਗਰਾਮਰ ਅੱਗੇ ਇੱਕ ਕਾਸਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਦਦ ਕਰਦਾ ਹੈ।


As it turns out, allocating memory is the easy part of the equation.

ਜਿਵੇਂ ਕਿ ਇਹ ਸਾਹਮਣੇ ਆਉਂਦਾ ਹੈ, ਮੈਮੋਰੀ ਅਲਾਟ ਕਰਨਾ ਸਮੀਕਰਨ ਦਾ ਆਸਾਨ ਹਿੱਸਾ ਹੈ।


Forgetting To Allocate Memory is a common error.

ਮੈਮੋਰੀ ਅਲਾਟ ਕਰਨਾ ਭੁੱਲਣਾ ਇੱਕ ਆਮ ਗਲਤੀ ਹੈ।


When you run this code, it will likely lead to a segmentation fault.

ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਕੋਡ ਨੂੰ ਚਲਾਉਂਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਇੱਕ ਸੈਗਮੈਂਟੇਸ਼ਨ ਫਾਲਟ ਵੱਲ ਲੈ ਜਾਵੇਗਾ।


Just because a program compiled(!) or even ran once or many times correctly does not mean the program is correct.

ਇਸ ਤੱਥ ਦੇ ਕਾਰਨ ਕਿ ਇੱਕ ਪ੍ਰੋਗਰਾਮ ਨੇ ਕੰਪਾਇਲ ਕੀਤਾ (!) ਜਾਂ ਇੱਕ ਵਾਰ ਜਾਂ ਕਈ ਵਾਰ ਸਹੀ ਢੰਗ ਨਾਲ ਚਲਾਇਆ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਸਹੀ ਹੈ।


A related error is not allocating enough memory, sometimes called a buffer overflow.

ਇੱਕ ਸੰਬੰਧਿਤ ਗਲਤੀ ਲੋੜੀਂਦੀ ਮੈਮੋਰੀ ਅਲਾਟ ਨਾ ਕਰਨਾ ਹੈ, ਜਿਸਨੂੰ ਕਈ ਵਾਰ ਇੱਕ ਬਫਰ ਓਵਰਫਲੋ ਕਿਹਾ ਜਾਂਦਾ ਹੈ।


In some cases, when the string copy executes, it writes one byte too far past the end of the allocated space.

ਕੁਝ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਜਦੋਂ ਸਟ੍ਰਿੰਗ ਕਾਪੀ ਚੱਲਦੀ ਹੈ, ਤਾਂ ਇਹ ਅਲਾਟ ਕੀਤੀ ਜਗ੍ਹਾ ਦੇ ਅੰਤ ਤੋਂ ਇੱਕ ਬਾਈਟ ਬਹੁਤ ਦੂਰ ਲਿਖਦੀ ਹੈ।


Forgetting to Initialize Allocated Memory is another common error.

ਅਲਾਟ ਕੀਤੀ ਮੈਮੋਰੀ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਭੁੱਲਣਾ ਇੱਕ ਹੋਰ ਆਮ ਗਲਤੀ ਹੈ।


Forgetting To Free Memory is another common error known as a memory leak.

ਮੈਮੋਰੀ ਨੂੰ ਫ੍ਰੀ ਕਰਨਾ ਭੁੱਲਣਾ ਇੱਕ ਹੋਰ ਆਮ ਗਲਤੀ ਹੈ ਜਿਸਨੂੰ ਮੈਮੋਰੀ ਲੀਕ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ।


Calling free() Incorrectly is another problem.

free() ਨੂੰ ਗਲਤ ਤਰੀਕੇ ਨਾਲ ਕਾਲ ਕਰਨਾ ਇੱਕ ਹੋਰ ਸਮੱਸਿਆ ਹੈ।


With address translation, the hardware transforms each memory access.

ਐਡਰੈੱਸ ਅਨੁਵਾਦ ਦੇ ਨਾਲ, ਹਾਰਡਵੇਅਰ ਹਰੇਕ ਮੈਮੋਰੀ ਐਕਸੈਸ ਨੂੰ ਬਦਲਦਾ ਹੈ।


Efficiency and control together are two of the main goals of any modern operating system.

ਕੁਸ਼ਲਤਾ ਅਤੇ ਨਿਯੰਤਰਣ ਇਕੱਠੇ ਕਿਸੇ ਵੀ ਆਧੁਨਿਕ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਦੋ ਮੁੱਖ ਟੀਚੇ ਹਨ।


How can we build an efficient virtualization of memory?

ਅਸੀਂ ਮੈਮੋਰੀ ਦਾ ਇੱਕ ਕੁਸ਼ਲ ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਕਿਵੇਂ ਬਣਾ ਸਕਦੇ ਹਾਂ?


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

ਓਐਸ ਨੂੰ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਇਹ ਧਿਆਨ ਰੱਖਦੇ ਹੋਏ ਕਿ ਕਿਹੜੀਆਂ ਥਾਵਾਂ ਖਾਲੀ ਹਨ ਅਤੇ ਕਿਹੜੀਆਂ ਵਰਤੋਂ ਵਿੱਚ ਹਨ।


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

ਵਰਚੁਅਲਾਈਜੇਸ਼ਨ ਰਾਹੀਂ, ਓਐਸ ਭੱਦੀ ਮਸ਼ੀਨ ਹਕੀਕਤ ਨੂੰ ਅਜਿਹੀ ਚੀਜ਼ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜੋ ਇੱਕ ਉਪਯੋਗੀ, ਸ਼ਕਤੀਸ਼ਾਲੀ, ਅਤੇ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨ ਐਬਸਟਰੈਕਸ਼ਨ ਹੈ।


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

ਅਸੀਂ ਹੁਣ ਲਈ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਉਪਭੋਗਤਾ ਦੀ ਐਡਰੈੱਸ ਸਪੇਸ ਨੂੰ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵਿੱਚ ਲਗਾਤਾਰ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


Don’t worry if these assumptions sound unrealistic; we will relax them as we go.

ਚਿੰਤਾ ਨਾ ਕਰੋ ਜੇਕਰ ਇਹ ਧਾਰਨਾਵਾਂ ਅਵਾਸਤਵਿਕ ਲੱਗਦੀਆਂ ਹਨ; ਅਸੀਂ ਜਿਵੇਂ-ਜਿਵੇਂ ਅੱਗੇ ਵਧਾਂਗੇ, ਉਨ੍ਹਾਂ ਨੂੰ ਢਿੱਲਾ ਕਰਾਂਗੇ।


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

ਐਡਰੈੱਸ ਅਨੁਵਾਦ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਸਾਨੂੰ ਕੀ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਇਸ ਨੂੰ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਸਮਝਣ ਲਈ, ਆਓ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਵੇਖੀਏ।


Imagine there is a process whose address space as indicated in Figure 15.1.

ਕਲਪਨਾ ਕਰੋ ਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸਦੀ ਐਡਰੈੱਸ ਸਪੇਸ ਚਿੱਤਰ 15.1 ਵਿੱਚ ਦਰਸਾਈ ਗਈ ਹੈ।


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 and grows to a maximum of 16 KB.

ਪ੍ਰੋਗਰਾਮ ਦੇ ਦ੍ਰਿਸ਼ਟੀਕੋਣ ਤੋਂ, ਇਸਦੀ ਐਡਰੈੱਸ ਸਪੇਸ ਐਡਰੈੱਸ 0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ 16 KB ਤੱਕ ਵਧਦੀ ਹੈ।


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

ਅਸੀਂ ਇਸ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਇਸ ਤਰੀਕੇ ਨਾਲ ਕਿਵੇਂ ਮੁੜ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਪ੍ਰਕਿਰਿਆ ਲਈ ਪਾਰਦਰਸ਼ੀ ਹੋਵੇ?


An example of what physical memory might look like once this process’s address space has been placed in memory is found in Figure 15.2.

ਇਸ ਪ੍ਰਕਿਰਿਆ ਦੀ ਐਡਰੈੱਸ ਸਪੇਸ ਦੇ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖੇ ਜਾਣ ਤੋਂ ਬਾਅਦ ਭੌਤਿਕ ਮੈਮੋਰੀ ਕਿਹੋ ਜਿਹੀ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈ, ਇਸਦੀ ਇੱਕ ਉਦਾਹਰਣ ਚਿੱਤਰ 15.2 ਵਿੱਚ ਮਿਲਦੀ ਹੈ।


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

ਚਿੱਤਰ ਵਿੱਚ, ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਓਐਸ ਆਪਣੇ ਲਈ ਭੌਤਿਕ ਮੈਮੋਰੀ ਦੇ ਪਹਿਲੇ ਸਲਾਟ ਦੀ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹੈ।


To gain some understanding of hardware-based address translation, we’ll first discuss its first incarnation.

ਹਾਰਡਵੇਅਰ-ਅਧਾਰਿਤ ਐਡਰੈੱਸ ਅਨੁਵਾਦ ਦੀ ਕੁਝ ਸਮਝ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, ਅਸੀਂ ਪਹਿਲਾਂ ਇਸਦੇ ਪਹਿਲੇ ਰੂਪ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ।


Specifically, we’ll need two hardware registers within each CPU.

ਖਾਸ ਤੌਰ 'ਤੇ, ਸਾਨੂੰ ਹਰੇਕ CPU ਦੇ ਅੰਦਰ ਦੋ ਹਾਰਡਵੇਅਰ ਰਜਿਸਟਰਾਂ ਦੀ ਲੋੜ ਪਵੇਗੀ।


This base-and-bounds pair is going to allow us to place the address space anywhere we’d like in physical memory.

ਇਹ ਬੇਸ-ਅਤੇ-ਬਾਉਂਡਸ ਜੋੜਾ ਸਾਨੂੰ ਐਡਰੈੱਸ ਸਪੇਸ ਨੂੰ ਭੌਤਿਕ ਮੈਮੋਰੀ ਵਿੱਚ ਕਿਤੇ ਵੀ ਰੱਖਣ ਦੀ ਆਗਿਆ ਦੇਵੇਗਾ।


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 OS must take action when a process is created, finding space for its address space in memory.

ਓਐਸ ਨੂੰ ਕਾਰਵਾਈ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਬਣਾਈ ਜਾਂਦੀ ਹੈ, ਮੈਮੋਰੀ ਵਿੱਚ ਇਸਦੀ ਐਡਰੈੱਸ ਸਪੇਸ ਲਈ ਥਾਂ ਲੱਭਦੀ ਹੈ।


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

ਓਐਸ ਨੂੰ ਉਦੋਂ ਵੀ ਕਾਰਵਾਈ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜਦੋਂ ਇੱਕ ਸੰਦਰਭ ਸਵਿੱਚ ਹੁੰਦਾ ਹੈ।


The total amount of free space exceeds the size of the request.

ਕੁੱਲ ਖਾਲੀ ਥਾਂ ਦੀ ਮਾਤਰਾ ਬੇਨਤੀ ਦੇ ਆਕਾਰ ਤੋਂ ਵੱਧ ਹੈ।


The figure shows an example of this problem.

ਇਹ ਅੰਕੜਾ ਇਸ ਸਮੱਸਿਆ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਦਰਸਾਉਂਦਾ ਹੈ।


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

ਇਸ ਮਾਮਲੇ ਵਿੱਚ, ਉਪਲਬਧ ਕੁੱਲ ਖਾਲੀ ਥਾਂ 20 ਬਾਈਟ ਹੈ।


Unfortunately, it is fragmented into two chunks of size 10 each.

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਹ 10 ਦੇ ਆਕਾਰ ਦੇ ਦੋ ਟੁਕੜਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਹੋਇਆ ਹੈ।


As a result, a request for 15 bytes will fail even though there are 20 bytes free.

ਨਤੀਜੇ ਵਜੋਂ, 15 ਬਾਈਟ ਦੀ ਬੇਨਤੀ ਅਸਫਲ ਹੋ ਜਾਵੇਗੀ ਭਾਵੇਂ 20 ਬਾਈਟ ਖਾਲੀ ਹਨ।


And thus we arrive at the problem addressed in this chapter.

ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਇਸ ਅਧਿਆਇ ਵਿੱਚ ਸੰਬੋਧਿਤ ਸਮੱਸਿਆ 'ਤੇ ਪਹੁੰਚਦੇ ਹਾਂ।


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

ਵੇਰੀਏਬਲ-ਆਕਾਰ ਦੀਆਂ ਬੇਨਤੀਆਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਸਮੇਂ, ਖਾਲੀ ਥਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਿਵੇਂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?


What strategies can be used to minimize fragmentation?

ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਨੂੰ ਘੱਟ ਕਰਨ ਲਈ ਕਿਹੜੀਆਂ ਰਣਨੀਤੀਆਂ ਵਰਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ?


What are the time and space overheads of alternate approaches?

ਵਿਕਲਪਕ ਪਹੁੰਚਾਂ ਦੇ ਸਮੇਂ ਅਤੇ ਸਪੇਸ ਓਵਰਹੈੱਡ ਕੀ ਹਨ?


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

ਅਸੀਂ ਇੱਕ ਬੁਨਿਆਦੀ ਇੰਟਰਫੇਸ ਮੰਨਦੇ ਹਾਂ ਜਿਵੇਂ ਕਿ malloc() ਅਤੇ free() ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ।


Specifically, void * malloc(size t size) takes a single parameter, size.

ਖਾਸ ਤੌਰ 'ਤੇ, void * malloc(size t size) ਇੱਕ ਸਿੰਗਲ ਪੈਰਾਮੀਟਰ, size ਲੈਂਦਾ ਹੈ।


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 further assume that primarily we are concerned with external fragmentation.

ਅਸੀਂ ਅੱਗੇ ਮੰਨਦੇ ਹਾਂ ਕਿ ਮੁੱਖ ਤੌਰ 'ਤੇ ਅਸੀਂ ਬਾਹਰੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਨਾਲ ਸੰਬੰਧਿਤ ਹਾਂ।


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

ਅਲਾਕੇਟਰਾਂ ਨੂੰ ਅੰਦਰੂਨੀ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਦੀ ਸਮੱਸਿਆ ਵੀ ਹੋ ਸਕਦੀ ਹੈ।


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

ਅਸੀਂ ਇਹ ਵੀ ਮੰਨਾਂਗੇ ਕਿ ਇੱਕ ਵਾਰ ਮੈਮੋਰੀ ਇੱਕ ਕਲਾਇੰਟ ਨੂੰ ਸੌਂਪ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਦੁਬਾਰਾ ਨਹੀਂ ਰੱਖਿਆ ਜਾ ਸਕਦਾ।


Thus, no compaction of free space is possible.

ਇਸ ਤਰ੍ਹਾਂ, ਖਾਲੀ ਥਾਂ ਦਾ ਕੋਈ ਸੰਕੁਚਨ ਸੰਭਵ ਨਹੀਂ ਹੈ।


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

ਅਸੀਂ ਮੰਨਾਂਗੇ ਕਿ ਅਲਾਕੇਟਰ ਬਾਈਟਾਂ ਦੇ ਇੱਕ ਲਗਾਤਾਰ ਖੇਤਰ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


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

ਪਹਿਲਾਂ, ਅਸੀਂ ਵੰਡਣ ਅਤੇ ਇਕੱਠੇ ਕਰਨ ਦੀਆਂ ਮੁਢਲੀਆਂ ਗੱਲਾਂ 'ਤੇ ਚਰਚਾ ਕਰਾਂਗੇ।


A free list contains a set of elements that describe the free space still remaining in the heap.

ਇੱਕ ਮੁਫਤ ਸੂਚੀ ਵਿੱਚ ਤੱਤਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਹੁੰਦਾ ਹੈ ਜੋ ਹੀਪ ਵਿੱਚ ਬਾਕੀ ਬਚੀ ਮੁਫਤ ਥਾਂ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ।


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.

ਸੈਗਮੈਂਟੇਸ਼ਨ ਫਾਲਟ ਜਾਂ ਉਲੰਘਣਾ ਸ਼ਬਦ ਇੱਕ ਸੈਗਮੈਂਟਡ ਮਸ਼ੀਨ 'ਤੇ ਇੱਕ ਗੈਰ-ਕਾਨੂੰਨੀ ਪਤੇ ਤੱਕ ਮੈਮੋਰੀ ਪਹੁੰਚ ਤੋਂ ਪੈਦਾ ਹੁੰਦਾ ਹੈ।


Now let’s look at an address in the heap, virtual address 4200.

ਹੁਣ ਆਓ ਹੀਪ ਵਿੱਚ ਇੱਕ ਪਤੇ 'ਤੇ ਨਜ਼ਰ ਮਾਰੀਏ, ਵਰਚੁਅਲ ਐਡਰੈੱਸ 4200।


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.

ਹਾਰਡਵੇਅਰ ਅਨੁਵਾਦ ਦੌਰਾਨ ਸੈਗਮੈਂਟ ਰਜਿਸਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


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

ਸਾਡੀ ਉਦਾਹਰਣ ਵਿੱਚ, ਜੇਕਰ ਸਭ ਤੋਂ ਉੱਪਰਲੇ ਦੋ ਬਿੱਟ 00 ਹਨ, ਤਾਂ ਹਾਰਡਵੇਅਰ ਜਾਣਦਾ ਹੈ ਕਿ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਕੋਡ ਸੈਗਮੈਂਟ ਵਿੱਚ ਹੈ।


The bottom 12 bits are the offset into the segment: 0000 0110 1000, or hex 0x068, or 104 in decimal.

ਹੇਠਲੇ 12 ਬਿੱਟ ਸੈਗਮੈਂਟ ਵਿੱਚ ਆਫਸੈੱਟ ਹਨ: 0000 0110 1000, ਜਾਂ ਹੈਕਸ 0x068, ਜਾਂ ਦਸ਼ਮਲਵ ਵਿੱਚ 104।


Engineers like Jeff Bonwick are the heart of Silicon Valley.

ਜੈਫ ਬੋਨਵਿਕ ਵਰਗੇ ਇੰਜੀਨੀਅਰ ਸਿਲੀਕਾਨ ਵੈਲੀ ਦਾ ਦਿਲ ਹਨ।


Behind almost any great product is a human who is way above average in their talents.

ਲਗਭਗ ਕਿਸੇ ਵੀ ਮਹਾਨ ਉਤਪਾਦ ਦੇ ਪਿੱਛੇ ਇੱਕ ਇਨਸਾਨ ਹੁੰਦਾ ਹੈ ਜੋ ਆਪਣੀ ਪ੍ਰਤਿਭਾ ਵਿੱਚ ਔਸਤ ਤੋਂ ਬਹੁਤ ਉੱਪਰ ਹੁੰਦਾ ਹੈ।


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

ਮਿਹਨਤ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਵੀ ਅਜਿਹੇ “100x” ਵਿਅਕਤੀ ਬਣ ਸਕਦੇ ਹੋ।


Failing that, work with such a person; you’ll learn more in a day than most learn in a month.

ਜੇਕਰ ਅਜਿਹਾ ਨਹੀਂ ਹੁੰਦਾ, ਤਾਂ ਅਜਿਹੇ ਵਿਅਕਤੀ ਨਾਲ ਕੰਮ ਕਰੋ; ਤੁਸੀਂ ਇੱਕ ਦਿਨ ਵਿੱਚ ਓਨਾ ਸਿੱਖੋਗੇ ਜਿੰਨਾ ਜ਼ਿਆਦਾਤਰ ਇੱਕ ਮਹੀਨੇ ਵਿੱਚ ਸਿੱਖਦੇ ਹਨ।


The slab allocator also goes beyond most segregated list approaches.

ਸਲੈਬ ਅਲਾਕੇਟਰ ਜ਼ਿਆਦਾਤਰ ਵੱਖ-ਵੱਖ ਸੂਚੀ ਪਹੁੰਚਾਂ ਤੋਂ ਵੀ ਅੱਗੇ ਜਾਂਦਾ ਹੈ।


By keeping free objects on the lists in a pre-initialized state, the slab allocator thus avoids frequent initialization and destruction cycles.

ਮੁਫਤ ਵਸਤੂਆਂ ਨੂੰ ਪਹਿਲਾਂ ਤੋਂ ਸ਼ੁਰੂ ਕੀਤੀ ਸਥਿਤੀ ਵਿੱਚ ਸੂਚੀਆਂ ਵਿੱਚ ਰੱਖ ਕੇ, ਸਲੈਬ ਅਲਾਕੇਟਰ ਇਸ ਤਰ੍ਹਾਂ ਵਾਰ-ਵਾਰ ਸ਼ੁਰੂਆਤੀ ਅਤੇ ਵਿਨਾਸ਼ ਚੱਕਰਾਂ ਤੋਂ ਬਚਦਾ ਹੈ।


When a request for memory is made, the search for free space recursively divides free space by two.

ਜਦੋਂ ਮੈਮੋਰੀ ਦੀ ਬੇਨਤੀ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਮੁਫਤ ਸਪੇਸ ਦੀ ਖੋਜ ਮੁਫਤ ਸਪੇਸ ਨੂੰ ਦੋ ਨਾਲ ਦੁਬਾਰਾ ਵੰਡਦੀ ਹੈ।


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

ਇਸ ਬਿੰਦੂ 'ਤੇ, ਬੇਨਤੀ ਕੀਤਾ ਬਲਾਕ ਉਪਭੋਗਤਾ ਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।


In the example, the leftmost 8KB block is allocated and returned to the user.

ਉਦਾਹਰਨ ਵਿੱਚ, ਸਭ ਤੋਂ ਖੱਬੇ 8KB ਬਲਾਕ ਨੂੰ ਅਲਾਟ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਵਾਪਸ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ।


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.

ਬੱਡੀ ਅਲਾਟਮੈਂਟ ਇੰਨਾ ਵਧੀਆ ਕੰਮ ਕਰਨ ਦਾ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਕਿਸੇ ਖਾਸ ਬਲਾਕ ਦੇ ਬੱਡੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਆਸਾਨ ਹੈ।


Think about the addresses of the blocks in the free space above.

ਉੱਪਰ ਦਿੱਤੀ ਮੁਫਤ ਸਪੇਸ ਵਿੱਚ ਬਲਾਕਾਂ ਦੇ ਪਤਿਆਂ ਬਾਰੇ ਸੋਚੋ।


One major problem with many of the approaches described above is their lack of scaling.

ਉੱਪਰ ਦੱਸੇ ਗਏ ਬਹੁਤ ਸਾਰੇ ਪਹੁੰਚਾਂ ਨਾਲ ਇੱਕ ਵੱਡੀ ਸਮੱਸਿਆ ਉਨ੍ਹਾਂ ਵਿੱਚ ਸਕੇਲਿੰਗ ਦੀ ਘਾਟ ਹੈ।


Specifically, searching lists can be quite slow.

ਖਾਸ ਤੌਰ 'ਤੇ, ਸੂਚੀਆਂ ਦੀ ਖੋਜ ਕਰਨਾ ਕਾਫ਼ੀ ਹੌਲੀ ਹੋ ਸਕਦਾ ਹੈ।


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.

ਅਜਿਹੇ ਅਲਾਕੇਟਰ ਹਰ ਥਾਂ ਮੌਜੂਦ ਹਨ, ਜੋ ਤੁਹਾਡੇ ਦੁਆਰਾ ਲਿਖੇ ਹਰ C ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਲਿੰਕ ਕੀਤੇ ਗਏ ਹਨ।


As with many systems, there are many trade-offs to be made in building such a system.

ਬਹੁਤ ਸਾਰੇ ਸਿਸਟਮਾਂ ਵਾਂਗ, ਅਜਿਹੇ ਸਿਸਟਮ ਬਣਾਉਣ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਸਮਝੌਤੇ ਕਰਨੇ ਪੈਂਦੇ ਹਨ।


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

ਇੱਕ ਤੇਜ਼, ਸਪੇਸ-ਕੁਸ਼ਲ, ਸਕੇਲੇਬਲ ਅਲਾਕੇਟਰ ਬਣਾਉਣਾ ਜੋ ਕੰਮ ਦੇ ਇੱਕ ਵਿਸ਼ਾਲ ਦਾਇਰੇ ਲਈ ਵਧੀਆ ਕੰਮ ਕਰਦਾ ਹੈ, ਇੱਕ ਚੱਲ ਰਹੀ ਚੁਣੌਤੀ ਬਣੀ ਹੋਈ ਹੈ।


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

ਪਹਿਲੀ ਹਦਾਇਤ ਮੁੱਲ ਜ਼ੀਰੋ ਨੂੰ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਪਤੇ ਵਿੱਚ ਲੈ ਜਾਂਦੀ ਹੈ।


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 array itself. Its size is 4000 bytes (1000 integers), and it lives at virtual addresses 40000 through 44000.

ਐਰੇ ਖੁਦ। ਇਸਦਾ ਆਕਾਰ 4000 ਬਾਈਟ (1000 ਪੂਰਨ ਅੰਕ) ਹੈ, ਅਤੇ ਇਹ ਵਰਚੁਅਲ ਪਤਿਆਂ 40000 ਤੋਂ 44000 ਤੱਕ ਰਹਿੰਦਾ ਹੈ।


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

ਜਦੋਂ ਇਹ ਚੱਲਦਾ ਹੈ, ਤਾਂ ਹਰੇਕ ਹਦਾਇਤ ਫੈਚ ਦੋ ਮੈਮੋਰੀ ਹਵਾਲੇ ਤਿਆਰ ਕਰੇਗਾ।


The entire process, for the first five loop iterations, is depicted in Figure 18.7.

ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ, ਪਹਿਲੇ ਪੰਜ ਲੂਪ ਦੁਹਰਾਓ ਲਈ, ਚਿੱਤਰ 18.7 ਵਿੱਚ ਦਰਸਾਈ ਗਈ ਹੈ।


See if you can make sense of the patterns that show up in this visualization.

ਦੇਖੋ ਕਿ ਕੀ ਤੁਸੀਂ ਇਸ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਵਿੱਚ ਦਿਖਾਈ ਦੇਣ ਵਾਲੇ ਪੈਟਰਨਾਂ ਨੂੰ ਸਮਝ ਸਕਦੇ ਹੋ।


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

ਅਸੀਂ ਵਰਚੁਅਲਾਈਜ਼ਿੰਗ ਮੈਮੋਰੀ ਦੀ ਸਾਡੀ ਚੁਣੌਤੀ ਦੇ ਹੱਲ ਵਜੋਂ ਪੇਜਿੰਗ ਦੀ ਧਾਰਨਾ ਪੇਸ਼ ਕੀਤੀ ਹੈ।


Paging has many advantages over previous approaches.

ਪੇਜਿੰਗ ਦੇ ਪਿਛਲੇ ਪਹੁੰਚਾਂ ਨਾਲੋਂ ਬਹੁਤ ਸਾਰੇ ਫਾਇਦੇ ਹਨ।


First, it does not lead to external fragmentation.

ਪਹਿਲਾਂ, ਇਹ ਬਾਹਰੀ ਟੁਕੜਿਆਂ ਵੱਲ ਨਹੀਂ ਜਾਂਦਾ।


Second, it is quite flexible, enabling the sparse use of virtual address spaces.

ਦੂਜਾ, ਇਹ ਕਾਫ਼ੀ ਲਚਕਦਾਰ ਹੈ, ਜੋ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਸਪੇਸ ਦੀ ਵਿਰਲ ਵਰਤੋਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ।


However, implementing paging support without care will lead to a slower machine.

ਹਾਲਾਂਕਿ, ਬਿਨਾਂ ਦੇਖਭਾਲ ਦੇ ਪੇਜਿੰਗ ਸਹਾਇਤਾ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਇੱਕ ਹੌਲੀ ਮਸ਼ੀਨ ਬਣ ਜਾਵੇਗੀ।


ਅਸੀਂ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੀ ਚੁਣੌਤੀ ਦੇ ਹੱਲ ਵਜੋਂ ਪੇਜਿੰਗ ਦੀ ਧਾਰਨਾ ਪੇਸ਼ ਕੀਤੀ ਹੈ।


How can we speed up address translation, and generally avoid the extra memory reference that paging seems to require?

ਅਸੀਂ ਐਡਰੈੱਸ ਅਨੁਵਾਦ ਨੂੰ ਕਿਵੇਂ ਤੇਜ਼ ਕਰ ਸਕਦੇ ਹਾਂ, ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਵਾਧੂ ਮੈਮੋਰੀ ਹਵਾਲੇ ਤੋਂ ਕਿਵੇਂ ਬਚ ਸਕਦੇ ਹਾਂ ਜਿਸਦੀ ਪੇਜਿੰਗ ਨੂੰ ਲੋੜ ਜਾਪਦੀ ਹੈ?


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), and is simply a hardware cache of popular virtual-to-physical address translations.

ਇੱਕ TLB ਚਿੱਪ ਦੇ ਮੈਮੋਰੀ-ਪ੍ਰਬੰਧਨ ਯੂਨਿਟ (MMU) ਦਾ ਹਿੱਸਾ ਹੈ, ਅਤੇ ਇਹ ਪ੍ਰਸਿੱਧ ਵਰਚੁਅਲ-ਟੂ-ਫਿਜ਼ੀਕਲ ਐਡਰੈੱਸ ਅਨੁਵਾਦਾਂ ਦਾ ਇੱਕ ਹਾਰਡਵੇਅਰ ਕੈਸ਼ ਹੈ।


Upon each virtual memory reference, the hardware first checks the TLB to see if the desired translation is held therein.

ਹਰੇਕ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਹਵਾਲੇ 'ਤੇ, ਹਾਰਡਵੇਅਰ ਪਹਿਲਾਂ ਇਹ ਦੇਖਣ ਲਈ TLB ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਲੋੜੀਂਦਾ ਅਨੁਵਾਦ ਉੱਥੇ ਰੱਖਿਆ ਗਿਆ ਹੈ।


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

ਜੇਕਰ ਅਜਿਹਾ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਾਡੇ ਕੋਲ ਇੱਕ TLB ਹਿੱਟ ਹੁੰਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ TLB ਅਨੁਵਾਦ ਨੂੰ ਰੱਖਦਾ ਹੈ।


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

TLB, ਸਾਰੇ ਕੈਸ਼ਾਂ ਵਾਂਗ, ਇਸ ਅਧਾਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ ਕਿ ਆਮ ਮਾਮਲੇ ਵਿੱਚ, ਅਨੁਵਾਦ ਕੈਸ਼ ਵਿੱਚ ਪਾਏ ਜਾਂਦੇ ਹਨ।


The operating system manages the computer's resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਦੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


ਕਿਰਪਾ ਕਰਕੇ ਦਸਤਾਵੇਜ਼ ਖੋਲ੍ਹੋ।


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


ਮੈਂ ਬਾਜ਼ਾਰ ਜਾ ਰਿਹਾ ਹਾਂ।


The program crashed due to a memory error.

ਪ੍ਰੋਗਰਾਮ ਇੱਕ ਮੈਮੋਰੀ ਗਲਤੀ ਕਾਰਨ ਕਰੈਸ਼ ਹੋ ਗਿਆ।


ਕੀ ਤੁਸੀਂ ਕਿਰਪਾ ਕਰਕੇ ਦੁਬਾਰਾ ਦੱਸ ਸਕਦੇ ਹੋ?


The company announced its quarterly earnings.

ਕੰਪਨੀ ਨੇ ਆਪਣੀ ਤਿਮਾਹੀ ਆਮਦਨ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


ਉਹ ਇੱਕ ਬਹੁਤ ਹੀ ਪ੍ਰਤਿਭਾਸ਼ਾਲੀ ਸੰਗੀਤਕਾਰ ਹੈ।


The government implemented new policies.

ਸਰਕਾਰ ਨੇ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ।


The system uses virtual memory to manage processes.

ਸਿਸਟਮ ਪ੍ਰਕਿਰਿਆਵਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The research team published their findings in a journal.

ਖੋਜ ਟੀਮ ਨੇ ਇੱਕ ਜਰਨਲ ਵਿੱਚ ਆਪਣੇ ਖੋਜ ਨਤੀਜੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ।


ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਸਫਲ ਹੋਏ।


ਸਾਫਟਵੇਅਰ ਅਪਡੇਟ ਨੇ ਕਈ ਬੱਗ ਠੀਕ ਕੀਤੇ।


ਆਰਥਿਕ ਭਵਿੱਖਬਾਣੀ ਵਿਕਾਸ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦੀ ਹੈ।


The complex algorithm requires significant computational resources.

ਗੁੰਝਲਦਾਰ ਐਲਗੋਰਿਦਮ ਲਈ ਮਹੱਤਵਪੂਰਨ ਗਣਨਾਤਮਕ ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


The company is investing heavily in research and development.

ਕੰਪਨੀ ਖੋਜ ਅਤੇ ਵਿਕਾਸ ਵਿੱਚ ਭਾਰੀ ਨਿਵੇਸ਼ ਕਰ ਰਹੀ ਹੈ।


The project was completed ahead of schedule.

ਪ੍ਰੋਜੈਕਟ ਸਮਾਂ-ਸਾਰਣੀ ਤੋਂ ਪਹਿਲਾਂ ਪੂਰਾ ਹੋ ਗਿਆ।


The security protocol protects against unauthorized access.

ਸੁਰੱਖਿਆ ਪ੍ਰੋਟੋਕੋਲ ਅਣਅਧਿਕਾਰਤ ਪਹੁੰਚ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ।


The team worked collaboratively to achieve their goals.

ਟੀਮ ਨੇ ਆਪਣੇ ਟੀਚਿਆਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਸਹਿਯੋਗ ਨਾਲ ਕੰਮ ਕੀਤਾ।


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-ਬਾਈਟ ਪੇਜ-ਟੇਬਲ ਐਂਟਰੀ ਮੰਨੋ।


An address space thus has roughly one million virtual pages in it (2^32 / 2^12); multiply by the page-table size and you see that our page table is 4MB in size.

ਇਸ ਤਰ੍ਹਾਂ ਇੱਕ ਐਡਰੈੱਸ ਸਪੇਸ ਵਿੱਚ ਲਗਭਗ ਇੱਕ ਮਿਲੀਅਨ ਵਰਚੁਅਲ ਪੰਨੇ ਹਨ (2^32 / 2^12); ਪੇਜ-ਟੇਬਲ ਦੇ ਆਕਾਰ ਨਾਲ ਗੁਣਾ ਕਰੋ ਅਤੇ ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਸਾਡਾ ਪੇਜ ਟੇਬਲ 4MB ਆਕਾਰ ਦਾ ਹੈ।


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.

ਜਦੋਂ ਵੀ ਤੁਹਾਡੇ ਕੋਲ ਜੀਵਨ ਵਿੱਚ ਕਿਸੇ ਚੀਜ਼ ਲਈ ਦੋ ਵਾਜਬ ਪਰ ਵੱਖ-ਵੱਖ ਪਹੁੰਚ ਹੁੰਦੇ ਹਨ, ਤਾਂ ਤੁਹਾਨੂੰ ਹਮੇਸ਼ਾ ਦੋਵਾਂ ਦੇ ਸੁਮੇਲ ਦੀ ਜਾਂਚ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਕਿ ਕੀ ਤੁਸੀਂ ਦੋਵਾਂ ਸੰਸਾਰਾਂ ਵਿੱਚੋਂ ਸਭ ਤੋਂ ਵਧੀਆ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹੋ।


ਅਸੀਂ ਅਜਿਹੇ ਸੁਮੇਲ ਨੂੰ ਇੱਕ ਹਾਈਬ੍ਰਿਡ ਕਹਿੰਦੇ ਹਾਂ।


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 critical difference in our hybrid scheme is the presence of a bounds register per segment.

ਸਾਡੀ ਹਾਈਬ੍ਰਿਡ ਸਕੀਮ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਅੰਤਰ ਹਰੇਕ ਹਿੱਸੇ ਲਈ ਇੱਕ ਸੀਮਾ ਰਜਿਸਟਰ ਦੀ ਮੌਜੂਦਗੀ ਹੈ।


The hardware searches the entries in parallel to see if there is a match.

ਹਾਰਡਵੇਅਰ ਇਹ ਵੇਖਣ ਲਈ ਸਮਾਨਤਾ ਵਿੱਚ ਐਂਟਰੀਆਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਮੇਲ ਹੈ।


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.

ਜਦੋਂ ਇੱਕ ਸਿਸਟਮ ਬੂਟ ਹੁੰਦਾ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਹਰੇਕ 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, code pages might be marked read and execute, whereas heap pages might be marked read and write.

ਉਦਾਹਰਨ ਲਈ, ਕੋਡ ਪੰਨਿਆਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕਿ ਢੇਰ ਪੰਨਿਆਂ ਨੂੰ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਲਈ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।


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 one process (P1) is running, it assumes the TLB might be caching translations that are valid for it.

ਜਦੋਂ ਇੱਕ ਪ੍ਰਕਿਰਿਆ (P1) ਚੱਲ ਰਹੀ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਇਹ ਮੰਨਦੀ ਹੈ ਕਿ TLB ਅਨੁਵਾਦਾਂ ਨੂੰ ਕੈਸ਼ ਕਰ ਰਿਹਾ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਇਸਦੇ ਲਈ ਵੈਧ ਹਨ।


In the TLB above, we clearly have a problem: VPN 10 translates to either PFN 100 (P1) or PFN 170 (P2), but the hardware can’t distinguish which entry is meant for which process.

ਉੱਪਰ ਦਿੱਤੇ TLB ਵਿੱਚ, ਸਾਡੇ ਕੋਲ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਇੱਕ ਸਮੱਸਿਆ ਹੈ: VPN 10 ਜਾਂ ਤਾਂ PFN 100 (P1) ਜਾਂ PFN 170 (P2) ਵਿੱਚ ਅਨੁਵਾਦ ਕਰਦਾ ਹੈ, ਪਰ ਹਾਰਡਵੇਅਰ ਇਹ ਵੱਖਰਾ ਨਹੀਂ ਕਰ ਸਕਦਾ ਕਿ ਕਿਹੜੀ ਐਂਟਰੀ ਕਿਸ ਪ੍ਰਕਿਰਿਆ ਲਈ ਹੈ।


Thus, we need to do some more work in order for the TLB to correctly and efficiently support virtualization across multiple processes.

ਇਸ ਤਰ੍ਹਾਂ, ਸਾਨੂੰ TLB ਨੂੰ ਕਈ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਵਰਚੁਅਲਾਈਜ਼ੇਸ਼ਨ ਦਾ ਸਹੀ ਅਤੇ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸਮਰਥਨ ਕਰਨ ਲਈ ਕੁਝ ਹੋਰ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।


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

ਇੱਕ ਪਹੁੰਚ ਹੈ ਕਿ ਸੰਦਰਭ ਸਵਿੱਚਾਂ 'ਤੇ TLB ਨੂੰ ਸਾਫ਼ ਕਰਨਾ, ਇਸ ਤਰ੍ਹਾਂ ਅਗਲੀ ਪ੍ਰਕਿਰਿਆ ਚਲਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਖਾਲੀ ਕਰਨਾ।


By flushing the TLB on each context switch, we now have a working solution, as a process will never accidentally encounter the wrong translations in the TLB.

ਹਰੇਕ ਸੰਦਰਭ ਸਵਿੱਚ 'ਤੇ TLB ਨੂੰ ਸਾਫ਼ ਕਰਕੇ, ਸਾਡੇ ਕੋਲ ਹੁਣ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ ਹੱਲ ਹੈ, ਕਿਉਂਕਿ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਕਦੇ ਵੀ ਗਲਤੀ ਨਾਲ TLB ਵਿੱਚ ਗਲਤ ਅਨੁਵਾਦਾਂ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕਰੇਗੀ।


To reduce this overhead, some systems add hardware support to enable sharing of the TLB across context switches.

ਇਸ ਓਵਰਹੈੱਡ ਨੂੰ ਘਟਾਉਣ ਲਈ, ਕੁਝ ਸਿਸਟਮ ਸੰਦਰਭ ਸਵਿੱਚਾਂ ਵਿੱਚ TLB ਦੀ ਸ਼ੇਅਰਿੰਗ ਨੂੰ ਸਮਰੱਥ ਬਣਾਉਣ ਲਈ ਹਾਰਡਵੇਅਰ ਸਹਾਇਤਾ ਸ਼ਾਮਲ ਕਰਦੇ ਹਨ।


In particular, some hardware systems provide an address space identifier (ASID) field in the TLB.

ਖਾਸ ਤੌਰ 'ਤੇ, ਕੁਝ ਹਾਰਡਵੇਅਰ ਸਿਸਟਮ TLB ਵਿੱਚ ਇੱਕ ਐਡਰੈੱਸ ਸਪੇਸ ਆਈਡੈਂਟੀਫਾਇਰ (ASID) ਫੀਲਡ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।


Thus, with address-space identifiers, the TLB can hold translations from different processes at the same time without any confusion.

ਇਸ ਤਰ੍ਹਾਂ, ਐਡਰੈੱਸ-ਸਪੇਸ ਪਛਾਣਕਰਤਾਵਾਂ ਦੇ ਨਾਲ, TLB ਬਿਨਾਂ ਕਿਸੇ ਉਲਝਣ ਦੇ ਇੱਕੋ ਸਮੇਂ ਵੱਖ-ਵੱਖ ਪ੍ਰਕਿਰਿਆਵਾਂ ਤੋਂ ਅਨੁਵਾਦਾਂ ਨੂੰ ਰੱਖ ਸਕਦਾ ਹੈ।


As with any cache, and thus also with the TLB, one more issue that we must consider is cache replacement.

ਕਿਸੇ ਵੀ ਕੈਸ਼ ਦੇ ਨਾਲ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ TLB ਦੇ ਨਾਲ ਵੀ, ਇੱਕ ਹੋਰ ਮੁੱਦਾ ਜਿਸ 'ਤੇ ਸਾਨੂੰ ਵਿਚਾਰ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ, ਉਹ ਹੈ ਕੈਸ਼ ਬਦਲਣਾ।


Specifically, when we are installing a new entry in the TLB, we have to replace an old one, and thus the question: which one to replace?

ਖਾਸ ਤੌਰ 'ਤੇ, ਜਦੋਂ ਅਸੀਂ TLB ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਐਂਟਰੀ ਸਥਾਪਤ ਕਰ ਰਹੇ ਹਾਂ, ਤਾਂ ਸਾਨੂੰ ਇੱਕ ਪੁਰਾਣੀ ਨੂੰ ਬਦਲਣਾ ਪੈਂਦਾ ਹੈ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਸਵਾਲ: ਕਿਸਨੂੰ ਬਦਲਣਾ ਹੈ?


The goal, of course, being to minimize the miss rate (or increase hit rate) and thus improve performance.

ਇਸਦਾ ਟੀਚਾ, ਬੇਸ਼ੱਕ, ਮਿਸ ਰੇਟ ਨੂੰ ਘੱਟ ਕਰਨਾ (ਜਾਂ ਹਿੱਟ ਰੇਟ ਵਧਾਉਣਾ) ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ ਹੈ।


One common approach is to evict the least-recently-used or LRU entry.

ਇੱਕ ਆਮ ਪਹੁੰਚ ਸਭ ਤੋਂ ਘੱਟ ਵਰਤੀ ਗਈ ਜਾਂ LRU ਐਂਟਰੀ ਨੂੰ ਬਾਹਰ ਕੱਢਣਾ ਹੈ।


The MIPS R4000 supports a 32-bit address space with 4KB pages.

MIPS R4000 4KB ਪੰਨਿਆਂ ਦੇ ਨਾਲ ਇੱਕ 32-ਬਿੱਟ ਐਡਰੈੱਸ ਸਪੇਸ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।


The system can thus form our desired physical address.

ਇਸ ਤਰ੍ਹਾਂ ਸਿਸਟਮ ਸਾਡਾ ਲੋੜੀਂਦਾ ਭੌਤਿਕ ਪਤਾ ਬਣਾ ਸਕਦਾ ਹੈ।


You should now have some idea of 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 and use it 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.

ਮਲਟੀ-ਲੈਵਲ ਪੇਜ ਟੇਬਲ ਬਣਾਉਣ ਵਿੱਚ ਸਾਡਾ ਟੀਚਾ ਯਾਦ ਰੱਖੋ: ਪੇਜ ਟੇਬਲ ਦੇ ਹਰੇਕ ਟੁਕੜੇ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਪੇਜ ਵਿੱਚ ਫਿੱਟ ਕਰਨਾ।


To determine how many levels are needed in a multi-level table to make all pieces of the page table fit within a page, we start by determining how many page-table entries fit within a page.

ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਿ ਇੱਕ ਮਲਟੀ-ਲੈਵਲ ਟੇਬਲ ਵਿੱਚ ਕਿੰਨੇ ਪੱਧਰਾਂ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਜੋ ਪੇਜ ਟੇਬਲ ਦੇ ਸਾਰੇ ਟੁਕੜੇ ਇੱਕ ਪੇਜ ਵਿੱਚ ਫਿੱਟ ਹੋ ਸਕਣ, ਅਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ ਕਿ ਇੱਕ ਪੇਜ ਵਿੱਚ ਕਿੰਨੀਆਂ ਪੇਜ-ਟੇਬਲ ਐਂਟਰੀਆਂ ਫਿੱਟ ਹੁੰਦੀਆਂ ਹਨ।


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

ਹੁਣ, ਉੱਚ-ਪੱਧਰੀ ਪੇਜ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਇੰਡੈਕਸ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਦੇ ਸਭ ਤੋਂ ਉੱਪਰਲੇ ਬਿੱਟਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ।


To summarize the entire process of address translation using a two-level page table, we once again present the control flow in algorithmic form.

ਦੋ-ਪੱਧਰੀ ਪੇਜ ਟੇਬਲ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਡਰੈੱਸ ਅਨੁਵਾਦ ਦੀ ਪੂਰੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਸਾਰ ਦੇਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਵਾਰ ਫਿਰ ਐਲਗੋਰਿਦਮਿਕ ਰੂਪ ਵਿੱਚ ਕੰਟਰੋਲ ਪ੍ਰਵਾਹ ਪੇਸ਼ ਕਰਦੇ ਹਾਂ।


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 (one per process of the system), we keep a single page table that has an entry for each physical page of the system.

ਇੱਥੇ, ਬਹੁਤ ਸਾਰੇ ਪੇਜ ਟੇਬਲ (ਸਿਸਟਮ ਦੇ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਲਈ ਇੱਕ) ਹੋਣ ਦੀ ਬਜਾਏ, ਅਸੀਂ ਇੱਕ ਸਿੰਗਲ ਪੇਜ ਟੇਬਲ ਰੱਖਦੇ ਹਾਂ ਜਿਸ ਵਿੱਚ ਸਿਸਟਮ ਦੇ ਹਰੇਕ ਭੌਤਿਕ ਪੇਜ ਲਈ ਇੱਕ ਐਂਟਰੀ ਹੁੰਦੀ ਹੈ।


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

ਮਲਟੀ-ਲੈਵਲ ਅਤੇ ਇਨਵਰਟਿਡ ਪੇਜ ਟੇਬਲ ਸਿਰਫ਼ ਬਹੁਤ ਸਾਰੀਆਂ ਚੀਜ਼ਾਂ ਦੀਆਂ ਦੋ ਉਦਾਹਰਣਾਂ ਹਨ ਜੋ ਕੋਈ ਵੀ ਕਰ ਸਕਦਾ ਹੈ।


We have now seen how real page tables are built; not necessarily just as linear arrays but as more complex data structures.

ਅਸੀਂ ਹੁਣ ਦੇਖਿਆ ਹੈ ਕਿ ਅਸਲ ਪੇਜ ਟੇਬਲ ਕਿਵੇਂ ਬਣਾਏ ਜਾਂਦੇ ਹਨ; ਜ਼ਰੂਰੀ ਤੌਰ 'ਤੇ ਸਿਰਫ਼ ਲੀਨੀਅਰ ਐਰੇ ਦੇ ਤੌਰ 'ਤੇ ਨਹੀਂ, ਸਗੋਂ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਡਾਟਾ ਢਾਂਚੇ ਵਜੋਂ।


The trade-offs such tables present are in time and space.

ਅਜਿਹੇ ਟੇਬਲ ਜੋ ਪੇਸ਼ ਕਰਦੇ ਹਨ ਉਹ ਸਮੇਂ ਅਤੇ ਸਥਾਨ ਵਿੱਚ ਹਨ।


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

ਅਸੀਂ ਹੁਣ ਇਨ੍ਹਾਂ ਵੱਡੀਆਂ ਧਾਰਨਾਵਾਂ ਨੂੰ ਢਿੱਲਾ ਕਰਾਂਗੇ, ਅਤੇ ਮੰਨ ਲਵਾਂਗੇ ਕਿ ਅਸੀਂ ਕਈ ਸਮਕਾਲੀ ਤੌਰ 'ਤੇ ਚੱਲ ਰਹੇ ਵੱਡੇ ਐਡਰੈੱਸ ਸਪੇਸ ਦਾ ਸਮਰਥਨ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ।


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?

ਓਐਸ ਇੱਕ ਵੱਡੇ, ਹੌਲੀ ਡਿਵਾਈਸ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹੈ ਤਾਂ ਜੋ ਇੱਕ ਵੱਡੇ ਵਰਚੁਅਲ ਐਡਰੈੱਸ ਸਪੇਸ ਦਾ ਭਰਮ ਪਾਰਦਰਸ਼ੀ ਢੰਗ ਨਾਲ ਪ੍ਰਦਾਨ ਕੀਤਾ ਜਾ ਸਕੇ?


With a large address space, you don’t have to worry about if there is room enough in memory for your program’s data structures.

ਇੱਕ ਵੱਡੇ ਐਡਰੈੱਸ ਸਪੇਸ ਦੇ ਨਾਲ, ਤੁਹਾਨੂੰ ਇਸ ਬਾਰੇ ਚਿੰਤਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਕਿ ਤੁਹਾਡੇ ਪ੍ਰੋਗਰਾਮ ਦੇ ਡੇਟਾ ਢਾਂਚੇ ਲਈ ਮੈਮੋਰੀ ਵਿੱਚ ਕਾਫ਼ੀ ਥਾਂ ਹੈ ਜਾਂ ਨਹੀਂ।


The invention of multiprogramming almost demanded the ability to swap out some pages.

ਮਲਟੀਪ੍ਰੋਗਰਾਮਿੰਗ ਦੀ ਕਾਢ ਨੇ ਲਗਭਗ ਕੁਝ ਪੰਨਿਆਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਦੀ ਸਮਰੱਥਾ ਦੀ ਮੰਗ ਕੀਤੀ।


In the example, three processes are actively sharing physical memory.

ਉਦਾਹਰਣ ਵਿੱਚ, ਤਿੰਨ ਪ੍ਰਕਿਰਿਆਵਾਂ ਸਰਗਰਮੀ ਨਾਲ ਭੌਤਿਕ ਮੈਮੋਰੀ ਨੂੰ ਸਾਂਝਾ ਕਰ ਰਹੀਆਂ ਹਨ।


The principle of locality suggests that programs often access data and code in clustered patterns.

ਸਥਾਨਕਤਾ ਦਾ ਸਿਧਾਂਤ ਦੱਸਦਾ ਹੈ ਕਿ ਪ੍ਰੋਗਰਾਮ ਅਕਸਰ ਕਲੱਸਟਰਡ ਪੈਟਰਨਾਂ ਵਿੱਚ ਡਾਟਾ ਅਤੇ ਕੋਡ ਤੱਕ ਪਹੁੰਚ ਕਰਦੇ ਹਨ।


LRU (Least Recently Used) is a page replacement algorithm that evicts the page that hasn't been used for the longest time.

LRU (ਘੱਟ ਹੀ ਵਰਤਿਆ ਗਿਆ) ਇੱਕ ਪੇਜ ਬਦਲਣ ਵਾਲਾ ਐਲਗੋਰਿਦਮ ਹੈ ਜੋ ਉਸ ਪੰਨੇ ਨੂੰ ਬਾਹਰ ਕੱਢਦਾ ਹੈ ਜੋ ਸਭ ਤੋਂ ਲੰਬੇ ਸਮੇਂ ਤੋਂ ਵਰਤਿਆ ਨਹੀਂ ਗਿਆ ਹੈ।


The operating system manages virtual memory to provide each process with its own address space.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਹਰੇਕ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਇਸਦੇ ਆਪਣੇ ਐਡਰੈੱਸ ਸਪੇਸ ਪ੍ਰਦਾਨ ਕਰਨ ਲਈ ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


Thrashing occurs when the system spends too much time swapping pages between memory and disk.

ਥ੍ਰੈਸ਼ਿੰਗ ਉਦੋਂ ਹੁੰਦੀ ਹੈ ਜਦੋਂ ਸਿਸਟਮ ਮੈਮੋਰੀ ਅਤੇ ਡਿਸਕ ਦੇ ਵਿਚਕਾਰ ਪੰਨਿਆਂ ਨੂੰ ਸਵੈਪ ਕਰਨ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਮਾਂ ਬਿਤਾਉਂਦਾ ਹੈ।


The clock algorithm is an approximation of LRU, using a use bit to track page access.

ਕਲਾਕ ਐਲਗੋਰਿਦਮ LRU ਦਾ ਇੱਕ ਅੰਦਾਜ਼ਾ ਹੈ, ਜੋ ਪੰਨੇ ਦੀ ਪਹੁੰਚ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਇੱਕ ਵਰਤੋਂ ਬਿੱਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Cache size significantly impacts the hit rate in memory management.

ਕੈਸ਼ ਦਾ ਆਕਾਰ ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਵਿੱਚ ਹਿੱਟ ਰੇਟ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ।


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

80-20 ਵਰਕਲੋਡ ਸਥਾਨਕਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ, 20% ਪੰਨਿਆਂ ਤੱਕ 80% ਪਹੁੰਚ ਦੇ ਨਾਲ।


Understanding page replacement policies is crucial for optimizing system performance.

ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਪੰਨੇ ਬਦਲਣ ਦੀਆਂ ਨੀਤੀਆਂ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The OS may use demand paging to bring pages into memory only when needed.

ਓਐਸ ਸਿਰਫ ਲੋੜ ਪੈਣ 'ਤੇ ਪੰਨਿਆਂ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਲਿਆਉਣ ਲਈ ਮੰਗ ਪੇਜਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।


Historical algorithms like LRU and LFU use past access patterns to make replacement decisions.

LRU ਅਤੇ LFU ਵਰਗੇ ਇਤਿਹਾਸਕ ਐਲਗੋਰਿਦਮ ਬਦਲਣ ਦੇ ਫੈਸਲੇ ਲੈਣ ਲਈ ਪਿਛਲੇ ਪਹੁੰਚ ਪੈਟਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ।


The system's performance degrades significantly during thrashing.

ਥ੍ਰੈਸ਼ਿੰਗ ਦੌਰਾਨ ਸਿਸਟਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਘਟ ਜਾਂਦੀ ਹੈ।


Modern systems often approximate LRU due to the overhead of perfect implementation.

ਸੰਪੂਰਨ ਲਾਗੂਕਰਨ ਦੇ ਓਵਰਹੈੱਡ ਕਾਰਨ ਆਧੁਨਿਕ ਪ੍ਰਣਾਲੀਆਂ ਅਕਸਰ LRU ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਂਦੀਆਂ ਹਨ।


The use bit is a hardware mechanism to track page access.

ਵਰਤੋਂ ਬਿੱਟ ਪੰਨੇ ਦੀ ਪਹੁੰਚ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਇੱਕ ਹਾਰਡਵੇਅਰ ਵਿਧੀ ਹੈ।


The operating system uses page replacement algorithms to manage the limited physical memory.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਸੀਮਤ ਭੌਤਿਕ ਮੈਮੋਰੀ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਪੰਨੇ ਬਦਲਣ ਵਾਲੇ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


A large cache size generally improves the hit rate.

ਇੱਕ ਵੱਡਾ ਕੈਸ਼ ਆਕਾਰ ਆਮ ਤੌਰ 'ਤੇ ਹਿੱਟ ਰੇਟ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ।


The system swaps pages to disk when memory is full.

ਜਦੋਂ ਮੈਮੋਰੀ ਭਰ ਜਾਂਦੀ ਹੈ ਤਾਂ ਸਿਸਟਮ ਪੰਨਿਆਂ ਨੂੰ ਡਿਸਕ ਤੇ ਸਵੈਪ ਕਰਦਾ ਹੈ।


Memory management is a critical function of the operating system.

ਮੈਮੋਰੀ ਪ੍ਰਬੰਧਨ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕੰਮ ਹੈ।


The OS decides which pages to keep in memory.

ਓਐਸ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੇ ਪੰਨਿਆਂ ਨੂੰ ਮੈਮੋਰੀ ਵਿੱਚ ਰੱਖਣਾ ਹੈ।


Virtual memory allows running programs larger than physical memory.

ਵਰਚੁਅਲ ਮੈਮੋਰੀ ਭੌਤਿਕ ਮੈਮੋਰੀ ਨਾਲੋਂ ਵੱਡੇ ਪ੍ਰੋਗਰਾਮਾਂ ਨੂੰ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ।


Page replacement algorithms help manage memory efficiently.

ਪੰਨਾ ਬਦਲਣ ਵਾਲੇ ਐਲਗੋਰਿਦਮ ਮੈਮੋਰੀ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ।


The operating system manages the computer's resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਦੇ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


ਕੀ ਤੁਸੀਂ ਮੈਨੂੰ ਲੂਣ ਦੇ ਸਕਦੇ ਹੋ?


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


I am going to the market to buy some vegetables.

ਮੈਂ ਕੁਝ ਸਬਜ਼ੀਆਂ ਖਰੀਦਣ ਲਈ ਬਾਜ਼ਾਰ ਜਾ ਰਿਹਾ ਹਾਂ।


The company announced its quarterly earnings.

ਕੰਪਨੀ ਨੇ ਆਪਣੀ ਤਿਮਾਹੀ ਆਮਦਨ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


Despite the challenges, they persevered and succeeded.

ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਨ੍ਹਾਂ ਨੇ ਲਗਾਤਾਰ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਅਤੇ ਸਫਲਤਾ ਪ੍ਰਾਪਤ ਕੀਤੀ।


The government implemented new policies to boost the economy.

ਸਰਕਾਰ ਨੇ ਅਰਥਵਿਵਸਥਾ ਨੂੰ ਹੁਲਾਰਾ ਦੇਣ ਲਈ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕੀਤੀਆਂ।


The complex system requires careful configuration.

ਗੁੰਝਲਦਾਰ ਸਿਸਟਮ ਨੂੰ ਧਿਆਨ ਨਾਲ ਸੰਰਚਨਾ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


The philosophical debate explored the nature of reality.

ਦਾਰਸ਼ਨਿਕ ਬਹਿਸ ਨੇ ਹਕੀਕਤ ਦੀ ਪ੍ਰਕਿਰਤੀ ਦੀ ਪੜਚੋਲ ਕੀਤੀ।


The intricate design of the software was impressive.

ਸਾਫਟਵੇਅਰ ਦਾ ਗੁੰਝਲਦਾਰ ਡਿਜ਼ਾਈਨ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸੀ।


The economic downturn significantly impacted global markets.

ਆਰਥਿਕ ਮੰਦੀ ਨੇ ਵਿਸ਼ਵ ਬਾਜ਼ਾਰਾਂ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਭਾਵ ਪਾਇਆ।


The scientist conducted a rigorous experiment to test the hypothesis.

ਵਿਗਿਆਨੀ ਨੇ ਪਰਿਕਲਪਨਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇੱਕ ਸਖ਼ਤ ਪ੍ਰਯੋਗ ਕੀਤਾ।


The artist's innovative techniques revolutionized the art world.

ਕਲਾਕਾਰ ਦੀਆਂ ਨਵੀਨਤਾਕਾਰੀ ਤਕਨੀਕਾਂ ਨੇ ਕਲਾ ਜਗਤ ਵਿੱਚ ਕ੍ਰਾਂਤੀ ਲਿਆਂਦੀ।


The company's strategic decisions led to unprecedented growth.

ਕੰਪਨੀ ਦੇ ਰਣਨੀਤਕ ਫੈਸਲਿਆਂ ਨੇ ਬੇਮਿਸਾਲ ਵਿਕਾਸ ਕੀਤਾ।


The implementation of the new protocol improved network efficiency.

ਨਵੇਂ ਪ੍ਰੋਟੋਕੋਲ ਨੂੰ ਲਾਗੂ ਕਰਨ ਨਾਲ ਨੈੱਟਵਰਕ ਦੀ ਕੁਸ਼ਲਤਾ ਵਿੱਚ ਸੁਧਾਰ ਹੋਇਆ।


The complex interplay of factors made the outcome unpredictable.

ਕਾਰਕਾਂ ਦੇ ਗੁੰਝਲਦਾਰ ਆਪਸੀ ਪ੍ਰਭਾਵ ਨੇ ਨਤੀਜੇ ਨੂੰ ਅਨੁਮਾਨ ਲਗਾਉਣਾ ਅਸੰਭਵ ਬਣਾ ਦਿੱਤਾ।


The historical analysis revealed the underlying causes of the conflict.

ਇਤਿਹਾਸਕ ਵਿਸ਼ਲੇਸ਼ਣ ਨੇ ਸੰਘਰਸ਼ ਦੇ ਅੰਦਰੂਨੀ ਕਾਰਨਾਂ ਦਾ ਖੁਲਾਸਾ ਕੀਤਾ।


The sophisticated algorithm optimized the data processing speed.

ਸੂਝਵਾਨ ਐਲਗੋਰਿਦਮ ਨੇ ਡਾਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੀ ਗਤੀ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਇਆ।


The profound philosophical treatise explored the nature of consciousness.

ਗਹਿਰੇ ਦਾਰਸ਼ਨਿਕ ਲੇਖ ਨੇ ਚੇਤਨਾ ਦੀ ਪ੍ਰਕਿਰਤੀ ਦੀ ਪੜਚੋਲ ਕੀਤੀ।


ਮੁੱਢਲੀਆਂ ਨੀਤੀਆਂ ਆਮ ਤੌਰ 'ਤੇ ਸਪੱਸ਼ਟ ਹੁੰਦੀਆਂ ਹਨ।


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 ਲਓ, ਕੰਜੂਸ।


ਮੈਂ ਦੁਬਾਰਾ ਕਦੇ ਵੀ ਡਿਸਕ 'ਤੇ ਸਵੈਪ ਨਹੀਂ ਕਰਾਂਗਾ।


And thus we reach the second of our three pillars of operating systems: concurrency.

ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਅਸੀਂ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਤਿੰਨ ਥੰਮ੍ਹਾਂ ਵਿੱਚੋਂ ਦੂਜੇ 'ਤੇ ਪਹੁੰਚਦੇ ਹਾਂ: ਸਮਕਾਲੀਤਾ।


ਮੈਂ ਸੋਚਿਆ ਸੀ ਕਿ ਚਾਰ ਥੰਮ੍ਹ ਸਨ...?


ਕਲਪਨਾ ਕਰੋ ਕਿ ਸਾਡੇ ਕੋਲ ਇੱਕ ਆੜੂ ਹੈ।


Peaches again! What is it with you and peaches?

ਦੁਬਾਰਾ ਆੜੂ! ਤੁਹਾਡੇ ਅਤੇ ਆੜੂਆਂ ਦਾ ਕੀ ਹੈ?


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.

ਖੈਰ, ਸ਼ਾਇਦ ਇਸ ਬਾਰੇ ਜਾਣ ਦਾ ਇੱਕ ਬਿਹਤਰ ਤਰੀਕਾ ਵਿਕਸਤ ਕਰੋ।


ਤੁਸੀਂ ਅਸਲ ਵਿੱਚ ਪ੍ਰਭਾਵਿਤ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਰਹੇ ਹੋ।


In fact, you just told us everything we need to know about concurrency!

ਅਸਲ ਵਿੱਚ, ਤੁਸੀਂ ਹੁਣੇ ਹੀ ਸਾਨੂੰ ਉਹ ਸਭ ਕੁਝ ਦੱਸਿਆ ਹੈ ਜੋ ਸਾਨੂੰ ਸਮਕਾਲੀਤਾ ਬਾਰੇ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ!


ਕਿਸੇ ਨੂੰ ਕਦੇ ਵੀ ਠੋਸ ਨੂੰ ਨਹੀਂ ਭੁੱਲਣਾ ਚਾਹੀਦਾ।


Well, as it turns out, there are certain types of programs that we call multi-threaded applications.

ਖੈਰ, ਜਿਵੇਂ ਕਿ ਇਹ ਨਿਕਲਦਾ ਹੈ, ਇੱਥੇ ਕੁਝ ਕਿਸਮਾਂ ਦੇ ਪ੍ਰੋਗਰਾਮ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਸੀਂ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਐਪਲੀਕੇਸ਼ਨ ਕਹਿੰਦੇ ਹਾਂ।


If we don’t coordinate access to memory between threads, the program won’t work as expected.

ਜੇਕਰ ਅਸੀਂ ਥ੍ਰੈਡਾਂ ਵਿਚਕਾਰ ਮੈਮੋਰੀ ਤੱਕ ਪਹੁੰਚ ਦਾ ਤਾਲਮੇਲ ਨਹੀਂ ਕਰਦੇ, ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਉਮੀਦ ਅਨੁਸਾਰ ਕੰਮ ਨਹੀਂ ਕਰੇਗਾ।


ਇੱਕ ਹਾਲਤ ਵੇਰੀਏਬਲ ਨੂੰ ਇੱਕ ਲਾਕ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


ਥ੍ਰੈਡ ਇੰਤਜ਼ਾਰ ਕਰਦੇ ਸਮੇਂ ਸੌਂ ਜਾਂਦਾ ਹੈ।


The lock should be held when calling these routines.

ਇਹਨਾਂ ਰੁਟੀਨਾਂ ਨੂੰ ਕਾਲ ਕਰਦੇ ਸਮੇਂ ਲਾਕ ਨੂੰ ਫੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ।


The thread checks if the variable has been set.

ਥ੍ਰੈਡ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕੀਤਾ ਗਿਆ ਹੈ।


ਇੰਤਜ਼ਾਰ ਕਾਲ ਲਾਕ ਨੂੰ ਰਿਲੀਜ਼ ਕਰਦੀ ਹੈ।


We always make sure to have the lock held when signaling.

ਅਸੀਂ ਹਮੇਸ਼ਾ ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਾਂ ਕਿ ਸਿਗਨਲਿੰਗ ਕਰਦੇ ਸਮੇਂ ਲਾਕ ਫੜਿਆ ਹੋਵੇ।


Using a while loop is the safe thing to do.

ਇੱਕ while ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੁਰੱਖਿਅਤ ਕੰਮ ਹੈ।


It is tempting to use a simple flag to signal between threads.

ਥ੍ਰੈਡਾਂ ਦੇ ਵਿਚਕਾਰ ਸਿਗਨਲ ਦੇਣ ਲਈ ਇੱਕ ਸਧਾਰਨ ਫਲੈਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਲੁਭਾਉਣਾ ਹੈ।


Don’t ever do this, for the following reasons.

ਇਹ ਕਦੇ ਨਾ ਕਰੋ, ਹੇਠਾਂ ਦਿੱਤੇ ਕਾਰਨਾਂ ਕਰਕੇ।


ਇਹ ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ ਮਾੜਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ।


ਇਹ ਗਲਤੀਆਂ ਦਾ ਸ਼ਿਕਾਰ ਹੈ।


Use condition variables even when you think you can get away without doing so.

ਇੱਥੋਂ ਤੱਕ ਕਿ ਜਦੋਂ ਤੁਸੀਂ ਸੋਚਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਅਜਿਹਾ ਕੀਤੇ ਬਿਨਾਂ ਬਚ ਸਕਦੇ ਹੋ, ਤਾਂ ਵੀ ਹਾਲਤ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।


You must include the header pthread.h in your code.

ਤੁਹਾਨੂੰ ਆਪਣੇ ਕੋਡ ਵਿੱਚ ਹੈਡਰ pthread.h ਸ਼ਾਮਲ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।


We have introduced the basics of the pthread library.

ਅਸੀਂ pthread ਲਾਇਬ੍ਰੇਰੀ ਦੀਆਂ ਮੁਢਲੀਆਂ ਗੱਲਾਂ ਪੇਸ਼ ਕੀਤੀਆਂ ਹਨ।


ਇਸਨੂੰ ਸਰਲ ਰੱਖੋ।


ਥ੍ਰੈਡ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਘੱਟ ਕਰੋ।


Initialize locks and condition variables.

ਲਾਕ ਅਤੇ ਹਾਲਤ ਵੇਰੀਏਬਲ ਸ਼ੁਰੂ ਕਰੋ।


ਆਪਣੇ ਰਿਟਰਨ ਕੋਡਾਂ ਦੀ ਜਾਂਚ ਕਰੋ।


ਹਰੇਕ ਥ੍ਰੈਡ ਦਾ ਆਪਣਾ ਸਟੈਕ ਹੁੰਦਾ ਹੈ।


Always use condition variables to signal between threads.

ਥ੍ਰੈਡਾਂ ਦੇ ਵਿਚਕਾਰ ਸਿਗਨਲ ਦੇਣ ਲਈ ਹਮੇਸ਼ਾ ਹਾਲਤ ਵੇਰੀਏਬਲ ਦੀ ਵਰਤੋਂ ਕਰੋ।


The operating system manages computer hardware and software resources.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੰਪਿਊਟਰ ਹਾਰਡਵੇਅਰ ਅਤੇ ਸਾਫਟਵੇਅਰ ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਦਾ ਹੈ।


Concurrency is a fundamental concept in operating systems.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮਾਂ ਵਿੱਚ ਸਮਕਾਲੀਤਾ ਇੱਕ ਬੁਨਿਆਦੀ ਸੰਕਲਪ ਹੈ।


Threads often need to synchronize access to shared resources.

ਥ੍ਰੈਡਾਂ ਨੂੰ ਅਕਸਰ ਸਾਂਝੇ ਸਰੋਤਾਂ ਤੱਕ ਪਹੁੰਚ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


Mutual exclusion is crucial for protecting critical sections.

ਆਪਸੀ ਬਾਹਰ ਕੱਢਣਾ ਨਾਜ਼ੁਕ ਭਾਗਾਂ ਦੀ ਰੱਖਿਆ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।


Condition variables facilitate thread communication and synchronization.

ਸ਼ਰਤ ਵੇਰੀਏਬਲ ਥ੍ਰੈਡ ਸੰਚਾਰ ਅਤੇ ਸਮਕਾਲੀਕਰਨ ਦੀ ਸਹੂਲਤ ਦਿੰਦੇ ਹਨ।


The program uses locks to prevent race conditions.

ਪ੍ਰੋਗਰਾਮ ਰੇਸ ਦੀਆਂ ਸਥਿਤੀਆਂ ਨੂੰ ਰੋਕਣ ਲਈ ਲਾਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Understanding thread APIs is essential for multi-threaded programming.

ਮਲਟੀ-ਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮਿੰਗ ਲਈ ਥ੍ਰੈਡ API ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ।


The operating system provides mechanisms for thread creation and management.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਥ੍ਰੈਡ ਬਣਾਉਣ ਅਤੇ ਪ੍ਰਬੰਧਨ ਲਈ ਵਿਧੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


Atomic operations ensure data consistency in concurrent environments.

ਪਰਮਾਣੂ ਕਾਰਵਾਈਆਂ ਸਮਕਾਲੀ ਵਾਤਾਵਰਣ ਵਿੱਚ ਡਾਟਾ ਇਕਸਾਰਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੀਆਂ ਹਨ।


The concept of a transaction is important in database management systems.

ਇੱਕ ਲੈਣ-ਦੇਣ ਦਾ ਸੰਕਲਪ ਡਾਟਾਬੇਸ ਪ੍ਰਬੰਧਨ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਮਹੱਤਵਪੂਰਨ ਹੈ।


The homework assignment involves analyzing thread interleavings.

ਹੋਮਵਰਕ ਅਸਾਈਨਮੈਂਟ ਵਿੱਚ ਥ੍ਰੈਡ ਇੰਟਰਲੀਵਿੰਗ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਸ਼ਾਮਲ ਹੈ।


Careful synchronization is needed to avoid data corruption.

ਡਾਟਾ ਭ੍ਰਿਸ਼ਟਾਚਾਰ ਤੋਂ ਬਚਣ ਲਈ ਸਾਵਧਾਨੀਪੂਰਵਕ ਸਮਕਾਲੀਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


The program uses mutexes to protect shared data.

ਪ੍ਰੋਗਰਾਮ ਸਾਂਝੇ ਕੀਤੇ ਡੇਟਾ ਦੀ ਰੱਖਿਆ ਲਈ ਮਿਊਟੈਕਸ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Threads can wait on condition variables to synchronize.

ਥ੍ਰੈਡ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਸ਼ਰਤ ਵੇਰੀਏਬਲਾਂ 'ਤੇ ਇੰਤਜ਼ਾਰ ਕਰ ਸਕਦੇ ਹਨ।


The example demonstrates how to create and join threads.

ਉਦਾਹਰਨ ਦਿਖਾਉਂਦੀ ਹੈ ਕਿ ਥ੍ਰੈਡਾਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਇਆ ਅਤੇ ਜੋੜਿਆ ਜਾਵੇ।


The code uses pthread_create to start a new thread.

ਕੋਡ ਇੱਕ ਨਵਾਂ ਥ੍ਰੈਡ ਸ਼ੁਰੂ ਕਰਨ ਲਈ pthread_create ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The main thread waits for the child thread to complete.

ਮੁੱਖ ਥ੍ਰੈਡ ਬੱਚੇ ਦੇ ਥ੍ਰੈਡ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ।


The program uses a wrapper function for error checking.

ਪ੍ਰੋਗਰਾਮ ਗਲਤੀ ਜਾਂਚ ਲਈ ਇੱਕ ਰੈਪਰ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


Understanding the thread API is crucial for writing concurrent programs.

ਸਮਕਾਲੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਲਈ ਥ੍ਰੈਡ API ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਹੈ।


The operating system is the first concurrent program.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਪਹਿਲਾ ਸਮਕਾਲੀ ਪ੍ਰੋਗਰਾਮ ਹੈ।


ਇਹ ਕੋਡ ਇੱਕ ਸਧਾਰਨ ਸਪਿਨ ਲਾਕ ਵਰਤਦਾ ਹੈ।


Test-and-set instructions are used for atomic operations.

ਪਰਮਾਣੂ ਕਾਰਵਾਈਆਂ ਲਈ ਟੈਸਟ-ਅਤੇ-ਸੈੱਟ ਹਦਾਇਤਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


Spin locks can lead to CPU cycle wastage.

ਸਪਿਨ ਲਾਕ CPU ਚੱਕਰਾਂ ਦੀ ਬਰਬਾਦੀ ਦਾ ਕਾਰਨ ਬਣ ਸਕਦੇ ਹਨ।


The compare-and-swap instruction is more powerful.

ਕੰਪੇਅਰ-ਅਤੇ-ਸਵੈਪ ਹਦਾਇਤ ਵਧੇਰੇ ਸ਼ਕਤੀਸ਼ਾਲੀ ਹੈ।


Load-linked and store-conditional instructions work together.

ਲੋਡ-ਲਿੰਕਡ ਅਤੇ ਸਟੋਰ-ਕੰਡੀਸ਼ਨਲ ਹਦਾਇਤਾਂ ਇਕੱਠੀਆਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ।


Fetch-and-add atomically increments a value.

ਫੈਚ-ਅਤੇ-ਐਡ ਪਰਮਾਣੂ ਤੌਰ 'ਤੇ ਇੱਕ ਮੁੱਲ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ।


Ticket locks ensure progress for all threads.

ਟਿਕਟ ਲਾਕ ਸਾਰੇ ਥ੍ਰੈਡਾਂ ਲਈ ਤਰੱਕੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ।


Spinning wastes CPU cycles unnecessarily.

ਸਪਿਨਿੰਗ ਬੇਲੋੜੇ CPU ਚੱਕਰਾਂ ਨੂੰ ਬਰਬਾਦ ਕਰਦੀ ਹੈ।


Yielding can be a simple approach to avoid spinning.

ਸਪਿਨਿੰਗ ਤੋਂ ਬਚਣ ਲਈ ਯੀਲਡਿੰਗ ਇੱਕ ਸਧਾਰਨ ਪਹੁੰਚ ਹੋ ਸਕਦੀ ਹੈ।


Queues can be used to manage thread waiting.

ਥ੍ਰੈਡ ਦੀ ਉਡੀਕ ਦਾ ਪ੍ਰਬੰਧਨ ਕਰਨ ਲਈ ਕਤਾਰਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।


The operating system provides support for efficient locks.

ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਕੁਸ਼ਲ ਲਾਕ ਲਈ ਸਹਾਇਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।


Different operating systems offer different support.

ਵੱਖ-ਵੱਖ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵੱਖ-ਵੱਖ ਸਹਾਇਤਾ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ।


The code is designed to avoid starvation.

ਕੋਡ ਨੂੰ ਭੁੱਖਮਰੀ ਤੋਂ ਬਚਣ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਹੈ।


ਸੰਦਰਭ ਸਵਿੱਚ ਮਹਿੰਗੇ ਹੋ ਸਕਦੇ ਹਨ।


ਗਾਰਡ ਨੂੰ ਸਪਿਨ-ਲਾਕ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।


This approach doesn't avoid spin-waiting entirely.

ਇਹ ਪਹੁੰਚ ਪੂਰੀ ਤਰ੍ਹਾਂ ਸਪਿਨ-ਉਡੀਕ ਤੋਂ ਬਚਦੀ ਨਹੀਂ ਹੈ।


The flag does not get set back to zero immediately.

ਝੰਡਾ ਤੁਰੰਤ ਜ਼ੀਰੋ 'ਤੇ ਵਾਪਸ ਸੈੱਟ ਨਹੀਂ ਹੁੰਦਾ।


The code uses futex calls for synchronization.

ਕੋਡ ਸਮਕਾਲੀਕਰਨ ਲਈ ਫਿਊਟੈਕਸ ਕਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।


The goal is to build a working mutual exclusion primitive.

ਇਸਦਾ ਟੀਚਾ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ ਪਰਸਪਰ ਬਾਹਰ ਕੱਢਣ ਵਾਲਾ ਪ੍ਰਾਇਮਿਟਿਵ ਬਣਾਉਣਾ ਹੈ।


Short, concise code is always preferred.

ਛੋਟਾ, ਸੰਖੇਪ ਕੋਡ ਹਮੇਸ਼ਾ ਪਸੰਦੀਦਾ ਹੁੰਦਾ ਹੈ।


ਪ੍ਰੋਗਰਾਮ ਸਫਲਤਾਪੂਰਵਕ ਕੰਪਾਇਲ ਹੋ ਗਿਆ।


ਕਿਰਪਾ ਕਰਕੇ ਦਰਵਾਜ਼ਾ ਬੰਦ ਕਰੋ।


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


He is going to the market to buy vegetables.

ਉਹ ਸਬਜ਼ੀਆਂ ਖਰੀਦਣ ਲਈ ਬਾਜ਼ਾਰ ਜਾ ਰਿਹਾ ਹੈ।


The company announced its quarterly earnings.

ਕੰਪਨੀ ਨੇ ਆਪਣੀ ਤਿਮਾਹੀ ਆਮਦਨ ਦਾ ਐਲਾਨ ਕੀਤਾ।


Could you please help me with this task?

ਕੀ ਤੁਸੀਂ ਇਸ ਕੰਮ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ?


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


She enjoys reading novels in her free time.

ਉਹ ਆਪਣੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਨਾਵਲ ਪੜ੍ਹਨਾ ਪਸੰਦ ਕਰਦੀ ਹੈ।


The government is implementing new policies.

ਸਰਕਾਰ ਨਵੀਆਂ ਨੀਤੀਆਂ ਲਾਗੂ ਕਰ ਰਹੀ ਹੈ।


The complex system requires careful analysis.

ਗੁੰਝਲਦਾਰ ਪ੍ਰਣਾਲੀ ਨੂੰ ਧਿਆਨ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਲੋੜ ਹੈ।


ਡਾਕਟਰ ਨੇ ਉਸਨੂੰ ਆਰਾਮ ਕਰਨ ਦੀ ਸਲਾਹ ਦਿੱਤੀ।


ਪ੍ਰੋਜੈਕਟ ਸਮੇਂ ਸਿਰ ਪੂਰਾ ਹੋ ਗਿਆ।


The weather forecast predicts rain tomorrow.

ਮੌਸਮ ਵਿਭਾਗ ਕੱਲ੍ਹ ਮੀਂਹ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ।


The research paper explores new findings.

ਖੋਜ ਪੱਤਰ ਨਵੇਂ ਖੋਜਾਂ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ।


ਉਹ ਇੱਕ ਬਹੁਤ ਹੀ ਪ੍ਰਤਿਭਾਸ਼ਾਲੀ ਸੰਗੀਤਕਾਰ ਹੈ।


The economic situation is improving gradually.

ਆਰਥਿਕ ਸਥਿਤੀ ਹੌਲੀ-ਹੌਲੀ ਸੁਧਰ ਰਹੀ ਹੈ।


The software update includes several bug fixes.

ਸਾਫਟਵੇਅਰ ਅਪਡੇਟ ਵਿੱਚ ਕਈ ਬੱਗ ਫਿਕਸ ਸ਼ਾਮਲ ਹਨ।


ਉਹ ਕਈ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਰੱਖਦੀ ਹੈ।


The company is expanding its operations globally.

ਕੰਪਨੀ ਵਿਸ਼ਵ ਪੱਧਰ 'ਤੇ ਆਪਣੇ ਕੰਮ ਦਾ ਵਿਸਤਾਰ ਕਰ ਰਹੀ ਹੈ।


The intricate design required advanced techniques.

ਗੁੰਝਲਦਾਰ ਡਿਜ਼ਾਈਨ ਲਈ ਉੱਨਤ ਤਕਨੀਕਾਂ ਦੀ ਲੋੜ ਸੀ।


The lock spins for a while, hoping that it can acquire the lock.

ਤਾਲਾ ਕੁਝ ਦੇਰ ਲਈ ਘੁੰਮਦਾ ਹੈ, ਇਹ ਉਮੀਦ ਕਰਦਾ ਹੈ ਕਿ ਇਹ ਤਾਲਾ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦਾ ਹੈ।


Two-phase locks are yet another instance of a hybrid approach.

ਦੋ-ਪੜਾਅ ਵਾਲੇ ਤਾਲੇ ਇੱਕ ਹਾਈਬ੍ਰਿਡ ਪਹੁੰਚ ਦੀ ਇੱਕ ਹੋਰ ਮਿਸਾਲ ਹਨ।


The Linux lock above is a form of such a lock, but it only spins once.

ਉੱਪਰ ਦਿੱਤਾ ਲੀਨਕਸ ਤਾਲਾ ਅਜਿਹੇ ਤਾਲੇ ਦਾ ਇੱਕ ਰੂਪ ਹੈ, ਪਰ ਇਹ ਸਿਰਫ਼ ਇੱਕ ਵਾਰ ਘੁੰਮਦਾ ਹੈ।


Making a single general-purpose lock is quite a challenge.

ਇੱਕ ਸਿੰਗਲ ਆਮ-ਮਕਸਦ ਵਾਲਾ ਤਾਲਾ ਬਣਾਉਣਾ ਇੱਕ ਚੁਣੌਤੀ ਹੈ।


Check out the Solaris or Linux open source code bases if you want to see more details.

ਜੇਕਰ ਤੁਸੀਂ ਹੋਰ ਵੇਰਵੇ ਦੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੋਲਰਿਸ ਜਾਂ ਲੀਨਕਸ ਓਪਨ ਸੋਰਸ ਕੋਡ ਬੇਸਾਂ ਦੀ ਜਾਂਚ ਕਰੋ।


This concurrent counter is simple and works correctly.

ਇਹ ਸਮਕਾਲੀ ਕਾਊਂਟਰ ਸਧਾਰਨ ਹੈ ਅਤੇ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ।


If your data structure is too slow, you’ll have to do more than just add a single lock.

ਜੇਕਰ ਤੁਹਾਡਾ ਡਾਟਾ ਢਾਂਚਾ ਬਹੁਤ ਹੌਲੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਤਾਲਾ ਜੋੜਨ ਤੋਂ ਵੱਧ ਕੁਝ ਕਰਨਾ ਪਵੇਗਾ।


The performance of the synchronized counter scales poorly.

ਸਮਕਾਲੀ ਕਾਊਂਟਰ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਮਾੜਾ ਹੈ।


Researchers have studied how to build more scalable counters for years.

ਖੋਜਕਰਤਾਵਾਂ ਨੇ ਕਈ ਸਾਲਾਂ ਤੋਂ ਵਧੇਰੇ ਸਕੇਲੇਬਲ ਕਾਊਂਟਰ ਬਣਾਉਣ ਦਾ ਅਧਿਐਨ ਕੀਤਾ ਹੈ।


ਇਸ ਵਿਚਾਰ ਨੂੰ ਇੱਕ ਢਿੱਲੇ ਕਾਊਂਟਰ ਵਜੋਂ ਜਾਣਿਆ ਜਾਂਦਾ ਹੈ।


When a thread wishes to increment the counter, it increments its local counter.

ਜਦੋਂ ਇੱਕ ਥ੍ਰੈਡ ਕਾਊਂਟਰ ਨੂੰ ਵਧਾਉਣਾ ਚਾਹੁੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਆਪਣੇ ਸਥਾਨਕ ਕਾਊਂਟਰ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ।


The smaller S is, the more the counter behaves like the non-scalable counter.

S ਜਿੰਨਾ ਛੋਟਾ ਹੁੰਦਾ ਹੈ, ਕਾਊਂਟਰ ਗੈਰ-ਸਕੇਲੇਬਲ ਕਾਊਂਟਰ ਵਾਂਗ ਹੀ ਵਿਵਹਾਰ ਕਰਦਾ ਹੈ।


Performance is excellent; the time taken to update the counter four million times on four processors is hardly higher.

ਪ੍ਰਦਰਸ਼ਨ ਸ਼ਾਨਦਾਰ ਹੈ; ਚਾਰ ਪ੍ਰੋਸੈਸਰਾਂ 'ਤੇ ਚਾਰ ਮਿਲੀਅਨ ਵਾਰ ਕਾਊਂਟਰ ਨੂੰ ਅਪਡੇਟ ਕਰਨ ਵਿੱਚ ਲੱਗਿਆ ਸਮਾਂ ਮੁਸ਼ਕਿਲ ਨਾਲ ਵੱਧ ਹੈ।


We next examine a more complicated structure, the linked list.

ਅਸੀਂ ਅਗਲਾ ਇੱਕ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਢਾਂਚਾ, ਲਿੰਕਡ ਸੂਚੀ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਾਂ।


For simplicity, we’ll omit some of the obvious routines.

ਸੌਖ ਲਈ, ਅਸੀਂ ਕੁਝ ਸਪੱਸ਼ਟ ਰੁਟੀਨਾਂ ਨੂੰ ਛੱਡ ਦੇਵਾਂਗੇ।


One small tricky issue arises if malloc() happens to fail.

ਇੱਕ ਛੋਟਾ ਜਿਹਾ ਗੁੰਝਲਦਾਰ ਮੁੱਦਾ ਉੱਠਦਾ ਹੈ ਜੇਕਰ malloc() ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ।


Can we rewrite the insert and lookup routines to remain correct under concurrent insert?

ਕੀ ਅਸੀਂ ਸਮਕਾਲੀ ਸੰਮਿਲਨ ਦੇ ਅਧੀਨ ਸਹੀ ਰਹਿਣ ਲਈ ਸੰਮਿਲਨ ਅਤੇ ਲੁੱਕਅੱਪ ਰੁਟੀਨਾਂ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖ ਸਕਦੇ ਹਾਂ?


ਇਹ ਵਿਚਾਰ ਕਾਫ਼ੀ ਸਧਾਰਨ ਹੈ।


Simple schemes tend to work well, especially if they use costly routines rarely.

ਸਧਾਰਨ ਸਕੀਮਾਂ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜੇਕਰ ਉਹ ਘੱਟ ਹੀ ਮਹਿੰਗੀਆਂ ਰੁਟੀਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀਆਂ ਹਨ।


We end our discussion with a simple and widely applicable concurrent data structure, the hash table.

ਅਸੀਂ ਆਪਣੀ ਚਰਚਾ ਨੂੰ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਵਿਆਪਕ ਤੌਰ 'ਤੇ ਲਾਗੂ ਹੋਣ ਵਾਲੇ ਸਮਕਾਲੀ ਡਾਟਾ ਢਾਂਚੇ, ਹੈਸ਼ ਟੇਬਲ ਨਾਲ ਸਮਾਪਤ ਕਰਦੇ ਹਾਂ।


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.

ਇਹ ਮਨ੍ਹਾ ਹੈ; ਅਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਨਿਰਮਾਤਾ ਦਾ ਕੋਈ ਵੀ ਡਾਟਾ ਗੁੰਮ ਹੋ ਜਾਵੇ।


As you can see, what we’ve forgotten here is mutual exclusion.

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਜੋ ਅਸੀਂ ਇੱਥੇ ਭੁੱਲ ਗਏ ਹਾਂ ਉਹ ਹੈ ਆਪਸੀ ਬਾਹਰ ਕੱਢਣਾ।


The consumer acquires the mutex and is waiting for someone to signal full.

ਖਪਤਕਾਰ ਮਿਊਟੈਕਸ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਕਿਸੇ ਦੇ ਪੂਰਾ ਹੋਣ ਦਾ ਸੰਕੇਤ ਦੇਣ ਦੀ ਉਡੀਕ ਕਰ ਰਿਹਾ ਹੈ।


To solve this problem, we simply must reduce the scope of the lock.

ਇਸ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਸਿਰਫ਼ ਲਾਕ ਦੇ ਦਾਇਰੇ ਨੂੰ ਘਟਾਉਣਾ ਚਾਹੀਦਾ ਹੈ।


Reader-writer locks should be used with some caution.

ਰੀਡਰ-ਰਾਈਟਰ ਲਾਕ ਦੀ ਵਰਤੋਂ ਕੁਝ ਸਾਵਧਾਨੀ ਨਾਲ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ।


The problem is famous because it is fun and somewhat intellectually interesting.

ਸਮੱਸਿਆ ਮਸ਼ਹੂਰ ਹੈ ਕਿਉਂਕਿ ਇਹ ਮਜ਼ੇਦਾਰ ਹੈ ਅਤੇ ਕੁਝ ਹੱਦ ਤੱਕ ਬੌਧਿਕ ਤੌਰ 'ਤੇ ਦਿਲਚਸਪ ਹੈ।


In order to eat, a philosopher needs two forks.

ਖਾਣ ਲਈ, ਇੱਕ ਦਾਰਸ਼ਨਿਕ ਨੂੰ ਦੋ ਕਾਂਟਿਆਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


The key challenge is to write the routines getforks() and putforks().

ਮੁੱਖ ਚੁਣੌਤੀ ਰੁਟੀਨ getforks() ਅਤੇ putforks() ਲਿਖਣਾ ਹੈ।


The intuition behind this (broken) solution is as follows.

ਇਸ (ਟੁੱਟੇ ਹੋਏ) ਹੱਲ ਦੇ ਪਿੱਛੇ ਦੀ ਅਨੁਭੂਤੀ ਇਸ ਪ੍ਰਕਾਰ ਹੈ।


ਸਮੱਸਿਆ ਡੈੱਡਲਾਕ ਹੈ।


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.

ਜੇਕਰ ਹਰੇਕ ਦਾਰਸ਼ਨਿਕ ਆਪਣੇ ਖੱਬੇ ਪਾਸੇ ਦਾ ਕਾਂਟਾ ਫੜ ਲੈਂਦਾ ਹੈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਕੋਈ ਵੀ ਦਾਰਸ਼ਨਿਕ ਆਪਣੇ ਸੱਜੇ ਪਾਸੇ ਦਾ ਕਾਂਟਾ ਫੜ ਸਕੇ, ਤਾਂ ਹਰ ਕੋਈ ਫਸ ਜਾਵੇਗਾ।


Because the last philosopher tries to grab right before left, there is no situation where each philosopher grabs one fork and is stuck waiting for another.

ਕਿਉਂਕਿ ਆਖਰੀ ਦਾਰਸ਼ਨਿਕ ਖੱਬੇ ਤੋਂ ਪਹਿਲਾਂ ਸੱਜੇ ਨੂੰ ਫੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ, ਅਜਿਹੀ ਕੋਈ ਸਥਿਤੀ ਨਹੀਂ ਹੈ ਜਿੱਥੇ ਹਰੇਕ ਦਾਰਸ਼ਨਿਕ ਇੱਕ ਕਾਂਟਾ ਫੜ ਲੈਂਦਾ ਹੈ ਅਤੇ ਦੂਜੇ ਦੀ ਉਡੀਕ ਵਿੱਚ ਫਸ ਜਾਂਦਾ ਹੈ।


Study the code for yourself until you really understand it.

ਆਪਣੇ ਲਈ ਕੋਡ ਦਾ ਅਧਿਐਨ ਕਰੋ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਇਸਨੂੰ ਅਸਲ ਵਿੱਚ ਨਹੀਂ ਸਮਝਦੇ।


Semaphores are a powerful and flexible primitive for writing concurrent programs.

ਸੈਮਾਫੋਰ ਸਮਕਾਲੀ ਪ੍ਰੋਗਰਾਮ ਲਿਖਣ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਅਤੇ ਲਚਕਦਾਰ ਪ੍ਰਾਇਮਰੀ ਹਨ।


In this chapter, we have presented just a few classic problems and solutions.

ਇਸ ਅਧਿਆਇ ਵਿੱਚ, ਅਸੀਂ ਸਿਰਫ਼ ਕੁਝ ਕਲਾਸਿਕ ਸਮੱਸਿਆਵਾਂ ਅਤੇ ਹੱਲ ਪੇਸ਼ ਕੀਤੇ ਹਨ।


Becoming a real concurrency expert takes years of effort.

ਇੱਕ ਅਸਲ ਸਮਕਾਲੀ ਮਾਹਰ ਬਣਨ ਵਿੱਚ ਸਾਲਾਂ ਦੀ ਕੋਸ਼ਿਸ਼ ਲੱਗਦੀ ਹੈ।


Concurrency bugs tend to come in a variety of common patterns.

ਸਮਕਾਲੀ ਬੱਗ ਆਮ ਪੈਟਰਨਾਂ ਦੀ ਇੱਕ ਕਿਸਮ ਵਿੱਚ ਆਉਂਦੇ ਹਨ।


ਖਪਤਕਾਰ ਸਿਰਫ਼ ਵਾਪਸ ਸੌਂ ਜਾਂਦਾ ਹੈ।


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.

ਇੱਕ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚ ਇੱਕ ਸ਼ਰਤ ਦੀ ਜਾਂਚ ਕਰਦੇ ਸਮੇਂ, ਇੱਕ ਵਾਈਲ ਲੂਪ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹਮੇਸ਼ਾ ਸਹੀ ਹੁੰਦਾ ਹੈ।


In some thread packages, it is possible that two threads get woken up though just a single signal has taken place.

ਕੁਝ ਥ੍ਰੈਡ ਪੈਕੇਜਾਂ ਵਿੱਚ, ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਦੋ ਥ੍ਰੈਡ ਜਾਗ ਜਾਣਗੇ ਭਾਵੇਂ ਸਿਰਫ਼ ਇੱਕ ਸਿੰਗਲ ਸਿਗਨਲ ਹੋਇਆ ਹੋਵੇ।


The problem they ran into is best shown via simple example.

ਉਹ ਜਿਸ ਸਮੱਸਿਆ ਵਿੱਚ ਭੱਜੇ, ਉਹ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਰਾਹੀਂ ਸਭ ਤੋਂ ਵਧੀਆ ਦਿਖਾਈ ਗਈ ਹੈ।


The astute reader might also have noticed we could have used this approach earlier.

ਚੁਸਤ ਪਾਠਕ ਨੇ ਇਹ ਵੀ ਦੇਖਿਆ ਹੋਵੇਗਾ ਕਿ ਅਸੀਂ ਇਸ ਪਹੁੰਚ ਦੀ ਪਹਿਲਾਂ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਸੀ।


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, sem_wait() or sem_post().

ਇੱਕ ਸੈਮਾਫੋਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਇਸਦੇ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਲਈ ਦੋ ਵਿੱਚੋਂ ਇੱਕ ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦੇ ਹਾਂ, sem_wait() ਜਾਂ sem_post().


For now, we are not concerned with the implementation of these routines, which clearly requires some care.

ਇਸ ਵੇਲੇ, ਅਸੀਂ ਇਹਨਾਂ ਰੁਟੀਨਾਂ ਦੇ ਲਾਗੂ ਹੋਣ ਨਾਲ ਚਿੰਤਤ ਨਹੀਂ ਹਾਂ, ਜਿਸ ਲਈ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਕੁਝ ਦੇਖਭਾਲ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।


First, we can see that sem_wait() will either return right away.

ਪਹਿਲਾਂ, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ sem_wait() ਜਾਂ ਤਾਂ ਤੁਰੰਤ ਵਾਪਸ ਆ ਜਾਵੇਗਾ।


Second, we can see that sem_post() does not wait for some particular condition to hold.

ਦੂਜਾ, ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ ਕਿ sem_post() ਕੁਝ ਖਾਸ ਸ਼ਰਤ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਨਹੀਂ ਕਰਦਾ ਹੈ।


ਅਸੀਂ ਹੁਣ ਇੱਕ ਸੈਮਾਫੋਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਤਿਆਰ ਹਾਂ।


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.

ਸੈਮਾਫੋਰ ਉਦੋਂ ਵੀ ਉਪਯੋਗੀ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਇੱਕ ਥ੍ਰੈਡ ਕਿਸੇ ਸ਼ਰਤ ਦੇ ਸੱਚ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰਦੇ ਹੋਏ ਆਪਣੀ ਤਰੱਕੀ ਨੂੰ ਰੋਕਣਾ ਚਾਹੁੰਦਾ ਹੈ।


ਇਸ ਅਧਿਐਨ ਵਿੱਚ ਸਮਕਾਲੀਨਤਾ ਦੀਆਂ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕੀਤੀ ਗਈ ਹੈ।


MySQL is a popular database management system.

MySQL ਇੱਕ ਮਸ਼ਹੂਰ ਡਾਟਾਬੇਸ ਪ੍ਰਬੰਧਨ ਸਿਸਟਮ ਹੈ।


ਲੇਖਕ ਸਮਕਾਲੀਨਤਾ ਦੀਆਂ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਦੇ ਹਨ।


Understanding these results can help you understand what types of problems actually occur.

ਇਨ੍ਹਾਂ ਨਤੀਜਿਆਂ ਨੂੰ ਸਮਝਣ ਨਾਲ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਵਿੱਚ ਮਦਦ ਮਿਲ ਸਕਦੀ ਹੈ ਕਿ ਅਸਲ ਵਿੱਚ ਕਿਸ ਤਰ੍ਹਾਂ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਆਉਂਦੀਆਂ ਹਨ।


ਟੇਬਲ 32.1 ਗਲਤੀਆਂ ਦਾ ਸਾਰ ਦਰਸਾਉਂਦਾ ਹੈ।


ਜ਼ਿਆਦਾਤਰ ਗਲਤੀਆਂ ਡੈੱਡਲਾਕ ਨਹੀਂ ਸਨ।


We now dive into these different classes of bugs.

ਹੁਣ ਅਸੀਂ ਇਨ੍ਹਾਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੀਆਂ ਗਲਤੀਆਂ ਵਿੱਚ ਡੂੰਘਾਈ ਨਾਲ ਜਾਂਚ ਕਰਦੇ ਹਾਂ।


Atomicity-Violation Bugs are a type of problem.

ਐਟੋਮਿਸਿਟੀ-ਵਾਇਲੇਸ਼ਨ ਗਲਤੀਆਂ ਇੱਕ ਕਿਸਮ ਦੀ ਸਮੱਸਿਆ ਹਨ।


Here is a simple example, found in MySQL.

ਇੱਥੇ ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਹੈ, ਜੋ MySQL ਵਿੱਚ ਮਿਲਦੀ ਹੈ।


ਕੋਡ ਵਿੱਚ ਇੱਕ ਐਟੋਮਿਸਿਟੀ ਧਾਰਨਾ ਹੈ।


Finding a fix for this type of problem is often straightforward.

ਇਸ ਕਿਸਮ ਦੀ ਸਮੱਸਿਆ ਦਾ ਹੱਲ ਲੱਭਣਾ ਅਕਸਰ ਸਿੱਧਾ ਹੁੰਦਾ ਹੈ।


We simply add locks around the shared-variable references.

ਅਸੀਂ ਸਾਂਝੇ-ਵੇਰੀਏਬਲ ਹਵਾਲਿਆਂ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸਿਰਫ਼ ਲਾਕ ਜੋੜਦੇ ਹਾਂ।


Another common type of non-deadlock bug 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.

ਜਦੋਂ ਥ੍ਰੈਡਾਂ ਵਿਚਕਾਰ ਆਰਡਰ ਮਹੱਤਵਪੂਰਨ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸ਼ਰਤ ਵੇਰੀਏਬਲ ਬਚਾਅ ਲਈ ਆ ਸਕਦੇ ਹਨ।


A large fraction of non-deadlock bugs are either atomicity or order violations.

ਗੈਰ-ਡੈੱਡਲਾਕ ਗਲਤੀਆਂ ਦਾ ਇੱਕ ਵੱਡਾ ਹਿੱਸਾ ਜਾਂ ਤਾਂ ਐਟੋਮਿਸਿਟੀ ਜਾਂ ਆਰਡਰ ਦੀ ਉਲੰਘਣਾ ਹੈ।


Deadlock occurs in many concurrent systems.

ਡੈੱਡਲਾਕ ਬਹੁਤ ਸਾਰੇ ਸਮਕਾਲੀ ਪ੍ਰਣਾਲੀਆਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ।


How should we build systems to prevent deadlock?

ਸਾਨੂੰ ਡੈੱਡਲਾਕ ਨੂੰ ਰੋਕਣ ਲਈ ਸਿਸਟਮ ਕਿਵੇਂ ਬਣਾਉਣੇ ਚਾਹੀਦੇ ਹਨ?


Simple deadlocks seem readily avoidable.

ਸਧਾਰਨ ਡੈੱਡਲਾਕ ਆਸਾਨੀ ਨਾਲ ਬਚਣਯੋਗ ਲੱਗਦੇ ਹਨ।


One reason is that in large code bases, complex dependencies arise.

ਇੱਕ ਕਾਰਨ ਇਹ ਹੈ ਕਿ ਵੱਡੇ ਕੋਡ ਅਧਾਰਾਂ ਵਿੱਚ, ਗੁੰਝਲਦਾਰ ਨਿਰਭਰਤਾਵਾਂ ਪੈਦਾ ਹੁੰਦੀਆਂ ਹਨ।


ਕਿਤਾਬ ਮੇਜ਼ ਉੱਤੇ ਹੈ।


ਤੁਸੀਂ ਕਿਵੇਂ ਹੋ?


ਅੱਜ ਮੌਸਮ ਚੰਗਾ ਹੈ।


ਮੈਨੂੰ ਸੇਬ ਖਾਣਾ ਪਸੰਦ ਹੈ।


ਕਿਰਪਾ ਕਰਕੇ ਦਰਵਾਜ਼ਾ ਬੰਦ ਕਰੋ।


ਕੰਪਨੀ ਨੇ ਇੱਕ ਨਵੇਂ ਉਤਪਾਦ ਦਾ ਐਲਾਨ ਕੀਤਾ।


ਉਹ ਕੰਪਿਊਟਰ ਵਿਗਿਆਨ ਦੀ ਪੜ੍ਹਾਈ ਕਰ ਰਿਹਾ ਹੈ।


The government is working on a new policy.

ਸਰਕਾਰ ਇੱਕ ਨਵੀਂ ਨੀਤੀ 'ਤੇ ਕੰਮ ਕਰ ਰਹੀ ਹੈ।


She went to the market to buy vegetables.

ਉਹ ਸਬਜ਼ੀਆਂ ਖਰੀਦਣ ਲਈ ਬਾਜ਼ਾਰ ਗਈ।


ਮੀਟਿੰਗ ਦੁਪਹਿਰ 2 ਵਜੇ ਸ਼ੁਰੂ ਹੋਵੇਗੀ।


The algorithm efficiently sorts the data.

ਐਲਗੋਰਿਦਮ ਡਾਟਾ ਨੂੰ ਕੁਸ਼ਲਤਾ ਨਾਲ ਛਾਂਟਦਾ ਹੈ।


The research paper explores the impact of climate change.

ਖੋਜ ਪੱਤਰ ਜਲਵਾਯੂ ਪਰਿਵਰਤਨ ਦੇ ਪ੍ਰਭਾਵ ਦੀ ਪੜਚੋਲ ਕਰਦਾ ਹੈ।


The company's financial performance exceeded expectations.

ਕੰਪਨੀ ਦਾ ਵਿੱਤੀ ਪ੍ਰਦਰਸ਼ਨ ਉਮੀਦਾਂ ਤੋਂ ਵੱਧ ਗਿਆ।


The complex system requires careful analysis.

ਗੁੰਝਲਦਾਰ ਪ੍ਰਣਾਲੀ ਨੂੰ ਧਿਆਨ ਨਾਲ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਲੋੜ ਹੈ।


The implications of the new technology are far-reaching.

ਨਵੀਂ ਤਕਨਾਲੋਜੀ ਦੇ ਪ੍ਰਭਾਵ ਦੂਰ-ਦੂਰ ਤੱਕ ਫੈਲੇ ਹੋਏ ਹਨ।


The judge delivered a verdict of not guilty.

ਜੱਜ ਨੇ ਦੋਸ਼ੀ ਨਾ ਹੋਣ ਦਾ ਫੈਸਲਾ ਸੁਣਾਇਆ।


The economic reforms have had a significant impact on the country.

ਆਰਥਿਕ ਸੁਧਾਰਾਂ ਦਾ ਦੇਸ਼ 'ਤੇ ਮਹੱਤਵਪੂਰਨ ਪ੍ਰਭਾਵ ਪਿਆ ਹੈ।


The scientific community is debating the findings of the study.

ਵਿਗਿਆਨਕ ਭਾਈਚਾਰਾ ਅਧਿਐਨ ਦੇ ਨਤੀਜਿਆਂ 'ਤੇ ਬਹਿਸ ਕਰ ਰਿਹਾ ਹੈ।


The project's success depends on effective collaboration.

ਪ੍ਰੋਜੈਕਟ ਦੀ ਸਫਲਤਾ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਸਹਿਯੋਗ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ।


The philosophical implications of artificial intelligence are profound.

ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ ਦੇ ਦਾਰਸ਼ਨਿਕ ਪ੍ਰਭਾਵ ਡੂੰਘੇ ਹਨ।


ਸਰਵਰ ਰੱਖ-ਰਖਾਅ ਲਈ ਬੰਦ ਹੈ।


ਕਿਰਪਾ ਕਰਕੇ ਕੰਪਿਊਟਰ ਨੂੰ ਮੁੜ ਚਾਲੂ ਕਰੋ।


ਖ਼ਬਰਾਂ ਵਿੱਚ ਇੱਕ ਵੱਡੇ ਭੂਚਾਲ ਦੀ ਰਿਪੋਰਟ ਦਿੱਤੀ ਗਈ।


ਉਹ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਇੱਕ ਕਿਤਾਬ ਪੜ੍ਹ ਰਹੀ ਹੈ।


ਕੀ ਤੁਸੀਂ ਇਸ ਸਮੱਸਿਆ ਵਿੱਚ ਮੇਰੀ ਮਦਦ ਕਰ ਸਕਦੇ ਹੋ?


The company announced its quarterly results.

ਕੰਪਨੀ ਨੇ ਆਪਣੇ ਤਿਮਾਹੀ ਨਤੀਜਿਆਂ ਦਾ ਐਲਾਨ ਕੀਤਾ।


The government is discussing new policies.

ਸਰਕਾਰ ਨਵੀਂਆਂ ਨੀਤੀਆਂ 'ਤੇ ਚਰਚਾ ਕਰ ਰਹੀ ਹੈ।


The research team published their findings.

ਖੋਜ ਟੀਮ ਨੇ ਆਪਣੇ ਖੋਜ ਨਤੀਜੇ ਪ੍ਰਕਾਸ਼ਿਤ ਕੀਤੇ।


The meeting was held to discuss the project's progress.

ਮੀਟਿੰਗ ਪ੍ਰੋਜੈਕਟ ਦੀ ਪ੍ਰਗਤੀ 'ਤੇ ਚਰਚਾ ਕਰਨ ਲਈ ਕੀਤੀ ਗਈ ਸੀ।


ਚੁਣੌਤੀਆਂ ਦੇ ਬਾਵਜੂਦ, ਉਹ ਸਫਲ ਹੋਏ।


The economic forecast predicts a recession.

ਆਰਥਿਕ ਪੂਰਵ ਅਨੁਮਾਨ ਇੱਕ ਮੰਦੀ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ।


The philosophical debate explored existentialism.

ਦਾਰਸ਼ਨਿਕ ਬਹਿਸ ਨੇ ਹੋਂਦਵਾਦ ਦੀ ਪੜਚੋਲ ਕੀਤੀ।


The intricate design of the software is impressive.

ਸਾਫਟਵੇਅਰ ਦਾ ਗੁੰਝਲਦਾਰ ਡਿਜ਼ਾਈਨ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਹੈ।


The implications of the new law are far-reaching.

ਨਵੇਂ ਕਾਨੂੰਨ ਦੇ ਪ੍ਰਭਾਵ ਦੂਰ-ਦੂਰ ਤੱਕ ਫੈਲੇ ਹੋਏ ਹਨ।


The company's strategic plan involves global expansion.

ਕੰਪਨੀ ਦੀ ਰਣਨੀਤਕ ਯੋਜਨਾ ਵਿੱਚ ਵਿਸ਼ਵ ਪੱਧਰ 'ਤੇ ਵਿਸਥਾਰ ਸ਼ਾਮਲ ਹੈ।


The scientific community is debating climate change.

ਵਿਗਿਆਨਕ ਭਾਈਚਾਰਾ ਜਲਵਾਯੂ ਪਰਿਵਰਤਨ 'ਤੇ ਬਹਿਸ ਕਰ ਰਿਹਾ ਹੈ।


The historical analysis revealed hidden truths.

ਇਤਿਹਾਸਕ ਵਿਸ਼ਲੇਸ਼ਣ ਨੇ ਲੁਕਵੇਂ ਸੱਚਾਈਆਂ ਦਾ ਖੁਲਾਸਾ ਕੀਤਾ।


The intricate details of the contract were carefully reviewed.

ਇਕਰਾਰਨਾਮੇ ਦੇ ਗੁੰਝਲਦਾਰ ਵੇਰਵਿਆਂ ਦੀ ਧਿਆਨ ਨਾਲ ਸਮੀਖਿਆ ਕੀਤੀ ਗਈ।


ਪਤਾ 0x1F3 = LBA ਘੱਟ ਬਾਈਟ


ਡਰਾਈਵ ਦੇ ਤਿਆਰ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੋ।


ਕਮਾਂਡ ਰਜਿਸਟਰਾਂ ਵਿੱਚ ਪੈਰਾਮੀਟਰ ਲਿਖੋ।


ਵਿਘਨਾਂ ਨੂੰ ਸੰਭਾਲੋ।


If the ERROR bit is on, read the error register for details.

ਜੇਕਰ ERROR ਬਿੱਟ ਚਾਲੂ ਹੈ, ਤਾਂ ਵੇਰਵਿਆਂ ਲਈ ਗਲਤੀ ਰਜਿਸਟਰ ਪੜ੍ਹੋ।


The basic protocol to interact with the device is as follows.

ਡਿਵਾਈਸ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨ ਦਾ ਮੁੱਢਲਾ ਪ੍ਰੋਟੋਕੋਲ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਹੈ।


The drive consists of a large number of sectors.

ਡਰਾਈਵ ਵਿੱਚ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਸੈਕਟਰ ਹੁੰਦੇ ਹਨ।


ਮਲਟੀ-ਸੈਕਟਰ ਓਪਰੇਸ਼ਨ ਸੰਭਵ ਹਨ।


The basic interface for all modern drives is straightforward.

ਸਾਰੇ ਆਧੁਨਿਕ ਡਰਾਈਵਾਂ ਲਈ ਮੁੱਢਲਾ ਇੰਟਰਫੇਸ ਸਿੱਧਾ ਹੈ।


The sectors are numbered from 0 to n-1 on a disk with n sectors.

ਸੈਕਟਰਾਂ ਨੂੰ n ਸੈਕਟਰਾਂ ਵਾਲੀ ਡਿਸਕ 'ਤੇ 0 ਤੋਂ n-1 ਤੱਕ ਗਿਣਿਆ ਜਾਂਦਾ ਹੈ।


How do modern hard-disk drives store data?

ਆਧੁਨਿਕ ਹਾਰਡ-ਡਿਸਕ ਡਰਾਈਵ ਡਾਟਾ ਕਿਵੇਂ ਸਟੋਰ ਕਰਦੇ ਹਨ?


Let’s start by understanding the interface to a modern disk drive.

ਆਓ ਇੱਕ ਆਧੁਨਿਕ ਡਿਸਕ ਡਰਾਈਵ ਦੇ ਇੰਟਰਫੇਸ ਨੂੰ ਸਮਝ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ।


The drive has to first move the disk arm to the correct track.

ਡਰਾਈਵ ਨੂੰ ਪਹਿਲਾਂ ਡਿਸਕ ਆਰਮ ਨੂੰ ਸਹੀ ਟ੍ਰੈਕ 'ਤੇ ਲਿਜਾਣਾ ਪੈਂਦਾ ਹੈ।


Seeks, along with rotations, are one of the most costly disk operations.

ਖੋਜਾਂ, ਰੋਟੇਸ਼ਨਾਂ ਦੇ ਨਾਲ, ਸਭ ਤੋਂ ਮਹਿੰਗੇ ਡਿਸਕ ਓਪਰੇਸ਼ਨਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹਨ।


The disk head is attached to a single disk arm.

ਡਿਸਕ ਹੈੱਡ ਇੱਕ ਸਿੰਗਲ ਡਿਸਕ ਆਰਮ ਨਾਲ ਜੁੜਿਆ ਹੁੰਦਾ ਹੈ।


Data is encoded on each surface in concentric circles of sectors.

ਡਾਟਾ ਹਰੇਕ ਸਤਹ 'ਤੇ ਸੈਕਟਰਾਂ ਦੇ ਸੰਕੇਂਦਰੀ ਚੱਕਰਾਂ ਵਿੱਚ ਏਨਕੋਡ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।


The rate of rotation is often measured in rotations per minute (RPM).

ਰੋਟੇਸ਼ਨ ਦੀ ਦਰ ਨੂੰ ਅਕਸਰ ਪ੍ਰਤੀ ਮਿੰਟ ਰੋਟੇਸ਼ਨਾਂ (RPM) ਵਿੱਚ ਮਾਪਿਆ ਜਾਂਦਾ ਹੈ।


ਇੱਕ ਡਿਸਕ ਵਿੱਚ ਇੱਕ ਜਾਂ ਵੱਧ ਪਲੇਟਰ ਹੋ ਸਕਦੇ ਹਨ।


Let's understand how disks work by building up a model one track at a time.

ਆਓ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰੈਕ ਦਾ ਮਾਡਲ ਬਣਾ ਕੇ ਸਮਝੀਏ ਕਿ ਡਿਸਕ ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ।


After the seek, the disk arm has positioned the head over the right track.

ਖੋਜ ਤੋਂ ਬਾਅਦ, ਡਿਸਕ ਆਰਮ ਨੇ ਹੈੱਡ ਨੂੰ ਸਹੀ ਟ੍ਰੈਕ 'ਤੇ ਰੱਖਿਆ ਹੈ।


The Cheetah 15K.5 is a high-performance SCSI drive.

ਚੀਤਾ 15K.5 ਇੱਕ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੀ SCSI ਡਰਾਈਵ ਹੈ।


The Barracuda is a drive built for capacity.

ਬੈਰਾਕੁਡਾ ਸਮਰੱਥਾ ਲਈ ਬਣਾਈ ਗਈ ਇੱਕ ਡਰਾਈਵ ਹੈ।


Details on both are found in Table 37.1.

ਦੋਵਾਂ ਦੇ ਵੇਰਵੇ ਟੇਬਲ 37.1 ਵਿੱਚ ਮਿਲਦੇ ਹਨ।


As you can see, the drives have quite different characteristics.

ਜਿਵੇਂ ਕਿ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ, ਡਰਾਈਵਾਂ ਦੀਆਂ ਬਹੁਤ ਵੱਖਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ।


The first is the “high performance” drive market.

ਪਹਿਲਾ “ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ” ਡਰਾਈਵ ਮਾਰਕੀਟ ਹੈ।


ਦੂਜਾ “ਸਮਰੱਥਾ” ਮਾਰਕੀਟ ਹੈ।


From these numbers, we can start to calculate how well the drives would do.

ਇਹਨਾਂ ਅੰਕੜਿਆਂ ਤੋਂ, ਅਸੀਂ ਇਹ ਗਣਨਾ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹਾਂ ਕਿ ਡਰਾਈਵ ਕਿੰਨੀ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਨਗੇ।


Let’s start by looking at the random workload.

ਆਓ ਬੇਤਰਤੀਬ ਕੰਮ ਦੇ ਬੋਝ ਨੂੰ ਦੇਖ ਕੇ ਸ਼ੁਰੂਆਤ ਕਰੀਏ।


Assuming each 4 KB read occurs at a random location on disk.

ਇਹ ਮੰਨਦੇ ਹੋਏ ਕਿ ਹਰੇਕ 4 KB ਰੀਡ ਡਿਸਕ 'ਤੇ ਇੱਕ ਬੇਤਰਤੀਬ ਸਥਾਨ 'ਤੇ ਹੁੰਦਾ ਹੈ।


The average seek time is just taken as the average time reported by the manufacturer.

ਔਸਤ ਸੀਕ ਟਾਈਮ ਸਿਰਫ਼ ਨਿਰਮਾਤਾ ਦੁਆਰਾ ਦੱਸੇ ਗਏ ਔਸਤ ਸਮੇਂ ਵਜੋਂ ਲਿਆ ਜਾਂਦਾ ਹੈ।


The average rotational delay is calculated from the RPM directly.

ਔਸਤ ਰੋਟੇਸ਼ਨਲ ਦੇਰੀ ਦੀ ਗਣਨਾ ਸਿੱਧੇ RPM ਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।


Finally, the transfer time is just the size of the transfer over the peak transfer rate.

ਅੰਤ ਵਿੱਚ, ਟ੍ਰਾਂਸਫਰ ਸਮਾਂ ਸਿਰਫ਼ ਸਿਖਰ ਟ੍ਰਾਂਸਫਰ ਦਰ ਉੱਤੇ ਟ੍ਰਾਂਸਫਰ ਦਾ ਆਕਾਰ ਹੈ।


To compute the rate of I/O, we just divide the size of the transfer by the average time.

I/O ਦੀ ਦਰ ਦੀ ਗਣਨਾ ਕਰਨ ਲਈ, ਅਸੀਂ ਸਿਰਫ਼ ਟ੍ਰਾਂਸਫਰ ਦੇ ਆਕਾਰ ਨੂੰ ਔਸਤ ਸਮੇਂ ਨਾਲ ਵੰਡਦੇ ਹਾਂ।


The same calculation for the Barracuda yields a T I/O of about 13.2 ms.

ਬੈਰਾਕੁਡਾ ਲਈ ਇੱਕੋ ਜਿਹੀ ਗਣਨਾ ਲਗਭਗ 13.2 ms ਦਾ T I/O ਦਿੰਦੀ ਹੈ।


Now let’s look at the sequential workload.

ਹੁਣ ਆਓ ਲੜੀਵਾਰ ਕੰਮ ਦੇ ਬੋਝ ਨੂੰ ਦੇਖੀਏ।


Here we can assume there is a single seek and rotation before a very long transfer.

ਇੱਥੇ ਅਸੀਂ ਮੰਨ ਸਕਦੇ ਹਾਂ ਕਿ ਇੱਕ ਬਹੁਤ ਲੰਬੇ ਟ੍ਰਾਂਸਫਰ ਤੋਂ ਪਹਿਲਾਂ ਇੱਕ ਸਿੰਗਲ ਸੀਕ ਅਤੇ ਰੋਟੇਸ਼ਨ ਹੈ।


For simplicity, assume the size of the transfer is 100 MB.

ਸੌਖ ਲਈ, ਮੰਨ ਲਓ ਕਿ ਟ੍ਰਾਂਸਫਰ ਦਾ ਆਕਾਰ 100 MB ਹੈ।


The rates of I/O are thus very nearly the peak transfer rates of 125 MB/s and 105 MB/s, respectively.

ਇਸ ਤਰ੍ਹਾਂ I/O ਦੀਆਂ ਦਰਾਂ ਕ੍ਰਮਵਾਰ 125 MB/s ਅਤੇ 105 MB/s ਦੀਆਂ ਸਿਖਰ ਟ੍ਰਾਂਸਫਰ ਦਰਾਂ ਦੇ ਬਹੁਤ ਨੇੜੇ ਹਨ।


First, and most importantly, there is a huge gap in drive performance.

ਪਹਿਲਾਂ, ਅਤੇ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ, ਡਰਾਈਵ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਇੱਕ ਵੱਡਾ ਪਾੜਾ ਹੈ।