ഹോംവർക്ക് (അളവെടുപ്പ്).


ഷെഡ്യൂളിംഗ് മെട്രിക്സുകൾ.


ആദ്യം വരുന്നയാൾക്ക് ആദ്യം (FIFO).


ഏറ്റവും ചെറിയ ജോലി ആദ്യം (SJF).


റൗണ്ട് റോബിൻ.


I/O ഉൾപ്പെടുത്തുന്നു.


MLFQ: അടിസ്ഥാന നിയമങ്ങൾ.


മുൻഗണന എങ്ങനെ മാറ്റാം.


മുൻഗണന വർദ്ധിപ്പിക്കൽ.


കൂടുതൽ നല്ല അക്കൗണ്ടിംഗ്.


Basic Concept: Tickets Represent Your Share.

അടിസ്ഥാന ആശയം: ടിക്കറ്റുകൾ നിങ്ങളുടെ ഓഹരിയെ പ്രതിനിധീകരിക്കുന്നു.


ടിക്കറ്റ് സംവിധാനങ്ങൾ.


ടിക്കറ്റുകൾ എങ്ങനെ നൽകാം?


പശ്ചാത്തലം: മൾട്ടിപ്രൊസസ്സർ ആർക്കിടെക്ചർ.


സമന്വയം മറക്കരുത്.


സിംഗിൾ-ക്യൂ ഷെഡ്യൂളിംഗ്.


മൾട്ടി-ക്യൂ ഷെഡ്യൂളിംഗ്.


അബ്‌സ്ട്രാക്ഷൻ: വിലാസ സ്ഥലങ്ങൾ.


ആദ്യകാല സംവിധാനങ്ങൾ.


തടസ്സങ്ങൾ നിയന്ത്രിക്കുന്നു.


ഒരു പ്രവർത്തനക്ഷമമായ സ്പിൻ ലോക്ക് നിർമ്മിക്കുന്നു.


സ്പിൻ ലോക്കുകൾ വിലയിരുത്തുന്നു.


താരതമ്യം ചെയ്യുക-മാറ്റുക.


ഒരു ലളിതമായ സമീപനം: വിളവ് നൽകുക, കുഞ്ഞേ.


Using Queues: Sleeping Instead Of Spinning.

ക്യൂകൾ ഉപയോഗിക്കുന്നു: കറങ്ങുന്നതിനുപകരം ഉറങ്ങുക.


വ്യത്യസ്ത OS, വ്യത്യസ്ത പിന്തുണ.


രണ്ട് ഘട്ട ലോക്കുകൾ.


സമാന്തര കൗണ്ടറുകൾ.


സമാന്തര ലിങ്ക്ഡ് ലിസ്റ്റുകൾ.


സമാന്തര ക്യൂകൾ.


സമാന്തര ഹാഷ് ടേബിൾ.


നിർവചനവും ദിനചര്യകളും.


The Producer/Consumer (Bound Buffer) Problem.

നിർമ്മാതാവ്/ഉപഭോക്താവ് (ബന്ധിത ബഫർ) പ്രശ്നം.


സാഹചര്യങ്ങൾ മൂടുന്നു.


സെമാഫോറുകൾ: ഒരു നിർവചനം.


ബൈനറി സെമാഫോറുകൾ (ലോക്കുകൾ).


സാഹചര്യ വേരിയബിളുകളായി സെമാഫോറുകൾ.


ഭക്ഷണശാലയിലെ തത്ത്വചിന്തകർ.


എന്തെല്ലാം തരത്തിലുള്ള ബഗുകളാണ് നിലവിലുള്ളത്?


Key To Fast Crash Recovery: Statelessness.

വേഗത്തിലുള്ള ക്രാഷ് വീണ്ടെടുക്കലിന്റെ താക്കോൽ: സ്റ്റേറ്റ്‌ലെസ്നെസ്.


NFSv2 പ്രോട്ടോക്കോൾ.


From Protocol to Distributed File System.

പ്രോട്ടോക്കോളിൽ നിന്ന് വിതരണം ചെയ്ത ഫയൽ സിസ്റ്റത്തിലേക്ക്.


Handling Server Failure with Idempotent Operations.

ഐഡംപോർട്ടന്റ് ഓപ്പറേഷനുകൾ ഉപയോഗിച്ച് സെർവർ പരാജയം കൈകാര്യം ചെയ്യുക.


Improving Performance: Client-side Caching.

പ്രകടനം മെച്ചപ്പെടുത്തുന്നു: ക്ലയിന്റ്-സൈഡ് കാഷിംഗ്.


കാഷെ സ്ഥിരത പ്രശ്നം.


NFS കാഷെ സ്ഥിരത വിലയിരുത്തുന്നു.


Implications on Server-Side Write Buffering.

സെർവർ-സൈഡ് റൈറ്റ് ബഫറിംഗിന്റെ പ്രത്യാഘാതങ്ങൾ.


AFS പതിപ്പ് 1.


പതിപ്പ് 1-ലെ പ്രശ്നങ്ങൾ.


പ്രോട്ടോക്കോൾ മെച്ചപ്പെടുത്തുന്നു.


AFS പതിപ്പ് 2.


കാഷെ സ്ഥിരത.


ക്രാഷ് വീണ്ടെടുക്കൽ.


AFSv2-ന്റെ സ്കെയിലും പ്രകടനവും.


AFS: മറ്റ് മെച്ചപ്പെടുത്തലുകൾ.


വിതരണത്തെക്കുറിച്ചുള്ള സംഗ്രഹ സംവാദം.


Simple Example: Code That Loops and Prints.

ലളിതമായ ഉദാഹരണം: ലൂപ്പ് ചെയ്ത് പ്രിന്റ് ചെയ്യുന്ന കോഡ്.


ഒരേ സമയം നിരവധി പ്രോഗ്രാമുകൾ പ്രവർത്തിപ്പിക്കുന്നു.


മെമ്മറി ആക്സസ് ചെയ്യുന്ന ഒരു പ്രോഗ്രാം.


The operating system virtualizes resources.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വിഭവങ്ങൾ വെർച്വലൈസ് ചെയ്യുന്നു.


A running program executes instructions.

പ്രവർത്തിക്കുന്ന ഒരു പ്രോഗ്രാം നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുന്നു.


ഓപ്പറേറ്റിംഗ് സിസ്റ്റം സിസ്റ്റം ഉപയോഗിക്കാൻ എളുപ്പമാക്കുന്നു.


വെർച്വലൈസേഷൻ ഒരു പ്രധാന സാങ്കേതികതയാണ്.


ആപ്ലിക്കേഷനുകൾക്കായി OS API-കൾ നൽകുന്നു.


CPU സിസ്റ്റത്തിന്റെ ഒരു വിഭവമാണ്.


The program prints the string to the console.

പ്രോഗ്രാം സ്ട്രിംഗ് കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യുന്നു.


The operating system manages resources efficiently.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വിഭവങ്ങൾ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യുന്നു.


Multiple programs seem to run at the same time.

ഒന്നിലധികം പ്രോഗ്രാമുകൾ ഒരേ സമയം പ്രവർത്തിക്കുന്നതായി തോന്നുന്നു.


ഓപ്പറേറ്റിംഗ് സിസ്റ്റം CPU വെർച്വലൈസ് ചെയ്യുന്നു.


Each process has its own virtual address space.

ഓരോ പ്രോസസ്സിനും അതിൻ്റേതായ വെർച്വൽ വിലാസ ഇടമുണ്ട്.


Concurrency is a major theme of this book.

ഈ പുസ്തകത്തിലെ ഒരു പ്രധാന വിഷയമാണ് കൺകറൻസി.


Modern multi-threaded programs exhibit concurrency problems.

ആധുനിക മൾട്ടി-ത്രെഡ് പ്രോഗ്രാമുകൾ കൺകറൻസി പ്രശ്നങ്ങൾ കാണിക്കുന്നു.


The operating system is in charge of this illusion.

ഈ മിഥ്യക്ക് പിന്നിൽ പ്രവർത്തിക്കുന്നത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ്.


The OS transforms a physical resource into a virtual form.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു ഭൗതിക വിഭവത്തെ ഒരു വെർച്വൽ രൂപത്തിലേക്ക് മാറ്റുന്നു.


How does the OS virtualize resources efficiently?

എങ്ങനെയാണ് OS വിഭവങ്ങൾ കാര്യക്ഷമമായി വെർച്വലൈസ് ചെയ്യുന്നത്?


The program allocates memory using malloc().

പ്രോഗ്രാം malloc() ഉപയോഗിച്ച് മെമ്മറി അനുവദിക്കുന്നു.


The OS provides a standard library to applications.

ആപ്ലിക്കേഷനുകൾക്കായി OS ഒരു സ്റ്റാൻഡേർഡ് ലൈബ്രറി നൽകുന്നു.


Understanding concurrency is crucial for building correct programs.

കൃത്യമായ പ്രോഗ്രാമുകൾ നിർമ്മിക്കുന്നതിന് കൺകറൻസി മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.


The operating system is a resource manager.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഒരു വിഭവ മാനേജറാണ്.


The book is called Operating Systems: Three Easy Pieces.

ഈ പുസ്തകത്തിന്റെ പേര് ഓപ്പറേറ്റിംഗ് സിസ്റ്റംസ്: ത്രീ ഈസി പീസസ് എന്നാണ്.


This book will help you understand what operating systems are all about.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളെക്കുറിച്ച് നിങ്ങൾക്ക് മനസ്സിലാക്കാൻ ഈ പുസ്തകം സഹായിക്കും.


The three easy pieces refer to virtualization, concurrency, and persistence.

ഈസി പീസസ് എന്നാൽ വെർച്വലൈസേഷൻ, കൺകറൻസി, പെർസിസ്റ്റൻസ് എന്നിവയാണ്.


പുതിയ കാര്യങ്ങൾ പഠിക്കുന്നത് രസകരമാണ്, അല്ലേ?


Each major concept is divided into a set of chapters.

ഓരോ പ്രധാന ആശയവും അധ്യായങ്ങളായി തിരിച്ചിരിക്കുന്നു.


സാധ്യമെങ്കിൽ യഥാർത്ഥ കോഡ് ഉപയോഗിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു.


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

യഥാർത്ഥ സിസ്റ്റങ്ങളിൽ യഥാർത്ഥ കോഡ് പ്രവർത്തിപ്പിക്കുന്നത് പഠിക്കാനുള്ള ഏറ്റവും നല്ല മാർഗ്ഗമാണ്.


There are a few homeworks to ensure you are understanding what is going on.

എന്താണ് സംഭവിക്കുന്നതെന്ന് നിങ്ങൾക്ക് മനസ്സിലാകുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ കുറച്ച് ഹോംവർക്കുകൾ ഉണ്ട്.


The projects are in the C programming language.

പ്രോജക്റ്റുകൾ സി പ്രോഗ്രാമിംഗ് ഭാഷയിലാണ്.


സി ഒരു ലളിതവും ശക്തവുമായ ഭാഷയാണ്.


If you are an instructor, feel free to use this book.

നിങ്ങൾ ഒരു ഇൻസ്ട്രക്ടർ ആണെങ്കിൽ, ഈ പുസ്തകം ഉപയോഗിക്കാൻ മടിക്കേണ്ടതില്ല.


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

15 ആഴ്ചത്തെ സെമസ്റ്ററിൽ കോഴ്സ് നന്നായി വിഭജിക്കപ്പെട്ടിരിക്കുന്നു.


Concurrency is pushed off until the student understands virtualization.

വിദ്യാർത്ഥി വെർച്വലൈസേഷൻ മനസ്സിലാക്കിയ ശേഷം മാത്രമേ കൺകറൻസി പഠിപ്പിക്കുകയുള്ളൂ.


We believe in the most old-fashioned of teaching methods: chalk and a blackboard.

ഏറ്റവും പഴയ രീതിയിലുള്ള പഠന രീതിയാണ് ഞങ്ങൾ വിശ്വസിക്കുന്നത്: ചോക്കും, ബ്ലാക്ക്ബോർഡും.


Using the blackboard makes lecture a “live” viewing experience.

ബ്ലാക്ക്ബോർഡ് ഉപയോഗിക്കുന്നത് പ്രഭാഷണത്തെ ഒരു


If you are a student reading this book, thank you!

ഈ പുസ്തകം വായിക്കുന്ന ഒരു വിദ്യാർത്ഥിയാണെങ്കിൽ, നന്ദി!


പാഠപുസ്തകങ്ങൾ സാധാരണയായി വളരെ വിലകൂടിയതാണ്.


We hope to point you to the original sources.

യഥാർത്ഥ ഉറവിടങ്ങളിലേക്ക് നിങ്ങളെ എത്തിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു.


Ideas come from smart and hard-working people.

ആശയങ്ങൾ വരുന്നത് മിടുക്കരായ, കഠിനാധ്വാനം ചെയ്യുന്ന ആളുകളിൽ നിന്നാണ്.


The Turing Award is the highest award in Computer Science.

കമ്പ്യൂട്ടർ സയൻസിലെ ഏറ്റവും വലിയ പുരസ്കാരമാണ് ട്യൂറിംഗ് അവാർഡ്.


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

fork() സിസ്റ്റം കോൾ ഉപയോഗിച്ച് പ്രോഗ്രാം ഒരു പുതിയ പ്രോസസ്സ് ഉണ്ടാക്കുന്നു.


The child process then executes a different program using exec().

തുടർന്ന്, എക്സിക്യൂട്ട്() ഉപയോഗിച്ച് ശിശു പ്രോസസ്സ് മറ്റൊരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.


The parent process waits for the child to finish using wait().

ചൈൽഡ് പ്രോസസ്സ് പൂർത്തിയാകുന്നതുവരെ മാതാപിതാക്കൾ കാത്തിരിക്കുന്നത് വെയിറ്റ്() ഉപയോഗിച്ചാണ്.


This interlude discusses process creation in UNIX systems.

ഈ ആമുഖം UNIX സിസ്റ്റങ്ങളിൽ പ്രോസസ്സ് ഉണ്ടാക്കുന്നതിനെക്കുറിച്ച് ചർച്ച ചെയ്യുന്നു.


UNIX presents an intriguing way to create a new process.

ഒരു പുതിയ പ്രോസസ്സ് ഉണ്ടാക്കാൻ UNIX ഒരു കൗതുകകരമായ വഴി നൽകുന്നു.


The fork() system call is used to create a new process.

ഒരു പുതിയ പ്രോസസ്സ് ഉണ്ടാക്കാൻ fork() സിസ്റ്റം കോൾ ഉപയോഗിക്കുന്നു.


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

ചൈൽഡ് പ്രോസസ്സ്, മാതാപിതാക്കളുടെ ഏകദേശം കൃത്യമായ പകർപ്പാണ്.


The parent receives the PID of the child.

മാതാപിതാക്കൾക്ക് കുട്ടിയുടെ PID ലഭിക്കുന്നു.


ചൈൽഡ് പ്രോസസ്സിന് 0 തിരികെ ലഭിക്കുന്നു.


ഔട്ട്‌പുട്ട് നിർണ്ണയിക്കാനാകില്ല.


The CPU scheduler determines which process runs.

CPU ഷെഡ്യൂളർ ഏത് പ്രോസസ്സാണ് പ്രവർത്തിപ്പിക്കേണ്ടതെന്ന് നിർണ്ണയിക്കുന്നു.


The wait() system call delays execution.

wait() സിസ്റ്റം കോൾ എക്സിക്യൂഷൻ വൈകിപ്പിക്കുന്നു.


The exec() system call runs a different program.

exec() സിസ്റ്റം കോൾ മറ്റൊരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നു.


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

കമാൻഡുകൾ പ്രവർത്തിപ്പിക്കാൻ ഷെൽ fork() ഉം exec() ഉം ഉപയോഗിക്കുന്നു.


The output of a program can be redirected.

ഒരു പ്രോഗ്രാമിന്റെ ഔട്ട്‌പുട്ട് റീഡയറക്‌ട് ചെയ്യാൻ കഴിയും.


UNIX pipes are implemented in a similar way.

UNIX പൈപ്പുകൾ സമാനമായ രീതിയിലാണ് നടപ്പിലാക്കുന്നത്.


കൂടുതൽ വിവരങ്ങൾക്കായി മാനുവൽ പേജുകൾ വായിക്കുക.


The OS must virtualize the CPU efficiently.

OS CPU കാര്യക്ഷമമായി വെർച്വലൈസ് ചെയ്യണം.


നേരിട്ടുള്ള എക്സിക്യൂഷൻ വേഗതയുള്ളതാണ്.


User mode restricts what a process can do.

ഒരു പ്രോസസ്സിന് എന്ത് ചെയ്യാൻ കഴിയുമെന്നത് ഉപയോക്തൃ മോഡ് നിയന്ത്രിക്കുന്നു.


The operating system manages the computer's resources.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കമ്പ്യൂട്ടറിന്റെ വിഭവങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.


System calls allow user programs to access kernel functionality.

സിസ്റ്റം കോളുകൾ ഉപയോക്തൃ പ്രോഗ്രാമുകളെ കേർണൽ പ്രവർത്തനങ്ങൾ ആക്സസ് ചെയ്യാൻ അനുവദിക്കുന്നു.


The hardware saves the caller’s register state.

ഹാർഡ്‌വെയർ കോളറുടെ രജിസ്റ്റർ നില സംരക്ഷിക്കുന്നു.


The kernel initializes the trap table at boot time.

കേർണൽ ബൂട്ട് സമയത്ത് ട്രാപ്പ് പട്ടിക ആരംഭിക്കുന്നു.


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

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഈ ട്രാപ്പ് ഹാൻഡിലർമാരുടെ സ്ഥാനങ്ങളെക്കുറിച്ച് ഹാർഡ്‌വെയറിനെ അറിയിക്കുന്നു.


The process wishes to issue a system call, it traps back into the OS.

പ്രക്രിയ ഒരു സിസ്റ്റം കോൾ നൽകാൻ ആഗ്രഹിക്കുമ്പോൾ, അത് വീണ്ടും OS-ലേക്ക് പ്രവേശിക്കുന്നു.


ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വൃത്തിയാക്കുന്നു, നമ്മൾ പൂർത്തിയാകുന്നു.


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?

പ്രക്രിയകൾക്കിടയിൽ മാറാൻ കഴിയുന്ന തരത്തിൽ എങ്ങനെയാണ് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് CPU-ന്റെ നിയന്ത്രണം വീണ്ടെടുക്കാൻ കഴിയുക?


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

അപ്ലിക്കേഷനുകൾ എന്തെങ്കിലും നിയമവിരുദ്ധമായി ചെയ്യുമ്പോൾ, അവ OS-ലേക്ക് നിയന്ത്രണം കൈമാറുന്നു.


The OS will then have control of the CPU again.

അതിനുശേഷം OS-ന് വീണ്ടും CPU-ന്റെ നിയന്ത്രണം ലഭിക്കും.


What happens if a process ends up in an infinite loop?

ഒരു പ്രക്രിയ അനന്തമായ ലൂപ്പിൽ എത്തിയാൽ എന്ത് സംഭവിക്കും?


A timer interrupt halts the currently running process.

ഒരു ടൈമർ തടസ്സം നിലവിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയയെ താൽക്കാലികമായി നിർത്തുന്നു.


ഓപ്പറേറ്റിംഗ് സിസ്റ്റം CPU-ന്റെ നിയന്ത്രണം വീണ്ടെടുത്തു.


The OS must start the timer, which is a privileged operation.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ടൈമർ ആരംഭിക്കണം, ഇത് ഒരു പ്രത്യേക പ്രവർത്തനമാണ്.


The hardware saves the state of the program.

ഹാർഡ്‌വെയർ പ്രോഗ്രാമിന്റെ അവസ്ഥ സംരക്ഷിക്കുന്നു.


The OS decides whether to continue running the current process.

നിലവിലെ പ്രക്രിയ തുടരണോ വേണ്ടയോ എന്ന് OS തീരുമാനിക്കുന്നു.


ഒരു കോൺടെക്സ്റ്റ് സ്വിച്ച് രജിസ്റ്റർ മൂല്യങ്ങൾ സംരക്ഷിക്കുന്നു.


The OS ensures that the system resumes execution of another process.

സിസ്റ്റം മറ്റൊരു പ്രക്രിയയുടെ പ്രവർത്തനം പുനരാരംഭിക്കുന്നു എന്ന് OS ഉറപ്പാക്കുന്നു.


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

സോഫ്റ്റ്‌വെയർ എഞ്ചിനിയറിംഗിനെക്കുറിച്ചുള്ള ഒരു ക്ലാസിക് പാഠപുസ്തകം; തീർച്ചയായും വായിക്കാൻ അർഹതയുള്ള ഒന്ന്.


Another great intro to how computer systems work.

കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങൾ എങ്ങനെ പ്രവർത്തിക്കുമെന്നതിനെക്കുറിച്ചുള്ള മികച്ചൊരു ആമുഖം.


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

എന്തായാലും, നിങ്ങളുടെ അറിവ് വർദ്ധിപ്പിക്കാനുള്ള ഒരു നല്ല വഴി, മറ്റ് പല വീക്ഷണകോണുകളും കേൾക്കുക, തുടർന്ന് വിഷയത്തിൽ നിങ്ങളുടെ സ്വന്തം അഭിപ്രായങ്ങളും ചിന്തകളും രൂപപ്പെടുത്തുക എന്നതാണ്.


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

ആധുനിക സംവിധാനങ്ങളിൽ നിങ്ങൾ കാണുന്ന പല കാര്യങ്ങൾക്കും തുടക്കമിട്ടത് അറ്റ്ലസ് ആണ്.


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

കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളുടെ ആദ്യകാല വികസനത്തെയും, അറ്റ്ലസിൻ്റെ മുൻകൈയെടുത്തുള്ള ശ്രമങ്ങളെയും കുറിച്ചുള്ള നല്ലൊരു ചരിത്രപരമായ ഭാഗം.


മൾട്ടിക്സിനെക്കുറിച്ചുള്ള ഒരു മികച്ച വിവരണം.


One of our favorite intro to computing systems books.

കമ്പ്യൂട്ടിംഗ് സിസ്റ്റങ്ങളെക്കുറിച്ചുള്ള ഞങ്ങളുടെ പ്രിയപ്പെട്ട ആമുഖ പുസ്തകങ്ങളിലൊന്ന്.


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

കമ്പ്യൂട്ടിംഗ് ലോകം കീഴടക്കുമ്പോൾ, അത് എഴുതിയ ആളുകൾ തന്നെ എഴുതിയ, UNIX-ൻ്റെ ഒരു മികച്ച സംഗ്രഹം.


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

അതെ, ഒരു സാങ്കേതിക മാനുവൽ ആയിരുന്നു ഞങ്ങൾക്ക് കണ്ടെത്താൻ കഴിഞ്ഞതിൽ ഏറ്റവും മികച്ചത്.


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

എന്നാൽ, ഈ പഴയ സിസ്റ്റം ഡോക്യുമെന്റുകൾ വായിക്കുന്നതും, 1960-കളുടെ അവസാനത്തിൽ എത്രത്തോളം കാര്യങ്ങൾ നിലവിൽ വന്നു എന്ന് കാണുന്നതും വളരെ രസകരമാണ്.


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

നിങ്ങളുടെ സ്വന്തം ക്ലാസ് നോട്ടുകൾ എഴുതുന്നതിൻ്റെ ഏറ്റവും വലിയ ഗുണം: നിങ്ങളുടെ സ്വന്തം ഗവേഷണം പരസ്യം ചെയ്യാൻ കഴിയും എന്നതാണ്.


നമ്മുടെ കയ്യിൽ ഒരു പീച്ച് ഉണ്ടെന്ന് കരുതുക.


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

ഓരോ കഴിക്കുന്നവർക്കും അവരവരുടെ സ്വന്തം പീച്ച് നൽകാനാണ് ഞങ്ങൾ ആഗ്രഹിക്കുന്നത്, അതുവഴി അവർക്ക് സന്തോഷമുണ്ടാകും.


We call the peach we give eaters virtual peaches; we somehow create many of these virtual peaches out of the one physical peach.

നമ്മൾ കഴിക്കുന്നവർക്ക് നൽകുന്ന പീച്ചിനെ വെർച്വൽ പീച്ചുകൾ എന്ന് വിളിക്കുന്നു; ഏതെങ്കിലും വിധത്തിൽ ഈ ഒരു യഥാർത്ഥ പീച്ചിൽ നിന്ന് നിരവധി വെർച്വൽ പീച്ചുകൾ ഉണ്ടാക്കുന്നു.


In this illusion, it looks to each eater like they have a physical peach, but in reality they don’t.

ഈ മായാജാലത്തിൽ, ഓരോ കഴിക്കുന്നവർക്കും ഒരു യഥാർത്ഥ പീച്ച് ഉള്ളതായി തോന്നുന്നു, എന്നാൽ വാസ്തവത്തിൽ അവർക്കില്ല.


So you are sharing the peach, but you don’t even know it?

അപ്പോൾ നിങ്ങൾ പീച്ച് പങ്കിടുകയാണ്, എന്നാൽ നിങ്ങൾക്കത് അറിയില്ല അല്ലേ?


Assume there is one physical CPU in a system (though now there are often two or four or more).

ഒരു സിസ്റ്റത്തിൽ ഒരു ഫിസിക്കൽ CPU ഉണ്ടെന്ന് കരുതുക (എന്നാൽ ഇപ്പോൾ പലപ്പോഴും രണ്ടോ അതിലധികമോ ഉണ്ട്).


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

വിർച്ച്വലൈസേഷൻ ചെയ്യുന്നത്, ആ ഒരൊറ്റ CPU എടുത്ത്, സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന ആപ്ലിക്കേഷനുകൾക്ക് നിരവധി വെർച്വൽ CPU-കളായി തോന്നിക്കുന്നു.


Wow! That sounds like magic. Tell me more!

അത്ഭുതകരമായിരിക്കുന്നു! കൂടുതൽ പറയൂ!


The program itself is a lifeless thing: it just sits there on the disk, a bunch of instructions (and maybe some static data), waiting to spring into action.

പ്രോഗ്രാം ഒരു ജീവനില്ലാത്ത വസ്തുവാണ്: അത് ഡിസ്കിൽ ഇരിക്കുന്നു, ഒരു കൂട്ടം നിർദ്ദേശങ്ങൾ (ഒരുപക്ഷേ ചില സ്ഥിര ഡാറ്റയും), പ്രവർത്തനത്തിലേക്ക് വരാൻ കാത്തിരിക്കുന്നു.


The operating system decides whether to remove the current user.

പ്രവർത്തന സംവിധാനം നിലവിലെ ഉപയോക്താവിനെ നീക്കം ചെയ്യണോ വേണ്ടയോ എന്ന് തീരുമാനിക്കുന്നു.


lmbench ഡൗൺലോഡ് ചെയ്ത് ഒന്നു പരീക്ഷിച്ചു നോക്കൂ.


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

ഇത് വായിക്കാൻ ബുദ്ധിമുട്ടാണ്, അതിനാൽ കഴിയുമെങ്കിൽ ഒഴിവാക്കുക.


The author shows that if you can jump into code arbitrarily, you can essentially stitch together any code sequence you like.

ആവശ്യമുള്ളിടത്തേക്ക് കോഡ് മാറ്റാൻ സാധിച്ചാൽ, ഇഷ്ടമുള്ള കോഡ് ശൃംഖല ഉണ്ടാക്കാൻ കഴിയുമെന്ന് ലേഖകൻ പറയുന്നു.


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

ഈ ഹോംവർക്കിൽ, ഒരു സിസ്റ്റം കോളിൻ്റെയും, കോൺടെക്സ്റ്റ് സ്വിച്ചിൻ്റെയും ചിലവുകൾ നിങ്ങൾ അളക്കും.


Measuring the cost of a system call is relatively easy.

ഒരു സിസ്റ്റം കോളിൻ്റെ ചിലവ് അളക്കുന്നത് താരതമ്യേന എളുപ്പമാണ്.


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

പൈപ്പുകൾ ഉപയോഗിച്ചോ, അല്ലെങ്കിൽ UNIX സോക്കറ്റുകൾ പോലുള്ള മറ്റ് ആശയവിനിമയ മാർഗ്ഗങ്ങൾ ഉപയോഗിച്ചോ നിങ്ങൾക്ക് ഇവിടെ സമാനമായ ഒന്ന് പുനഃസൃഷ്ടിക്കാൻ ശ്രമിക്കാം.


By measuring the cost of communicating like this repeatedly, lmbench can make a good estimate of the cost of a context switch.

ഇതുപോലെ വീണ്ടും വീണ്ടും ആശയവിനിമയം നടത്തുന്നതിലൂടെ, ഒരു കോൺടെക്സ്റ്റ് സ്വിച്ചിൻ്റെ ചിലവിനെക്കുറിച്ച് lmbench-ന് നല്ലരീതിയിൽ വിലയിരുത്താൻ കഴിയും.


Fortunately, most operating systems have calls to bind a process to a particular processor.

ഭാഗ്യവശാൽ, മിക്ക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിലും ഒരു പ്രോസസ്സിനെ ഒരു പ്രത്യേക പ്രൊസസ്സറുമായി ബന്ധിപ്പിക്കുന്നതിനുള്ള കോളുകൾ ഉണ്ട്.


By now low-level mechanisms of running processes should be clear.

ഇപ്പോൾ പ്രോസസ്സുകൾ പ്രവർത്തിപ്പിക്കുന്നതിൻ്റെ താഴ്ന്ന നിലയിലുള്ള സംവിധാനങ്ങൾ വ്യക്തമായിരിക്കണം.


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

വർഷങ്ങളായി വിവിധ ആളുകൾ വികസിപ്പിച്ചെടുത്ത ഷെഡ്യൂളിംഗ് നയങ്ങളുടെ ഒരു പരമ്പര ഇപ്പോൾ അവതരിപ്പിക്കാം.


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

ഷെഡ്യൂളിംഗിൻ്റെ ഉത്ഭവം കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങൾ വരുന്നതിനുമുമ്പുള്ളതാണ്.


How should we develop a basic framework for thinking about scheduling policies?

ഷെഡ്യൂളിംഗ് നയങ്ങളെക്കുറിച്ച് ചിന്തിക്കാൻ ഒരു അടിസ്ഥാന ചട്ടക്കൂട് എങ്ങനെ വികസിപ്പിക്കും?


Determining the workload is a critical part of building policies.

ജോലിഭാരം നിർണ്ണയിക്കുന്നത് നയങ്ങൾ രൂപീകരിക്കുന്നതിൽ ഒരു നിർണായക ഘടകമാണ്.


We will make the following assumptions about the processes.

പ്രക്രിയകളെക്കുറിച്ച് ഞങ്ങൾ ഇനി പറയുന്ന കാര്യങ്ങൾ അനുമാനിക്കും.


Each job runs for the same amount of time.

ഓരോ ജോലിയും ഒരേ സമയം എടുത്ത് പ്രവർത്തിക്കുന്നു.


A metric is just something that we use to measure something.

ഒരു മെട്രിക് എന്നാൽ എന്തെങ്കിലും അളക്കാൻ ഉപയോഗിക്കുന്ന ഒന്നാണ്.


The turnaround time of a job is defined as the time at which the job completes minus the time at which the job arrived in the system.

ഒരു ജോലിയുടെ ടേൺഅറൗണ്ട് സമയം എന്നത്, ജോലി പൂർത്തിയാകുന്ന സമയവും, സിസ്റ്റത്തിൽ എത്തുന്ന സമയവും തമ്മിലുള്ള വ്യത്യാസമാണ്.


FIFO has a number of positive properties.

FIFO-യ്ക്ക് നിരവധി നല്ല ഗുണങ്ങളുണ്ട്.


Imagine three jobs arrive in the system, A, B, and C, at roughly the same time.

A, B, C എന്നീ മൂന്ന് ജോലികൾ ഏകദേശം ഒരേ സമയം സിസ്റ്റത്തിൽ എത്തിയെന്ന് കരുതുക.


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.

bedഭാഗ്യവശാൽ, മുകളിലുള്ള പ്രോഗ്രാമിന്റെ ഒരു പ്രധാന ഭാഗം, അതായത് പങ്കിട്ട കൗണ്ടർ വർദ്ധിപ്പിക്കുന്നത്, മൂന്ന് നിർദ്ദേശങ്ങൾ എടുക്കുന്നു: കൗണ്ടറിന്റെ മൂല്യം മെമ്മറിയിൽ നിന്ന് ഒരു രജിസ്റ്ററിലേക്ക് ലോഡ് ചെയ്യാൻ ഒന്ന്, അത് വർദ്ധിപ്പിക്കാൻ ഒന്ന്, തുടർന്ന് അത് മെമ്മറിയിലേക്ക് തിരികെ സംഭരിക്കാൻ ഒന്ന്.


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.

സിസ്റ്റം മെമ്മറിയിൽ, ഡാറ്റ എളുപ്പത്തിൽ നഷ്ടപ്പെടാം, കാരണം DRAM പോലുള്ള ഉപകരണങ്ങൾ മൂല്യങ്ങൾ അസ്ഥിരമായ രീതിയിൽ സംഭരിക്കുന്നു; വൈദ്യുതി പോകുമ്പോഴോ അല്ലെങ്കിൽ സിസ്റ്റം തകരുമ്പോഴോ, മെമ്മറിയിലുള്ള ഏതൊരു ഡാറ്റയും നഷ്ടപ്പെടുന്നു.


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 ഉപകരണത്തിന്റെ രൂപത്തിലാണ് വരുന്നത്; ആധുനിക സിസ്റ്റങ്ങളിൽ, ഒരു ഹാർഡ് ഡ്രൈവ് വളരെക്കാലം നിലനിൽക്കുന്ന വിവരങ്ങൾക്കുള്ള ഒരു സാധാരണ സംഭരണിയാണ്, എന്നിരുന്നാലും സോളിഡ്-സ്റ്റേറ്റ് ഡ്രൈവുകൾ (SSD-കൾ) ഈ രംഗത്ത് മുന്നേറ്റം നടത്തുന്നുണ്ട്.


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 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 improve processor utilization.

പ്രോസസ്സറിന്റെ ഉപയോഗം മെച്ചപ്പെടുത്തുന്നതിന് ഷെഡ്യൂളർ I/O-യെ ഉൾക്കൊള്ളുന്നു.


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

മൾട്ടി-ലെവൽ ഫീഡ്‌ബാക്ക് ക്യൂ എന്നത് വളരെ അറിയപ്പെടുന്ന ഒരു ഷെഡ്യൂളിംഗ് രീതിയാണ്.


The system learns from the past to predict the future.

ഭാവി പ്രവചിക്കാൻ സിസ്റ്റം ഭൂതകാലത്തിൽ നിന്ന് പഠിക്കുന്നു.


MLFQ ടേൺഅറൗണ്ട് സമയം ഒപ്റ്റിമൈസ് ചെയ്യാൻ ശ്രമിക്കുന്നു.


Interactive users expect a responsive system.

സംവേദനാത്മക ഉപയോക്താക്കൾ പ്രതികരിക്കുന്ന ഒരു സിസ്റ്റം പ്രതീക്ഷിക്കുന്നു.


The scheduler varies the priority of a job based on its behavior.

ജോലിയുടെ സ്വഭാവത്തെ ആശ്രയിച്ച് ഷെഡ്യൂളർ അതിന്റെ മുൻഗണന മാറ്റുന്നു.


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

ഒരു ജോലി മുഴുവൻ സമയ സ്ലൈസും ഉപയോഗിക്കുകയാണെങ്കിൽ, അതിന്റെ മുൻഗണന കുറയും.


A short job will run quickly and complete.

ചെറിയ ജോലികൾ വേഗത്തിൽ പ്രവർത്തിക്കുകയും പൂർത്തിയാക്കുകയും ചെയ്യും.


അൽഗോരിതം SJF-നെ ഏകദേശം വിലയിരുത്തുന്നു.


I/O-intensive jobs relinquish the CPU frequently.

I/O-ഇന്റൻസീവ് ജോലികൾ CPU-വിനെ ഇടയ്ക്കിടെ കൈവിടുന്നു.


Starvation can occur if there are too many interactive jobs.

അമിതമായി സംവേദനാത്മക ജോലികൾ ഉണ്ടായാൽ, വിശപ്പ് സംഭവിക്കാം.


A smart user could try to game the scheduler.

ഒരു സമർത്ഥനായ ഉപയോക്താവിന് ഷെഡ്യൂളറിനെ കബളിപ്പിക്കാൻ ശ്രമിക്കാം.


The priority boost helps prevent starvation.

മുൻഗണന വർദ്ധിപ്പിക്കുന്നത് വിശപ്പ് ഒഴിവാക്കാൻ സഹായിക്കുന്നു.


The system should keep track of CPU time at each level.

ഓരോ തലത്തിലും CPU സമയം സിസ്റ്റം ട്രാക്ക് ചെയ്യണം.


Gaming the scheduler can lead to unfair CPU allocation.

ഷെഡ്യൂളറിനെ കബളിപ്പിക്കുന്നത് CPU വിതരണത്തിൽ നീതികേടുണ്ടാക്കും.


Tuning MLFQ involves adjusting parameters like time slices.

MLFQ ട്യൂൺ ചെയ്യുന്നതിൽ സമയ സ്ലൈസുകൾ പോലുള്ള പാരാമീറ്ററുകൾ ക്രമീകരിക്കുന്നത് ഉൾപ്പെടുന്നു.


The administrator can configure the scheduler's behavior.

അഡ്മിനിസ്ട്രേറ്റർക്ക് ഷെഡ്യൂളറിന്റെ പ്രവർത്തനം കോൺഫിഗർ ചെയ്യാൻ കഴിയും.


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

ഓരോ പ്രക്രിയക്കും ഏറ്റവും നല്ലത് എന്താണെന്ന് ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന് വളരെ അപൂർവമായി മാത്രമേ അറിയൂ.


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

അത്തരം സൂചനകൾ ഷെഡ്യൂളർ ഉൾപ്പെടെ OS-ൻ്റെ പല ഭാഗങ്ങളിലും ഉപയോഗപ്രദമാണ്.


When a job enters the system, it is placed at the highest priority.

ഒരു ജോലി സിസ്റ്റത്തിലേക്ക് പ്രവേശിക്കുമ്പോൾ, അത് ഏറ്റവും ഉയർന്ന മുൻഗണനയിൽ സ്ഥാപിക്കപ്പെടുന്നു.


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

ഒരു ജോലിയുടെ എക്സിക്യൂഷൻ നിരീക്ഷിക്കുന്നതുകൊണ്ട് MLFQ രസകരമാണ്.


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

അനേകം സിസ്റ്റങ്ങൾ അവരുടെ അടിസ്ഥാന ഷെഡ്യൂളറായി MLFQ-യുടെ ഒരു രൂപം ഉപയോഗിക്കുന്നു.


Proportional-share is based around a simple concept.

ആനുപാതിക പങ്കിടൽ എന്നത് ലളിതമായ ഒരു ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


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

കൂടുതൽ തവണ പ്രവർത്തിപ്പിക്കേണ്ട പ്രക്രിയകൾക്ക് കൂടുതൽ അവസരങ്ങൾ നൽകണം.


The scheduler then picks a winning ticket.

തുടർന്ന് ഷെഡ്യൂളർ ഒരു വിജയിക്കുന്ന ടിക്കറ്റ് തിരഞ്ഞെടുക്കുന്നു.


The use of randomness in lottery scheduling leads to a probabilistic correctness.

ലോട്ടറി ഷെഡ്യൂളിംഗിലെ ക്രമരഹിതത്വം സാധ്യതയുള്ള ശരിയിലേക്ക് നയിക്കുന്നു.


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

ലോട്ടറി ഷെഡ്യൂളിംഗിൻ്റെ ഏറ്റവും മനോഹരമായ ഒരു വശം അതിന്റെ ക്രമരഹിതത്വത്തിന്റെ ഉപയോഗമാണ്.


Random often avoids strange corner-case behaviors.

ക്രമരഹിതത്വം പലപ്പോഴും വിചിത്രമായ കോണിലുള്ള പെരുമാറ്റങ്ങൾ ഒഴിവാക്കുന്നു.


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

കൂടാതെ, ക്രമരഹിതത്വം ഭാരം കുറഞ്ഞതുമാണ്, കൂടാതെ ബദലുകൾ ട്രാക്ക് ചെയ്യാൻ കുറഞ്ഞ സ്റ്റേറ്റ് ആവശ്യമാണ്.


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

ഒരു പ്രക്രിയയുടെ CPU വിഹിതം പ്രതിനിധീകരിക്കുന്നതിന് ടിക്കറ്റ് ഉപയോഗിക്കുന്നു.


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

കറൻസി ഉപയോക്താവിനെ അവരുടെ സ്വന്തം ജോലികൾക്കിടയിൽ ടിക്കറ്റുകൾ വിതരണം ചെയ്യാൻ അനുവദിക്കുന്നു.


A process can temporarily hand off its tickets to another process.

ഒരു പ്രക്രിയക്ക് താൽക്കാലികമായി അതിൻ്റെ ടിക്കറ്റുകൾ മറ്റൊരു പ്രക്രിയയിലേക്ക് കൈമാറാൻ കഴിയും.


With inflation, a process can temporarily raise or lower the number of tickets it owns.

പണപ്പെരുപ്പം ഉപയോഗിച്ച്, ഒരു പ്രക്രിയക്ക് താൽക്കാലികമായി അതിൻ്റെ ടിക്കറ്റുകളുടെ എണ്ണം വർദ്ധിപ്പിക്കാനോ കുറയ്ക്കാനോ കഴിയും.


Probably the most amazing thing about lottery scheduling is the simplicity of its implementation.

ലോട്ടറി ഷെഡ്യൂളിംഗിനെക്കുറിച്ച് ഏറ്റവും അത്ഭുതകരമായ കാര്യം അതിന്റെ നടപ്പാക്കലിന്റെ ലാളിത്യമാണ്.


To make a scheduling decision, we first have to pick a random number.

ഒരു ഷെഡ്യൂളിംഗ് തീരുമാനം എടുക്കുന്നതിന്, നമ്മൾ ആദ്യം ഒരു ക്രമരഹിത സംഖ്യ തിരഞ്ഞെടുക്കണം.


The ordering does not affect the correctness of the algorithm.

ഓർഡറിംഗ് അൽഗോരിതത്തിന്റെ ശരിയെ ബാധിക്കില്ല.


We have introduced the concept of proportional-share scheduling.

ആനുപാതിക പങ്കിടൽ ഷെഡ്യൂളിംഗിന്റെ ആശയം ഞങ്ങൾ അവതരിപ്പിച്ചു.


The paper discusses lottery scheduling and its impact on system performance.

സിസ്റ്റം പ്രകടനത്തിൽ ലോട്ടറി ഷെഡ്യൂളിംഗിൻ്റെ സ്വാധീനത്തെക്കുറിച്ച് ഈ പേപ്പർ ചർച്ച ചെയ്യുന്നു.


Lottery scheduling provides a flexible approach to resource management.

വിഭവ മാനേജ്മെൻ്റിന് ലോട്ടറി ഷെഡ്യൂളിംഗ് ഒരു ഫ്ലെക്സിബിൾ സമീപനം നൽകുന്നു.


The thesis outlines lottery and stride scheduling methods.

തീസിസ് ലോട്ടറി, സ്ട്രൈഡ് ഷെഡ്യൂളിംഗ് രീതികളെക്കുറിച്ച് വിവരിക്കുന്നു.


This paper is about memory resource management in VMware ESX Server.

വിഎംവെയർ ഇഎസ്എക്സ് സെർവറിലെ മെമ്മറി വിഭവ മാനേജ്മെൻ്റിനെക്കുറിച്ചാണ് ഈ പ്രബന്ധം.


The program lottery.py allows you to see how a lottery scheduler works.

ലോട്ടറി ഷെഡ്യൂളർ എങ്ങനെ പ്രവർത്തിക്കുമെന്നും lottery.py പ്രോഗ്രാം നിങ്ങളെ കാണിക്കുന്നു.


Compute the solutions for simulations with 3 jobs.

3 ജോലികൾ ഉൾപ്പെടുന്ന സിമുലേഷനുകൾക്കുള്ള പരിഹാരങ്ങൾ കണക്കാക്കുക.


What happens when the number of tickets is so imbalanced?

ടിക്കറ്റുകളുടെ എണ്ണം ഇത്രയധികം അസന്തുലിതമാകുമ്പോൾ എന്ത് സംഭവിക്കും?


Will job 0 ever run before job 1 completes?

ജോലി 1 പൂർത്തിയാകുന്നതിന് മുമ്പ് ജോലി 0 പ്രവർത്തിക്കുമോ?


ഷെഡ്യൂളർ എത്രത്തോളം നീതിരഹിതമാണ്?


How does your answer to the previous question change as the quantum size gets larger?

ക്വാണ്ടം വലുപ്പം കൂടുന്തോറും, മുൻ ചോദ്യത്തിനുള്ള നിങ്ങളുടെ ഉത്തരത്തിൽ എന്ത് മാറ്റമാണ് വരുന്നത്?


This chapter will introduce the basics of multiprocessor scheduling.

ഈ അധ്യായം മൾട്ടിപ്രൊസസ്സർ ഷെഡ്യൂളിംഗിൻ്റെ അടിസ്ഥാന കാര്യങ്ങൾ അവതരിപ്പിക്കും.


Multiprocessor systems are increasingly commonplace.

മൾട്ടിപ്രൊസസ്സർ സിസ്റ്റങ്ങൾ ഇന്ന് സാധാരണമാണ്.


The rise of the multicore processor is the source of this proliferation.

മൾട്ടികോർ പ്രൊസസ്സറുകളുടെ വളർച്ചയാണ് ഇതിന് കാരണം.


Multi-threaded applications can spread work across multiple CPUs.

മൾട്ടി-ത്രെഡ് ആപ്ലിക്കേഷനുകൾക്ക് ഒന്നിലധികം CPU-കളിൽ ജോലി വിതരണം ചെയ്യാൻ കഴിയും.


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

ഒരു സാധാരണ ആപ്ലിക്കേഷൻ ഒരു CPU മാത്രമേ ഉപയോഗിക്കൂ എന്നുള്ളതാണ് ഒരു പ്രധാന പ്രശ്നം.


How should the OS schedule jobs on multiple CPUs?

ഒന്നിലധികം CPU-കളിൽ OS എങ്ങനെ ജോലികൾ ഷെഡ്യൂൾ ചെയ്യണം?


This difference centers around the use of hardware caches.

ഈ വ്യത്യാസം ഹാർഡ്‌വെയർ കാഷെകളുടെ ഉപയോഗത്തെ ആശ്രയിച്ചിരിക്കുന്നു.


Caches are small, fast memories that hold copies of popular data.

കാഷെകൾ ചെറിയതും വേഗതയേറിയതുമായ മെമ്മറികളാണ്, അവ സാധാരണയായി ഡാറ്റയുടെ പകർപ്പുകൾ സൂക്ഷിക്കുന്നു.


Caches are thus based on the notion of locality.

കാഷെകൾ പ്രാദേശികത എന്ന ആശയത്തെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


The basic solution is provided by the hardware.

അടിസ്ഥാനപരമായ പരിഹാരം ഹാർഡ്‌വെയർ നൽകുന്നു.


ഓപ്പറേറ്റിംഗ് സിസ്റ്റം CPU വിർച്ച്വലൈസ് ചെയ്യുന്നു.


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

മെഷീന്റെ നിയന്ത്രണം നിലനിർത്താൻ OS-ന് ആഗ്രഹമുണ്ട്.


The OS also wants to be able to say “Ah! Not so fast my friend” in case of an errant or malicious process.

തെറ്റായതോ ദോഷകരമായതോ ആയ പ്രക്രിയ ഉണ്ടായാൽ “അഹ്! അത്ര വേഗമൊന്നും വേണ്ടെടാ” എന്ന് പറയാൻ OS-ന് കഴിയണം.


Do the class projects and I bet by the end it will all kind of make sense.

ക്ലാസ് പ്രോജക്റ്റുകൾ ചെയ്യുക, അവസാനം എല്ലാം മനസ്സിലാകും.


It seems like the OS is fairly paranoid.

OS വളരെ ഭയത്തോടെയാണ് കാര്യങ്ങൾ ചെയ്യുന്നത്.


Paranoia rules the day, and certainly keeps the OS in charge of the machine.

സംശയമാണ് ഇവിടെ പ്രധാനം, ഇത് തീർച്ചയായും OS-നെ മെഷീന്റെ ചുമതലയിൽ നിലനിർത്തുന്നു.


Perhaps that is why we think of the OS as a resource manager.

ഒരുപക്ഷേ അതുകൊണ്ടായിരിക്കാം നമ്മൾ OS-നെ ഒരു resource മാനേജരായി കണക്കാക്കുന്നത്.


Like the notion of bumping short jobs to the front of the queue.

ചെറിയ ജോലികൾ ക്യൂവിന്റെ മുന്നിലേക്ക് എത്തിക്കുന്ന ആശയം പോലെ.


Building up a real scheduler seems difficult.

ഒരു ശരിയായ ഷെഡ്യൂളർ ഉണ്ടാക്കുന്നത് ബുദ്ധിമുട്ടാണ്.


After all, even our own metrics are at odds.

എന്തായാലും, നമ്മുടെ സ്വന്തം അളവുകൾ പോലും വ്യത്യസ്തമാണ്.


നല്ല എഞ്ചിനീയറിംഗ് അങ്ങനെ ആയിരിക്കാം.


It’s just your perspective on it, really.

നിങ്ങളുടെ കാഴ്ചപ്പാടാണ് ഇതിന് പിന്നിലുള്ളത്.


I personally think being pragmatic is a good thing.

പ്രായോഗികമായിരിക്കുന്നത് നല്ലതാണെന്ന് ഞാൻ വ്യക്തിപരമായി കരുതുന്നു.


വേറെന്തെങ്കിലും നിങ്ങൾക്ക് ഇഷ്ടപ്പെട്ടോ?


I really liked the notion of gaming the scheduler.

ഷെഡ്യൂളറിനെ ഗെയിം ചെയ്യുന്ന ആശയം എനിക്ക് ശരിക്കും ഇഷ്ടപ്പെട്ടു.


It looks like I might have created a monster!

ഞാനൊരു രാക്ഷസനെ സൃഷ്ടിച്ചുവെന്ന് തോന്നുന്നു!


We are not nearly done with virtualization!

വിർച്ച്വലൈസേഷൻ നമ്മൾ ഇതുവരെ പൂർത്തിയാക്കിയിട്ടില്ല!


Virtualizing memory is complicated and requires us to understand many more intricate details.

മെമ്മറി വിർച്ച്വലൈസ് ചെയ്യുന്നത് സങ്കീർണ്ണമാണ്, കൂടാതെ കൂടുതൽ സൂക്ഷ്മമായ വിശദാംശങ്ങൾ മനസ്സിലാക്കേണ്ടതുണ്ട്.


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

ഒരു ഉപയോക്തൃ പ്രോഗ്രാം സൃഷ്ടിക്കുന്ന എല്ലാ വിലാസവും ഒരു വെർച്വൽ വിലാസമാണ്.


The OS is just providing an illusion to each process.

ഓരോ പ്രക്രിയക്കും OS ഒരു മിഥ്യ നൽകുന്നു.


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

UNIX/C പ്രോഗ്രാമുകളിൽ, ശക്തവും വിശ്വാസയോഗ്യവുമായ സോഫ്റ്റ്‌വെയർ നിർമ്മിക്കുന്നതിന് മെമ്മറി എങ്ങനെ അനുവദിക്കണമെന്നും കൈകാര്യം ചെയ്യണമെന്നും മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.


The main problem we address is this: CRUX: HOWTOALLOCATEANDMANAGEMEMORY

നമ്മൾ അഭിമുഖീകരിക്കുന്ന പ്രധാന പ്രശ്നം ഇതാണ്: CRUX: എങ്ങനെ മെമ്മറി അനുവദിക്കാം കൂടാതെ കൈകാര്യം ചെയ്യാം.


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

ഒരു C പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ, രണ്ട് തരത്തിലുള്ള മെമ്മറി അനുവദിക്കപ്പെടുന്നു.


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

ആദ്യത്തേതിനെ സ്റ്റാക്ക് മെമ്മറി എന്ന് വിളിക്കുന്നു, കൂടാതെ അതിന്റെ വിതരണവും നീക്കം ചെയ്യലും പ്രോഗ്രാമറായ നിങ്ങൾക്കായി കംപൈലർ വ്യക്തമല്ലാത്ത രീതിയിൽ കൈകാര്യം ചെയ്യുന്നു.


Declaring memory on the stack in C is easy.

C-യിൽ സ്റ്റാക്കിൽ മെമ്മറി പ്രഖ്യാപിക്കുന്നത് എളുപ്പമാണ്.


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

ഉദാഹരണത്തിന്, x എന്ന് പേരുള്ള ഒരു പൂർണ്ണസംഖ്യയ്ക്കായി func() എന്ന ഫംഗ്ഷനിൽ നിങ്ങൾക്ക് കുറച്ച് ഇടം ആവശ്യമാണെന്ന് കരുതുക.


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

നിങ്ങൾ func() വിളിക്കുമ്പോൾ സ്റ്റാക്കിൽ ഇടം ഉണ്ടാക്കുന്നു എന്ന് കംപൈലർ ഉറപ്പാക്കുന്നു.


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

നിങ്ങൾ ഫംഗ്ഷനിൽ നിന്ന് മടങ്ങുമ്പോൾ, കംപൈലർ നിങ്ങൾക്കായി മെമ്മറി ഒഴിവാക്കുന്നു.


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

ഇതാണ് ദീർഘകാല മെമ്മറിയുടെ ആവശ്യം, ഇത് നമ്മെ രണ്ടാമത്തെ തരം മെമ്മറിയിലേക്ക് എത്തിക്കുന്നു, ഇതിനെ ഹീപ് മെമ്മറി എന്ന് വിളിക്കുന്നു.


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

ഹീപ്പിൽ ഒരു പൂർണ്ണസംഖ്യയിലേക്ക് ഒരു പോയിന്റർ എങ്ങനെ അനുവദിക്കാമെന്നതിന്റെ ഒരു ഉദാഹരണം ഇതാ:


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

അതിന്റെ വ്യക്തമായ സ്വഭാവം കൊണ്ടും, വൈവിധ്യമാർന്ന ഉപയോഗം കൊണ്ടും, ഹീപ് മെമ്മറി ഉപയോക്താക്കൾക്കും സിസ്റ്റങ്ങൾക്കും കൂടുതൽ വെല്ലുവിളികൾ ഉയർത്തുന്നു.


The malloc() call is quite simple: you pass it a size asking for some room on the heap, and it either succeeds and gives you back a pointer to the newly-allocated space, or fails and returns NULL.

malloc() കോൾ വളരെ ലളിതമാണ്: നിങ്ങൾ അതിലേക്ക് ഒരു വലുപ്പം നൽകുന്നു, ഹീപ്പിൽ കുറച്ച് ഇടം ആവശ്യപ്പെടുന്നു, ഒന്നുകിൽ അത് വിജയിക്കുകയും പുതുതായി അനുവദിച്ച സ്ഥലത്തേക്ക് ഒരു പോയിന്റർ തിരികെ നൽകുകയും ചെയ്യുന്നു, അല്ലെങ്കിൽ പരാജയപ്പെടുകയും NULL നൽകുകയും ചെയ്യുന്നു.


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

ഈ വിവരങ്ങളിൽ നിന്ന്, malloc ഉപയോഗിക്കുന്നതിന് stdlib.h എന്ന ഹെഡർ ഫയൽ ഉൾപ്പെടുത്തേണ്ടതുണ്ടെന്ന് നിങ്ങൾക്ക് കാണാൻ കഴിയും.


In fact, you don’t really need to even do this, as the C library, which all C programs link with by default, has the code for malloc() inside of it.

വാസ്തവത്തിൽ, ഇത് ചെയ്യേണ്ടതില്ല, കാരണം എല്ലാ C പ്രോഗ്രാമുകളും സ്ഥിരസ്ഥിതിയായി ലിങ്ക് ചെയ്യുന്ന C ലൈബ്രറിയിൽ malloc() എന്നതിനുള്ള കോഡ് ഉണ്ട്.


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

malloc() എടുക്കുന്ന ഒരൊറ്റ പാരാമീറ്റർ size_t എന്ന ടൈപ്പിലുള്ളതാണ്, ഇത് നിങ്ങൾക്ക് എത്ര ബൈറ്റുകളാണ് ആവശ്യമെന്ന് ലളിതമായി വിവരിക്കുന്നു.


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

ഉദാഹരണത്തിന്, ഒരു ഇരട്ട കൃത്യതയുള്ള ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യത്തിനായി ഇടം അനുവദിക്കാൻ, നിങ്ങൾ ഇത് ലളിതമായി ചെയ്യുക:


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

നിങ്ങൾ ഉപയോഗിക്കുന്ന ചില റൂട്ടീനുകളോ ഓപ്പറേറ്ററോ എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് നിങ്ങൾക്ക് ഉറപ്പില്ലെങ്കിൽ, അത് പരീക്ഷിച്ചുനോക്കുന്നതിനും നിങ്ങൾ പ്രതീക്ഷിച്ചതുപോലെ പ്രവർത്തിക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നതിനും ഒരു പകരവുമില്ല.


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

ആദ്യ വരിയിൽ, ഞങ്ങൾ 10 പൂർണ്ണസംഖ്യകളുടെ ഒരു ശ്രേണിക്കായി ഇടം പ്രഖ്യാപിച്ചു, അത് നല്ലതാണ്.


When declaring space for a string, use the following idiom: malloc(strlen(s) + 1), which gets the length of the string using the function strlen(), and adds 1 to it in order to make room for the end-of-string character.

ഒരു സ്ട്രിംഗിനായി ഇടം പ്രഖ്യാപിക്കുമ്പോൾ, ഇനിപ്പറയുന്ന ശൈലി ഉപയോഗിക്കുക: malloc(strlen(s) + 1), ഇത് strlen() ഫംഗ്ഷൻ ഉപയോഗിച്ച് സ്ട്രിംഗിന്റെ നീളം നേടുകയും സ്ട്രിംഗ്-അവസാന പ്രതീകത്തിനായി ഇടം ഉണ്ടാക്കാൻ 1 ചേർക്കുകയും ചെയ്യുന്നു.


As it turns out, allocating memory is the easy part of the equation; knowing when, how, and even if to free memory is the hard part.

മെമ്മറി അനുവദിക്കുന്നത് എളുപ്പമാണെന്ന് പറയേണ്ടതില്ല, എപ്പോൾ, എങ്ങനെ, മെമ്മറി സ്വതന്ത്രമാക്കണോ വേണ്ടയോ എന്നറിയുന്നതാണ് പ്രയാസകരമായ ഭാഗം.


On each and every memory reference, an address translation is performed by the hardware.

ഓരോ മെമ്മറി റഫറൻസിലും, ഒരു വിലാസ വിവർത്തനം ഹാർഡ്‌വെയർ നിർവ്വഹിക്കുന്നു.


The OS must get involved at key points to set up the hardware so that the correct translations take place.

കൃത്യമായ വിവർത്തനങ്ങൾ നടപ്പിലാക്കാൻ, പ്രധാന പോയിന്റുകളിൽ OS ഹാർഡ്‌വെയർ സജ്ജീകരിക്കണം.


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

അതുകൊണ്ട് തന്നെ, OS മെമ്മറി കൈകാര്യം ചെയ്യണം, ഏതെല്ലാം സ്ഥാനങ്ങളാണ് ഒഴിവുള്ളതെന്നും, ഏതൊക്കെയാണ് ഉപയോഗത്തിലുള്ളതെന്നും ട്രാക്ക് ചെയ്യണം.


Once again the goal of all of this work is to create a beautiful illusion.

വീണ്ടും, ഈ എല്ലാ പ്രവർത്തികളുടെയും ലക്ഷ്യം മനോഹരമായ ഒരു മിഥ്യ സൃഷ്ടിക്കുക എന്നതാണ്.


Behind that virtual reality lies the ugly physical truth.

ആ വെർച്വൽ യാഥാർത്ഥ്യത്തിന് പിന്നിൽ, വിരൂപമായ ഭൗതിക സത്യം നിലകൊള്ളുന്നു.


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

വിർച്ച്വലൈസേഷനിലൂടെ, OS, വിരൂപമായ മെഷീൻ യാഥാർത്ഥ്യത്തെ, ഉപയോഗപ്രദവും, ശക്തവും, എളുപ്പത്തിൽ ഉപയോഗിക്കാവുന്നതുമായ ഒരു അമൂർത്ത രൂപമാക്കി മാറ്റുന്നു.


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

ഉപയോക്താവിൻ്റെ വിലാസ ഇടം, ഫിസിക്കൽ മെമ്മറിയിൽ തുടർച്ചയായി സ്ഥാപിക്കണം എന്ന് നമ്മൾ ഇപ്പോൾ അനുമാനിക്കും.


We will also assume, for simplicity, that the size of the address space is not too big.

ലളിതമാക്കാൻ വേണ്ടി, വിലാസ സ്ഥലത്തിൻ്റെ വലുപ്പം വളരെ വലുതല്ലെന്നും നമ്മൾ അനുമാനിക്കും.


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 വരെ വളരുന്നു.


However, to virtualize memory, the OS wants to place the process somewhere else in physical memory, not necessarily at address 0.

എങ്കിലും, മെമ്മറി വെർച്വലൈസ് ചെയ്യുന്നതിന്, OS പ്രക്രിയയെ ഫിസിക്കൽ മെമ്മറിയിൽ മറ്റെവിടെയെങ്കിലും സ്ഥാപിക്കാൻ ആഗ്രഹിക്കുന്നു, അത് 0 എന്ന വിലാസത്തിൽ ആയിരിക്കണമെന്നില്ല.


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-ൽ കാണാം.


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

ഹാർഡ്‌വെയർ അടിസ്ഥാനമാക്കിയുള്ള വിലാസ വിവർത്തനത്തെക്കുറിച്ച് മനസ്സിലാക്കാൻ, നമുക്ക് അതിന്റെ ആദ്യ രൂപത്തെക്കുറിച്ച് ചർച്ച ചെയ്യാം.


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

പ്രക്രിയ സൃഷ്ടിക്കുന്ന ഓരോ മെമ്മറി റഫറൻസും ഒരു വെർച്വൽ വിലാസമാണ്.


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

ഡൈനാമിക് റീലൊക്കേഷൻ ഉപയോഗിച്ച്, അൽപം ഹാർഡ്‌വെയർ എങ്ങനെ ഒരുപാട് ദൂരം മുന്നോട്ട് പോകുമെന്ന് നമുക്ക് കാണാൻ കഴിയും.


The figure shows an example of this problem.

ഈ പ്രശ്നത്തിന്റെ ഒരു ഉദാഹരണം ഈ ചിത്രം കാണിക്കുന്നു.


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

ഈ സാഹചര്യത്തിൽ, ലഭ്യമായ മൊത്തം ഒഴിവുള്ള സ്ഥലം 20 ബൈറ്റാണ്.


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

അതിന്റെ ഫലമായി, 20 ബൈറ്റ് ഒഴിവുണ്ടായിട്ടും 15 ബൈറ്റിനായുള്ള അഭ്യർത്ഥന പരാജയപ്പെടും.


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

വിവിധ വലുപ്പത്തിലുള്ള അഭ്യർത്ഥനകൾ നിറവേറ്റുമ്പോൾ, ഒഴിവുള്ള സ്ഥലം എങ്ങനെ കൈകാര്യം ചെയ്യണം?


What strategies can be used to minimize fragmentation?

വിഭജനം കുറയ്ക്കാൻ എന്ത് തന്ത്രങ്ങൾ ഉപയോഗിക്കാം?


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

malloc() , free() എന്നിവ നൽകുന്നതുപോലെയുള്ള ഒരു അടിസ്ഥാന ഇന്റർഫേസ് ഞങ്ങൾ അനുമാനിക്കുന്നു.


Specifically, void * malloc(size t size) takes a single parameter, size, which is the number of bytes requested by the application.

പ്രത്യേകിച്ചും, void * malloc(size t size) എന്നതിന് ഒരു സിംഗിൾ പാരാമീറ്റർ ഉണ്ട്, size, ഇത് ആപ്ലിക്കേഷൻ ആവശ്യപ്പെടുന്ന ബൈറ്റുകളുടെ എണ്ണമാണ്.


The complementary routine void free(void * ptr) takes a pointer and frees the corresponding chunk.

അനുബന്ധമായ routine void free(void * ptr) ഒരു പോയിന്റർ എടുക്കുകയും അതിനനുസരിച്ചുള്ള ഭാഗം സ്വതന്ത്രമാക്കുകയും ചെയ്യുന്നു.


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.

ഈ ലൈബ്രറി കൈകാര്യം ചെയ്യുന്ന സ്ഥലത്തെ ചരിത്രപരമായി കൂന (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 to another location in memory.

മെമ്മറി ഒരു ക്ലയിന്റിന് നൽകിക്കഴിഞ്ഞാൽ, അത് മെമ്മറിയിലെ മറ്റൊരു സ്ഥലത്തേക്ക് മാറ്റാൻ കഴിയില്ലെന്നും ഞങ്ങൾ അനുമാനിക്കുന്നു.


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

സെഗ്മെന്റേഷൻ നടപ്പിലാക്കുമ്പോൾ വിഭജനം കൈകാര്യം ചെയ്യാൻ OS-ൽ കംപാക്ഷൻ ഉപയോഗിക്കാം.


We’ll first cover some common mechanisms used in most allocators.

മിക്ക അലോക്കേറ്ററുകളിലും ഉപയോഗിക്കുന്ന ചില പൊതുവായ സംവിധാനങ്ങൾ ഞങ്ങൾ ആദ്യം ഉൾപ്പെടുത്തും.


A request for anything greater than 10 bytes will fail.

10 ബൈറ്റിൽ കൂടുതലുള്ള എന്തിനുമുള്ള അഭ്യർത്ഥന പരാജയപ്പെടും.


Assume we have a request for just a single byte of memory.

ഒരു ബൈറ്റ് മെമ്മറിക്കുള്ള അഭ്യർത്ഥനയുണ്ടെന്ന് കരുതുക.


The allocator will perform an action known as splitting.

അലോക്കേറ്റർ സ്പ്ലിറ്റിംഗ് എന്നറിയപ്പെടുന്ന ഒരു പ്രവർത്തനം നടത്തും.


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

പല അലോക്കേറ്ററുകളിലും കാണുന്ന ഒരു അനുബന്ധ സംവിധാനം സൗജന്യ സ്ഥലത്തിന്റെ കോയലേസിംഗ് എന്നറിയപ്പെടുന്നു.


The idea is simple: when returning a free chunk in memory, look carefully at the addresses of the chunk you are returning as well as the nearby chunks of free space.

ആശയം ലളിതമാണ്: മെമ്മറിയിൽ ഒരു സൗജന്യ ഭാഗം തിരികെ നൽകുമ്പോൾ, നിങ്ങൾ തിരികെ നൽകുന്ന ഭാഗത്തിന്റെയും അടുത്തുള്ള സൗജന്യ സ്ഥലത്തിന്റെയും വിലാസങ്ങൾ ശ്രദ്ധാപൂർവ്വം പരിശോധിക്കുക.


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.

വിവർത്തന സമയത്ത് ഹാർഡ്‌വെയർ സെഗ്‌മെൻ്റ് രജിസ്റ്ററുകൾ ഉപയോഗിക്കുന്നു.


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

ഒരു സാധാരണ രീതി, ചിലപ്പോൾ വ്യക്തമായ സമീപനം എന്ന് വിളിക്കപ്പെടുന്നു, വിർച്വൽ വിലാസത്തിൻ്റെ ആദ്യത്തെ കുറച്ച് ബിറ്റുകളെ അടിസ്ഥാനമാക്കി വിലാസ സ്ഥലത്തെ സെഗ്‌മെൻ്റുകളായി വിഭജിക്കുക എന്നതാണ്.


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

നമ്മുടെ ഉദാഹരണത്തിൽ, ആദ്യത്തെ രണ്ട് ബിറ്റുകൾ 00 ആണെങ്കിൽ, വിർച്വൽ വിലാസം കോഡ് സെഗ്‌മെൻ്റിലാണെന്ന് ഹാർഡ്‌വെയറിന് അറിയാം.


The 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 or technology is a human who is way above average in their talents.

ഏതൊരു മികച്ച ഉൽപ്പന്നത്തിൻ്റെയും സാങ്കേതികവിദ്യയുടെയും പിന്നിൽ അവരുടെ കഴിവുകളിൽ ശരാശരിക്ക് മുകളിലുള്ള ഒരു വ്യക്തിയുണ്ട്.


This is why, still today, one or two people can start a company that changes the face of the world forever.

ഇന്നും, ഒന്നോ രണ്ടോ ആളുകൾക്ക് ലോകത്തിൻ്റെ മുഖം എന്നെന്നേക്കുമായി മാറ്റാൻ കഴിയുന്ന ഒരു കമ്പനി ആരംഭിക്കാൻ കഴിയുന്നത് ഇതുകൊണ്ടാണ്.


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

കഠിനാധ്വാനം ചെയ്യുക, അത്തരത്തിലുള്ള ഒരു “100x” വ്യക്തിയാകാൻ നിങ്ങൾക്ക് കഴിഞ്ഞേക്കാം.


The slab allocator also goes beyond most segregated list approaches.

സ്ലാബ് അലോക്കേറ്റർ, വേർതിരിച്ച ലിസ്റ്റ് സമീപനങ്ങളെക്കാൾ കൂടുതലായി പ്രവർത്തിക്കുന്നു.


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

പ്രത്യേക ലിസ്റ്റിൽ പ്രാരംഭ അവസ്ഥയിൽ സ്വതന്ത്രമാക്കിയ ഒബ്ജക്റ്റുകൾ നിലനിർത്തുന്നതിലൂടെ, സ്ലാബ് അലോക്കേറ്റർ ഇടയ്ക്കിടെയുള്ള പ്രാരംഭ, വിനാശ ചക്രങ്ങൾ ഒഴിവാക്കുന്നു.


One good example is found in the binary buddy allocator.

ബൈനറി ബഡ്ഡി അലോക്കേറ്ററിൽ ഇതിനൊരു നല്ല ഉദാഹരണം കാണാം.


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

മെമ്മറിക്കായി ഒരു അഭ്യർത്ഥന ഉണ്ടാകുമ്പോൾ, ഒഴിവുള്ള സ്ഥലത്തിനായി തിരയുന്നത് സ്വതന്ത്ര സ്ഥലത്തെ രണ്ട് ഭാഗങ്ങളായി വിഭജിക്കുന്നു.


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.

ബഡ്ഡി അലോക്കേഷൻ നന്നായി പ്രവർത്തിക്കാനുള്ള കാരണം, ഒരു പ്രത്യേക ബ്ലോക്കിൻ്റെ ബഡ്ഡി നിർണ്ണയിക്കാൻ എളുപ്പമാണ് എന്നതാണ്.


Specifically, searching lists can be quite slow.

പ്രത്യേകിച്ചും, ലിസ്റ്റുകൾ തിരയുന്നത് വളരെ മന്ദഗതിയിലായിരിക്കും.


Examples include balanced binary trees, splay trees, or partially-ordered trees.

സന്തുലിതമായ ബൈനറി ട്രീകൾ, സ്പ്ലേ ട്രീകൾ അല്ലെങ്കിൽ ഭാഗികമായി ഓർഡർ ചെയ്ത ട്രീകൾ എന്നിവ ഉദാഹരണങ്ങളാണ്.


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

ഈ അധ്യായത്തിൽ, മെമ്മറി അലോക്കേറ്ററുകളുടെ ഏറ്റവും പ്രാഥമിക രൂപങ്ങളെക്കുറിച്ച് നമ്മൾ ചർച്ച ചെയ്തു.


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

നിങ്ങൾ എഴുതുന്ന എല്ലാ സി പ്രോഗ്രാമുകളിലും ലിങ്ക് ചെയ്‌തിട്ടുള്ള ഇത്തരം അലോക്കേറ്ററുകൾ എല്ലായിടത്തും ഉണ്ട്.


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.

വിശാലമായ വർക്ക്‌ലോഡുകൾക്കായി നന്നായി പ്രവർത്തിക്കുന്ന വേഗതയേറിയതും, സ്ഥല-കാര്യക്ഷമതയുള്ളതും, സ്കേലബിളുമായ ഒരു അലോക്കേറ്റർ ഉണ്ടാക്കുക എന്നത് ഇപ്പോഴും ഒരു വെല്ലുവിളിയാണ്.


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

നമ്മുടെ അഡ്രസ് സ്പേസിനെ മൂന്ന് ലോജിക്കൽ സെഗ്‌മെന്റുകളായി വിഭജിക്കുന്നതിനുപകരം, നമ്മുടെ അഡ്രസ് സ്പേസിനെ ഒരു പേജ് എന്ന് വിളിക്കുന്ന സ്ഥിര വലുപ്പത്തിലുള്ള യൂണിറ്റുകളായി വിഭജിക്കുന്നു.


With paging, physical memory is also split into some number of pages as well; we sometimes will call each page of physical memory a page frame.

പേജിംഗിൽ, ഫിസിക്കൽ മെമ്മറിയും കുറച്ച് പേജുകളായി വിഭജിക്കപ്പെട്ടിരിക്കുന്നു; ചിലപ്പോൾ ഫിസിക്കൽ മെമ്മറിയുടെ ഓരോ പേജിനെയും ഒരു പേജ് ഫ്രെയിം എന്ന് വിളിക്കും.


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

അഡ്രസ് സ്പേസിൻ്റെ ഓരോ വെർച്വൽ പേജുകൾക്കുമുള്ള വിലാസ വിവർത്തനങ്ങൾ സംഭരിക്കുക എന്നതാണ് പേജ് ടേബിളിൻ്റെ പ്രധാന പങ്ക്.


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

ആദ്യത്തെ നിർദ്ദേശം പൂജ്യമായ മൂല്യം വെർച്വൽ മെമ്മറി വിലാസത്തിലേക്ക് നീക്കുന്നു.


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

രണ്ടാമത്തെ നിർദ്ദേശം %eax-ൽ സൂക്ഷിച്ചിരിക്കുന്ന അറേ സൂചിക വർദ്ധിപ്പിക്കുന്നു.


If the comparison shows that the 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).

അറേ തന്നെ. ഇതിന്റെ വലുപ്പം 4000 ബൈറ്റാണ് (1000 പൂർണ്ണസംഖ്യകൾ).


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-ൽ ചിത്രീകരിച്ചിരിക്കുന്നു.


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.

രണ്ടാമതായി, ഇത് വളരെ വഴക്കമുള്ളതാണ്, വെർച്വൽ വിലാസ സ്ഥലങ്ങളുടെ കുറഞ്ഞ ഉപയോഗം പ്രാപ്തമാക്കുന്നു.


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

മെമ്മറി വെർച്വലൈസ് ചെയ്യാനുള്ള നമ്മുടെ വെല്ലുവിളിക്ക് ഒരു പരിഹാരമായി പേജിംഗിന്റെ ആശയം ഞങ്ങൾ അവതരിപ്പിച്ചു.


How can we speed up address translation?

വിലാസം വിവർത്തനം ചെയ്യുന്നത് എങ്ങനെ വേഗത്തിലാക്കാം?


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

ഒരു TLB ചിപ്പിന്റെ മെമ്മറി-മാനേജ്മെൻ്റ് യൂണിറ്റിന്റെ (MMU) ഭാഗമാണ്.


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

ഓരോ വെർച്വൽ മെമ്മറി റഫറൻസിലും, ഹാർഡ്‌വെയർ ആദ്യം TLB പരിശോധിക്കുന്നു.


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

അങ്ങനെയാണെങ്കിൽ, നമുക്ക് ഒരു TLB ഹിറ്റ് ഉണ്ട്, അതായത് TLB-യിൽ വിവർത്തനം ഉണ്ട്.


The algorithm the hardware follows works like this.

ഹാർഡ്‌വെയർ പിന്തുടരുന്ന അൽഗോരിതം ഇങ്ങനെയാണ് പ്രവർത്തിക്കുന്നത്.


When a miss occurs, the high cost of paging is incurred.

ഒരു മിസ് സംഭവിച്ചാൽ, പേജിംഗിന്റെ ഉയർന്ന ചിലവ് ഉണ്ടാകും.


In this example, let’s assume we have an array of 10 4-byte integers in memory.

ഈ ഉദാഹരണത്തിൽ, മെമ്മറിയിൽ 10 നാല്-ബൈറ്റ് പൂർണ്ണസംഖ്യകളുടെ ഒരു അറേ ഉണ്ടെന്ന് കരുതുക.


The elements of the array are packed tightly into pages.

അറേയുടെ ഘടകങ്ങൾ പേജുകളിലേക്ക് അടുക്കി വെച്ചിരിക്കുന്നു.


Caching is one of the most fundamental performance techniques.

കാഷിംഗ് ഏറ്റവും അടിസ്ഥാനപരമായ പ്രകടനാത്മക സാങ്കേതികതകളിൽ ഒന്നാണ്.


The idea behind CISC was that instructions should be high-level primitives.

CISC-യുടെ പിന്നിലുള്ള ആശയം, നിർദ്ദേശങ്ങൾ ഉയർന്ന തലത്തിലുള്ള പ്രാഥമിക ഘടകങ്ങൾ ആയിരിക്കണം എന്നതായിരുന്നു.


RISC instruction sets are exactly the opposite.

RISC നിർദ്ദേശ സെറ്റുകൾ ഇതിന് നേരെ വിപരീതമാണ്.


A key observation behind RISC is that instruction sets are really compiler targets.

RISC-യുടെ പിന്നിലെ ഒരു പ്രധാന നിരീക്ഷണം, നിർദ്ദേശ സെറ്റുകൾ യഥാർത്ഥത്തിൽ കംപൈലർ ലക്ഷ്യസ്ഥാനങ്ങളാണ് എന്നതാണ്.


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

ആദ്യകാലങ്ങളിൽ, RISC ചിപ്പുകൾ വലിയ സ്വാധീനം ചെലുത്തി, കാരണം അവ ശ്രദ്ധേയമായ വേഗതയുള്ളവയായിരുന്നു.


However, as time progressed, CISC manufacturers such as Intel incorporated many RISC techniques.

എങ്കിലും, കാലക്രമേണ, Intel പോലുള്ള CISC നിർമ്മാതാക്കൾ നിരവധി RISC സാങ്കേതിക വിദ്യകൾ ഉൾക്കൊള്ളിച്ചു.


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

അവസാന ഫലം സംവാദം അവസാനിച്ചു, ഇന്ന് രണ്ട് തരം പ്രോസസ്സറുകളും വേഗത്തിൽ പ്രവർത്തിപ്പിക്കാൻ കഴിയും.


Let’s look at the contents of the hardware TLB in more detail.

ഹാർഡ്‌വെയർ TLB-യുടെ ഉള്ളടക്കം നമുക്ക് കൂടുതൽ വിശദമായി പരിശോധിക്കാം.


A typical TLB might have 32, 64, or 128 entries.

ഒരു സാധാരണ TLB-യിൽ 32, 64, അല്ലെങ്കിൽ 128 എൻട്രികൾ ഉണ്ടാകാം.


Basically, this just means that any given translation can be anywhere in the TLB.

അടിസ്ഥാനപരമായി, ഏതെങ്കിലും വിവർത്തനം TLB-യിൽ എവിടെയും ഉണ്ടാകാം എന്നാണ് ഇതിനർത്ഥം.


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

TLB-യിൽ കാണുന്ന സാധുവായ ബിറ്റുകളും പേജ് ടേബിളിൽ കാണുന്നവയും തമ്മിൽ ആശയക്കുഴപ്പത്തിലാകുന്നത് ഒരു സാധാരണ തെറ്റാണ്.


When a system boots, a common initial state for each TLB entry is to be set to invalid.

ഒരു സിസ്റ്റം ബൂട്ട് ചെയ്യുമ്പോൾ, ഓരോ TLB എൻട്രിയുടെയും സാധാരണ പ്രാരംഭ അവസ്ഥ അസാധുവായ രീതിയിൽ സജ്ജീകരിക്കുക എന്നതാണ്.


The TLB valid bit is quite useful when performing a context switch too.

ഒരു കോൺടെക്സ്റ്റ് സ്വിച്ച് നടപ്പിലാക്കുമ്പോഴും TLB സാധുവായ ബിറ്റ് വളരെ ഉപയോഗപ്രദമാണ്.


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

എല്ലാ TLB എൻട്രികളും അസാധുവായ രീതിയിൽ സജ്ജീകരിക്കുന്നതിലൂടെ, പ്രവർത്തിക്കാൻ പോകുന്ന പ്രക്രിയക്ക് മുൻ പ്രക്രിയയിൽ നിന്നുള്ള വെർച്വൽ-ടു-ഫിസിക്കൽ വിവർത്തനം അബദ്ധത്തിൽ ഉപയോഗിക്കില്ലെന്ന് സിസ്റ്റത്തിന് ഉറപ്പാക്കാൻ കഴിയും.


കൂടുതൽ രസകരമായത് “മറ്റ് ബിറ്റുകളാണ്”.


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

ഉദാഹരണത്തിന്, TLB-യിൽ സാധാരണയായി ഒരു സാധുവായ ബിറ്റ് ഉണ്ട്, അത് എൻട്രിക്ക് സാധുവായ വിവർത്തനം ഉണ്ടോ ഇല്ലയോ എന്ന് പറയുന്നു.


With TLBs, some new issues arise when switching between processes.

TLB-കൾ ഉപയോഗിക്കുമ്പോൾ, പ്രക്രിയകൾക്കിടയിൽ മാറുമ്പോൾ ചില പുതിയ പ്രശ്നങ്ങൾ ഉണ്ടാകുന്നു.


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

പ്രത്യേകിച്ചും, TLB-യിൽ നിലവിൽ പ്രവർത്തിക്കുന്ന പ്രക്രിയയ്ക്ക് മാത്രം സാധുവായ വെർച്വൽ-ടു-ഫിസിക്കൽ വിവർത്തനങ്ങൾ അടങ്ങിയിരിക്കുന്നു.


When one process (P1) is running, it assumes the TLB might be caching translations that are valid for it.

ഒരു പ്രോസസ്സ് (P1) പ്രവർത്തിക്കുമ്പോൾ, അതിന് സാധുവായ വിവർത്തനങ്ങൾ TLB കാഷെ ചെയ്യുന്നു എന്ന് ഇത് അനുമാനിക്കുന്നു.


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

പ്രക്രിയകൾക്കിടയിൽ കോൺടെക്സ്റ്റ് സ്വിച്ച് ചെയ്യുമ്പോൾ, അവസാന പ്രക്രിയയുടെ TLB-യിലുള്ള വിവർത്തനങ്ങൾ പ്രവർത്തിക്കാൻ പോകുന്ന പ്രക്രിയയ്ക്ക് അർത്ഥവത്തല്ല.


One approach is to simply flush the TLB on context switches.

ഒരു സമീപനം, കോൺടെക്സ്റ്റ് സ്വിച്ചുകളിൽ TLB ഫ്ലഷ് ചെയ്യുക എന്നതാണ്.


Will this affect your code and its timing?

ഇത് നിങ്ങളുടെ കോഡിനെയും സമയക്രമത്തെയും ബാധിക്കുമോ?


What can you do to counterbalance these potential costs?

ഈ സാധ്യതയുള്ള ചിലവുകൾ എങ്ങനെയാണ് നിങ്ങൾക്ക് പ്രതിരോധിക്കാൻ കഴിയുക?


Simple array-based page tables (usually called linear pagetables) are too big.

ലളിതമായ അറേ അടിസ്ഥാനമാക്കിയുള്ള പേജ് ടേബിളുകൾ (സാധാരണയായി ലീനിയർ പേജ് ടേബിളുകൾ എന്ന് വിളിക്കപ്പെടുന്നു) വളരെ വലുതാണ്.


നമുക്ക് എങ്ങനെ പേജ് ടേബിളുകൾ ചെറുതാക്കാം?


പ്രധാന ആശയങ്ങൾ എന്തൊക്കെയാണ്?


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.

എങ്കിലും, ഈ സമീപനത്തിലെ പ്രധാന പ്രശ്നം വലിയ പേജുകൾ ഓരോ പേജിനുള്ളിലും മാലിന്യം ഉണ്ടാക്കുന്നു എന്നതാണ്.


Applications thus end up allocating pages but only using little bits and pieces of each.

അങ്ങനെ ആപ്ലിക്കേഷനുകൾ പേജുകൾ അനുവദിക്കുകയും എന്നാൽ ഓരോന്നിന്റെയും ചെറിയ ഭാഗങ്ങൾ മാത്രം ഉപയോഗിക്കുകയും ചെയ്യുന്നു.


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.

ജീവിതത്തിൽ ഏതെങ്കിലും ഒന്നിനോട് രണ്ട് ന്യായമായതും എന്നാൽ വ്യത്യസ്തവുമായ സമീപനങ്ങളുണ്ടെങ്കിൽ, നിങ്ങൾ എപ്പോഴും രണ്ടിന്റെയും സംയോജനം പരിശോധിക്കണം.


അത്തരം സംയോജനത്തെ ഞങ്ങൾ ഹൈബ്രിഡ് എന്ന് വിളിക്കുന്നു.


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

ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് രണ്ട് കാര്യങ്ങളും ചേർത്ത് ഉണ്ടാക്കുന്ന, റീസെസ് പീനട്ട് ബട്ടർ കപ്പ് എന്ന മനോഹരമായ ഹൈബ്രിഡ് ഉണ്ടാക്കാമെങ്കിൽ, എന്തിനാണ് വെറും ചോക്ലേറ്റോ പീനട്ട് ബട്ടറോ മാത്രം കഴിക്കുന്നത്?


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

പ്രത്യേകിച്ചും, പേജ് ടേബിളുകളുടെ മെമ്മറി ഓവർഹെഡ് കുറയ്ക്കുന്നതിന് പേജിംഗും സെഗ്മെന്റേഷനും സംയോജിപ്പിക്കുക എന്ന ആശയം ഡെന്നിസിനുണ്ടായി.


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?

അതുകൊണ്ട്, നമ്മുടെ ഹൈബ്രിഡ് സമീപനം: പ്രക്രിയയുടെ മുഴുവൻ വിലാസ സ്ഥലത്തിനും ഒരൊറ്റ പേജ് ടേബിൾ ഉണ്ടാക്കുന്നതിനുപകരം, ഓരോ ലോജിക്കൽ സെഗ്‌മെൻ്റിനും ഒരെണ്ണം ഉണ്ടാക്കിയാലോ?


On a context switch, these registers must be changed to reflect the location of the page tables of the newly-running process.

ഒരു കോൺടെക്സ്റ്റ് സ്വിച്ചിൽ, പുതുതായി പ്രവർത്തിക്കുന്ന പ്രക്രിയയുടെ പേജ് ടേബിളുകളുടെ സ്ഥാനം പ്രതിഫലിക്കുന്നതിന് ഈ രജിസ്റ്ററുകൾ മാറ്റണം.


The critical difference in our hybrid scheme is the presence of a bounds register per segment.

നമ്മുടെ ഹൈബ്രിഡ് സ്കീമിലെ നിർണായകമായ വ്യത്യാസം ഓരോ സെഗ്‌മെൻ്റിനും ഒരു ബൗണ്ട്സ് രജിസ്റ്റർ ഉണ്ട് എന്നതാണ്.


When you have two good and seemingly opposing ideas, you should always see if you can combine them into a hybrid that manages to achieve the best of both worlds.

രണ്ട് നല്ലതും പരസ്പരം വിരുദ്ധമെന്ന് തോന്നുന്നതുമായ ആശയങ്ങൾ ഉണ്ടാകുമ്പോൾ, രണ്ടിന്റെയും മികച്ചത് നേടുന്ന ഒരു ഹൈബ്രിഡായി അവയെ സംയോജിപ്പിക്കാൻ കഴിയുമോ എന്ന് നിങ്ങൾ എപ്പോഴും പരിശോധിക്കണം.


System designers should be wary of adding complexity into their system.

സിസ്റ്റം ഡിസൈനർമാർ അവരുടെ സിസ്റ്റത്തിലേക്ക് സങ്കീർണ്ണത ചേർക്കുന്നതിൽ ജാഗ്രത പാലിക്കണം.


The operating system manages the computer's resources.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കമ്പ്യൂട്ടറിന്റെ വിഭവങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.


Please provide more details about the issue.

പ്രശ്നത്തെക്കുറിച്ച് കൂടുതൽ വിവരങ്ങൾ നൽകാമോ?


സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റ് ഇപ്പോൾ പൂർത്തിയായി.


The news reported a significant rise in the stock market.

ഓഹരി വിപണിയിൽ കാര്യമായ വളർച്ചയുണ്ടായതായി വാർത്തകൾ റിപ്പോർട്ട് ചെയ്തു.


Can you explain the concept of virtual memory?

വിർച്വൽ മെമ്മറിയുടെ ആശയം വിശദീകരിക്കാമോ?


The company is facing some financial challenges.

കമ്പനി ഇപ്പോൾ ചില സാമ്പത്തിക വെല്ലുവിളികൾ നേരിടുകയാണ്.


The algorithm efficiently sorts the data.

അൽഗോരിതം ഡാറ്റയെ കാര്യക്ഷമമായി അടുക്കുന്നു.


The government announced new policies to boost the economy.

സമ്പദ്‌വ്യവസ്ഥയെ ശക്തിപ്പെടുത്തുന്നതിനായി സർക്കാർ പുതിയ നയങ്ങൾ പ്രഖ്യാപിച്ചു.


The user interface is intuitive and easy to use.

ഉപയോക്തൃ ഇന്റർഫേസ് വളരെ ലളിതവും ഉപയോഗിക്കാൻ എളുപ്പമുള്ളതുമാണ്.


The research team is working on a new project.

ഗവേഷണ സംഘം ഒരു പുതിയ പ്രോജക്റ്റിലാണ് ഇപ്പോൾ പ്രവർത്തിക്കുന്നത്.


The complexity of the system requires careful planning.

സിസ്റ്റത്തിന്റെ സങ്കീർണ്ണത കാരണം വളരെ ശ്രദ്ധയോടെയുള്ള ആസൂത്രണം ആവശ്യമാണ്.


The economic impact of the pandemic was substantial.

മഹാമാരിയുടെ സാമ്പത്തികപരമായ ആഘാതം വളരെ വലുതായിരുന്നു.


The implementation of the new protocol is complex.

പുതിയ പ്രോട്ടോക്കോൾ നടപ്പിലാക്കുന്നത് സങ്കീർണ്ണമാണ്.


The company's strategic decisions will affect its future.

കമ്പനിയുടെ തന്ത്രപരമായ തീരുമാനങ്ങൾ അതിന്റെ ഭാവിയെ സ്വാധീനിക്കും.


The analysis revealed several critical vulnerabilities.

വിശകലനം നിരവധി നിർണായകമായ ദൗർബല്യങ്ങൾ വെളിപ്പെടുത്തി.


The long-term consequences of climate change are concerning.

കാലാവസ്ഥാ വ്യതിയാനത്തിന്റെ ദീർഘകാല പ്രത്യാഘാതങ്ങൾ ആശങ്കാജനകമാണ്.


The intricate details of the project require careful attention.

പ്രോജക്റ്റിന്റെ സങ്കീർണ്ണമായ വിശദാംശങ്ങൾ ശ്രദ്ധാപൂർവ്വം കൈകാര്യം ചെയ്യണം.


The legal ramifications of the agreement are extensive.

കരാറിലെ നിയമപരമായ പ്രത്യാഘാതങ്ങൾ വളരെ വലുതാണ്.


The algorithm's performance is optimized for speed and efficiency.

വേഗതയും കാര്യക്ഷമതയും വർദ്ധിപ്പിക്കുന്നതിന് അൽഗോരിതത്തിന്റെ പ്രകടനം ഒപ്റ്റിമൈസ് ചെയ്തിരിക്കുന്നു.


The complex interplay of factors makes prediction difficult.

ഘടകങ്ങളുടെ സങ്കീർണ്ണമായ പരസ്പരബന്ധം പ്രവചനം കൂടുതൽ ദുഷ്കരമാക്കുന്നു.


The hardware first checks the TLB; upon a hit, the physical address is formed directly without accessing the page table at all, as before.

ഹാർഡ്‌വെയർ ആദ്യം TLB പരിശോധിക്കുന്നു; ഒരു ഹിറ്റ് ഉണ്ടായാൽ, പേജ് ടേബിളിലേക്ക് പ്രവേശിക്കാതെ തന്നെ, മുമ്പത്തെപ്പോലെ, ഫിസിക്കൽ വിലാസം നേരിട്ട് രൂപപ്പെടുന്നു.


If the VPN is not found in the TLB (i.e., a TLB miss), the hardware locates the page table in memory.

VPN TLB-യിൽ കണ്ടെത്തിയില്ലെങ്കിൽ (അതായത്, TLB മിസ്), ഹാർഡ്‌വെയർ മെമ്മറിയിലെ പേജ് ടേബിൾ കണ്ടെത്തുന്നു.


The OS will need to swap the page into memory in order to service the page fault.

പേജ് ഫോൾട്ട് സേവിക്കുന്നതിന്, OS പേജ് മെമ്മറിയിലേക്ക് സ്വാപ്പ് ചെയ്യേണ്ടതുണ്ട്.


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

ആധുനിക സംവിധാനങ്ങളിൽ, ഈ പങ്ക് സാധാരണയായി ഒരു ഹാർഡ് ഡിസ്ക് ഡ്രൈവാണ് നിർവഹിക്കുന്നത്.


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 OS will be free to run other ready processes while the page fault is being serviced.

പേജ് ഫോൾട്ട് സേവിക്കുമ്പോൾ മറ്റ് റെഡി പ്രോസസ്സുകൾ പ്രവർത്തിപ്പിക്കാൻ OS-ന് കഴിയും.


The hardware first extracts the VPN from the virtual address, checks the TLB for a match.

ഹാർഡ്‌വെയർ ആദ്യം വെർച്വൽ വിലാസത്തിൽ നിന്ന് VPN വേർതിരിച്ചെടുക്കുന്നു, ഒരു മത്സരത്തിനായി TLB പരിശോധിക്കുന്നു.


The program is called, perhaps unsurprisingly: paging-multilevel-translate.py; see the README for details.

പ്രോഗ്രാമിന്റെ പേര്, അതിശയിക്കാനില്ല: paging-multilevel-translate.py; വിശദാംശങ്ങൾക്കായി README കാണുക.


The OS could use the bits in the PTE normally used for data such as the PFN of the page for a disk address.

ഒരു ഡിസ്ക് വിലാസത്തിനായി പേജിന്റെ PFN പോലുള്ള ഡാറ്റയ്ക്കായി സാധാരണയായി ഉപയോഗിക്കുന്ന PTE-യിലെ ബിറ്റുകൾക്ക് OS ഉപയോഗിക്കാൻ കഴിയും.


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

മൾട്ടിപ്രോഗ്രാമിംഗിന്റെ കണ്ടുപിടുത്തം ചില പേജുകൾ സ്വാപ്പ് ഔട്ട് ചെയ്യാനുള്ള കഴിവിനെ ആവശ്യപ്പെട്ടു.


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

യഥാർത്ഥ പേജ് ടേബിളുകൾ എങ്ങനെയാണ് നിർമ്മിച്ചിരിക്കുന്നത് എന്ന് നമ്മൾ ഇപ്പോൾ കണ്ടു; ഇത് രേഖീയമായ അറേകളായി മാത്രമല്ല, കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകളായും കാണാം.


The size of the swap space is important, as ultimately it determines the maximum number of memory pages that can be in use by a system at a given time.

ഒരു നിശ്ചിത സമയത്ത് ഒരു സിസ്റ്റത്തിന് ഉപയോഗിക്കാൻ കഴിയുന്ന മെമ്മറി പേജുകളുടെ പരമാവധി എണ്ണം നിർണ്ണയിക്കുന്നത് സ്വാപ്പ് സ്പേസിന്റെ വലുപ്പമാണ്.


If the present bit is set to zero, the page is not in memory but rather on disk somewhere.

പ്രസന്റ് ബിറ്റ് പൂജ്യമായി സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, പേജ് മെമ്മറിയിലല്ല, ഡിസ്കിൽ എവിടെയെങ്കിലും ഉണ്ട്.


The OS will need to remember the disk address of a given page.

ഒരു പ്രത്യേക പേജിന്റെ ഡിസ്ക് വിലാസം OS ഓർമ്മിക്കേണ്ടതുണ്ട്.


The act of accessing a page that is not in physical memory is commonly referred to as a page fault.

ഫിസിക്കൽ മെമ്മറിയിൽ ഇല്ലാത്ത ഒരു പേജിലേക്ക് പ്രവേശിക്കുന്നതിനെ സാധാരണയായി ഒരു പേജ് ഫോൾട്ട് എന്ന് വിളിക്കുന്നു.


The OS is put in charge to handle the page fault.

പേജ് ഫോൾട്ട് കൈകാര്യം ചെയ്യാൻ OS-നെ ചുമതലപ്പെടുത്തിയിരിക്കുന്നു.


ഹാർഡ്‌വെയർ ആദ്യം TLB പരിശോധിക്കുന്നു.


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

ഈ വലിയ അനുമാനങ്ങൾ ഇപ്പോൾ നമ്മൾ മാറ്റിവെക്കുന്നു, കൂടാതെ ഒരേസമയം പ്രവർത്തിക്കുന്ന നിരവധി വലിയ വിലാസ സ്ഥലങ്ങളെ പിന്തുണയ്ക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു എന്ന് കരുതുക.


The OS will need a place to stash away portions of address spaces that currently aren’t in great demand.

നിലവിൽ വലിയ ഡിമാൻഡ് ഇല്ലാത്ത വിലാസ സ്ഥലങ്ങളുടെ ഭാഗങ്ങൾ സൂക്ഷിക്കാൻ OS-ന് ഒരു സ്ഥലം ആവശ്യമാണ്.


The OS will need to swap the page into memory.

OS-ന് പേജ് മെമ്മറിയിലേക്ക് സ്വാപ്പ് ചെയ്യേണ്ടതുണ്ട്.


The principle of locality suggests that programs tend to 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 80-20 workload demonstrates that 80% of references are to 20% of the pages.

80-20 വർക്ക്ലോഡ്, 80% റഫറൻസുകൾ പേജുകളുടെ 20%-ലേക്കാണ് എന്ന് വ്യക്തമാക്കുന്നു.


In a looping-sequential workload, pages are accessed in a sequential order and then looped.

ഒരു ലൂപ്പിംഗ്-സീക്വൻഷ്യൽ വർക്ക്ലോഡിൽ, പേജുകൾ ഒരു ക്രമത്തിൽ ആക്സസ് ചെയ്യുകയും തുടർന്ന് ലൂപ്പ് ചെയ്യുകയും ചെയ്യുന്നു.


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

LRU പോലുള്ള ചരിത്രപരമായ അൽഗോരിതങ്ങൾ, റീപ്ലേസ്‌മെന്റ് തീരുമാനങ്ങൾ എടുക്കാൻ പഴയ ആക്സസ് പാറ്റേണുകൾ ഉപയോഗിക്കുന്നു.


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

ഒരു ഉപയോഗ ബിറ്റ് ഉപയോഗിച്ച് സമീപകാല ആക്സസ് ട്രാക്ക് ചെയ്യുന്ന LRU-യുടെ ഒരു ഏകദേശ രൂപമാണ് ക്ലോക്ക് അൽഗോരിതം.


Thrashing occurs when the system spends too much time paging, rather than executing processes.

പ്രോസസ്സുകൾ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുപകരം, സിസ്റ്റം കൂടുതൽ സമയം പേജിംഗിൽ ചെലവഴിക്കുമ്പോളാണ് ത്രഷിംഗ് സംഭവിക്കുന്നത്.


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

VAX/VMS ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നന്നായി രൂപകൽപ്പന ചെയ്ത ഒരു വെർച്വൽ മെമ്മറി മാനേജറാണ്.


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

തികഞ്ഞ നടപ്പാക്കലിന്റെ അധിക ചിലവ് കാരണം ആധുനിക സിസ്റ്റങ്ങൾ പലപ്പോഴും LRU-യുടെ ഏകദേശ രൂപങ്ങൾ ഉപയോഗിക്കുന്നു.


The goal is to keep frequently accessed pages in memory.

പതിവായി ഉപയോഗിക്കുന്ന പേജുകൾ മെമ്മറിയിൽ നിലനിർത്തുക എന്നതാണ് ലക്ഷ്യം.


Cache size significantly impacts the hit rate in memory management.

മെമ്മറി മാനേജ്മെന്റിൽ കാഷെ വലുപ്പം ഹിറ്റ് നിരക്കിനെ വളരെയധികം സ്വാധീനിക്കുന്നു.


The OS decides when to bring a page into memory.

ഒരു പേജ് എപ്പോൾ മെമ്മറിയിലേക്ക് കൊണ്ടുവരണമെന്ന് OS തീരുമാനിക്കുന്നു.


Demand paging brings pages into memory only when they are accessed.

ആവശ്യാനുസരണം പേജിംഗ്, പേജുകൾ ആക്സസ് ചെയ്യുമ്പോൾ മാത്രം മെമ്മറിയിലേക്ക് കൊണ്ടുവരുന്നു.


Prefetching can improve performance by anticipating future page accesses.

ഭാവിയിലെ പേജ് ആക്സസുകൾ മുൻകൂട്ടി കാണുന്നതിലൂടെ പ്രീഫെച്ചിംഗിന് പ്രകടനം മെച്ചപ്പെടുത്താൻ കഴിയും.


Clustering writes improves disk I/O efficiency.

ക്ലസ്റ്ററിംഗ് റൈറ്റുകൾ ഡിസ്ക് I/O കാര്യക്ഷമത മെച്ചപ്പെടുത്തുന്നു.


The modified bit indicates whether a page has been changed.

ഒരു പേജ് മാറ്റിയിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്നത് മോഡിഫൈഡ് ബിറ്റാണ്.


Admission control can prevent thrashing by limiting the number of running processes.

പ്രവർത്തിക്കുന്ന പ്രോസസ്സുകളുടെ എണ്ണം പരിമിതപ്പെടുത്തി ത്രഷിംഗ് തടയാൻ പ്രവേശന നിയന്ത്രണത്തിന് കഴിയും.


The choice of page replacement policy affects system performance.

പേജ് റീപ്ലേസ്‌മെന്റ് നയത്തിന്റെ തിരഞ്ഞെടുക്കൽ സിസ്റ്റം പ്രകടനത്തെ ബാധിക്കുന്നു.


Understanding locality is crucial for designing efficient memory systems.

കാര്യക്ഷമമായ മെമ്മറി സിസ്റ്റങ്ങൾ രൂപകൽപ്പന ചെയ്യുന്നതിന് ലൊക്കാലിറ്റി മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.


The performance of different policies varies depending on the workload.

വിവിധ നയങ്ങളുടെ പ്രകടനം വർക്ക്ലോഡിനെ ആശ്രയിച്ചിരിക്കുന്നു.


The operating system manages the computer's resources.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം കമ്പ്യൂട്ടറിന്റെ വിഭവങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.


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

ഫിസിക്കൽ ആയി ലഭ്യമല്ലാത്തതിനേക്കാൾ കൂടുതൽ മെമ്മറി ഉപയോഗിക്കാൻ വിർച്വൽ മെമ്മറി സിസ്റ്റത്തെ അനുവദിക്കുന്നു.


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

വിപുലമായ മെമ്മറി മാനേജ്മെൻ്റ് ടെക്നിക്കുകൾക്ക് പേരുകേട്ടതായിരുന്നു VAX/VMS ഓപ്പറേറ്റിംഗ് സിസ്റ്റം.


Page tables are crucial for translating virtual addresses to physical addresses.

വിർച്വൽ വിലാസങ്ങളെ ഫിസിക്കൽ വിലാസങ്ങളിലേക്ക് പരിവർത്തനം ചെയ്യാൻ പേജ് ടേബിളുകൾ അത്യാവശ്യമാണ്.


The kernel manages the core functions of the operating system.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ പ്രധാന പ്രവർത്തനങ്ങൾ കേർണൽ കൈകാര്യം ചെയ്യുന്നു.


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

ഒരു പ്രോസസ്സിൽ നിന്ന് മറ്റൊന്നിലേക്ക് മാറുന്ന പ്രക്രിയയാണ് കോൺടെക്സ്റ്റ് സ്വിച്ചിംഗ്.


Demand zeroing is a lazy optimization technique used in memory management.

മെമ്മറി മാനേജ്മെൻ്റിൽ ഉപയോഗിക്കുന്ന ഒരു മടിയൻ ഒപ്റ്റിമൈസേഷൻ ടെക്നിക്കാണ് ഡിമാൻഡ് സീറോയിംഗ്.


Copy-on-write is a technique to share memory pages efficiently.

മെമ്മറി പേജുകൾ കാര്യക്ഷമമായി പങ്കിടാനുള്ള ഒരു സാങ്കേതികതയാണ് കോപ്പി-ഓൺ-റൈറ്റ്.


The TLB (Translation Lookaside Buffer) speeds up address translation.

TLB (ട്രാൻസ്‌ലേഷൻ ലുക്ക്‌സൈഡ് ബഫർ) വിലാസ പരിഭാഷ വേഗത്തിലാക്കുന്നു.


The operating system provides an abstraction of the hardware.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ഹാർഡ്‌വെയറിൻ്റെ ഒരു അമൂർത്തീകരണം നൽകുന്നു.


Understanding how virtual memory works is crucial for system programmers.

വിർച്വൽ മെമ്മറി എങ്ങനെ പ്രവർത്തിക്കുമെന്നത് മനസ്സിലാക്കുന്നത് സിസ്റ്റം പ്രോഗ്രാമർമാർക്ക് നിർണായകമാണ്.


The VMS designers faced challenges due to the small page size.

ചെറിയ പേജ് വലുപ്പം കാരണം VMS ഡിസൈനർമാർക്ക് വെല്ലുവിളികൾ നേരിടേണ്ടിവന്നു.


The segmented FIFO replacement policy was used in VMS.

വിഎംഎസിൽ സെഗ്മെന്റഡ് FIFO റീപ്ലേസ്‌മെന്റ് പോളിസി ഉപയോഗിച്ചു.


Clustering improves disk I/O efficiency during swapping.

സ്വാപ്പിംഗ് സമയത്ത് ഡിസ്ക് I/O കാര്യക്ഷമത വർദ്ധിപ്പിക്കാൻ ക്ലസ്റ്ററിംഗ് സഹായിക്കുന്നു.


The kernel is mapped into each address space for various reasons.

വിവിധ കാരണങ്ങളാൽ കേർണൽ ഓരോ വിലാസ സ്ഥലത്തേക്കും മാപ്പ് ചെയ്യുന്നു.


Hardware protection levels are used to secure the OS.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം സുരക്ഷിതമാക്കാൻ ഹാർഡ്‌വെയർ പ്രൊട്ടക്ഷൻ ലെവലുകൾ ഉപയോഗിക്കുന്നു.


The OS must handle null pointer dereferences carefully.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ശൂന്യമായ പോയിന്റർ ഡെറിഫറൻസുകൾ ശ്രദ്ധയോടെ കൈകാര്യം ചെയ്യണം.


The VAX architecture had limitations that VMS addressed.

VAX ആർക്കിടെക്ചറിന് VMS പരിഹരിച്ച പരിമിതികൾ ഉണ്ടായിരുന്നു.


Modern operating systems still use many of the ideas from VMS.

ആധുനിക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ഇപ്പോഴും VMS-ൽ നിന്നുള്ള പല ആശയങ്ങളും ഉപയോഗിക്കുന്നു.


The study of VMS provides insights into real-world system design.

VMS-നെക്കുറിച്ചുള്ള പഠനം, ലോകത്തിലെ സിസ്റ്റം രൂപകൽപ്പനയെക്കുറിച്ച് ഉൾക്കാഴ്ച നൽകുന്നു.


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.

ത്രെഡുകൾക്ക് പൊതുവായ വിഭവങ്ങളിലേക്ക് പ്രവേശനം സമന്വയിപ്പിക്കേണ്ടതുണ്ട്.


A process might wait for I/O to complete before continuing.

തുടരുന്നതിന് മുമ്പ് ഒരു പ്രക്രിയക്ക് I/O പൂർത്തിയാകുന്നതുവരെ കാത്തിരിക്കേണ്ടി വന്നേക്കാം.


Atomicity ensures that operations are indivisible.

ആറ്റോമിസിറ്റി പ്രവർത്തനങ്ങൾ വിഭജിക്കാൻ കഴിയാത്തതാണെന്ന് ഉറപ്പാക്കുന്നു.


The OS was the first concurrent program.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ആദ്യത്തെ സമകാലിക പ്രോഗ്രാമായിരുന്നു.


File systems use techniques like journaling.

ഫയൽ സിസ്റ്റങ്ങൾ ജേർണലിംഗ് പോലുള്ള സാങ്കേതിക വിദ്യകൾ ഉപയോഗിക്കുന്നു.


Atomic operations are crucial for building computer systems.

കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നതിന് ആറ്റോമിക് പ്രവർത്തനങ്ങൾ നിർണായകമാണ്.


The book is considered the bible of transaction processing.

ഈ പുസ്തകം ഇടപാട് പ്രോസസ്സിംഗിന്റെ ബൈബിളായി കണക്കാക്കപ്പെടുന്നു.


Carefully access kernel data structures.

കെർണൽ ഡാറ്റാ ഘടനകൾ ശ്രദ്ധാപൂർവ്വം ആക്സസ് ചെയ്യുക.


The program allows you to see how different thread interleavings cause race conditions.

വിവിധ ത്രെഡ് ഇന്റർലീവിംഗുകൾ എങ്ങനെ റേസ് അവസ്ഥകൾക്ക് കാരണമാകുന്നു എന്ന് ഈ പ്രോഗ്രാം കാണാൻ നിങ്ങളെ അനുവദിക്കുന്നു.


POSIX threads provide functions for mutual exclusion.

പരസ്പരം ഒഴിവാക്കുന്നതിനുള്ള പ്രവർത്തനങ്ങൾ POSIX ത്രെഡുകൾ നൽകുന്നു.


നിർണായക ഭാഗങ്ങൾ പരിരക്ഷിക്കാൻ ലോക്കുകൾ ഉപയോഗിക്കുക.


എല്ലാ ലോക്കുകളും ശരിയായി ആരംഭിക്കുക.


Always check error codes when calling lock and unlock.

ലോക്കും അൺലോക്കും വിളിക്കുമ്പോൾ എപ്പോഴും എറർ കോഡുകൾ പരിശോധിക്കുക.


Condition variables are useful for signaling between threads.

ത്രെഡുകൾക്കിടയിൽ സിഗ്നൽ ചെയ്യുന്നതിന് കണ്ടീഷൻ വേരിയബിളുകൾ ഉപയോഗപ്രദമാണ്.


The main thread waits for the other threads to complete.

മറ്റ് ത്രെഡുകൾ പൂർത്തിയാകുന്നതിനായി പ്രധാന ത്രെഡ് കാത്തിരിക്കുന്നു.


പ്രോഗ്രാം ഒരു പുതിയ ത്രെഡ് ഉണ്ടാക്കുന്നു.


The thread begins execution with a function.

ഒരു ഫംഗ്ഷൻ ഉപയോഗിച്ച് ത്രെഡ് എക്സിക്യൂഷൻ ആരംഭിക്കുന്നു.


The thread can return any type of result.

ത്രെഡിന് ഏത് തരത്തിലുള്ള ഫലവും തിരികെ നൽകാൻ കഴിയും.


അടിസ്ഥാന നയങ്ങൾ ലളിതമാണ്.


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.

അങ്ങനെ, നമ്മുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ മൂന്ന് തൂണുകളിൽ രണ്ടാമത്തേതായ കൺകറൻസിയിൽ നമ്മൾ എത്തിച്ചേരുന്നു.


നമ്മുടെ കയ്യിൽ ഒരു പീച്ച് ഉണ്ടെന്ന് കരുതുക.


നിങ്ങൾക്കും പീച്ചിനും തമ്മിലെന്താണ് ബന്ധം?


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.

ഓരോരുത്തരും ആദ്യം ഒരു പീച്ചിനെ ദൃശ്യപരമായി തിരിച്ചറിയുന്നു, തുടർന്ന് അത് എടുത്ത് കഴിക്കാൻ ശ്രമിക്കുന്നു.


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.

ശരി, സംഭവിക്കുന്നത് എന്തെന്നാൽ, മൾട്ടി-ത്രെഡ് ആപ്ലിക്കേഷനുകൾ എന്ന് വിളിക്കപ്പെടുന്ന ചിലതരം പ്രോഗ്രാമുകളുണ്ട്.


Each thread is kind of like an independent agent running around in this program.

ഓരോ ത്രെഡും ഈ പ്രോഗ്രാമിൽ കറങ്ങുന്ന ഒരു സ്വതന്ത്ര ഏജൻ്റിന് തുല്യമാണ്.


The OS must support multi-threaded applications with primitives such as locks and condition variables.

ലോക്കുകളും കണ്ടീഷൻ വേരിയബിളുകളും പോലുള്ള പ്രിമിറ്റീവുകൾ ഉപയോഗിച്ച് OS മൾട്ടി-ത്രെഡ് ആപ്ലിക്കേഷനുകളെ പിന്തുണയ്ക്കണം.


We have seen how to create the illusion of a large, private virtual memory for each process.

ഓരോ പ്രോസസ്സിനും ഒരു വലിയ, സ്വകാര്യ വെർച്വൽ മെമ്മറിയുടെ മിഥ്യ എങ്ങനെ സൃഷ്ടിക്കാമെന്ന് നമ്മൾ കണ്ടു.


In this note, we introduce a new abstraction for a single running process: that of a thread.

ഈ കുറിപ്പിൽ, ഒരു സിംഗിൾ റണ്ണിംഗ് പ്രോസസ്സിനായുള്ള ഒരു പുതിയ അബ്‌സ്ട്രാക്ഷൻ നമ്മൾ അവതരിപ്പിക്കുന്നു: അതായത് ഒരു ത്രെഡ്.


Each thread has its own private set of registers it uses for computation.

ഓരോ ത്രെഡിനും കമ്പ്യൂട്ടേഷനായി ഉപയോഗിക്കുന്ന സ്വന്തമായ രജിസ്റ്ററുകൾ ഉണ്ട്.


The thread checks if the variable initialized has yet been set to something other than zero.

വേരിയബിൾ ഇനിഷ്യലൈസ് ചെയ്തത് പൂജ്യത്തിൽ നിന്ന് വ്യത്യസ്തമായ ഒന്നിലേക്ക് മാറ്റിയിട്ടുണ്ടോ എന്ന് ത്രെഡ് പരിശോധിക്കുന്നു.


If not, the thread simply calls the wait routine in order to sleep until some other thread wakes it.

അല്ലെങ്കിൽ, മറ്റ് ചില ത്രെഡ് അത് ഉണർത്തുന്നത് വരെ ഉറങ്ങാൻ വേണ്ടി ത്രെഡ് വെയിറ്റ് റ routine ട്ടീൻ വിളിക്കുന്നു.


The code to wake a thread, which would run in some other thread, looks like this.

മറ്റൊരു ത്രെഡിൽ പ്രവർത്തിക്കുന്ന ഒരു ത്രെഡിനെ ഉണർത്താനുള്ള കോഡ് ഇപ്രകാരമാണ്.


First, when signaling (as well as when modifying the global variable initialized), we always make sure to have the lock held.

ആദ്യം, സിഗ്നൽ ചെയ്യുമ്പോൾ (ഗ്ലോബൽ വേരിയബിൾ ഇനിഷ്യലൈസ് ചെയ്തത് പരിഷ്കരിക്കുമ്പോൾ), ലോക്ക് നിലനിർത്താൻ ഞങ്ങൾ എപ്പോഴും ശ്രദ്ധിക്കുന്നു.


This ensures that we don’t accidentally introduce a race condition into our code.

ഇത് ഞങ്ങളുടെ കോഡിലേക്ക് ആകസ്മികമായി ഒരു റേസ് അവസ്ഥ ഉണ്ടാകാതിരിക്കാൻ സഹായിക്കുന്നു.


Second, you might notice that the wait call takes a lock as its second parameter, whereas the signal call only takes a condition.

രണ്ടാമതായി, വെയിറ്റ് കോൾ അതിന്റെ രണ്ടാമത്തെ പാരാമീറ്ററായി ഒരു ലോക്ക് എടുക്കുന്നു, അതേസമയം സിഗ്നൽ കോൾ ഒരു കണ്ടീഷൻ മാത്രമേ എടുക്കൂ എന്ന് നിങ്ങൾ ശ്രദ്ധിച്ചേക്കാം.


The reason for this difference is that the wait call, in addition to putting the calling thread to sleep, releases the lock when putting said caller to sleep.

ഈ വ്യത്യാസത്തിന്റെ കാരണം, വെയിറ്റ് കോൾ, വിളിക്കുന്ന ത്രെഡിനെ ഉറക്കുന്നതിനു പുറമേ, കോളിനെ ഉറക്കുമ്പോൾ ലോക്ക് റിലീസ് ചെയ്യുന്നു.


Imagine if it did not: how could the other thread acquire the lock and signal it to wake up?

അങ്ങനെ ചെയ്തില്ലെങ്കിൽ: മറ്റ് ത്രെഡിന് എങ്ങനെ ലോക്ക് നേടാനും അത് ഉണർത്താൻ സിഗ്നൽ ചെയ്യാനും കഴിയും?


However, before returning after being woken, the pthread condwait() re-acquires the lock, thus ensuring that any time the waiting thread is running between the lock acquire at the beginning of the wait sequence, and the lock release at the end, it holds the lock.

എങ്കിലും, ഉണർത്തിയ ശേഷം മടങ്ങിവരുന്നതിനുമുമ്പ്, pthread condwait() ലോക്ക് വീണ്ടും നേടുന്നു, അതുവഴി കാത്തിരിക്കുന്ന ത്രെഡ് വെയിറ്റ് സീക്വൻസിന്റെ തുടക്കത്തിൽ ലോക്ക് നേടുന്നതിനും അവസാനത്തിൽ ലോക്ക് റിലീസ് ചെയ്യുന്നതിനും ഇടയിൽ പ്രവർത്തിക്കുമ്പോൾ, അത് ലോക്ക് നിലനിർത്തുന്നു.


One last oddity: the waiting thread re-checks the condition in a while loop, instead of a simple if statement.

ഒടുവിലത്തെ വിചിത്രമായ ഒന്ന്: കാത്തിരിക്കുന്ന ത്രെഡ് ഒരു ലളിതമായ if സ്റ്റേറ്റ്‌മെന്റിനുപകരം ഒരു while ലൂപ്പിൽ കണ്ടീഷൻ വീണ്ടും പരിശോധിക്കുന്നു.


We’ll discuss this issue in detail when we study condition variables in a future chapter, but in general, using a while loop is the simple and safe thing to do.

ഭാവിയിലെ അധ്യായത്തിൽ കണ്ടീഷൻ വേരിയബിളുകളെക്കുറിച്ച് പഠിക്കുമ്പോൾ ഈ വിഷയം വിശദമായി ചർച്ച ചെയ്യാം, എന്നാൽ പൊതുവേ, ഒരു while ലൂപ്പ് ഉപയോഗിക്കുന്നത് ലളിതവും സുരക്ഷിതവുമാണ്.


Although it rechecks the condition (perhaps adding a little overhead), there are some pthread implementations that could spuriously wake up a waiting thread; in such a case, without rechecking, the waiting thread will continue thinking that the condition has changed even though it has not.

അത് കണ്ടീഷൻ വീണ്ടും പരിശോധിക്കുമ്പോൾ (ഒരു ചെറിയ ഓവർഹെഡ് ചേർക്കുന്നു), ചില pthread നടപ്പിലാക്കലുകൾ കാത്തിരിക്കുന്ന ഒരു ത്രെഡിനെ തെറ്റായി ഉണർത്താൻ സാധ്യതയുണ്ട്; അത്തരം സാഹചര്യത്തിൽ, വീണ്ടും പരിശോധിക്കാതെ, കണ്ടീഷൻ മാറിയിട്ടില്ലെങ്കിലും മാറിയെന്ന് കാത്തിരിക്കുന്ന ത്രെഡ് തുടർന്നും ചിന്തിക്കും.


It is safer thus to view waking up as a hint that something might have changed, rather than an absolute fact.

അതുകൊണ്ട്, ഉണരുന്നത് ഒരു കേവല വസ്തുതയേക്കാൾ, എന്തെങ്കിലും മാറിയേക്കാം എന്നതിന്റെ സൂചനയായി കണക്കാക്കുന്നത് സുരക്ഷിതമാണ്.


Note that sometimes it is tempting to use a simple flag to signal between two threads, instead of a condition variable and associated lock.

രണ്ട് ത്രെഡുകൾക്കിടയിൽ സിഗ്നൽ ചെയ്യാൻ, ഒരു കണ്ടീഷൻ വേരിയബിളും അനുബന്ധ ലോക്കും ഉപയോഗിക്കുന്നതിനുപകരം, ലളിതമായ ഒരു ഫ്ലാഗ് ഉപയോഗിക്കാൻ ചിലപ്പോൾ പ്രലോഭനമുണ്ടാകാറുണ്ട്.


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

താഴെ പറയുന്ന കാരണങ്ങളാൽ ഇത് ഒരിക്കലും ചെയ്യരുത്.


First, it performs poorly in many cases (spinning for a long time just wastes CPU cycles).

ഒന്നാമതായി, ഇത് പലപ്പോഴും മോശമായി പ്രവർത്തിക്കുന്നു (ഒരുപാട് നേരം സ്പിൻ ചെയ്യുന്നത് CPU സൈക്കിളുകൾ പാഴാക്കുന്നു).


രണ്ടാമതായി, ഇത് തെറ്റുകൾ വരുത്താൻ സാധ്യതയുണ്ട്.


As recent research shows, it is surprisingly easy to make mistakes when using flags to synchronize between threads.

ഏറ്റവും പുതിയ ഗവേഷണങ്ങൾ കാണിക്കുന്നത്, ത്രെഡുകൾക്കിടയിൽ സമന്വയിപ്പിക്കാൻ ഫ്ലാഗുകൾ ഉപയോഗിക്കുമ്പോൾ തെറ്റുകൾ വരുത്തുന്നത് വളരെ എളുപ്പമാണെന്നാണ്.


Don’t be lazy; use condition variables even when you think you can get away without doing so.

മടിയനാകരുത്; നിങ്ങൾക്ക് ചെയ്യാതെ ഒഴിവാക്കാൻ കഴിയുമെന്ന് തോന്നിയാലും കണ്ടീഷൻ വേരിയബിളുകൾ ഉപയോഗിക്കുക.


We have introduced the basics of the pthread library, including thread creation, building mutual exclusion via locks, and signaling and waiting via condition variables.

ത്രെഡ് ഉണ്ടാക്കുക, ലോക്കുകൾ വഴി പരസ്പരം ഒഴിവാക്കുക, കണ്ടീഷൻ വേരിയബിളുകൾ വഴി സിഗ്നൽ ചെയ്യുകയും കാത്തിരിക്കുകയും ചെയ്യുന്നത് ഉൾപ്പെടെ pthread ലൈബ്രറിയുടെ അടിസ്ഥാന കാര്യങ്ങൾ ഞങ്ങൾ അവതരിപ്പിച്ചു.


The program stores 'new' into the memory location pointed to by ptr.

പ്രോഗ്രാം 'new' എന്ന മൂല്യം ptr സൂചിപ്പിക്കുന്ന മെമ്മറി സ്ഥാനത്ത് സംഭരിക്കുന്നു.


The test-and-set instruction returns the old value.

ടെസ്റ്റ്-ആൻഡ്-സെറ്റ് നിർദ്ദേശം പഴയ മൂല്യം നൽകുന്നു.


This sequence of operations is performed atomically.

ഈ പ്രവർത്തനങ്ങളുടെ ശ്രേണി ആറ്റോമികമായി നിർവ്വഹിക്കപ്പെടുന്നു.


Imagine a thread calls lock() and no other thread currently holds the lock.

ഒരു ത്രെഡ് lock() എന്ന് വിളിക്കുകയും നിലവിൽ മറ്റൊരു ത്രെഡും ലോക്ക് കൈവശം വെച്ചിട്ടില്ലെന്നും കരുതുക.


The thread will also atomically set the value to 1.

ത്രെഡ് മൂല്യം 1 ആയി ആറ്റോമികമായി സജ്ജമാക്കുകയും ചെയ്യും.


When the flag is finally set to 0 by some other thread, this thread will call TestAndSet() again.

മറ്റേതെങ്കിലും ത്രെഡ് ഫ്ലാഗ് 0 ആയി സജ്ജീകരിക്കുമ്പോൾ, ഈ ത്രെഡ് വീണ്ടും TestAndSet() എന്ന് വിളിക്കും.


It is the simplest type of lock to build, and simply spins, using CPU cycles, until the lock becomes available.

നിർമ്മിക്കാൻ ഏറ്റവും ലളിതമായ തരം ലോക്കാണിത്, കൂടാതെ ലോക്ക് ലഭ്യമാകുന്നതുവരെ CPU സൈക്കിളുകൾ ഉപയോഗിച്ച് സ്പിൻ ചെയ്യുന്നു.


The spin lock only allows a single thread to enter the critical section at a time.

ഒരു സ്പിൻ ലോക്ക് ഒരു സമയം ഒരു ത്രെഡിനെ മാത്രമേ ക്രിട്ടിക്കൽ വിഭാഗത്തിൽ പ്രവേശിക്കാൻ അനുവദിക്കൂ.


Spin locks are not fair and may lead to starvation.

സ്പിൻ ലോക്കുകൾ നീതിയുക്തമല്ല, ഇത് പട്ടിണിയിലേക്ക് നയിച്ചേക്കാം.


Imagine threads competing for the lock on a single processor.

ഒരു പ്രോസസ്സറിൽ ലോക്കിനായി ത്രെഡുകൾ മത്സരിക്കുന്നു എന്ന് കരുതുക.


On multiple CPUs, spin locks work reasonably well.

ഒന്നിലധികം CPU-കളിൽ, സ്പിൻ ലോക്കുകൾ നന്നായി പ്രവർത്തിക്കുന്നു.


The basic idea is for compare-and-swap to test whether the value at the address specified by ptr is equal to expected.

ptr വ്യക്തമാക്കിയ വിലാസത്തിലെ മൂല്യം പ്രതീക്ഷിച്ചതുമായി തുല്യമാണോ എന്ന് പരിശോധിക്കുക എന്നതാണ് compare-and-swap-ൻ്റെ അടിസ്ഥാന ആശയം.


If so, update the memory location pointed to by ptr with the new value.

അങ്ങനെയാണെങ്കിൽ, ptr സൂചിപ്പിക്കുന്ന മെമ്മറി സ്ഥാനം പുതിയ മൂല്യം ഉപയോഗിച്ച് അപ്‌ഡേറ്റ് ചെയ്യുക.


With the compare-and-swap instruction, we can build a lock in a manner quite similar to that with test-and-set.

compare-and-swap നിർദ്ദേശങ്ങൾ ഉപയോഗിച്ച്, ടെസ്റ്റ്-ആൻഡ്-സെറ്റ് ഉപയോഗിക്കുന്നതിന് സമാനമായ രീതിയിൽ നമുക്ക് ഒരു ലോക്ക് നിർമ്മിക്കാൻ കഴിയും.


The load-linked operates much like a typical load instruction.

ലോഡ്-ലിങ്ക്ഡ് ഒരു സാധാരണ ലോഡ് നിർദ്ദേശത്തിന് സമാനമായി പ്രവർത്തിക്കുന്നു.


The key difference comes with the store-conditional, which only succeeds if no intermittent store to the address has taken place.

വിലാസത്തിലേക്ക് ഇടവിട്ടുള്ള സ്റ്റോറൊന്നും നടന്നിട്ടില്ലെങ്കിൽ മാത്രമേ സ്റ്റോർ-കണ്ടീഷണൽ വിജയിക്കൂ എന്നതാണ് പ്രധാന വ്യത്യാസം.


The lock() code is the only interesting piece.

lock() കോഡാണ് ഇതിലെ ഏക രസകരമായ ഭാഗം.


Once so, the thread tries to acquire the lock via the store-conditional.

അങ്ങനെ സംഭവിച്ചാൽ, സ്റ്റോർ-കണ്ടീഷണൽ വഴി ത്രെഡ് ലോക്ക് നേടാൻ ശ്രമിക്കുന്നു.


The fetch-and-add instruction atomically increments a value while returning the old value.

fetch-and-add നിർദ്ദേശം പഴയ മൂല്യം നൽകുമ്പോൾ തന്നെ ഒരു മൂല്യം ആറ്റോമികമായി വർദ്ധിപ്പിക്കുന്നു.


This solution uses a ticket and turn variable in combination to build a lock.

ഈ പരിഹാരം ഒരു ലോക്ക് നിർമ്മിക്കാൻ ടിക്കറ്റും ടേൺ വേരിയബിളും സംയോജിപ്പിച്ച് ഉപയോഗിക്കുന്നു.


The code uses two-phase locks to manage access to shared resources.

പങ്കിട്ട വിഭവങ്ങളിലേക്കുള്ള പ്രവേശനം നിയന്ത്രിക്കാൻ കോഡ് രണ്ട്-ഘട്ട ലോക്കുകൾ ഉപയോഗിക്കുന്നു.


Spinning can be useful if the lock is about to be released.

ലോക്ക് റിലീസ് ചെയ്യാൻ പോവുകയാണെങ്കിൽ സ്പിന്നിംഗ് സഹായകമാകും.


രണ്ട്-ഘട്ട ലോക്കുകൾ ഒരു ഹൈബ്രിഡ് സമീപനമാണ്.


ലിനക്സ് ലോക്ക് ഒരു തവണ മാത്രമേ സ്പിൻ ചെയ്യൂ.


Making a general-purpose lock is quite a challenge.

ഒരു പൊതു ആവശ്യത്തിനുള്ള ലോക്ക് ഉണ്ടാക്കുന്നത് ഒരു വെല്ലുവിളിയാണ്.


Real locks are built with hardware and operating system support.

യഥാർത്ഥ ലോക്കുകൾ നിർമ്മിച്ചിരിക്കുന്നത് ഹാർഡ്‌വെയറും, ഓപ്പറേറ്റിംഗ് സിസ്റ്റം പിന്തുണയും ഉപയോഗിച്ചാണ്.


Check the Solaris or Linux open source code bases for details.

വിശദാംശങ്ങൾക്കായി സോളാരിസ് അല്ലെങ്കിൽ ലിനക്സ് ഓപ്പൺ സോഴ്സ് കോഡ് അടിസ്ഥാനം പരിശോധിക്കുക.


The book is more about Al Davis and the Raiders.

പുസ്തകം കൂടുതലും അൽ ഡേവിസിനെയും റെയ്ഡേഴ്സിനെയും കുറിച്ചുള്ളതാണ്.


This paper discusses Dijkstra's original concurrency problem.

ഈ പേപ്പർ ഡിക്സ്ട്രയുടെ യഥാർത്ഥ കൺകറൻസി പ്രശ്നം ചർച്ച ചെയ്യുന്നു.


A landmark paper introducing a different approach.

ഒരു വ്യത്യസ്ത സമീപനം അവതരിപ്പിക്കുന്ന ഒരു പ്രധാന പേപ്പർ.


കൗണ്ടർ ഒരു ലളിതമായ ഡാറ്റാ ഘടനയാണ്.


ഈ കോഡിനെ എങ്ങനെ ത്രെഡ് സുരക്ഷിതമാക്കാം?


This concurrent counter is simple and works correctly.

ഈ കൺകറൻ്റ് കൗണ്ടർ ലളിതവും ശരിയായി പ്രവർത്തിക്കുന്നതുമാണ്.


The performance of the synchronized counter scales poorly.

സമന്വയിപ്പിച്ച കൗണ്ടറിൻ്റെ പ്രകടനം മോശമായി സ്കെയിൽ ചെയ്യുന്നു.


തികഞ്ഞ സ്കെയിലിംഗ് കൈവരിക്കുക എന്നതാണ് ലക്ഷ്യം.


Sloppy counters represent a single logical counter.

ഒരു സ്ലോപ്പി കൗണ്ടറുകൾ ഒരു സിംഗിൾ ലോജിക്കൽ കൗണ്ടറിനെ പ്രതിനിധീകരിക്കുന്നു.


ഈ ആശയം സ്ലോപ്പി കൗണ്ടർ എന്നറിയപ്പെടുന്നു.


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

ഒരു ത്രെഡിന് കൗണ്ടർ വർദ്ധിപ്പിക്കാൻ ആഗ്രഹമുണ്ടെങ്കിൽ, അത് അതിൻ്റെ പ്രാദേശിക കൗണ്ടർ വർദ്ധിപ്പിക്കുന്നു.


The global counter is updated periodically.

ഗ്ലോബൽ കൗണ്ടർ കാലാകാലങ്ങളിൽ അപ്‌ഡേറ്റ് ചെയ്യപ്പെടുന്നു.


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

അടുത്തതായി, ഞങ്ങൾ കൂടുതൽ സങ്കീർണ്ണമായ ഒരു ഘടന, ലിങ്ക്ഡ് ലിസ്റ്റ് പരിശോധിക്കുന്നു.


The program uses a hash table to store and retrieve data efficiently.

ഡാറ്റ കാര്യക്ഷമമായി സംഭരിക്കാനും വീണ്ടെടുക്കാനും പ്രോഗ്രാം ഒരു ഹാഷ് ടേബിൾ ഉപയോഗിക്കുന്നു.


Locks are essential for managing concurrent access to shared data structures.

പങ്കിട്ട ഡാറ്റാ ഘടനകളിലേക്കുള്ള ഒരേസമയത്തുള്ള പ്രവേശനം നിയന്ത്രിക്കുന്നതിന് ലോക്കുകൾ അത്യാവശ്യമാണ്.


Condition variables help threads wait for specific conditions to become true.

നിർദ്ദിഷ്ട സാഹചര്യങ്ങൾ ശരിയാകുന്നതുവരെ കാത്തിരിക്കാൻ അവസ്ഥാ വേരിയബിളുകൾ ത്രെഡുകളെ സഹായിക്കുന്നു.


The producer-consumer problem is a classic concurrency challenge.

നിർമ്മാതാവ്-ഉപഭോക്താവ് പ്രശ്നം ഒരു ക്ലാസിക് സമകാലിക വെല്ലുവിളിയാണ്.


Avoid premature optimization; focus on correctness first.

അകാലത്തിലുള്ള ഒപ്റ്റിമൈസേഷൻ ഒഴിവാക്കുക; ആദ്യം ശരിയായ കാര്യത്തിൽ ശ്രദ്ധിക്കുക.


The operating system manages resources and provides services to applications.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വിഭവങ്ങൾ കൈകാര്യം ചെയ്യുകയും ആപ്ലിക്കേഷനുകൾക്ക് സേവനങ്ങൾ നൽകുകയും ചെയ്യുന്നു.


Concurrency can improve performance, but it also introduces complexity.

ഒരേസമയം പ്രവർത്തിക്കുന്നത് പ്രകടനം മെച്ചപ്പെടുത്തും, എന്നാൽ ഇത് സങ്കീർണ്ണതയും ഉണ്ടാക്കുന്നു.


The code uses mutexes to protect shared data from race conditions.

റേസ് അവസ്ഥകളിൽ നിന്ന് പങ്കിട്ട ഡാറ്റയെ സംരക്ഷിക്കാൻ കോഡ് മ്യൂട്ടെക്സുകൾ ഉപയോഗിക്കുന്നു.


Understanding the Linux kernel is crucial for system programmers.

സിസ്റ്റം പ്രോഗ്രാമർമാർക്ക് Linux കേർണൽ മനസ്സിലാക്കുന്നത് നിർണായകമാണ്.


The program is designed to handle multiple threads concurrently.

ഒന്നിലധികം ത്രെഡുകൾ ഒരേസമയം കൈകാര്യം ചെയ്യാൻ പ്രോഗ്രാം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.


The hash table provides fast lookups based on keys.

കീകൾ അടിസ്ഥാനമാക്കി ഹാഷ് ടേബിൾ വേഗത്തിലുള്ള ലുക്ക്അപ്പുകൾ നൽകുന്നു.


The child thread signals the parent thread when it is done.

ചൈൽഡ് ത്രെഡ് പൂർത്തിയാകുമ്പോൾ, അത് പാരന്റ് ത്രെഡിന് സിഗ്നൽ നൽകുന്നു.


The bounded buffer problem involves producers and consumers.

നിർമ്മാതാക്കളും ഉപഭോക്താക്കളും തമ്മിലുള്ള ബന്ധമാണ് പരിമിതമായ ബഫർ പ്രശ്നം.


The while loop ensures the condition is checked repeatedly.

സ്ഥിരമായി കണ്ടീഷൻ പരിശോധിക്കുന്നത് ഉറപ്പാക്കുന്നത് വൈൽ ലൂപ്പാണ്.


The code uses condition variables for synchronization.

സമന്വയത്തിനായി കോഡ് അവസ്ഥാ വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു.


The program's performance scales well with multiple cores.

ഒന്നിലധികം കോറുകൾ ഉപയോഗിക്കുമ്പോൾ പ്രോഗ്രാമിന്റെ പ്രകടനം നന്നായി സ്കെയിൽ ചെയ്യുന്നു.


The system uses locks to prevent data corruption.

ഡാറ്റാ കേടുപാടുകൾ തടയാൻ സിസ്റ്റം ലോക്കുകൾ ഉപയോഗിക്കുന്നു.


The consumer waits for data to become available in the buffer.

ഡാറ്റ ബഫറിൽ ലഭ്യമാകുന്നതുവരെ ഉപഭോക്താവ് കാത്തിരിക്കുന്നു.


The producer inserts items into the shared buffer.

നിർമ്മാതാവ് പങ്കിട്ട ബഫറിലേക്ക് ഇനങ്ങൾ ചേർക്കുന്നു.


Understanding concurrency is key to building efficient systems.

കാര്യക്ഷമമായ സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നതിന് കൺകറൻസി മനസ്സിലാക്കുന്നത് പ്രധാനമാണ്.


ഉപയോക്താവ് വീണ്ടും ഉറക്കത്തിലേക്ക് മടങ്ങുന്നു.


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, in this case in a simple multi-threaded memory allocation library.

അവർക്ക് നേരിടേണ്ടി വന്ന പ്രശ്നം ലളിതമായ ഉദാഹരണത്തിലൂടെ നന്നായി കാണിച്ചിരിക്കുന്നു, ഈ സാഹചര്യത്തിൽ ലളിതമായ മൾട്ടി-ത്രെഡ് മെമ്മറി അലോക്കേഷൻ ലൈബ്രറിയിൽ.


By doing so, we guarantee that any threads that should be woken are.

അങ്ങനെ ചെയ്യുന്നതിലൂടെ, ഉണർത്തേണ്ട ഏതൊരു ത്രെഡും ഉറപ്പാക്കുന്നു.


We have seen the introduction of another important synchronization primitive beyond locks: condition variables.

ലോക്കുകൾക്ക് പുറമെ, മറ്റൊരു പ്രധാനപ്പെട്ട സമന്വയ പ്രിമിറ്റീവിന്റെ ആമുഖം നമ്മൾ കണ്ടു: കണ്ടീഷൻ വേരിയബിളുകൾ.


A more dramatic concluding sentence would go here, such as “He loved Big Brother”.

കൂടുതൽ നാടകീയമായ ഒരു ഉപസംഹാര വാക്യം ഇവിടെ നൽകാം, ഉദാഹരണത്തിന് “അവൻ വലിയ സഹോദരനെ സ്നേഹിച്ചു”.


Indeed, Dijkstra and colleagues invented the semaphore as a single primitive for all things related to synchronization.

തീർച്ചയായും, സമന്വയവുമായി ബന്ധപ്പെട്ട എല്ലാ കാര്യങ്ങൾക്കും വേണ്ടി ഡിക്സ്ട്രയും സഹപ്രവർത്തകരും ഒരു സെമാഫോർ കണ്ടുപിടിച്ചു.