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: மற்ற மேம்பாடுகள்.


விநியோகம் பற்றிய சுருக்கமான உரையாடல்


நினைவகத்தை அணுகும் ஒரு நிரல்.


பல நிரல்களை ஒரே நேரத்தில் இயக்குதல்.


இடைமறிப்புகளைக் கட்டுப்படுத்துதல்.


வேலை செய்யும் ஸ்பின் பூட்டை உருவாக்குதல்.


ஸ்பின் பூட்டுகளை மதிப்பீடு செய்தல்.


ஒப்பிட்டுப் பரிமாற்றம்.


எடுத்துச் சேர்.


அவ்வளவு சுழற்சி.


கொடுத்து விடுங்கள், செல்லமே.


Using Queues: Sleeping Instead Of Spinning.

வரிசைகளைப் பயன்படுத்துதல்: சுழல்வதற்குப் பதிலாக தூங்குதல்.


வேறுபட்ட இயக்க முறைமை, வேறுபட்ட ஆதரவு.


இரண்டு கட்ட பூட்டுகள்.


ஒரே நேரத்தில் இயங்கும் கவுண்டர்கள்.


ஒரே நேரத்தில் இயங்கும் இணைக்கப்பட்ட பட்டியல்கள்.


ஒரே நேரத்தில் இயங்கும் வரிசைகள்.


ஒரே நேரத்தில் இயங்கும் ஹாஷ் அட்டவணை.


வரையறையும் வழக்கங்களும்.


The Producer/Consumer (Bound Buffer) Problem.

உற்பத்தியாளர்/நுகர்வோர் (வரையறுக்கப்பட்ட இடையகம்) சிக்கல்.


நிபந்தனைகளை உள்ளடக்குதல்.


செமாபோர்கள்: ஒரு வரையறை.


துணை செமாபோர்கள் (பூட்டுகள்).


நிபந்தனை மாறிகளாக செமாபோர்கள்.


The operating system virtualizes resources.

இயக்க முறைமை வளங்களை மெய்நிகராக்குகிறது.


ஒரு நிரல் வழிமுறைகளை செயல்படுத்துகிறது.


இயக்க முறைமை கணினியைப் பயன்படுத்துவதை எளிதாக்குகிறது.


மெய்நிகராக்கம் ஒரு முக்கிய நுட்பமாகும்.


இயக்க முறைமை கணினி அழைப்புகளை வழங்குகிறது.


Each program has its own virtual address space.

ஒவ்வொரு நிரலும் அதன் சொந்த மெய்நிகர் முகவரி இடத்தைக் கொண்டுள்ளது.


இயக்க முறைமை வளங்களை திறமையாக நிர்வகிக்கிறது.


ஒருங்கிணைப்பு ஒரு முக்கிய கருப்பொருளாகும்.


Multiple programs can run at the same time.

பல நிரல்களை ஒரே நேரத்தில் இயக்க முடியும்.


The processor fetches instructions from memory.

செயலி நினைவகத்திலிருந்து வழிமுறைகளை எடுக்கிறது.


The operating system is a resource manager.

இயக்க முறைமை ஒரு வள மேலாளர் ஆகும்.


Understanding virtualization is crucial.

மெய்நிகராக்கத்தைப் புரிந்துகொள்வது முக்கியம்.


இயக்க முறைமை இயற்பியல் வளங்களை மாற்றுகிறது.


The program increments a counter in a loop.

நிரல் ஒரு சுழற்சியில் ஒரு கவுண்டரை அதிகரிக்கிறது.


The OS provides a standard library to applications.

இயக்க முறைமை பயன்பாடுகளுக்கு ஒரு நிலையான நூலகத்தை வழங்குகிறது.


Concurrency problems arise in multi-threaded programs.

ஒருங்கிணைப்பு சிக்கல்கள் பல-திரிக்கப்பட்ட நிரல்களில் எழுகின்றன.


The OS allows many programs to seemingly run at once.

இயக்க முறைமை பல நிரல்கள் ஒரே நேரத்தில் இயங்குவது போல் தோன்ற அனுமதிக்கிறது.


The operating system is responsible for making the system easy to use.

கணினியைப் பயன்படுத்துவதை எளிதாக்குவதற்கு இயக்க முறைமை பொறுப்பாகும்.


Virtualization allows many programs to share the CPU.

மெய்நிகராக்கம் பல நிரல்கள் CPU ஐப் பகிர்ந்து கொள்ள அனுமதிக்கிறது.


The OS manages memory overload in a virtual memory system.

இயக்க முறைமை மெய்நிகர் நினைவக அமைப்பில் நினைவக ஓவர்லோடை நிர்வகிக்கிறது.


The operating system manages the computer's resources.

இயக்க முறைமை கணினியின் வளங்களை நிர்வகிக்கிறது.


Scheduling algorithms determine the order in which processes are executed.

நிரலாக்க வழிமுறைகள் செயல்முறைகள் எந்த வரிசையில் செயல்படுத்தப்படும் என்பதைத் தீர்மானிக்கின்றன.


The system uses FIFO for job scheduling.

வேலை அட்டவணைக்காக கணினி FIFO ஐப் பயன்படுத்துகிறது.


Shortest Job First (SJF) is a scheduling algorithm.

குறுகிய வேலை முதல் (SJF) என்பது ஒரு அட்டவணைப்படுத்தும் வழிமுறை ஆகும்.


Round Robin scheduling provides fair time slices to each process.

ரவுண்ட் ராபின் அட்டவணைப்படுத்துதல் ஒவ்வொரு செயலுக்கும் நியாயமான நேர துண்டுகளை வழங்குகிறது.


I/O operations can impact the performance of scheduling.

I/O செயல்பாடுகள் அட்டவணைப்படுத்துதலின் செயல்திறனை பாதிக்கலாம்.


The MLFQ algorithm uses multiple queues for scheduling.

MLFQ வழிமுறை அட்டவணைப்படுத்துதலுக்காக பல வரிசைகளைப் பயன்படுத்துகிறது.


Tickets represent your share in proportional share scheduling.

டிக்கெட்டுகள் விகிதாசார பகிர்வு அட்டவணையில் உங்கள் பங்கைக் குறிக்கின்றன.


Multiprocessor scheduling involves managing multiple CPUs.

பல செயலி அட்டவணைப்படுத்துதல் பல CPUகளை நிர்வகிப்பதை உள்ளடக்கியது.


Address spaces are a key concept in memory virtualization.

முகவரி இடங்கள் நினைவக மெய்நிகராக்கத்தில் ஒரு முக்கிய கருத்தாகும்.


The malloc() call is used to allocate memory.

malloc() அழைப்பு நினைவகத்தை ஒதுக்க பயன்படுகிறது.


The free() call releases allocated memory.

free() அழைப்பு ஒதுக்கப்பட்ட நினைவகத்தை வெளியிடுகிறது.


Address translation is a mechanism for virtual memory.

முகவரி மொழிபெயர்ப்பு மெய்நிகர் நினைவகத்திற்கான ஒரு வழிமுறை ஆகும்.


Segmentation is a memory management technique.

பிரிவு என்பது ஒரு நினைவக மேலாண்மை நுட்பமாகும்.


Free-space management is crucial for efficient storage.

திறமையான சேமிப்பகத்திற்கு இலவச-இட மேலாண்மை முக்கியமானது.


Paging divides memory into fixed-size blocks.

பக்கமாக்குதல் நினைவகத்தை நிலையான அளவு தொகுதிகளாகப் பிரிக்கிறது.


TLBகள் முகவரி மொழிபெயர்ப்பை துரிதப்படுத்துகின்றன.


Multi-level page tables optimize memory usage.

பல நிலை பக்க அட்டவணைகள் நினைவக பயன்பாட்டை மேம்படுத்துகின்றன.


The operating system handles page faults.

இயக்க முறைமை பக்கக் குறைபாடுகளைக் கையாளுகிறது.


Concurrency introduces challenges in software design.

ஒருங்கிணைப்பு மென்பொருள் வடிவமைப்பில் சவால்களை அறிமுகப்படுத்துகிறது.


The book is called Operating Systems: Three Easy Pieces.

இந்தப் புத்தகத்தின் பெயர் இயக்க முறைமைகள்: மூன்று எளிய பகுதிகள்.


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

இந்தப் புத்தகத்தை எழுதுவதில் நாங்கள் எவ்வளவு மகிழ்ந்தோமோ, அதே அளவு நீங்கள் படிப்பதில் மகிழ்வீர்கள் என்று நம்புகிறோம்.


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

மூன்று எளிய பகுதிகள் என்பது புத்தகத்தில் உள்ள மூன்று முக்கிய கருப்பொருள்களைக் குறிக்கின்றன: மெய்நிகராக்கம், ஒருங்குசெயல் மற்றும் நிலைப்புத்தன்மை.


புதிய விஷயங்களைக் கற்றுக்கொள்வது வேடிக்கையாக இருக்கிறது, இல்லையா?


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

ஒவ்வொரு முக்கிய கருத்தும் பல அத்தியாயங்களாகப் பிரிக்கப்பட்டுள்ளன, அவற்றில் பெரும்பாலானவை ஒரு குறிப்பிட்ட சிக்கலை முன்வைத்து, அதை எவ்வாறு தீர்ப்பது என்பதைக் காட்டுகின்றன.


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

இந்தப் புத்தகத்தை எழுதுவதன் மூலம், வரலாற்றின் பாதைகளை முடிந்தவரை தெளிவாகக் காட்டுவதே எங்கள் குறிக்கோளாகும்.


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

இந்தப் புத்தகத்தில் நாம் பயன்படுத்தும் சில விஷயங்கள் உள்ளன, அவற்றை இங்கே அறிமுகப்படுத்துவது பயனுள்ளதாக இருக்கும்.


முதலாவது, பிரச்சனையின் மையக்கருத்து.


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

துணை விஷயங்கள், முக்கிய உரைக்கு தொடர்புடைய (ஆனால் அவசியமில்லாத) ஒன்றை விவாதிக்க முனைகின்றன.


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

இந்தப் புத்தகத்தில், மிகப்பழமையான கற்பித்தல் முறைகளில் ஒன்றான உரையாடலைப் பயன்படுத்துகிறோம்.


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

ஒவ்வொரு முக்கிய பகுதியின் தொடக்கத்திலும், இயக்க முறைமை வழங்கும் ஒரு கருத்தை முதலில் முன்வைப்போம்.


Throughout the chapters, we try to use real code where possible.

அத்தியாயங்கள் முழுவதும், முடிந்தவரை உண்மையான குறியீட்டைப் பயன்படுத்த முயற்சிக்கிறோம்.


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

உண்மையான அமைப்புகளில் உண்மையான குறியீட்டை இயக்குவது, இயக்க முறைமைகளைப் பற்றி அறிய சிறந்த வழியாகும்.


The most important addendum to this book is a set of projects.

இந்தப் புத்தகத்தின் மிக முக்கியமான இணைப்பு, திட்டங்களின் தொகுப்பாகும்.


C is a simple and powerful language that underlies most operating systems.

சி என்பது ஒரு எளிய மற்றும் சக்திவாய்ந்த மொழி, இது பெரும்பாலான இயக்க முறைமைகளுக்கு அடிப்படையாக உள்ளது.


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

நீங்கள் இந்தப் புத்தகத்தைப் பயன்படுத்த விரும்பும் ஒரு பயிற்றுவிப்பாளர் அல்லது பேராசிரியராக இருந்தால், தயங்காமல் பயன்படுத்தலாம்.


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

இந்த பாடநெறி 15 வார செமஸ்டரில் நன்றாகப் பிரிக்கப்பட்டுள்ளது.


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

புத்தகத்தின் சற்று அசாதாரணமான அம்சம் என்னவென்றால், பல இயக்க முறைமை புத்தகங்களில் முன்னணியில் இருக்கும் ஒருங்குசெயல், மாணவர் மெய்நிகராக்கத்தைப் பற்றிய புரிதலை உருவாக்கும் வரை இங்கே தள்ளி வைக்கப்படுகிறது.


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

இயக்க முறைமைகளில் உங்கள் ஆர்வத்தைத் தூண்டுவதற்காக இந்த குறிப்புகளை உருவாக்கினோம்.


It is a great field, full of exciting and wonderful ideas that have shaped computing history in profound and important ways.

இது ஒரு சிறந்த துறையாகும், கணினி வரலாற்றை ஆழமான மற்றும் முக்கியமான வழிகளில் வடிவமைத்த அற்புதமான மற்றும் அற்புதமான யோசனைகளால் நிறைந்தது.


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

அந்த நிரல் '/tmp/file' என்ற பெயரில் ஒரு கோப்பை உருவாக்குகிறது.


Data in system memory can be easily lost.

கணினி நினைவகத்தில் உள்ள தரவை எளிதில் இழக்க நேரிடும்.


The file system manages persistent data.

கோப்பு முறைமை நிலையான தரவை நிர்வகிக்கிறது.


இயக்க முறைமைகள் சுருக்கங்களை வழங்குகின்றன.


Abstraction makes it possible to write large programs.

சுருக்கம் பெரிய நிரல்களை எழுத உதவுகிறது.


The OS must provide protection between applications.

இயக்க முறைமை பயன்பாடுகளுக்கு இடையே பாதுகாப்பை வழங்க வேண்டும்.


Early operating systems were just libraries.

ஆரம்பகால இயக்க முறைமைகள் வெறும் நூலகங்களாக இருந்தன.


System calls are routed to the file system.

கணினி அழைப்புகள் கோப்பு முறைமைக்கு அனுப்பப்படுகின்றன.


இயக்க முறைமை ஒருங்கே நிகழ்வு சிக்கல்களைக் கையாளுகிறது.


UNIX made systems simpler and easier to use.

UNIX அமைப்புகளை எளிமையாகவும் பயன்படுத்த எளிதாகவும் ஆக்கியது.


நிரல் கோப்பில் தரவை எழுதுகிறது.


The file system is responsible for storing files.

கோப்பு முறைமை கோப்புகளை சேமிப்பதற்கு பொறுப்பாகும்.


இயக்க முறைமை வளங்களை மெய்நிகராக்குகிறது.


We will discuss devices and I/O in general.

நாம் சாதனங்கள் மற்றும் I/O பற்றி பொதுவாக விவாதிப்போம்.


The OS provides a standard way to access devices.

இயக்க முறைமை சாதனங்களை அணுக ஒரு நிலையான வழியை வழங்குகிறது.


File systems employ many different data structures.

கோப்பு முறைமைகள் பலதரப்பட்ட தரவு கட்டமைப்புகளைப் பயன்படுத்துகின்றன.


The OS strives to provide a high degree of reliability.

இயக்க முறைமை அதிக அளவிலான நம்பகத்தன்மையை வழங்க முயற்சிக்கிறது.


The key difference is that a system call transfers control.

முக்கிய வேறுபாடு என்னவென்றால், ஒரு கணினி அழைப்பு கட்டுப்பாட்டை மாற்றுகிறது.


Multiprogramming became commonplace to make better use of machine resources.

இயந்திர வளங்களை சிறப்பாகப் பயன்படுத்துவதற்காக மல்டிப்ரோகிராம்மிங் பொதுவானதாக மாறியது.


The OS must run non-stop; when it fails, all applications fail as well.

இயக்க முறைமை இடைவிடாமல் இயங்க வேண்டும்; அது தோல்வியுற்றால், அனைத்து பயன்பாடுகளும் தோல்வியடையும்.


The book is a classic text on software engineering.

இந்தப் புத்தகம் மென்பொருள் பொறியியலில் ஒரு உன்னதமான உரை ஆகும்.


This paper provides a great overview of early computer systems.

இந்தக் கட்டுரை ஆரம்பகால கணினி அமைப்புகளைப் பற்றிய ஒரு சிறந்த கண்ணோட்டத்தை வழங்குகிறது.


The OS creates this illusion by virtualizing the CPU.

இயக்க முறைமை CPU-ஐ மெய்நிகராக்குவதன் மூலம் இந்த மாயையை உருவாக்குகிறது.


நம்மிடம் ஒரு பீச் பழம் இருப்பதாக கற்பனை செய்து கொள்ளுங்கள்.


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

இயக்க முறைமைக்கு சில குறைந்த-நிலை இயந்திரங்கள் மற்றும் சில உயர்-நிலை நுண்ணறிவு இரண்டும் தேவைப்படும்.


நிரல் என்பது உயிரற்ற ஒன்று.


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

இயக்க முறைமையால் வழங்கப்படும் இயங்கும் நிரலின் சுருக்கம் நாம் ஒரு செயல்முறை என்று அழைப்போம்.


அந்த நிரல் மேகத்தில் இயங்குகிறது.


தயவுசெய்து ஒரு புதிய செயல்முறையை உருவாக்குங்கள்.


The child process is created using fork().

குழந்தை செயல்முறை fork() பயன்படுத்தி உருவாக்கப்படுகிறது.


The parent process waits for the child to finish.

பெற்றோர் செயல்முறை குழந்தை முடிவதற்கு காத்திருக்கிறது.


The exec() system call replaces the current process image.

exec() சிஸ்டம் கால் தற்போதைய செயல்முறை படத்தை மாற்றுகிறது.


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

ஷெல் கட்டளைகளை இயக்க fork() மற்றும் exec() பயன்படுத்துகிறது.


நான் மேன் பக்கங்களைப் படிக்கிறேன்.


The system is experiencing high CPU load.

கணினி அதிக CPU சுமையை அனுபவித்து வருகிறது.


இயக்க முறைமை செயல்முறைகளை நிர்வகிக்கிறது.


Virtualization is achieved through time sharing.

நேர பகிர்வு மூலம் மெய்நிகராக்கம் அடையப்படுகிறது.


இயக்க முறைமை CPU ஐ கட்டுப்படுத்த வேண்டும்.


நேரடி செயல்படுத்தல் ஒரு வேகமான நுட்பமாகும்.


நிரலின் நுழைவு புள்ளி main().


பயனர் முறை செயல்பாடுகளை கட்டுப்படுத்துகிறது.


Kernel mode allows privileged operations.

கர்னல் முறை சிறப்புரிமை செயல்பாடுகளை அனுமதிக்கிறது.


வன்பொருள் இயக்க முறைமைக்கு உதவுகிறது.


I need to learn more about system calls.

நான் சிஸ்டம் கால்களைப் பற்றி மேலும் தெரிந்து கொள்ள வேண்டும்.


ஷெல் ஒரு பயனர் நிரல் ஆகும்.


வெளியீடு ஒரு கோப்பிற்கு திருப்பி விடப்படுகிறது.


பைப்கள் இதே முறையில் செயல்படுத்தப்படுகின்றன.


The operating system manages the computer's resources.

இயக்க முறைமை கணினியின் வளங்களை நிர்வகிக்கிறது.


System calls allow user programs to access kernel functionality.

கட்டளைகளை இயக்குவதன் மூலம் பயனர் நிரல்கள் கர்னல் செயல்பாட்டை அணுக அனுமதிக்கிறது.


The hardware saves the caller’s register state.

வன்பொருள் அழைப்பவரின் பதிவேடு நிலையை சேமிக்கிறது.


The kernel initializes the trap table at boot time.

கெர்னல் துவக்க நேரத்தில் பொறி அட்டவணையைத் துவக்குகிறது.


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

இயக்க முறைமை இந்த பொறி கையாளுபவர்களின் இருப்பிடங்களை வன்பொருளுக்குத் தெரிவிக்க வேண்டும்.


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

டைமர் குறுக்கீடு இயக்க முறைமைக்கு மீண்டும் இயங்கும் திறனை அளிக்கிறது.


இயக்க முறைமை CPU இன் கட்டுப்பாட்டை மீண்டும் பெறுகிறது.


The process wishes to issue a system call.

செயல்முறை ஒரு கணினி அழைப்பை வெளியிட விரும்புகிறது.


Switching between processes should be simple.

செயல்முறைகளுக்கு இடையில் மாறுவது எளிதாக இருக்க வேண்டும்.


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

இயக்க முறைமை இயங்கவில்லை என்றால், அது எப்படி எதையும் செய்ய முடியும்?


இயக்க முறைமை CPU இன் கட்டுப்பாட்டை மீண்டும் பெற முடியும்.


The OS trusts the processes of the system to behave reasonably.

இயக்க முறைமை அமைப்பின் செயல்முறைகள் நியாயமான முறையில் செயல்படும் என்று நம்புகிறது.


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

சட்டவிரோதமான ஒன்றைச் செய்யும்போது பயன்பாடுகளும் இயக்க முறைமைக்கு கட்டுப்பாட்டை மாற்றுகின்றன.


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

ஒரு செயல்முறை கணினி அழைப்புகளைச் செய்ய மறுக்கும்போது இயக்க முறைமையால் அதிகம் செய்ய முடியாது.


A timer interrupt is used to regain control.

கட்டுப்பாட்டை மீண்டும் பெற ஒரு டைமர் குறுக்கீடு பயன்படுத்தப்படுகிறது.


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

இயக்க முறைமை டைமரைத் தொடங்க வேண்டும், இது ஒரு சிறப்புரிமை செயல்பாடு ஆகும்.


The hardware saves the state of the program.

வன்பொருள் நிரலின் நிலையை சேமிக்கிறது.


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

இயக்க முறைமை செயல்முறை A இலிருந்து செயல்முறை B க்கு மாற முடிவு செய்கிறது.


சூழல் மாற்றம் நிறைவடைந்தது.


இயக்க முறைமை CPU ஐ குழந்தைக்கு பாதுகாப்பானதாக்குகிறது.


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.

ஒரு கணினி அழைப்பின் செலவை அளவிடுவது ஒப்பீட்டளவில் எளிதானது.


For example, you could repeatedly call a simple system call (e.g., performing a 0-byte read), and time how long it takes.

உதாரணமாக, நீங்கள் ஒரு எளிய கணினி அழைப்பை மீண்டும் மீண்டும் அழைக்கலாம் (எ.கா., 0-பைட் ரீட் செய்தல்), மேலும் எவ்வளவு நேரம் எடுக்கும் என்பதை அளவிடலாம்.


One thing you’ll have to take into account is the precision and accuracy of your timer.

நீங்கள் கணக்கில் எடுத்துக்கொள்ள வேண்டிய ஒரு விஷயம் உங்கள் டைமரின் துல்லியம் மற்றும் துல்லியம் ஆகும்.


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

ஒரு சூழல் மாற்றத்தின் செலவை அளவிடுவது சற்று தந்திரமானது.


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 ensuring both processes are on the same processor, you are making sure to measure the cost of the OS stopping one process and restoring another on the same CPU.

இரண்டு செயல்முறைகளும் ஒரே செயலியிலிருப்பதை உறுதி செய்வதன் மூலம், ஒரே CPU இல் ஒரு செயல்முறையை நிறுத்திவிட்டு மற்றொன்றை மீட்டெடுப்பதற்கான OS இன் செலவை அளவிடுகிறீர்கள்.


However, we have yet to understand the high-level policies that an OS scheduler employs.

இருப்பினும், ஒரு OS திட்டமிடுபவர் பயன்படுத்தும் உயர்-நிலை கொள்கைகளை நாம் இன்னும் புரிந்து கொள்ளவில்லை.


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

திட்டமிடலின் தோற்றம், உண்மையில், கணினி அமைப்புகளுக்கு முந்தையது.


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

திட்டமிடல் கொள்கைகளைப் பற்றி சிந்திப்பதற்கான ஒரு அடிப்படை கட்டமைப்பை நாம் எவ்வாறு உருவாக்க வேண்டும்?


முக்கிய அனுமானங்கள் என்ன?


எந்த அளவீடுகள் முக்கியம்?


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

கணினியில் இயங்கும் செயல்முறைகள், சில நேரங்களில் வேலைகள் என்று அழைக்கப்படுகின்றன, பற்றி நாம் பின்வரும் அனுமானங்களை செய்வோம்:


Each job runs for the same amount of time.

ஒவ்வொரு வேலையும் ஒரே நேரத்தில் இயங்கும்.


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.

ஒரு வேலையின் திரும்பும் நேரம் என்பது, வேலை முடிந்த நேரத்திலிருந்து, வேலை கணினியில் வந்த நேரத்தைக் கழித்தால் கிடைப்பது.


Because we have assumed that all jobs arrive at the same time, for now T arrival = 0 and hence T turnaround = T completion.

நாம் எல்லா வேலைகளும் ஒரே நேரத்தில் வருகின்றன என்று கருதியுள்ளதால், இப்போது T வருகை = 0 மற்றும் எனவே T திரும்பும் நேரம் = T நிறைவு.


The scheduler decides which process gets to use the CPU.

நிரல் திட்டமிடுபவர் எந்த செயல்முறை CPU ஐப் பயன்படுத்த வேண்டும் என்பதைத் தீர்மானிக்கிறார்.


MLFQ சுழற்சி நேரத்தை மேம்படுத்த முயற்சிக்கிறது.


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

இயக்க முறைமை பொதுவாக ஒவ்வொரு பணியின் நீளம் பற்றி மிகக் குறைவாகவே தெரியும்.


We have introduced the basic ideas behind scheduling.

நிரலாக்கத்தின் பின்னால் உள்ள அடிப்படை யோசனைகளை நாங்கள் அறிமுகப்படுத்தியுள்ளோம்.


The scheduler makes sure processes that are interactive get run frequently.

ஊடாடும் செயல்முறைகள் அடிக்கடி இயங்குவதை திட்டமிடுபவர் உறுதி செய்கிறார்.


Overlap is useful in many different domains.

மேலடுக்கு பல வெவ்வேறு களங்களில் பயனுள்ளதாக இருக்கும்.


எனவே, கணினி சிறப்பாகப் பயன்படுத்தப்படுகிறது.


We will see how to overcome this problem.

இந்த சிக்கலை எவ்வாறு சமாளிப்பது என்பதைப் பார்ப்போம்.


The multi-level feedback queue is an excellent example.

பல-நிலை பின்னூட்ட வரிசை ஒரு சிறந்த எடுத்துக்காட்டு.


The scheduler should keep track of CPU time.

திட்டமிடுபவர் CPU நேரத்தைக் கண்காணிக்க வேண்டும்.


How can we build a scheduler to achieve these goals?

இந்த இலக்குகளை அடைய நாம் எவ்வாறு ஒரு திட்டமிடுபவரை உருவாக்க முடியும்?


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

MLFQ ஒரு வேலையின் முன்னுரிமையை அதன் கவனிக்கப்பட்ட நடத்தையின் அடிப்படையில் மாற்றுகிறது.


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

ஒரு வேலை முழு நேர துண்டையும் பயன்படுத்தினால், அதன் முன்னுரிமை குறைக்கப்படும்.


இந்த விதியின் நோக்கம் எளிமையானது.


Gaming the scheduler generally refers to the idea of doing something sneaky.

திட்டமிடுபவரை ஏமாற்றுவது என்பது பொதுவாக ஏதாவது தந்திரமான ஒன்றைச் செய்வதைக் குறிக்கிறது.


We’d like to make some progress on these jobs.

இந்த வேலைகளில் சில முன்னேற்றம் அடைய விரும்புகிறோம்.


The simple idea here is to periodically boost the priority.

இங்குள்ள எளிய யோசனை என்னவென்றால், அவ்வப்போது முன்னுரிமையை அதிகரிப்பதாகும்.


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

கால இடைவெளி S ஐச் சேர்ப்பது ஒரு தெளிவான கேள்விக்கு வழிவகுக்கிறது.


The scheduler should keep track; once a process has used its allotment, it is demoted.

திட்டமிடுபவர் கண்காணிக்க வேண்டும்; ஒரு செயல்முறை அதன் ஒதுக்கீட்டைப் பயன்படுத்தியதும், அது தரமிறக்கப்படுகிறது.


There are no easy answers to these questions.

இந்த கேள்விகளுக்கு எளிதான பதில்கள் இல்லை.


இந்தக் கட்டுரை லாட்டரி திட்டமிடலைப் பற்றி விவாதிக்கிறது.


This thesis is a good example for aspiring Ph.D. students.

இந்த ஆய்வுக் கட்டுரை முனைவர் பட்டம் பெற விரும்புவோருக்கு ஒரு நல்ல எடுத்துக்காட்டு.


The paper explores memory resource management in VMMs.

இந்தக் கட்டுரை VMMகளில் நினைவக வள மேலாண்மையை ஆராய்கிறது.


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

இந்த நிரல் லாட்டரி திட்டமிடுபவர் எவ்வாறு செயல்படுகிறார் என்பதைப் பார்க்க உதவுகிறது.


Compute the solutions for simulations with 3 jobs.

3 வேலைகளுடன் உருவகப்படுத்துதலுக்கான தீர்வுகளைக் கணக்கிடுங்கள்.


Multi-core processors are becoming increasingly common.

பல மைய செயலிகள் பெருகிய முறையில் பொதுவானதாகி வருகின்றன.


Multi-threaded applications can run faster with more CPUs.

பல-திரெட் பயன்பாடுகள் அதிக CPU களுடன் வேகமாக இயங்க முடியும்.


This chapter introduces the basics of multiprocessor scheduling.

இந்த அத்தியாயம் பல செயலி திட்டமிடலின் அடிப்படைகளை அறிமுகப்படுத்துகிறது.


Caches help the processor run programs faster.

செயலிகள் நிரல்களை வேகமாக இயக்க உதவுகின்றன.


The system fetches data from main memory.

அமைப்பு முதன்மை நினைவகத்திலிருந்து தரவை எடுக்கிறது.


Caches are based on the notion of locality.

கேஷ்கள் உள்ளூர்மயமாக்கல் கருத்தை அடிப்படையாகக் கொண்டவை.


கேஷ் ஒருங்கிணைப்பு பிரச்சனை எழுகிறது.


Hardware ensures the right thing happens.

வன்பொருள் சரியானதை உறுதி செய்கிறது.


Synchronization is important when accessing shared data.

பகிர்ந்த தரவை அணுகும் போது ஒத்திசைவு முக்கியமானது.


Mutual exclusion primitives should be used.

பரஸ்பர விலக்கு பிரைமிடிவ்களைப் பயன்படுத்த வேண்டும்.


Cache affinity is a final issue to consider.

கேஷ் தொடர்பு என்பது கருத்தில் கொள்ள வேண்டிய இறுதிப் பிரச்சினை.


SQMS அளவிடுதலில் பற்றாக்குறையைக் கொண்டுள்ளது.


MQMS intrinsically provides cache affinity.

MQMS உள்ளார்ந்த வகையில் கேஷ் தொடர்பை வழங்குகிறது.


Load imbalance is a fundamental problem in MQMS.

MQMS இல் ஏற்றத்தாழ்வு ஒரு அடிப்படைப் பிரச்சனையாகும்.


Work stealing is a technique to handle load imbalance.

வேலை திருடுதல் என்பது ஏற்றத்தாழ்வைக் கையாளும் ஒரு நுட்பமாகும்.


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

இயக்க முறைமை ஒவ்வொரு செயலுக்கும் சிறந்தது எது என்பதை அரிதாகவே அறியும்.


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

அத்தகைய குறிப்புகள் இயக்க முறைமையின் பல பகுதிகளில் பயனுள்ளதாக இருக்கும், இதில் திட்டமிடுபவரும் அடங்குவர்.


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 இன் ஒரு வடிவத்தை அவற்றின் அடிப்படை திட்டமிடுபவராகப் பயன்படுத்துகின்றன.


The basic idea is quite simple: tickets represent your share.

அடிப்படை யோசனை மிகவும் எளிமையானது: டிக்கெட்டுகள் உங்கள் பங்கைக் குறிக்கின்றன.


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

A மற்றும் B ஆகிய இரண்டு செயல்முறைகளை கற்பனை செய்து கொள்ளுங்கள், A 75 டிக்கெட்டுகளையும், B 25 டிக்கெட்டுகளையும் கொண்டுள்ளது.


The scheduler then picks a winning ticket.

பின்னர் திட்டமிடுபவர் ஒரு வெற்றி டிக்கெட்டைத் தேர்ந்தெடுக்கிறார்.


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

லாட்டரி திட்டமிடலில் சீரற்ற தன்மையைப் பயன்படுத்துவது நிகழ்தகவு சரியான தன்மைக்கு வழிவகுக்கிறது.


One of the most powerful mechanisms is the ticket.

மிகவும் சக்திவாய்ந்த வழிமுறைகளில் ஒன்று டிக்கெட் ஆகும்.


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

பணம் ஒரு பயனர் தங்கள் சொந்த வேலைகளில் டிக்கெட்டுகளை ஒதுக்க அனுமதிக்கிறது.


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

டிக்கெட் பரிமாற்றங்களுடன், ஒரு செயல்முறை தற்காலிகமாக அதன் டிக்கெட்டுகளை ஒப்படைக்க முடியும்.


Ticket inflation can sometimes be a useful technique.

டிக்கெட் பணவீக்கம் சில நேரங்களில் ஒரு பயனுள்ள நுட்பமாக இருக்கலாம்.


All you need is a good random number generator.

உங்களுக்குத் தேவையானது ஒரு நல்ல சீரற்ற எண் ஜெனரேட்டர் மட்டுமே.


எண் 300 ஐத் தேர்ந்தெடுப்போம் என்று வைத்துக்கொள்வோம்.


குறியீடு செயல்முறைகளின் பட்டியலை உருவாக்குகிறது.


சராசரி நியாயமற்ற தன்மை மிகவும் கடுமையானதாக இருக்கலாம்.


How to assign tickets is a tough problem.

டிக்கெட்டுகளை எவ்வாறு ஒதுக்குவது என்பது ஒரு கடினமான பிரச்சினை.


Stride scheduling gets them exactly right at the end of each scheduling cycle.

ஸ்ட்ரைட் திட்டமிடல் ஒவ்வொரு திட்டமிடல் சுழற்சியின் முடிவிலும் அவற்றை சரியாகப் பெறுகிறது.


Proportional-share schedulers are more useful in domains where some of these problems are relatively easy to solve.

விகிதாசார-பங்கு திட்டமிடுபவர்கள், இந்த சிக்கல்களில் சிலவற்றை தீர்க்க ஒப்பீட்டளவில் எளிதான களங்களில் மிகவும் பயனுள்ளதாக இருக்கும்.


இயங்குதளம் CPUவை மெய்நிகராக்குகிறது.


The program uses a stack to keep track of function calls.

நிரல் செயல்பாட்டு அழைப்புகளை கண்காணிக்க ஒரு அடுக்கைப் பயன்படுத்துகிறது.


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

இயங்குதளம் இயந்திரத்தின் மீது கட்டுப்பாட்டை வைத்திருக்க விரும்புகிறது.


Good engineering can be that way. And it can also be uplifting!

நல்ல பொறியியல் அப்படித்தான் இருக்கும். அது உற்சாகமாகவும் இருக்கலாம்!


இயங்குதளம் ஓரளவு சந்தேகமாக உள்ளது.


The OS will give each program the view that it has its own large and private memory.

இயங்குதளம் ஒவ்வொரு நிரலுக்கும் அதன் சொந்த பெரிய மற்றும் தனிப்பட்ட நினைவகம் உள்ளது என்ற பார்வையை வழங்கும்.


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

ஒரு தவறான நிரல் மற்ற நிரலின் நினைவகத்தை படிக்கவோ அல்லது மேலோட்டமாக எழுதவோ நாங்கள் விரும்பவில்லை, இல்லையா?


The program code lives at the top of the address space.

நிரல் குறியீடு முகவரி இடத்தின் மேல் பகுதியில் உள்ளது.


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

இயங்குதளம் இயங்கும் நிரலுக்குத் தெரியாத வகையில் மெய்நிகர் நினைவகத்தை செயல்படுத்த வேண்டும்.


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

இயங்குதளம் மெய்நிகராக்கலை முடிந்தவரை திறமையாக செய்ய முயற்சி செய்ய வேண்டும்.


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

இயங்குதளம் செயல்முறைகளை ஒன்றிலிருந்து மற்றொன்றையும், அதே போல் இயங்குதளத்தையும் செயல்முறைகளிலிருந்து பாதுகாக்க வேண்டும்.


The program is loaded at some arbitrary physical address.

நிரல் சில தன்னிச்சையான இயற்பியல் முகவரியில் ஏற்றப்படுகிறது.


இயங்குதளம் நினைவகத்தை மெய்நிகராக்குகிறது.


இயங்குதளம் ஒரு வள மேலாளர் ஆகும்.


The notion of interactivity became important.

ஊடாடும் தன்மை என்ற கருத்து முக்கியமானது.


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

இயங்குதளம் இந்த பாசாங்கு மெய்நிகர் முகவரிகளை உண்மையான இயற்பியல் முகவரிகளாக மாற்றும்.


The OS provides an illusion to each process.

இயங்குதளம் ஒவ்வொரு செயல்முறைக்கும் ஒரு மாயையை வழங்குகிறது.


The OS is responsible for providing the illusion of a large, sparse, private address space to programs.

நிரல்களுக்கு ஒரு பெரிய, குறைந்த அடர்த்தியான, தனிப்பட்ட முகவரி இடத்தின் மாயையை வழங்குவதற்கு இயங்குதளம் பொறுப்பாகும்.


The OS will do this for many processes at once.

இயங்குதளம் இதை ஒரே நேரத்தில் பல செயல்முறைகளுக்கு செய்யும்.


The OS will take each of these virtual memory references, and turn them into physical addresses.

இயங்குதளம் இந்த மெய்நிகர் நினைவக குறிப்புகள் ஒவ்வொன்றையும் எடுத்து, அவற்றை இயற்பியல் முகவரிகளாக மாற்றும்.


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.

உதாரணமாக, func() என்ற செயல்பாட்டில் x எனப்படும் ஒரு முழு எண்ணுக்கு உங்களுக்கு இடம் தேவை என்று வைத்துக்கொள்வோம்.


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

நீங்கள் func() க்கு அழைக்கும்போது, அடுக்கு இடத்தில் இடம் இருப்பதை தொகுப்பாளர் உறுதி செய்வார்.


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

நீங்கள் செயல்பாட்டில் இருந்து திரும்பும்போது, தொகுப்பாளர் உங்களுக்காக நினைவகத்தை விடுவிப்பார்.


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

நீண்ட காலம் நீடிக்கும் நினைவகத்தின் தேவைதான் நம்மை இரண்டாவது வகை நினைவகத்திற்கு கொண்டு செல்கிறது, இது ஹீப் நினைவகம் என்று அழைக்கப்படுகிறது.


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

நிச்சயமாக இது ஒரு பெரிய பொறுப்பு! மேலும் இது பல பிழைகளுக்குக் காரணமாகும்.


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

ஹீப்பில் ஒரு முழு எண்ணுக்கு ஒரு சுட்டியை எவ்வாறு ஒதுக்குவது என்பதற்கான உதாரணம் இங்கே:


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

முதலில், இந்த வரியில் அடுக்கு மற்றும் ஹீப் ஒதுக்கீடு இரண்டும் நிகழ்கின்றன என்பதை நீங்கள் கவனிக்கலாம்.


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 ஐ வழங்குகிறது.


The manual page shows what you need to do to use malloc; type man malloc at the command line and you will see:

malloc ஐப் பயன்படுத்த நீங்கள் என்ன செய்ய வேண்டும் என்பதை கையேடு பக்கம் காட்டுகிறது; கட்டளை வரியில் man malloc என தட்டச்சு செய்தால், நீங்கள் இதைப் பார்ப்பீர்கள்:


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

இந்த தகவலில் இருந்து, malloc ஐப் பயன்படுத்த stdlib.h என்ற தலைப்பு கோப்பைச் சேர்ப்பது மட்டுமே நீங்கள் செய்ய வேண்டியது என்பதை நீங்கள் காணலாம்.


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

malloc() எடுக்கும் ஒரே அளவுரு size_t வகையைச் சேர்ந்தது, இது உங்களுக்கு எத்தனை பைட்டுகள் தேவை என்பதை விவரிக்கிறது.


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

உதாரணமாக, இரட்டை துல்லிய மிதவை புள்ளி மதிப்புக்கு இடத்தை ஒதுக்க, நீங்கள் இதைச் செய்யுங்கள்:


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

நீங்கள் பயன்படுத்தும் சில வழக்கமான அல்லது ஆபரேட்டர் எவ்வாறு செயல்படுகிறது என்று உங்களுக்குத் தெரியாவிட்டால், அதை முயற்சி செய்து, நீங்கள் எதிர்பார்த்தபடி அது செயல்படுகிறதா என்பதை உறுதிப்படுத்துவதற்கு வேறு எதுவும் இல்லை.


With address translation, the hardware transforms each memory access (e.g., an instruction fetch, load, or store), changing the virtual address provided by the instruction to a physical address where the desired information is actually located.

முகவரி மொழிபெயர்ப்புடன், வன்பொருள் ஒவ்வொரு நினைவக அணுகலையும் மாற்றுகிறது (எ.கா., ஒரு அறிவுறுத்தல் எடுப்பது, ஏற்றுதல் அல்லது சேமித்தல்), அறிவுறுத்தலால் வழங்கப்பட்ட மெய்நிகர் முகவரியை விரும்பிய தகவல் உண்மையில் அமைந்துள்ள ஒரு இயற்பியல் முகவரிக்கு மாற்றுகிறது.


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

மொத்த இலவச இடத்தின் அளவு கோரிக்கையின் அளவை விட அதிகமாக உள்ளது.


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

இந்த வழக்கில், கிடைக்கக்கூடிய மொத்த இலவச இடம் 20 பைட்டுகள் ஆகும்.


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

15 பைட்டுகளுக்கான கோரிக்கை தோல்வியடையும், இருப்பினும் 20 பைட்டுகள் இலவசமாக உள்ளன.


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

மாறும் அளவிலான கோரிக்கைகளை நிறைவேற்றும் போது, இலவச இடத்தை எவ்வாறு நிர்வகிக்க வேண்டும்?


What strategies can be used to minimize fragmentation?

துண்டுகளை குறைக்க என்ன உத்திகளைப் பயன்படுத்தலாம்?


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

malloc() மற்றும் free() மூலம் வழங்கப்பட்டதைப் போன்ற ஒரு அடிப்படை இடைமுகத்தை நாங்கள் கருதுகிறோம்.


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

பயனர் இடத்தை விடுவிக்கும் போது, அதன் அளவை நூலகத்திற்குத் தெரிவிக்க மாட்டார்.


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

இந்த நூலகம் நிர்வகிக்கும் இடம் வரலாற்று ரீதியாக ஹீப் என்று அழைக்கப்படுகிறது.


We are concerned with external fragmentation, as described above.

மேலே விவரிக்கப்பட்டுள்ளபடி, வெளிப்புற துண்டுகளைப் பற்றி நாங்கள் கவலைப்படுகிறோம்.


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

உள் துண்டுகளின் சிக்கலையும் ஒதுக்கீடு செய்பவர்கள் கொண்டிருக்கலாம்.


We’ll mostly focus on external fragmentation.

நாங்கள் பெரும்பாலும் வெளிப்புற துண்டுகளைப் பற்றி கவனம் செலுத்துவோம்.


Once memory is handed out to a client, it cannot be relocated.

ஒரு கிளையண்டிற்கு நினைவகம் வழங்கப்பட்டவுடன், அதை மீண்டும் வைக்க முடியாது.


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

துண்டுகளைக் கையாள OS இல் சுருக்கத்தைப் பயன்படுத்தலாம்.


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

ஒதுக்கீடு செய்பவர் அடுத்தடுத்த பைட்டுகளின் பகுதியை நிர்வகிப்பார் என்று நாங்கள் கருதுகிறோம்.


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

பெரும்பாலான ஒதுக்கீடு செய்பவர்களில் பயன்படுத்தப்படும் சில பொதுவான வழிமுறைகளை நாங்கள் முதலில் உள்ளடக்குவோம்.


A free list contains a set of elements that describe the free space.

இலவச பட்டியல், இலவச இடத்தை விவரிக்கும் கூறுகளின் தொகுப்பைக் கொண்டுள்ளது.


A request for anything greater than 10 bytes will fail.

10 பைட்டுகளுக்கு மேல் எதற்கும் கோரிக்கை தோல்வியடையும்.


The allocator will perform an action known as splitting.

ஒதுக்கீடு செய்பவர் பிரித்தல் என்று அழைக்கப்படும் ஒரு செயலைச் செய்வார்.


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

பல ஒதுக்கீடு செய்பவர்களில் காணப்படும் ஒரு துணை வழிமுறை ஒன்றிணைத்தல் என்று அழைக்கப்படுகிறது.


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

ஒன்றிணைப்பதன் மூலம், பெரிய இலவச நீட்டிப்புகள் கிடைக்கின்றன என்பதை ஒதுக்கீடு செய்பவர் சிறப்பாக உறுதிப்படுத்த முடியும்.


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

இயக்க முறைமை நினைவகத்தை நிர்வகிக்க வேண்டும், எந்த இடங்கள் இலவசம், எவை பயன்பாட்டில் உள்ளன என்பதைக் கண்காணிக்க வேண்டும்.


The goal of all of this work is to create a beautiful illusion: that the program has its own private memory.

இந்த அனைத்துப் பணிகளின் இலக்கு என்னவென்றால், ஒரு அழகான மாயையை உருவாக்குவதாகும்: நிரலுக்கு அதன் சொந்த தனிப்பட்ட நினைவகம் உள்ளது.


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

மெய்நிகராக்கம் மூலம், இயக்க முறைமை, அருவருப்பான இயந்திர யதார்த்தத்தை பயனுள்ள, சக்திவாய்ந்த மற்றும் பயன்படுத்த எளிதான ஒரு கருத்தாக மாற்றுகிறது.


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

தற்போதைக்கு, பயனரின் முகவரி இடம் இயற்பியல் நினைவகத்தில் தொடர்ச்சியாக வைக்கப்பட வேண்டும் என்று நாங்கள் கருதுகிறோம்.


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

இந்த அனுமானங்கள் யதார்த்தமற்றதாகத் தோன்றினால் கவலைப்பட வேண்டாம்; நாம் செல்லும்போது அவற்றை தளர்த்துவோம்.


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

முகவரி மொழிபெயர்ப்பை எவ்வாறு செயல்படுத்துவது என்பதைப் புரிந்து கொள்ள, ஒரு எளிய உதாரணத்தைப் பார்ப்போம்.


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

படம் 15.1 இல் சுட்டிக்காட்டப்பட்டுள்ளபடி முகவரி இடத்தைக் கொண்ட ஒரு செயல்முறை இருப்பதாக கற்பனை செய்து பாருங்கள்.


The compiler turns this line of code into assembly.

தொகுப்பி இந்த குறியீட்டு வரியை அசெம்பிளியாக மாற்றுகிறது.


This code snippet is relatively straightforward.

இந்த குறியீடு துணுக்கு ஒப்பீட்டளவில் நேரடியானது.


From the program’s perspective, its address space starts at address 0 and grows to a maximum of 16 KB.

நிரலின் பார்வையில், அதன் முகவரி இடம் முகவரி 0 இல் தொடங்கி அதிகபட்சமாக 16 KB வரை வளர்கிறது.


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

செயல்முறைக்கு வெளிப்படையாக இருக்கும் வகையில் இந்த செயல்முறையை நினைவகத்தில் எவ்வாறு மாற்றுவது?


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

இந்த செயல்முறையின் முகவரி இடம் நினைவகத்தில் வைக்கப்பட்டவுடன் இயற்பியல் நினைவகம் எப்படி இருக்கும் என்பதற்கு ஒரு உதாரணம் படம் 15.2 இல் காணப்படுகிறது.


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

அந்தப் படத்தில், இயக்க முறைமை இயற்பியல் நினைவகத்தின் முதல் இடத்தை தனக்காகப் பயன்படுத்துவதைக் காணலாம்.


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

வன்பொருள் அடிப்படையிலான முகவரி மொழிபெயர்ப்பைப் பற்றி ஓரளவு புரிந்து கொள்ள, முதலில் அதன் முதல் அவதாரத்தைப் பற்றி விவாதிப்போம்.


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

செயல்முறையால் உருவாக்கப்படும் ஒவ்வொரு நினைவக குறிப்பும் ஒரு மெய்நிகர் முகவரியாகும்.


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

ஒரு மெய்நிகர் முகவரியை இயற்பியல் முகவரியாக மாற்றுவதுதான் முகவரி மொழிபெயர்ப்பு என்று நாம் குறிப்பிடும் நுட்பமாகும்.


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

டைனமிக் ரீலோகேஷன் மூலம், சிறிது வன்பொருள் எவ்வாறு நீண்ட தூரம் செல்கிறது என்பதை நாம் காணலாம்.


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

ஒரு செயல்முறை உருவாக்கப்பட்டால், இயக்க முறைமை நடவடிக்கை எடுக்க வேண்டும், நினைவகத்தில் அதன் முகவரி இடத்திற்கான இடத்தை கண்டுபிடிக்க வேண்டும்.


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

சூழல் மாற்றம் நிகழும்போது இயக்க முறைமையும் நடவடிக்கை எடுக்க வேண்டும்.


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

வரையறுக்கப்பட்ட நேரடிச் செயலாக்கத்தின் கருத்தை, மெய்நிகர் நினைவகத்தில் பயன்படுத்தப்படும் ஒரு குறிப்பிட்ட வழிமுறையுடன், முகவரி மொழிபெயர்ப்பு என்று அழைக்கிறோம்.


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

இந்த யோசனை எளிமையானது: நமது MMU இல் ஒரே ஒரு அடிப்படை மற்றும் எல்லை ஜோடிக்கு பதிலாக, முகவரி இடத்தின் ஒவ்வொரு தர்க்கரீதியான பிரிவிற்கும் ஒரு அடிப்படை மற்றும் எல்லை ஜோடி ஏன் வைத்திருக்கக்கூடாது?


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

ஒரு பிரிவு என்பது ஒரு குறிப்பிட்ட நீளத்தின் முகவரி இடத்தின் தொடர்ச்சியான பகுதியாகும்.


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

பிரிவுபடுத்தல் OS செய்ய அனுமதிப்பது என்னவென்றால், அந்த பிரிவுகளில் ஒவ்வொன்றையும் இயற்பியல் நினைவகத்தின் வெவ்வேறு பகுதிகளில் வைப்பதாகும்.


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

படம் 16.1 இல் உள்ள முகவரி இடத்தை இயற்பியல் நினைவகத்தில் வைக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம்.


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

ஒரு பிரிவுக்கு ஒரு அடிப்படை மற்றும் எல்லை ஜோடியுடன், ஒவ்வொரு பிரிவையும் இயற்பியல் நினைவகத்தில் சுதந்திரமாக வைக்கலாம்.


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

படத்தில் நீங்கள் பார்க்க முடியும் என, பயன்படுத்தப்பட்ட நினைவகம் மட்டுமே இயற்பியல் நினைவகத்தில் இடத்தை ஒதுக்குகிறது.


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

பிரிவுபடுத்தலை ஆதரிக்க தேவையான எங்கள் MMU இல் உள்ள வன்பொருள் அமைப்பு நீங்கள் எதிர்பார்த்ததுதான்.


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

குறியீடு பிரிவு இயற்பியல் முகவரி 32KB இல் வைக்கப்பட்டுள்ளது மற்றும் 2KB அளவு கொண்டது என்பதை அட்டவணையில் இருந்து காணலாம்.


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

படம் 16.1 இல் உள்ள முகவரி இடத்தைப் பயன்படுத்தி, ஒரு எடுத்துக்காட்டு மொழிபெயர்ப்பைச் செய்வோம்.


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

மெய்நிகர் முகவரி 100 க்கு ஒரு குறிப்பு செய்யப்படுகிறது என்று வைத்துக்கொள்வோம் (இது குறியீடு பிரிவில் உள்ளது).


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

குறிப்பு நிகழும்போது (ஒரு அறிவுறுத்தல் எடுக்கும்போது), வன்பொருள் அடிப்படை மதிப்பை இந்த பிரிவில் உள்ள ஆஃப்செட்டுடன் சேர்க்கும்.


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

பிரிவுபடுத்தல் தவறு அல்லது மீறல் என்ற சொல், ஒரு பிரிப்பு இயந்திரத்தில் சட்டவிரோத முகவரிக்கு நினைவக அணுகலில் இருந்து எழுகிறது.


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

நாம் முதலில் செய்ய வேண்டியது, குவியலுக்குள் ஆஃப்செட்டைப் பிரித்தெடுப்பது, அதாவது, இந்த பிரிவில் எந்த பைட்(கள்) முகவரியைக் குறிக்கிறது.


If we just add the virtual address 4200 to the base of the heap (34KB), we get a physical address of 39016, which is not the correct physical address.

நாம் மெய்நிகர் முகவரி 4200 ஐ குவியலின் அடிப்பகுதியில் (34KB) சேர்த்தால், நமக்கு 39016 என்ற இயற்பியல் முகவரி கிடைக்கும், இது சரியான இயற்பியல் முகவரி அல்ல.


The hardware uses segment registers during translation.

மொழிபெயர்ப்பின் போது வன்பொருள் பிரிவு பதிவேடுகளைப் பயன்படுத்துகிறது.


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

ஒரு பொதுவான அணுகுமுறை, சில நேரங்களில் வெளிப்படையான அணுகுமுறை என்று குறிப்பிடப்படுகிறது, முகவரி இடத்தை மெய்நிகர் முகவரியின் மேல் சில பிட்களை அடிப்படையாகக் கொண்டு பிரிவுகளாக வெட்டுவதாகும்.


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

எடுத்துக்காட்டாக, முதல் இரண்டு பிட்கள் 00 ஆக இருந்தால், வன்பொருள் மெய்நிகர் முகவரி குறியீடு பிரிவில் உள்ளது என்பதை அறியும்.


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

மேலே உள்ள வரைபடத்தில் அடுக்கு இயற்பியல் முகவரி 28KB க்கு மாற்றப்பட்டுள்ளது, ஆனால் ஒரு முக்கியமான வேறுபாடு உள்ளது: அது பின்னோக்கி வளர்கிறது.


With the hardware understanding that segments can grow in the negative direction, the hardware must now translate such virtual addresses slightly differently.

பிரிவுகள் எதிர்மறை திசையில் வளர முடியும் என்பதை வன்பொருள் புரிந்துகொள்வதால், வன்பொருள் இப்போது அத்தகைய மெய்நிகர் முகவரிகளை சற்று வித்தியாசமாக மொழிபெயர்க்க வேண்டும்.


As support for segmentation grew, system designers soon realized that they could realize new types of efficiencies with a little more hardware support.

பிரிவுபடுத்தலுக்கான ஆதரவு வளர்ந்ததால், கணினி வடிவமைப்பாளர்கள் சிறிது வன்பொருள் ஆதரவுடன் புதிய வகையான செயல்திறனை உணர முடியும் என்பதை விரைவில் உணர்ந்தனர்.


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” நபராக மாறலாம்.


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

அவ்வாறு செய்ய முடியாவிட்டால், அப்படிப்பட்ட ஒரு நபருடன் வேலை செய்யுங்கள்; பெரும்பாலானோர் ஒரு மாதத்தில் கற்றுக்கொள்வதை விட ஒரு நாளில் அதிகமாகக் கற்றுக்கொள்வீர்கள்.


The slab allocator also goes beyond most segregated list approaches by keeping free objects on the lists in a pre-initialized state.

ஸ்லாப் அலகேட்டர், இலவச பொருட்களை பட்டியல்களில் முன்-தொடக்க நிலையில் வைத்திருப்பதன் மூலம், பெரும்பாலான தனிமைப்படுத்தப்பட்ட பட்டியல் அணுகுமுறைகளை விட அதிகமாக செல்கிறது.


Bonwick shows that initialization and destruction of data structures is costly.

தரவு கட்டமைப்புகளைத் தொடங்குவதும் அழிப்பதும் விலை உயர்ந்தது என்று போன்விக் காட்டுகிறார்.


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

வெளியேற்றப்பட்ட பொருட்களை அவற்றின் தொடக்க நிலையில் ஒரு குறிப்பிட்ட பட்டியலில் வைத்திருப்பதன் மூலம், ஸ்லாப் அலகேட்டர் ஒரு பொருளுக்கு அடிக்கடி தொடங்குதல் மற்றும் அழித்தல் சுழற்சியைத் தவிர்க்கிறது, இதனால் மேல்நிலைகளை கணிசமாகக் குறைக்கிறது.


When a request for memory is made, the search for free space recursively divides free space by two until a block that is big enough to accommodate the request is found.

நினைவகத்திற்கான கோரிக்கை விடுக்கப்படும்போது, கோரிக்கையைச் சமாளிக்க போதுமான அளவு பெரிய ஒரு தொகுதி கிடைக்கும் வரை, இலவச இடத்தை இரண்டு மடங்காகப் பிரித்து இலவச இடத்தைத் தேடுகிறது.


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

இந்த கட்டத்தில், கோரப்பட்ட தொகுதி பயனருக்கு திருப்பி அனுப்பப்படுகிறது.


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

அந்த தொகுதி விடுவிக்கப்பட்டால் என்ன நடக்கும் என்பதில் நண்பர் ஒதுக்கீட்டின் அழகு காணப்படுகிறது.


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

8KB தொகுதியை இலவசப் பட்டியலுக்குத் திருப்பி அனுப்பும் போது, அலகேட்டர் “நண்பர்” 8KB இலவசமாக உள்ளதா என சரிபார்க்கிறது.


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

நண்பர் ஒதுக்கீடு சிறப்பாக செயல்படுவதற்கான காரணம் என்னவென்றால், ஒரு குறிப்பிட்ட தொகுதியின் நண்பரைத் தீர்மானிப்பது எளிது.


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

மேலே உள்ள இலவச இடத்தில் உள்ள தொகுதிகளின் முகவரிகளைப் பற்றி சிந்தியுங்கள்.


If you think carefully enough, you’ll see that the address of each buddy pair only differs by a single bit.

நீங்கள் போதுமான அளவு கவனமாக யோசித்தால், ஒவ்வொரு நண்பர் ஜோடியின் முகவரியும் ஒரே ஒரு பிட் மட்டுமே வேறுபடுவதைக் காண்பீர்கள்.


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

மேலே விவரிக்கப்பட்ட பல அணுகுமுறைகளில் உள்ள ஒரு பெரிய பிரச்சனை அவற்றின் அளவிடுதல் இல்லாதது.


Specifically, searching lists can be quite slow.

குறிப்பாக, பட்டியல்களைத் தேடுவது மிகவும் மெதுவாக இருக்கலாம்.


Given that modern systems often have multiple processors and run multi-threaded workloads, it is not surprising that a lot of effort has been spent making allocators work well on multiprocessor-based systems.

நவீன அமைப்புகளில் பெரும்பாலும் பல செயலிகள் உள்ளன மற்றும் பல-திரிக்கப்பட்ட பணிச்சுமைகளை இயக்குகின்றன, பல செயலி அடிப்படையிலான அமைப்புகளில் அலகேட்டர்கள் சிறப்பாக செயல்பட நிறைய முயற்சி எடுக்கப்பட்டது என்பதில் ஆச்சரியமில்லை.


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 well as in the underlying OS which is managing memory for its own data structures.

நீங்கள் எழுதும் ஒவ்வொரு சி நிரலிலும், அத்துடன் அதன் சொந்த தரவு கட்டமைப்புகளுக்காக நினைவகத்தை நிர்வகிக்கும் அடிப்படை OS-லும் இதுபோன்ற அலகேட்டர்கள் எல்லா இடங்களிலும் உள்ளன.


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

முதல் கட்டளை பூஜ்ய மதிப்பை மெய்நிகர் நினைவக முகவரிக்கு நகர்த்துகிறது.


This address is computed by taking the contents of %edi and adding %eax multiplied by four to it.

%edi இன் உள்ளடக்கங்களை எடுத்து, அதனுடன் %eax ஐ நான்கால் பெருக்கி சேர்ப்பதன் மூலம் இந்த முகவரி கணக்கிடப்படுகிறது.


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

இரண்டாவது கட்டளை %eax இல் உள்ள வரிசை குறியீட்டை அதிகரிக்கிறது.


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

ஒப்பிடுதல் இரண்டு மதிப்புகளும் இன்னும் சமமாக இல்லை என்பதைக் காட்டினால், நான்காவது கட்டளை மீண்டும் சுழற்சியின் உச்சிக்குச் செல்கிறது.


We assume a virtual address space of size 64KB.

64KB அளவிலான மெய்நிகர் முகவரி இடத்தை நாங்கள் கருதுகிறோம்.


நாங்கள் 1 KB பக்க அளவையும் கருதுகிறோம்.


First, there is the virtual page the code lives on.

முதலில், குறியீடு வாழும் மெய்நிகர் பக்கம் உள்ளது.


Let’s assume this virtual page maps to physical frame 4.

இந்த மெய்நிகர் பக்கம் இயற்பியல் பிரேம் 4 க்கு வரைபடமாக்குகிறது என்று வைத்துக்கொள்வோம்.


Its size is 4000 bytes (1000 integers), and it lives at virtual addresses 40000 through 44000.

இதன் அளவு 4000 பைட்டுகள் (1000 முழு எண்கள்), மேலும் இது 40000 முதல் 44000 வரையிலான மெய்நிகர் முகவரிகளில் உள்ளது.


We are now ready to trace the memory references of the program.

நிரலின் நினைவக குறிப்புகளைக் கண்டறிய இப்போது தயாராக உள்ளோம்.


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

அது இயங்கும் போது, ஒவ்வொரு அறிவுறுத்தல் எடுப்பும் இரண்டு நினைவக குறிப்புகளை உருவாக்கும்.


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

முழு செயல்முறையும், முதல் ஐந்து சுழற்சி மறு செய்கைகளுக்கு, படம் 18.7 இல் சித்தரிக்கப்பட்டுள்ளது.


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

இந்த காட்சிப்படுத்தலில் தோன்றும் வடிவங்களை உங்களால் புரிந்து கொள்ள முடிகிறதா எனப் பாருங்கள்.


In particular, what will change as the loop continues to run beyond these first five iterations?

குறிப்பாக, இந்த முதல் ஐந்து மறு செய்கைகளுக்கு அப்பால் சுழற்சி தொடர்ந்து இயங்கும்போது என்ன மாறும்?


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

நினைவகத்தை மெய்நிகராக்குவதற்கான நமது சவாலுக்கு ஒரு தீர்வாக பக்கமிடல் என்ற கருத்தை அறிமுகப்படுத்தியுள்ளோம்.


Paging has many advantages over previous approaches.

பக்கமிடல் முந்தைய அணுகுமுறைகளை விட பல நன்மைகளைக் கொண்டுள்ளது.


First, it does not lead to external fragmentation.

முதலில், இது வெளிப்புற துண்டுகளாக வழிவகுக்காது.


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

இரண்டாவதாக, இது மிகவும் நெகிழ்வானது, மெய்நிகர் முகவரி இடங்களின் குறைந்த பயன்பாட்டை செயல்படுத்துகிறது.


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

இருப்பினும், கவனமின்றி பக்கமிடல் ஆதரவை செயல்படுத்துவது மெதுவான இயந்திரத்திற்கு வழிவகுக்கும்.


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.

இருப்பினும், காலம் செல்ல செல்ல, இன்டெல் போன்ற CISC உற்பத்தியாளர்கள் பல RISC நுட்பங்களை இணைத்தனர்.


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

இதன் விளைவாக விவாதம் குறைந்தது, மேலும் இன்று இரு வகையான செயலிகளும் வேகமாக இயங்க முடியும்.


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

ஒரு வழக்கமான 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, for example, a common initial state for each TLB entry is to be set to invalid.

எடுத்துக்காட்டாக, ஒரு கணினி துவங்கும் போது, ஒவ்வொரு TLB உள்ளீட்டிற்கும் ஒரு பொதுவான ஆரம்ப நிலை செல்லாததாக அமைக்கப்படும்.


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

அனைத்து TLB உள்ளீடுகளையும் செல்லாததாக அமைப்பதன் மூலம், கணினி, விரைவில் இயக்கப்படவிருக்கும் செயல்முறை, முந்தைய செயல்முறையிலிருந்து மெய்நிகர்-உடல் மொழிபெயர்ப்பை தற்செயலாகப் பயன்படுத்தாது என்பதை உறுதிப்படுத்த முடியும்.


மேலும் சுவாரஸ்யமானவை “மற்ற பிட்கள்”.


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 சேமிக்கக்கூடும் என்று கருதுகிறது.


If entries for both processes were in the TLB, the contents of the TLB would be:

இரண்டு செயல்முறைகளுக்கான உள்ளீடுகளும் TLB இல் இருந்தால், 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 ஐ வெறுமனே வெளியேற்றுவது.


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

இந்த மேலடுப்பைக் குறைக்க, சில அமைப்புகள் சூழல் மாறல்களுக்கு இடையில் TLB ஐப் பகிர்வதற்கு வன்பொருள் ஆதரவைச் சேர்க்கின்றன.


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

எனவே, முகவரி-இட அடையாளங்காட்டிகளுடன், TLB ஆனது எந்த குழப்பமும் இல்லாமல் ஒரே நேரத்தில் வெவ்வேறு செயல்முறைகளிலிருந்து மொழிபெயர்ப்புகளை வைத்திருக்க முடியும்.


Will this affect your code and its timing?

இது உங்கள் குறியீடு மற்றும் அதன் நேரத்தை பாதிக்குமா?


What can you do to counterbalance these potential costs?

இந்த சாத்தியமான செலவுகளை ஈடுசெய்ய நீங்கள் என்ன செய்ய முடியும்?


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

மீண்டும் ஒரு 32-பிட் முகவரி இடத்தை (2^32 பைட்டுகள்) எடுத்துக் கொள்ளுங்கள், 4KB (2^12 பைட்டுகள்) பக்கங்கள் மற்றும் 4-பைட் பக்க-அட்டவணை உள்ளீடு.


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

நூறு செயலில் உள்ள செயல்முறைகளுடன் (நவீன அமைப்பில் இது அசாதாரணமானது அல்ல), பக்க அட்டவணைகளுக்காக மட்டுமே நூற்றுக்கணக்கான மெகாபைட் நினைவகத்தை ஒதுக்குவோம்!


பக்க அட்டவணைகளை எவ்வாறு சிறியதாக்குவது?


முக்கிய யோசனைகள் என்ன?


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

இந்த புதிய தரவு கட்டமைப்புகளின் விளைவாக என்ன குறைபாடுகள் எழுகின்றன?


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

ஒரு எளிய வழியில் பக்க அட்டவணையின் அளவைக் குறைக்கலாம்: பெரிய பக்கங்களைப் பயன்படுத்தவும்.


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

இருப்பினும், இந்த அணுகுமுறையின் முக்கிய பிரச்சனை என்னவென்றால், பெரிய பக்கங்கள் ஒவ்வொரு பக்கத்திலும் கழிவுகளை ஏற்படுத்துகின்றன, இது உள் துண்டாடல் என்று அழைக்கப்படும் ஒரு பிரச்சனை.


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

எனவே, பயன்பாடுகள் பக்கங்களை ஒதுக்குகின்றன, ஆனால் ஒவ்வொன்றின் சிறிய பகுதிகளை மட்டுமே பயன்படுத்துகின்றன, மேலும் நினைவகம் இந்த அளவுக்கு பெரிய பக்கங்களால் விரைவாக நிரப்பப்படுகிறது.


அத்தகைய கலவையை ஒரு கலப்பினம் என்று அழைக்கிறோம்.


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.

எங்கள் கலப்பின திட்டத்தில் உள்ள முக்கியமான வேறுபாடு என்னவென்றால், ஒரு பிரிவுக்கு ஒரு எல்லை பதிவு இருப்பது.


In this manner, our hybrid approach realizes a significant memory savings compared to the linear page table.

இந்த வழியில், எங்கள் கலப்பின அணுகுமுறை நேரியல் பக்க அட்டவணையை விட குறிப்பிடத்தக்க நினைவக சேமிப்பை உணர்கிறது.


First, it still requires us to use segmentation.

முதலில், இது இன்னும் பிரிவினையைப் பயன்படுத்த வேண்டும்.


We call this approach a multi-level page table, as it turns the linear page table into something like a tree.

இந்த அணுகுமுறையை ஒரு பல-நிலை பக்க அட்டவணை என்று அழைக்கிறோம், ஏனெனில் இது நேரியல் பக்க அட்டவணையை ஒரு மரம் போன்ற ஒன்றாக மாற்றுகிறது.


The page directory thus either can be used to tell you where a page of the page table is, or that the entire page of the page table contains no valid pages.

பக்க அடைவு, பக்க அட்டவணையின் ஒரு பக்கம் எங்குள்ளது என்பதை உங்களுக்குச் சொல்லப் பயன்படுகிறது, அல்லது பக்க அட்டவணையின் முழு பக்கத்திலும் செல்லுபடியாகும் பக்கங்கள் இல்லை.


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 code pages from this binary are initially found on disk, and when the program runs, they are loaded into memory.

இந்த பைனரியில் இருந்து வரும் குறியீடு பக்கங்கள் ஆரம்பத்தில் வட்டில் காணப்படுகின்றன, மேலும் நிரல் இயங்கும் போது, அவை நினைவகத்தில் ஏற்றப்படுகின்றன.


If the present bit is set to one, it means the page is present in physical memory.

தற்போதைய பிட் ஒன்றுக்கு அமைக்கப்பட்டால், பக்கம் இயற்பியல் நினைவகத்தில் உள்ளது என்று பொருள்.


The OS is invoked to service the page fault.

பக்கக் கோளாறைச் சரிசெய்ய OS அழைக்கப்படுகிறது.


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 பயன்படுத்தலாம்.


When the disk I/O completes, the OS will then update the page table to mark the page as present.

வட்டு I/O முடிந்ததும், OS பக்கத்தை தற்போதுள்ளதாகக் குறிக்க பக்க அட்டவணையைப் புதுப்பிக்கும்.


The process of picking a page to kick out, or replace is known as the page-replacement policy.

வெளியேற்ற அல்லது மாற்ற ஒரு பக்கத்தைத் தேர்ந்தெடுக்கும் செயல்முறை பக்க-மாற்று கொள்கை என அழைக்கப்படுகிறது.


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

உண்மையான பக்க அட்டவணைகள் எவ்வாறு கட்டமைக்கப்படுகின்றன என்பதை இப்போது பார்த்தோம்; அவை நேரியல் வரிசைகளாக மட்டுமல்லாமல், மிகவும் சிக்கலான தரவு கட்டமைப்புகளாகவும் உள்ளன.


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

அத்தகைய அட்டவணைகள் வழங்கும் வர்த்தகங்கள் நேரம் மற்றும் இடத்தில் உள்ளன.


In a memory-constrained system, small structures make sense.

நினைவக-கட்டுப்படுத்தப்பட்ட அமைப்பில், சிறிய கட்டமைப்புகள் அர்த்தமுள்ளதாக இருக்கும்.


What new structures can you come up with?

நீங்கள் என்ன புதிய கட்டமைப்புகளை உருவாக்க முடியும்?


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

நிரல் அழைக்கப்படுகிறது, ஆச்சரியமளிக்காமல்: paging-multilevel-translate.py; விவரங்களுக்கு README ஐப் பார்க்கவும்.


How many registers do you need to locate a two-level page table?

இரண்டு நிலை பக்க அட்டவணையை கண்டுபிடிக்க உங்களுக்கு எத்தனை பதிவேடுகள் தேவை?


Given your understanding of how cache memory works, how do you think memory references to the page table will behave in the cache?

நீங்கள் கேச் நினைவகம் எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொண்டால், பக்க அட்டவணைக்கான நினைவக குறிப்புகள் கேச்சில் எவ்வாறு செயல்படும் என்று நினைக்கிறீர்கள்?


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

இப்போது இந்த பெரிய அனுமானங்களை தளர்த்துவோம், மேலும் பல ஒரே நேரத்தில் இயங்கும் பெரிய முகவரி இடங்களை ஆதரிக்க விரும்புகிறோம் என்று கருதுகிறோம்.


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

மல்டிப்ரோகிராமிங்கின் கண்டுபிடிப்பு கிட்டத்தட்ட சில பக்கங்களை வெளியே மாற்றும் திறனை கோரியது.


மொழிபெயர்ப்பின் போது வன்பொருள் என்ன செய்கிறது?


பக்கக் குறைபாடு ஏற்பட்டால் இயக்க முறைமை என்ன செய்யும்?


From the hardware control flow diagram in Figure 21.2, notice that there are now three important cases to understand when a TLB miss occurs.

படம் 21.2 இல் உள்ள வன்பொருள் கட்டுப்பாட்டு ஓட்ட வரைபடத்திலிருந்து, TLB தவறினால் புரிந்து கொள்ள வேண்டிய மூன்று முக்கியமான நிகழ்வுகள் உள்ளன என்பதை கவனிக்கவும்.


First, that the page was both present and valid.

முதலில், பக்கம் இருந்தது மற்றும் செல்லுபடியாகும்.


In this case, the TLB miss handler can simply grab the PFN from the PTE, retry the instruction.

இந்த வழக்கில், TLB மிஸ் ஹேண்ட்லர் PTE இலிருந்து PFN ஐப் பெற்று, வழிமுறையை மீண்டும் முயற்சிக்கலாம்.


In the second case, the page fault handler must be run.

இரண்டாவது வழக்கில், பக்கக் குறைபாடு கையாளுபவர் இயக்கப்பட வேண்டும்.


Third (and finally), the access could be to an invalid page, due for example to a bug in the program.

மூன்றாவதாக (மற்றும் இறுதியாக), அணுகல் ஒரு தவறான பக்கத்திற்கு இருக்கலாம், எடுத்துக்காட்டாக, நிரலில் உள்ள பிழை காரணமாக.


From the software control flow in Figure 21.3, we can see what the OS roughly must do in order to service the page fault.

படம் 21.3 இல் உள்ள மென்பொருள் கட்டுப்பாட்டு ஓட்டத்தில் இருந்து, பக்கக் குறைபாட்டைச் சேவை செய்ய OS தோராயமாக என்ன செய்ய வேண்டும் என்பதை நாம் காணலாம்.


First, the OS must find a physical frame for the soon-to-be-faulted-in page to reside within.

முதலில், விரைவில் தோல்வியடையக்கூடிய பக்கத்திற்குள் இருக்க, OS ஒரு இயற்பியல் சட்டகத்தைக் கண்டுபிடிக்க வேண்டும்.


If there is no such page, we’ll have to wait for the replacement algorithm to run and kick some pages out of memory.

அத்தகைய பக்கம் இல்லையென்றால், மாற்று வழிமுறை இயங்குவதற்கு நாம் காத்திருக்க வேண்டும் மற்றும் சில பக்கங்களை நினைவகத்திலிருந்து வெளியேற்ற வேண்டும்.


With a physical frame in hand, the handler then issues the I/O request to read in the page from swap space.

ஒரு இயற்பியல் சட்டகம் கையில் கிடைத்தவுடன், ஹேண்ட்லர் இடமாற்று இடத்திலிருந்து பக்கத்தைப் படிக்க I/O கோரிக்கையை வெளியிடுகிறது.


Finally, when that slow operation completes, the OS updates the page table and retries the instruction.

இறுதியாக, அந்த மெதுவான செயல்பாடு முடிந்ததும், OS பக்க அட்டவணையைப் புதுப்பித்து, வழிமுறையை மீண்டும் முயற்சிக்கிறது.


The retry will result in a TLB miss, and then, upon another retry, a TLB hit.

மீண்டும் முயற்சிப்பது TLB தவறலுக்கு வழிவகுக்கும், பின்னர், மற்றொரு மீண்டும் முயற்சியில், TLB ஹிட் ஆகும்.


Thus far, the way we’ve described how replacements occur assumes that the OS waits until memory is entirely full.

இதுவரை, மாற்றுதல் எவ்வாறு நிகழ்கிறது என்பதை நாம் விவரித்த விதம், நினைவகம் முழுவதுமாக நிரம்பும் வரை OS காத்திருக்கிறது என்று கருதுகிறது.


To keep a small amount of memory free, most operating systems thus have some kind of high watermark (HW) and low watermark (LW) to help decide when to start evicting pages from memory.

சிறிய அளவிலான நினைவகத்தை இலவசமாக வைத்திருக்க, பெரும்பாலான இயக்க முறைமைகள் சில வகையான உயர் வாட்டர்மார்க் (HW) மற்றும் குறைந்த வாட்டர்மார்க் (LW) ஆகியவற்றைக் கொண்டுள்ளன, நினைவகத்திலிருந்து பக்கங்களை எப்போது வெளியேற்றத் தொடங்க வேண்டும் என்பதைத் தீர்மானிக்க உதவுகின்றன.


By performing a number of replacements at once, new performance optimizations become possible.

ஒரு நேரத்தில் பல மாற்றங்களைச் செய்வதன் மூலம், புதிய செயல்திறன் மேம்படுத்தல்கள் சாத்தியமாகும்.


When you have some work to do, it is often a good idea to do it in the background to increase efficiency.

நீங்கள் சில வேலைகளைச் செய்யும்போது, செயல்திறனை அதிகரிக்க அதை பின்னணியில் செய்வது பெரும்பாலும் ஒரு நல்ல யோசனையாகும்.


In this brief chapter, we have introduced the notion of accessing more memory than is physically present within a system.

இந்த சுருக்கமான அத்தியாயத்தில், ஒரு கணினியில் இயல்பாக இருக்கும் நினைவகத்தை விட அதிகமான நினைவகத்தை அணுகுவதற்கான கருத்தை நாங்கள் அறிமுகப்படுத்தியுள்ளோம்.


To do so requires more complexity in page-table structures.

அவ்வாறு செய்ய, பக்க-அட்டவணை கட்டமைப்புகளில் அதிக சிக்கலான தன்மை தேவைப்படுகிறது.


As far as the process is concerned, it is just accessing its own private, contiguous virtual memory.

செயல்முறையைப் பொறுத்தவரை, அது அதன் சொந்த தனிப்பட்ட, தொடர்ச்சியான மெய்நிகர் நினைவகத்தை அணுகுகிறது.


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

அண்மையில் அணுகப்பட்ட பக்கங்கள் விரைவில் மீண்டும் அணுகப்படும் என்று லோகாலிட்டியின் கொள்கை கூறுகிறது.


LRU (Least Recently Used) is a page replacement algorithm that replaces the page that was least recently accessed.

LRU (குறைந்த நேரத்தில் பயன்படுத்தப்பட்டது) என்பது ஒரு பக்க மாற்று வழிமுறை ஆகும், இது கடைசியாக அணுகப்பட்ட பக்கத்தை மாற்றுகிறது.


Programs often exhibit temporal locality, meaning they access the same pages repeatedly over a short period.

நிரல்கள் பெரும்பாலும் தற்காலிக லோகாலிட்டியைக் காட்டுகின்றன, அதாவது அவை குறுகிய காலத்தில் ஒரே பக்கங்களை மீண்டும் மீண்டும் அணுகுகின்றன.


The operating system uses historical information to make decisions about which pages to keep in memory.

நினைவகத்தில் எந்தப் பக்கங்களை வைத்திருக்க வேண்டும் என்பது பற்றி முடிவுகளை எடுக்க இயக்க முறைமை வரலாற்றுத் தகவலைப் பயன்படுத்துகிறது.


In a looping-sequential workload, LRU performs poorly because it evicts pages that will be accessed again soon.

ஒரு லூப்பிங்-சீக்வென்ஷியல் பணிச்சுமையில், LRU மோசமாக செயல்படுகிறது, ஏனெனில் அது விரைவில் மீண்டும் அணுகப்படும் பக்கங்களை வெளியேற்றுகிறது.


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

கடிகார வழிமுறை என்பது LRU இன் தோராயமாகும், இது சமீபத்திய பக்க அணுகலை கண்காணிக்க ஒரு பயன்பாட்டு பிட்டைப் பயன்படுத்துகிறது.


When memory is oversubscribed, the system may start thrashing, leading to poor performance.

நினைவகம் அதிகமாகப் பயன்படுத்தப்படும்போது, அமைப்பு த்ராஷிங்கைத் தொடங்கலாம், இது மோசமான செயல்திறனுக்கு வழிவகுக்கும்.


The 80-20 workload demonstrates that LRU performs better than random or FIFO.

80-20 பணிச்சுமை LRU ஆனது ரேண்டம் அல்லது FIFO ஐ விட சிறப்பாக செயல்படுகிறது என்பதை நிரூபிக்கிறது.


Cache size significantly impacts the hit rate in various page replacement algorithms.

பல்வேறு பக்க மாற்று வழிமுறைகளில் கேச் அளவு ஹிட் வீதத்தை கணிசமாக பாதிக்கிறது.


The principle of locality is a heuristic that often proves useful in the design of computer systems.

லோகாலிட்டியின் கொள்கை என்பது ஒரு யூரிஸ்டிக் ஆகும், இது கணினி அமைப்புகளின் வடிவமைப்பில் அடிக்கடி பயனுள்ளதாக இருக்கும்.


Understanding page replacement policies is crucial for optimizing system performance.

அமைப்பு செயல்திறனை மேம்படுத்துவதற்கு பக்க மாற்று கொள்கைகளைப் புரிந்துகொள்வது முக்கியம்.


The operating system must decide when to bring a page into memory.

இயக்க முறைமை ஒரு பக்கத்தை எப்போது நினைவகத்திற்குள் கொண்டு வர வேண்டும் என்பதை தீர்மானிக்க வேண்டும்.


Demand paging brings a page into memory when it is accessed.

தேவை பக்கமிடல் ஒரு பக்கத்தை அணுகும் போது நினைவகத்திற்குள் கொண்டு வருகிறது.


Prefetching can improve performance by bringing pages into memory before they are needed.

பக்கங்கள் தேவைப்படுவதற்கு முன்பே நினைவகத்திற்குள் கொண்டு வருவதன் மூலம் ப்ரீஃபெச்சிங் செயல்திறனை மேம்படுத்த முடியும்.


Clustering writes can improve disk I/O efficiency.

கிளஸ்டரிங் எழுதுவது வட்டு I/O திறனை மேம்படுத்தும்.


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

VAX/VMS இயக்க முறைமை நன்கு வடிவமைக்கப்பட்ட மெய்நிகர் நினைவக மேலாளர் ஆகும்.


The use bit is set by hardware when a page is referenced.

ஒரு பக்கம் குறிப்பிடப்படும்போது வன்பொருள் மூலம் பயன்பாட்டு பிட் அமைக்கப்படுகிறது.


Approximating LRU is more feasible than implementing perfect LRU.

சரியான LRU ஐ செயல்படுத்துவதை விட LRU ஐ தோராயமாகப் பயன்படுத்துவது மிகவும் சாத்தியமானது.


Scan resistance is an important part of many modern page replacement algorithms.

ஸ்கேன் எதிர்ப்பு பல நவீன பக்க மாற்று வழிமுறைகளின் ஒரு முக்கிய பகுதியாகும்.


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

அதிகப்படியான பக்கமிடலுக்கான சிறந்த தீர்வு பெரும்பாலும் அதிக நினைவகத்தை வாங்குவதாகும்.


The operating system manages the computer's resources.

இயக்க முறைமை கணினியின் வளங்களை நிர்வகிக்கிறது.


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

மெய்நிகர் நினைவகம் ஒரு கணினிக்கு இயல்பாகக் கிடைக்கும் நினைவகத்தை விட அதிகமாகப் பயன்படுத்த அனுமதிக்கிறது.


The kernel is the core of the operating system.

கரு என்பது இயக்க முறைமையின் மையமாகும்.


Context switching is the process of switching between different processes.

சூழல் மாறுதல் என்பது வெவ்வேறு செயல்முறைகளுக்கு இடையில் மாறுவதற்கான செயல்முறையாகும்.


File systems organize data on storage devices.

கோப்பு முறைமைகள் சேமிப்பு சாதனங்களில் தரவை ஒழுங்கமைக்கின்றன.


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

VAX/VMS இயக்க முறைமை அதன் மேம்பட்ட நினைவக நிர்வாகத்திற்காக அறியப்பட்டது.


Demand zeroing is a technique used to optimize memory allocation.

தேவை பூஜ்ஜியமாக்கல் என்பது நினைவக ஒதுக்கீட்டை மேம்படுத்தப் பயன்படும் ஒரு நுட்பமாகும்.


Copy-on-write is a memory optimization strategy.

எழுதுவதில் நகலெடுப்பது என்பது ஒரு நினைவக உகப்பாக்க உத்தி ஆகும்.


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

TLB (மொழிபெயர்ப்பு லுக்அசைடு பஃபர்) மெய்நிகர் முகவரி மொழிபெயர்ப்பை துரிதப்படுத்துகிறது.


Page replacement algorithms decide which pages to evict from memory.

பக்க மாற்று வழிமுறைகள் நினைவகத்திலிருந்து எந்தப் பக்கங்களை வெளியேற்ற வேண்டும் என்பதைத் தீர்மானிக்கின்றன.


The system reduces the pressure page tables place on memory.

அமைப்பு நினைவகத்தில் பக்க அட்டவணைகள் வைக்கும் அழுத்தத்தைக் குறைக்கிறது.


The hardware designers don’t quite get everything right.

வன்பொருள் வடிவமைப்பாளர்கள் எல்லாவற்றையும் சரியாகப் பெறவில்லை.


The OS is not likely to support any one installation very well.

இயக்க முறைமை எந்தவொரு நிறுவலுக்கும் சிறப்பாக ஆதரவளிக்கும் வாய்ப்பில்லை.


The kernel is mapped into each address space for a number of reasons.

கரு பல காரணங்களுக்காக ஒவ்வொரு முகவரி இடத்திலும் இணைக்கப்பட்டுள்ளது.


The OS changes the P0 and P1 registers to point to the appropriate page tables.

இயக்க முறைமை P0 மற்றும் P1 பதிவேடுகளைப் பொருத்தமான பக்க அட்டவணைகளுக்குச் சுட்டிக்காட்ட மாற்றுகிறது.


The VAX-11 provided a 32-bit virtual address space per process.

VAX-11 ஒரு செயல்முறைக்கு 32-பிட் மெய்நிகர் முகவரி இடத்தை வழங்கியது.


One neat aspect of studying VMS is that we can see how a real address space is constructed.

VMS ஐப் படிப்பதில் ஒரு நேர்த்தியான அம்சம் என்னவென்றால், ஒரு உண்மையான முகவரி இடம் எவ்வாறு கட்டமைக்கப்படுகிறது என்பதை நாம் காணலாம்.


The OS must not be too aggressive in marking pages inaccessible.

இயக்க முறைமை பக்கங்களை அணுக முடியாததாகக் குறிப்பதில் மிகவும் ஆக்ரோஷமாக இருக்கக்கூடாது.


With clustering, VMS groups large batches of pages together from the global dirty list.

கிளஸ்டரிங் மூலம், VMS உலகளாவிய அழுக்கு பட்டியலிலிருந்து பெரிய அளவிலான பக்கங்களை ஒன்றாகக் குழுப்படுத்துகிறது.


The key to this “emulation” of reference bits is reducing overhead while still obtaining a good idea of page usage.

குறிப்பு பிட்களின் இந்த


அடிப்படை கொள்கைகள் ஒருவிதத்தில் வெளிப்படையானவை.


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.

ஒவ்வொருவரும் முதலில் ஒரு பீச் பழத்தை அடையாளம் கண்டு, பின்னர் அதை எடுத்து சாப்பிட முயற்சிக்கிறார்கள்.


Hmmm... seems like you might see a peach that somebody else also sees.

ம்ம்ம்... நீங்களும் பார்க்கிற ஒரு பீச் பழத்தை வேறு யாரோ பார்க்கிற மாதிரி இருக்கு.


If they get there first, when you reach out, no peach for you!

அவர்கள் முதலில் சென்றால், நீங்கள் சென்றடையும்போது, உங்களுக்கு பீச் பழம் கிடைக்காது!


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, doing things on the program’s behalf.

ஒவ்வொரு திரியும் இந்த நிரலில் இயங்கும் ஒரு சுயாதீன முகவரைப் போன்றது, நிரலுக்காக விஷயங்களைச் செய்கிறது.


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

திரிகளுக்கு இடையில் நினைவகத்திற்கான அணுகலை ஒருங்கிணைக்கவில்லை என்றால், நிரல் எதிர்பார்த்தபடி செயல்படாது.


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

OS பூட்டுகள் மற்றும் நிபந்தனை மாறிகள் போன்ற அடிப்படை கூறுகளைக் கொண்ட பல-திரி பயன்பாடுகளை ஆதரிக்க வேண்டும்.


The operating system manages computer hardware and software resources.

இயக்க முறைமை கணினி வன்பொருள் மற்றும் மென்பொருள் வளங்களை நிர்வகிக்கிறது.


Concurrency is a fundamental concept in operating systems.

ஒருங்கிணைப்பு என்பது இயக்க முறைமைகளில் ஒரு அடிப்படை கருத்தாகும்.


Threads allow a program to perform multiple tasks simultaneously.

திரெட்டுகள் ஒரு நிரலை ஒரே நேரத்தில் பல பணிகளைச் செய்ய அனுமதிக்கின்றன.


Synchronization primitives are essential for managing shared resources.

பகிர்ந்த வளங்களை நிர்வகிப்பதற்கு ஒத்திசைவு ஆதிக்கம் அவசியம்.


Locks and condition variables are used to coordinate thread execution.

திரெட் செயல்பாட்டை ஒருங்கிணைக்க பூட்டுகளும், நிபந்தனை மாறிகளும் பயன்படுத்தப்படுகின்றன.


The main function is the entry point of a C program.

முக்கிய செயல்பாடு ஒரு C நிரலின் நுழைவு புள்ளியாகும்.


Understanding thread APIs is crucial for multi-threaded programming.

பல திரெட் நிரலாக்கத்திற்கு திரெட் APIகளைப் புரிந்துகொள்வது முக்கியம்.


A race condition occurs when multiple threads access shared data concurrently.

பல திரெட்டுகள் ஒரே நேரத்தில் பகிரப்பட்ட தரவை அணுகும்போது ஒரு பந்தய நிலை ஏற்படுகிறது.


Atomic operations ensure that a sequence of actions is indivisible.

அணுசக்தி செயல்பாடுகள் ஒரு தொடர் செயல்கள் பிரிக்க முடியாதவை என்பதை உறுதி செய்கின்றன.


The operating system provides mechanisms for inter-process communication.

இயக்க முறைமை, செயல்முறைக்கு இடையேயான தொடர்புக்கு வழிமுறைகளை வழங்குகிறது.


The news reported a significant increase in the stock market.

பங்குச் சந்தையில் குறிப்பிடத்தக்க உயர்வு ஏற்பட்டதாக செய்தி தெரிவித்தது.


The company announced a new product launch next month.

அடுத்த மாதம் புதிய தயாரிப்பு அறிமுகம் செய்யப்படுவதாக நிறுவனம் அறிவித்தது.


The government is discussing new economic policies.

புதிய பொருளாதாரக் கொள்கைகள் குறித்து அரசு விவாதித்து வருகிறது.


She is reading a book about ancient history.

அவள் பண்டைய வரலாறு பற்றிய ஒரு புத்தகத்தைப் படித்துக் கொண்டிருக்கிறாள்.


The weather forecast predicts rain for tomorrow.

நாளை மழை பெய்யும் என்று வானிலை அறிக்கை கூறுகிறது.


He enjoys playing chess with his friends.

அவர் தனது நண்பர்களுடன் சதுரங்கம் விளையாடுவதை விரும்புகிறார்.


The restaurant serves delicious Italian food.

அந்த உணவகத்தில் சுவையான இத்தாலிய உணவு பரிமாறப்படுகிறது.


உப்பு கொஞ்சம் கொடுங்களேன்?


உங்களை இன்று பார்ப்பதில் நான் மிகவும் மகிழ்ச்சியடைகிறேன்.


வார இறுதி நாட்களில் உங்கள் திட்டங்கள் என்ன?


இந்தக் குறியீடு ஒரு எளிய சுழல் பூட்டைப் பயன்படுத்துகிறது.


சோதனை மற்றும் அமைத்தல் என்பது ஒரு வன்பொருள் அடிப்படை அலகு ஆகும்.


The thread will spin until the lock is released.

பூட்டு விடுவிக்கப்படும் வரை நூல் சுழலும்.


Spin locks can be inefficient on single-processor systems.

ஒரே செயலி அமைப்புகளில் சுழல் பூட்டுகள் திறமையற்றதாக இருக்கலாம்.


Compare-and-swap is another hardware instruction.

ஒப்பிட்டு மாற்று என்பது மற்றொரு வன்பொருள் அறிவுறுத்தல் ஆகும்.


இந்தக் குறியீடு கொடி பூஜ்யமாக உள்ளதா என சரிபார்க்கிறது.


Load-linked and store-conditional are used together.

ஏற்றுதல்-இணைப்பு மற்றும் சேமிப்பு-கட்டுப்பாடு ஆகியவை ஒன்றாகப் பயன்படுத்தப்படுகின்றன.


Fetch-and-add atomically increments a value.

Fetch-and-add ஒரு மதிப்பை அணுசக்தியாக அதிகரிக்கிறது.


Ticket locks ensure progress for all threads.

டிக்கெட் பூட்டுகள் அனைத்து நூல்களுக்கும் முன்னேற்றத்தை உறுதி செய்கின்றன.


The scheduler determines which thread runs next.

நிரல் திட்டமிடுபவர் அடுத்ததாக எந்த நூல் இயங்க வேண்டும் என்பதை தீர்மானிக்கிறார்.


உற்பத்தி ஒரு எளிய அணுகுமுறையாக இருக்கலாம்.


சூழல் மாற்றங்கள் விலை உயர்ந்ததாக இருக்கலாம்.


Queues are used to manage waiting threads.

காத்திருக்கும் நூல்களை நிர்வகிக்க வரிசைகள் பயன்படுத்தப்படுகின்றன.


காவலர் ஒரு சுழல் பூட்டாகப் பயன்படுத்தப்படுகிறார்.


The flag does not get set back to zero immediately.

கொடி உடனடியாக பூஜ்யத்திற்கு அமைக்கப்படவில்லை.


இது ஒரு பந்தய நிலை.


Futex உள்-கர்னல் செயல்பாட்டை வழங்குகிறது.


குறியீடு பொதுவான விஷயத்திற்கு உகந்ததாக உள்ளது.


பூட்டு மற்றொரு செயல்முறையால் வைத்திருக்கப்படுகிறது.


The system provides support for efficient locks.

திறமையான பூட்டுகளுக்கு கணினி ஆதரவை வழங்குகிறது.


A condition variable, one has to in addition have a lock that is associated with this condition.

ஒரு நிபந்தனை மாறியாக, இந்த நிபந்தனையுடன் தொடர்புடைய ஒரு பூட்டையும் கூடுதலாக வைத்திருக்க வேண்டும்.


When calling either of the above routines, this lock should be held.

மேலே உள்ள நடைமுறைகளில் எதையாவது அழைக்கும்போது, இந்த பூட்டு வைத்திருக்கப்பட வேண்டும்.


The first routine, pthread condwait(), puts the calling thread to sleep, and thus waits for some other thread to signal it.

முதல் நடைமுறை, pthread condwait(), அழைக்கும் திரையை தூங்க வைக்கிறது, இதனால் வேறு சில திரைகள் அதை சமிக்ஞை செய்யக் காத்திருக்கிறது.


For example, a typical usage looks like this: pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

உதாரணமாக, ஒரு வழக்கமான பயன்பாடு இப்படி இருக்கும்: pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;


In this code, after initialization of the relevant lock and condition, a thread checks to see 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.

இல்லையென்றால், வேறு சில திரைகள் அதை எழுப்பும் வரை தூங்குவதற்காக திரை காத்திருப்பு நடைமுறையை அழைக்கிறது.


The code to wake a thread, which would run in some other thread, looks like this: Pthread_mutex_lock(&lock);

ஒரு திரையை எழுப்புவதற்கான குறியீடு, இது வேறு சில திரைகளில் இயங்கும், இதுபோல் இருக்கும்: Pthread_mutex_lock(&lock);


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

முதலில், சமிக்ஞை செய்யும் போது (உலகளாவிய மாறி துவக்கத்தை மாற்றும் போது), பூட்டு வைத்திருப்பதை நாங்கள் எப்போதும் உறுதிசெய்கிறோம்.


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.

சில நேரங்களில், ஒரு நிபந்தனை மாறி மற்றும் தொடர்புடைய பூட்டுக்கு பதிலாக, இரண்டு திரைகளுக்கு இடையில் சமிக்ஞை செய்ய ஒரு எளிய கொடியைப் பயன்படுத்தத் தூண்டுவது கவனிக்கத்தக்கது.


For example, we could rewrite the waiting code above to look more like this in the waiting code: while (initialized == 0) ; // spin

உதாரணமாக, காத்திருப்பு குறியீட்டை மீண்டும் எழுதலாம், காத்திருப்பு குறியீட்டில் இதுபோல் இருக்கும்: while (initialized == 0) ; // சுழல்


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 சுழற்சியை வீணாக்குகிறது).


The Linux approach has the flavor of an old approach.

லினக்ஸ் அணுகுமுறை பழைய அணுகுமுறையின் சாயலைக் கொண்டுள்ளது.


A two-phase lock realizes that spinning can be useful.

இரண்டு-கட்ட பூட்டு சுழல்வது பயனுள்ளதாக இருக்கும் என்பதை உணர்த்துகிறது.


So in the first phase, the lock spins for a while.

எனவே முதல் கட்டத்தில், பூட்டு சிறிது நேரம் சுழல்கிறது.


The caller is put to sleep, and only woken up when the lock becomes free later.

அழைப்பவர் தூங்க வைக்கப்படுகிறார், மேலும் பூட்டு பின்னர் இலவசமாகிவிடும் போது மட்டுமே எழுப்பப்படுகிறார்.


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

இரண்டு-கட்ட பூட்டுகள் ஒரு கலப்பின அணுகுமுறையின் மற்றொரு எடுத்துக்காட்டு ஆகும்.


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

ஒரு பொதுப் பயன்பாட்டு பூட்டை உருவாக்குவது ஒரு பெரிய சவாலாகும்.


The above approach shows how real locks are built these days.

மேலே உள்ள அணுகுமுறை இன்றைய காலகட்டத்தில் உண்மையான பூட்டுகள் எவ்வாறு உருவாக்கப்படுகின்றன என்பதைக் காட்டுகிறது.


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

மேலும் விவரங்களைக் காண விரும்பினால், சோலாரிஸ் அல்லது லினக்ஸ் திறந்த மூல குறியீடு தளங்களைப் பார்க்கவும்.


There is even an undoubtedly bad book about Al Davis.

அல் டேவிஸ் பற்றி சந்தேகத்திற்கு இடமின்றி ஒரு மோசமான புத்தகம் கூட உள்ளது.


One of the early seminal papers in the area.

இந்த பகுதியில் ஆரம்பகால முக்கிய ஆவணங்களில் ஒன்று.


A landmark paper introducing a different approach.

ஒரு வித்தியாசமான அணுகுமுறையை அறிமுகப்படுத்தும் ஒரு முக்கிய கட்டுரை.


வேடிக்கையானது மற்றும் நுண்ணறிவுகள் நிறைந்தது.


In particular, take a look at the nptl subdirectory.

குறிப்பாக, nptl துணை கோப்பகத்தைப் பார்க்கவும்.


RDLK is thus an early test-and-set primitive.

RDLK ஒரு ஆரம்பகால சோதனை மற்றும் அமைவு அடிப்படை ஆகும்.


Adding locks to a data structure makes it thread safe.

தரவு கட்டமைப்பிற்கு பூட்டுகளைச் சேர்ப்பது அதை திரெட் பாதுகாப்பாக ஆக்குகிறது.


How should we add locks to it, in order to make it work correctly?

அதை சரியாக வேலை செய்ய வைக்க, அதில் நாம் எவ்வாறு பூட்டுகளைச் சேர்க்க வேண்டும்?


One of the simplest data structures is a counter.

மிகவும் எளிமையான தரவு கட்டமைப்புகளில் ஒன்று ஒரு கவுண்டர் ஆகும்.


This concurrent counter is simple and works correctly.

இந்த ஒரே நேரத்தில் இயங்கும் கவுண்டர் எளிமையானது மற்றும் சரியாக வேலை செய்கிறது.


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

உங்கள் தரவு கட்டமைப்பு மிகவும் மெதுவாக இருந்தால், நீங்கள் ஒரு பூட்டைச் சேர்ப்பதை விட அதிகமாகச் செய்ய வேண்டும்.


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

செயல்திறன் சிறந்தது; நான்கு செயலி அலகுகளில் கவுண்டரை நான்கு மில்லியன் முறை புதுப்பிக்க எடுக்கும் நேரம், ஒரு செயலி அலகில் ஒரு மில்லியன் முறை புதுப்பிக்க எடுக்கும் நேரத்தை விட அதிகம் இல்லை.


The program uses a hash table to store data.

இந்த நிரல் தரவைச் சேமிக்க ஒரு ஹாஷ் அட்டவணையைப் பயன்படுத்துகிறது.


Each bucket in the hash table is protected by a lock.

ஹாஷ் அட்டவணையில் உள்ள ஒவ்வொரு வாளியும் ஒரு பூட்டினால் பாதுகாக்கப்படுகின்றன.


Concurrent operations are enabled by using a lock per hash bucket.

ஒரு ஹாஷ் வாளிக்கு ஒரு பூட்டைப் பயன்படுத்துவதன் மூலம் ஒரே நேரத்தில் பல செயல்பாடுகளைச் செய்ய முடிகிறது.


Avoid premature optimization when building concurrent data structures.

ஒரே நேரத்தில் தரவு கட்டமைப்புகளை உருவாக்கும்போது முன்கூட்டியே மேம்படுத்துவதைத் தவிர்க்கவும்.


The big kernel lock was a source of performance problems.

பெரிய கர்னல் பூட்டு செயல்திறன் சிக்கல்களுக்கு ஒரு காரணமாக இருந்தது.


Condition variables are essential for building concurrent programs.

ஒரே நேரத்தில் இயங்கும் நிரல்களை உருவாக்க கண்டிஷன் மாறிகள் அவசியம்.


A thread can wait for a condition to become true.

ஒரு கண்டிஷன் உண்மை ஆகும் வரை ஒரு திரெட் காத்திருக்கலாம்.


The wait() call releases the lock and puts the thread to sleep.

wait() அழைப்பு பூட்டை விடுவித்து திரெட்டை தூங்க வைக்கிறது.


The producer/consumer problem is a classic synchronization challenge.

உற்பத்தியாளர்/நுகர்வோர் பிரச்சனை ஒரு உன்னதமான ஒத்திசைவு சவால் ஆகும்.


Producers put data into a buffer, and consumers take data out.

உற்பத்தியாளர்கள் தரவை ஒரு இடையகத்தில் வைக்கிறார்கள், நுகர்வோர் தரவை வெளியே எடுக்கிறார்கள்.


Synchronization is required to avoid race conditions.

பந்தய நிலைகளைத் தவிர்க்க ஒத்திசைவு தேவை.


The buffer can hold only one item at a time.

இடைமுகம் ஒரு நேரத்தில் ஒரு பொருளை மட்டுமே வைத்திருக்க முடியும்.


The producer waits if the buffer is full.

இடைமுகம் நிரம்பியிருந்தால் உற்பத்தியாளர் காத்திருப்பார்.


The consumer waits if the buffer is empty.

இடைமுகம் காலியாக இருந்தால் நுகர்வோர் காத்திருப்பார்.


Using 'while' instead of 'if' is crucial for correctness.

'if' க்கு பதிலாக 'while' பயன்படுத்துவது சரியானது.


Mesa semantics are commonly used in condition variables.

கண்டிஷன் மாறிகளில் மேசா சொற்பொருள் பொதுவாகப் பயன்படுத்தப்படுகிறது.


சிக்னல் செய்யும் போது எப்போதும் பூட்டைப் பிடித்துக் கொள்ளுங்கள்.


The bounded buffer problem is a fundamental concept.

வரையறுக்கப்பட்ட இடையகப் பிரச்சனை ஒரு அடிப்படை கருத்தாகும்.


This approach is broken due to a race condition.

ஒரு பந்தய நிலை காரணமாக இந்த அணுகுமுறை உடைந்துவிட்டது.


The consumer might sneak in and consume the data.

நுகர்வோர் உள்ளே நுழைந்து தரவை உட்கொள்ளலாம்.


நுகர்வோர் மீண்டும் தூங்கச் செல்கிறார்.


Thanks to Mesa semantics, a simple rule to remember with condition variables is to always use while loops.

மேசா சொற்பொருள் காரணமாக, நிபந்தனை மாறிகளுடன் நினைவில் கொள்ள வேண்டிய ஒரு எளிய விதி என்னவென்றால், எப்போதும் while சுழல்களைப் பயன்படுத்துவதாகும்.


The problem occurs when two consumers run first, and both go to sleep.

இரண்டு நுகர்வோர்கள் முதலில் இயங்கும் போது பிரச்சனை ஏற்படுகிறது, மேலும் இருவரும் தூங்கச் செல்கிறார்கள்.


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.

ஒரு பல-திரிக்கப்பட்ட நிரலில் ஒரு நிபந்தனையை சரிபார்க்கும் போது, ஒரு while சுழலைப் பயன்படுத்துவது எப்போதும் சரியானது.


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.

அவர்கள் எதிர்கொண்ட பிரச்சனை ஒரு எளிய உதாரணம் மூலம் சிறப்பாகக் காட்டப்பட்டுள்ளது, இந்த விஷயத்தில் ஒரு எளிய பல-திரிக்கப்பட்ட நினைவக ஒதுக்கீடு நூலகத்தில்.


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

கூர்மையான வாசகர் இந்த அணுகுமுறையை நாம் முன்னதாகவே பயன்படுத்தியிருக்கலாம் என்பதையும் கவனித்திருக்கலாம்.


We have seen the introduction of another important synchronization primitive beyond locks: condition variables.

பூட்டுகளுக்கு அப்பால் மற்றொரு முக்கியமான ஒத்திசைவு ஆதிக்கம் அறிமுகப்படுத்தப்பட்டதை நாம் பார்த்தோம்: நிபந்தனை மாறிகள்.


Indeed, Dijkstra and colleagues invented the semaphore as a single primitive for all things related to synchronization.

உண்மையில், டிஜிக்ஸ்டிரா மற்றும் சக ஊழியர்கள் ஒத்திசைவு தொடர்பான அனைத்து விஷயங்களுக்கும் ஒரு தனி ஆதிக்கமாக செமாபோரை கண்டுபிடித்தனர்.


A semaphore is as an object with an integer value that we can manipulate with two routines.

ஒரு செமாபோர் என்பது இரண்டு வழக்கமான நடைமுறைகளுடன் நாம் கையாளக்கூடிய ஒரு முழு எண் மதிப்பைக் கொண்ட ஒரு பொருள் ஆகும்.


Because the initial value of the semaphore determines its behavior, before calling any other routine to interact with the semaphore, we must first initialize it to some value.

செமாபோரின் ஆரம்ப மதிப்பு அதன் நடத்தையை தீர்மானிப்பதால், செமாபோருடன் தொடர்பு கொள்ள வேறு எந்த வழக்கத்தையும் அழைப்பதற்கு முன், அதை முதலில் சில மதிப்பிற்கு துவக்க வேண்டும்.


After a semaphore is initialized, we can call one of two functions to interact with it.

ஒரு செமாபோர் துவக்கப்பட்ட பிறகு, அதனுடன் தொடர்பு கொள்ள இரண்டு செயல்பாடுகளில் ஒன்றை அழைக்கலாம்.


First, we can see that sem_wait() will either return right away, or it will cause the caller to suspend execution waiting for a subsequent post.

முதலில், sem_wait() உடனடியாகத் திரும்பும் அல்லது அது அழைப்பாளரை ஒரு அடுத்தடுத்த இடுகைக்காகக் காத்திருக்கும்படி செய்யும்.


Rather, it simply increments the value of the semaphore and then, if there is a thread waiting to be woken, wakes one of them up.

மாறாக, இது செமாபோரின் மதிப்பை அதிகரிக்கிறது, பின்னர், எழுப்பக் காத்திருக்கும் ஒரு திரெட் இருந்தால், அவர்களில் ஒருவரை எழுப்புகிறது.


இப்போது நாம் ஒரு செமாபோரைப் பயன்படுத்தத் தயாராக உள்ளோம்.


Critical to making this work, though, is the initial value of the semaphore.

இதைச் செயல்படுத்துவதற்கு முக்கியமானது, செமாபோரின் ஆரம்ப மதிப்பு ஆகும்.


Semaphores are also useful when a thread wants to halt its progress waiting for a condition to become true.

ஒரு நிபந்தனை உண்மையாக மாறும் வரை காத்திருக்கும் போது ஒரு திரெட் அதன் முன்னேற்றத்தை நிறுத்த விரும்பும் போது செமாபோர்கள் பயனுள்ளதாக இருக்கும்.


சர்வர் பராமரிப்புக்காக செயல்படவில்லை.


தயவுசெய்து பயன்பாட்டை மீண்டும் தொடங்கவும்.


இன்று வானிலை நன்றாக உள்ளது.


இந்த வேலையில் எனக்கு உதவுவீர்களா?


நான் சந்தைக்குப் போகிறேன்.


நிறுவனம் ஒரு புதிய தயாரிப்பை அறிவித்தது.


The government is implementing new policies.

அரசு புதிய கொள்கைகளை அமல்படுத்துகிறது.


The stock market is experiencing volatility.

பங்குச் சந்தையில் ஏற்ற இறக்கம் காணப்படுகிறது.


The research team is working on a new project.

ஆராய்ச்சி குழு ஒரு புதிய திட்டத்தில் பணிபுரிகிறது.


The algorithm needs to be optimized for performance.

செயல்திறனுக்காக வழிமுறையை மேம்படுத்த வேண்டும்.


The complexities of the situation are difficult to understand.

இந்த சூழ்நிலையின் சிக்கல்களைப் புரிந்துகொள்வது கடினம்.


The implications of the decision are far-reaching.

இந்த முடிவின் விளைவுகள் தொலைநோக்குடையவை.


The philosophical underpinnings of the theory are complex.

இந்தக் கோட்பாட்டின் தத்துவார்த்த அடிப்படைகள் சிக்கலானவை.


The company's strategic plan involves significant restructuring.

நிறுவனத்தின் மூலோபாயத் திட்டத்தில் குறிப்பிடத்தக்க மறுசீரமைப்பு அடங்கும்.