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.

క్యూలను ఉపయోగించడం: స్పిన్నింగ్ బదులు నిద్రపోవడం.


వివిధ OS, వివిధ మద్దతు.


రెండు-దశల తాళాలు.


సమకాలిక కౌంటర్లు.


సమకాలిక లింక్ చేయబడిన జాబితాలు.


సమకాలిక క్యూలు.


సమకాలిక హాష్ టేబుల్.


నిర్వచనం మరియు రొటీన్లు.


The Producer/Consumer (Bound Buffer) Problem.

ఉత్పత్తిదారు/వినియోగదారు (బౌండ్ బఫర్) సమస్య.


పరిస్థితులను కవర్ చేయడం.


సెమాఫోర్‌లు: ఒక నిర్వచనం.


బైనరీ సెమాఫోర్‌లు (లాక్‌లు).


పరిస్థితి వేరియబుల్స్‌గా సెమాఫోర్‌లు.


భోజన తత్వవేత్తలు.


The operating system virtualizes resources.

ఆపరేటింగ్ సిస్టమ్ వనరులను వర్చువలైజ్ చేస్తుంది.


ఒక ప్రోగ్రామ్ సూచనలను అమలు చేస్తుంది.


OS సిస్టమ్‌ను ఉపయోగించడం సులభతరం చేస్తుంది.


వర్చువలైజేషన్ ఒక ముఖ్యమైన సాంకేతికత.


OS సిస్టమ్ కాల్‌లను అందిస్తుంది.


Each process has its own virtual address space.

ప్రతి ప్రక్రియ దాని స్వంత వర్చువల్ చిరునామా స్థలాన్ని కలిగి ఉంటుంది.


The operating system is a resource manager.

ఆపరేటింగ్ సిస్టమ్ ఒక వనరుల నిర్వాహకుడు.


సమకాలీనత ఒక ప్రధాన ఇతివృత్తం.


The program prints the string passed on the command line.

ప్రోగ్రామ్ కమాండ్ లైన్‌లో పంపిన స్ట్రింగ్‌ను ప్రింట్ చేస్తుంది.


OS CPUని వర్చువలైజ్ చేస్తుంది.


The system is designed to be easy to use.

సిస్టమ్ ఉపయోగించడానికి సులభంగా రూపొందించబడింది.


OS వనరులను సమర్ధవంతంగా నిర్వహిస్తుంది.


Multiple programs can seemingly run at once.

ఒకేసారి బహుళ ప్రోగ్రామ్‌లు నడుస్తున్నట్లు కనిపిస్తాయి.


The operating system provides a standard library.

ఆపరేటింగ్ సిస్టమ్ ఒక ప్రామాణిక లైబ్రరీని అందిస్తుంది.


Understanding virtualization is crucial for OS design.

OS రూపకల్పనకు వర్చువలైజేషన్‌ను అర్థం చేసుకోవడం చాలా ముఖ్యం.


Concurrency problems arise in multi-threaded programs.

బహుళ-త్రెడెడ్ ప్రోగ్రామ్‌లలో సమకాలీన సమస్యలు తలెత్తుతాయి.


The OS transforms physical resources into virtual ones.

OS భౌతిక వనరులను వర్చువల్ వనరులుగా మారుస్తుంది.


The crux of the problem is how to virtualize resources.

సమస్య యొక్క సారాంశం ఏమిటంటే వనరులను ఎలా వర్చువలైజ్ చేయాలి.


The operating system is responsible for making the system operate correctly and efficiently.

సిస్టమ్‌ను సరిగ్గా మరియు సమర్ధవంతంగా పనిచేసేలా చూసే బాధ్యత ఆపరేటింగ్ సిస్టమ్‌దే.


Virtualization allows many programs to run concurrently.

వర్చువలైజేషన్ అనేక ప్రోగ్రామ్‌లను ఏకకాలంలో అమలు చేయడానికి అనుమతిస్తుంది.


The operating system manages computer hardware and software resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్ వనరులను నిర్వహిస్తుంది.


Scheduling algorithms determine the order in which processes are executed.

షెడ్యూలింగ్ అల్గారిథమ్‌లు ప్రక్రియలను ఏ క్రమంలో అమలు చేయాలో నిర్ణయిస్తాయి.


Memory management is crucial for efficient system performance.

సమర్థవంతమైన సిస్టమ్ పనితీరు కోసం మెమరీ నిర్వహణ చాలా ముఖ్యం.


CPU కంప్యూటర్ మెదడు.


Virtual memory allows a system to run programs larger than physical memory.

వర్చువల్ మెమరీ భౌతిక మెమరీ కంటే పెద్ద ప్రోగ్రామ్‌లను అమలు చేయడానికి సిస్టమ్‌ను అనుమతిస్తుంది.


Concurrency and parallelism are important concepts in modern operating systems.

సమకాలీనత మరియు సమాంతరత ఆధునిక ఆపరేటింగ్ సిస్టమ్‌లలో ముఖ్యమైన భావనలు.


త్రెడ్‌లు ఒకే చిరునామా స్థలాన్ని పంచుకుంటాయి.


Locks are used to protect shared resources from race conditions.

షేర్డ్ వనరులను రేస్ పరిస్థితుల నుండి రక్షించడానికి లాక్‌లను ఉపయోగిస్తారు.


Condition variables help threads coordinate their actions.

కండిషన్ వేరియబుల్స్ థ్రెడ్‌లు వారి చర్యలను సమన్వయం చేయడానికి సహాయపడతాయి.


The operating system provides an abstraction of the hardware.

ఆపరేటింగ్ సిస్టమ్ హార్డ్‌వేర్ యొక్క అబ్‌స్ట్రాక్షన్ అందిస్తుంది.


The news reported a significant increase in inflation.

ద్రవ్యోల్బణం గణనీయంగా పెరిగిందని వార్తలు తెలిపాయి.


The company announced a new product launch.

కంపెనీ కొత్త ఉత్పత్తిని ప్రారంభించినట్లు ప్రకటించింది.


ఆమె పరీక్షల కోసం చదువుతోంది.


మీరు ఈ సమస్యలో నాకు సహాయం చేయగలరా?


The weather forecast predicts rain tomorrow.

రేపు వర్షం పడుతుందని వాతావరణ సూచన.


The government is implementing new policies.

ప్రభుత్వం కొత్త విధానాలను అమలు చేస్తోంది.


The team worked together to achieve their goals.

టీమ్ తమ లక్ష్యాలను సాధించడానికి కలిసి పనిచేసింది.


The project requires careful planning and execution.

ప్రాజెక్ట్ జాగ్రత్తగా ప్లాన్ చేయడం మరియు అమలు చేయడం అవసరం.


The economy is facing several challenges.

ఆర్థిక వ్యవస్థ అనేక సవాళ్లను ఎదుర్కొంటోంది.


Please submit your assignment by Friday.

దయచేసి శుక్రవారం లోపు మీ అసైన్‌మెంట్‌ను సమర్పించండి.


The book is called Operating Systems: Three Easy Pieces.

పుస్తకం పేరు ఆపరేటింగ్ సిస్టమ్స్: త్రీ ఈజీ పీసెస్.


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

మీరు దీన్ని చదవడం ఎంత ఆనందిస్తారో, మేము రాయడం కూడా అంతే ఆనందిస్తామని మేము ఆశిస్తున్నాము.


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

మూడు సులభమైన భాగాలు పుస్తకం నిర్వహించబడే మూడు ప్రధాన నేపథ్య అంశాలను సూచిస్తాయి: వర్చువలైజేషన్, ఏకకాలంలో అమలు మరియు నిరంతరాయత.


కొత్త విషయాలు నేర్చుకోవడం సరదాగా ఉంటుంది, కదా?


Each major concept is divided into a set of chapters.

ప్రతి ప్రధాన భావన అధ్యాయాల సమితిగా విభజించబడింది.


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

ఈ పుస్తకం రాయడంలో మా లక్ష్యాలలో ఒకటి చరిత్ర మార్గాలను వీలైనంత స్పష్టంగా ఉంచడం.


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

పుస్తకం అంతటా మేము ఉపయోగించే కొన్ని పరికరాలు ఇక్కడ పరిచయం చేయడానికి విలువైనవి.


మొదటిది సమస్య యొక్క సారాంశం.


Asides tend to discuss something relevant 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.

నిజమైన వ్యవస్థలపై నిజమైన కోడ్‌ను అమలు చేయడం ఆపరేటింగ్ సిస్టమ్‌ల గురించి తెలుసుకోవడానికి ఉత్తమ మార్గం.


We have sprinkled in a few homeworks to ensure that you are understanding what is going on.

మీరు ఏమి జరుగుతుందో అర్థం చేసుకుంటున్నారని నిర్ధారించుకోవడానికి మేము కొన్ని హోంవర్క్‌లను చేర్చాము.


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

ఈ పుస్తకానికి అత్యంత ముఖ్యమైన అనుబంధం ప్రాజెక్ట్‌ల సమితి.


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

C అనేది చాలా ఆపరేటింగ్ సిస్టమ్‌లకు ఆధారం అయిన ఒక సాధారణ మరియు శక్తివంతమైన భాష.


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 is pushed off herein until the student has built an understanding of virtualization.

పుస్తకం యొక్క కొంచెం అసాధారణమైన అంశం ఏమిటంటే, విద్యార్థి వర్చువలైజేషన్ గురించి అవగాహన పెంచుకునే వరకు ఏకకాలంలో అమలును ఇక్కడ వాయిదా వేయడం.


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

ఆపరేటింగ్ సిస్టమ్‌లపై మీకు ఆసక్తిని కలిగించడానికి మేము ఈ నోట్స్‌ను రూపొందించాము.


The OS creates this illusion by virtualizing the CPU.

ఆపరేటింగ్ సిస్టమ్ CPUని వర్చువలైజ్ చేయడం ద్వారా ఈ భ్రమను సృష్టిస్తుంది.


ఒక పీచు పండు ఉందని ఊహించుకోండి.


The OS will also likely initialize the stack with arguments.

ఆపరేటింగ్ సిస్టమ్ కూడా వాదనలతో స్టాక్‌ను ప్రారంభించే అవకాశం ఉంది.


ప్రోగ్రామ్ స్వయంగా ఒక నిర్జీవమైన విషయం.


Start at transistors and gets you all the way up to C.

ట్రాన్సిస్టర్‌లతో ప్రారంభించి, మిమ్మల్ని C వరకు తీసుకువెళుతుంది.


A great summary of UNIX written as it was taking over the world of computing.

UNIX యొక్క గొప్ప సారాంశం, ఇది కంప్యూటింగ్ ప్రపంచాన్ని ఆక్రమించినప్పుడు వ్రాయబడింది.


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

ఆధునిక వ్యవస్థలలో మీరు చూసే వాటిలో చాలా వరకు అట్లాస్ మార్గదర్శకం చేసింది.


One of our favorite intro to computing systems books.

కంప్యూటింగ్ సిస్టమ్స్ పుస్తకాలకు ఇది మా అభిమాన పరిచయం.


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

రన్నింగ్ ప్రోగ్రామ్ యొక్క OS అందించే అబ్‌స్ట్రాక్షన్ మనం ప్రాసెస్ అని పిలుస్తాము.


By running one process, then stopping it and running another, and so forth, the OS can promote the illusion that many virtual CPUs exist.

ఒక ప్రాసెస్‌ను నడుపుతూ, ఆపివేసి మరొకటి నడుపుతూ, ఆ విధంగా, OS అనేక వర్చువల్ CPUలు ఉన్నాయనే భ్రమను ప్రోత్సహించగలదు.


The OS will also do some other initialization tasks, particularly as related to input/output (I/O).

ఆపరేటింగ్ సిస్టమ్ ఇతర ప్రారంభ పనులను కూడా చేస్తుంది, ముఖ్యంగా ఇన్‌పుట్/అవుట్‌పుట్ (I/O)కి సంబంధించినవి.


The heap is needed for data structures such as linked lists, hash tables, trees, and other interesting data structures.

లింక్డ్ జాబితాలు, హాష్ పట్టికలు, చెట్లు మరియు ఇతర ఆసక్తికరమైన డేటా నిర్మాణాల వంటి డేటా నిర్మాణాల కోసం హీప్ అవసరం.


In the ready state, a process is ready to run but for some reason the OS has chosen not to run it at this given moment.

రెడీ స్థితిలో, ఒక ప్రక్రియ అమలు చేయడానికి సిద్ధంగా ఉంది, కానీ కొన్ని కారణాల వల్ల OS ఈ సమయంలో దీన్ని అమలు చేయకూడదని ఎంచుకుంది.


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

ప్రోగ్రామ్ స్వయంగా ఒక నిర్జీవమైన విషయం: అది డిస్క్‌లో అలాగే ఉంటుంది.


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

OSకి కొన్ని తక్కువ-స్థాయి యంత్రాలు మరియు కొన్ని ఉన్నత-స్థాయి మేధస్సు రెండూ అవసరం.


By combining mechanisms and policies, we will build up our understanding of how an operating system virtualizes the CPU.

మెకానిజమ్‌లు మరియు విధానాలను కలపడం ద్వారా, ఆపరేటింగ్ సిస్టమ్ CPUని ఎలా వర్చువలైజ్ చేస్తుందో మనం అర్థం చేసుకుంటాము.


The OS must also track, in some way, blocked processes.

OS తప్పనిసరిగా కొన్ని మార్గాల్లో బ్లాక్ చేయబడిన ప్రక్రియలను కూడా ట్రాక్ చేయాలి.


The operating system manages the computer's resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ వనరులను నిర్వహిస్తుంది.


System calls allow user programs to access kernel functionality.

సిస్టమ్ కాల్స్ యూజర్ ప్రోగ్రామ్‌లకు కెర్నల్ కార్యాచరణను యాక్సెస్ చేయడానికి అనుమతిస్తాయి.


The hardware needs to save the caller's register state.

హార్డ్‌వేర్ కాలింగ్ చేసేవారి రిజిస్టర్ స్థితిని సేవ్ చేయాలి.


The kernel sets up a trap table at boot time.

కెర్నల్ బూట్ సమయంలో ఒక ట్రాప్ టేబుల్‌ను ఏర్పాటు చేస్తుంది.


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

OS ట్రాప్ హ్యాండ్లర్‌ల స్థానాల గురించి హార్డ్‌వేర్‌కు తెలియజేస్తుంది.


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

టైమర్ అంతరాయం OSకి మళ్ళీ రన్ అయ్యే సామర్థ్యాన్ని ఇస్తుంది.


A context switch saves and restores register values.

సందర్భ మార్పిడి రిజిస్టర్ విలువలను సేవ్ చేస్తుంది మరియు పునరుద్ధరిస్తుంది.


The OS must inform the hardware of which code to run.

ఏ కోడ్‌ను అమలు చేయాలో OS హార్డ్‌వేర్‌కు తెలియజేయాలి.


The basic idea is to run the program on the CPU.

ప్రాథమిక ఆలోచన ఏమిటంటే ప్రోగ్రామ్‌ను CPUలో అమలు చేయడం.


Rebooting can be a useful tool in building robust systems.

పునఃప్రారంభించడం బలమైన వ్యవస్థలను నిర్మించడంలో ఉపయోగకరమైన సాధనం కావచ్చు.


ఈ రోజు వాతావరణం ఆహ్లాదకరంగా ఉంది.


దయచేసి నాకు ఉప్పు అందిస్తారా?


I am going to the market to buy groceries.

నేను కిరాణా సామాగ్రి కొనడానికి మార్కెట్‌కి వెళ్తున్నాను.


The company announced its quarterly earnings.

సంస్థ తన త్రైమాసిక ఆదాయాలను ప్రకటించింది.


The government is implementing new policies.

ప్రభుత్వం కొత్త విధానాలను అమలు చేస్తోంది.


She is a talented musician and composer.

ఆమె ప్రతిభావంతులైన సంగీత విద్వాంసురాలు మరియు స్వరకర్త.


The book was a bestseller for several weeks.

పుస్తకం చాలా వారాల పాటు బెస్ట్ సెల్లర్‌గా నిలిచింది.


సమావేశం వచ్చే నెలలో జరుగుతుంది.


He is studying for his exams diligently.

అతను తన పరీక్షల కోసం శ్రద్ధగా చదువుతున్నాడు.


The project requires careful planning and execution.

ప్రాజెక్ట్ జాగ్రత్తగా ప్రణాళిక మరియు అమలును కోరుతుంది.


The program prints a 'hello world' message.

ప్రోగ్రామ్ 'హలో వరల్డ్' సందేశాన్ని ముద్రిస్తుంది.


The operating system manages the computer's resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ వనరులను నిర్వహిస్తుంది.


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

చైల్డ్ ప్రాసెస్ అనేది పేరెంట్ ప్రాసెస్ యొక్క దాదాపు ఖచ్చితమైన కాపీ.


The shell allows the user to interact with the operating system.

షెల్ వినియోగదారుని ఆపరేటింగ్ సిస్టమ్‌తో పరస్పర చర్య చేయడానికి అనుమతిస్తుంది.


The fork() system call creates a new process.

ఫోర్క్() సిస్టమ్ కాల్ ఒక కొత్త ప్రక్రియను సృష్టిస్తుంది.


The exec() system call replaces the current process image with a new one.

ఎగ్జెక్() సిస్టమ్ కాల్ ప్రస్తుత ప్రాసెస్ ఇమేజ్‌ను కొత్తదానితో భర్తీ చేస్తుంది.


The wait() system call allows a parent process to wait for a child process to finish.

వెయిట్() సిస్టమ్ కాల్ ఒక చైల్డ్ ప్రాసెస్ ముగిసే వరకు పేరెంట్ ప్రాసెస్ వేచి ఉండేలా అనుమతిస్తుంది.


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

CPU షెడ్యూలర్ ఒక నిర్దిష్ట సమయంలో ఏ ప్రక్రియను అమలు చేయాలో నిర్ణయిస్తుంది.


The shell can redirect the output of a program to a file.

షెల్ ఒక ప్రోగ్రామ్ యొక్క అవుట్‌పుట్‌ను ఫైల్‌కు మళ్ళించగలదు.


Understanding the process API is crucial for systems programming.

సిస్టమ్స్ ప్రోగ్రామింగ్ కోసం ప్రాసెస్ APIని అర్థం చేసుకోవడం చాలా ముఖ్యం.


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

UNIX షెల్‌ను నిర్మించడానికి ఫోర్క్() మరియు ఎగ్జెక్()ల విభజన చాలా అవసరం.


The operating system provides different modes of execution, such as user mode and kernel mode.

ఆపరేటింగ్ సిస్టమ్ వినియోగదారు మోడ్ మరియు కెర్నల్ మోడ్ వంటి వివిధ అమలు విధానాలను అందిస్తుంది.


The program uses the fork() system call to create a child process.

ప్రోగ్రామ్ చైల్డ్ ప్రాసెస్‌ను సృష్టించడానికి ఫోర్క్() సిస్టమ్ కాల్‌ను ఉపయోగిస్తుంది.


The child process calls execvp() to run another program.

చైల్డ్ ప్రాసెస్ మరొక ప్రోగ్రామ్‌ను అమలు చేయడానికి ఎగ్జెక్విపి()ని పిలుస్తుంది.


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

వెయిట్() సిస్టమ్ కాల్‌ని ఉపయోగించి చైల్డ్ ప్రాసెస్ పూర్తయ్యే వరకు పేరెంట్ ప్రాసెస్ వేచి ఉంటుంది.


The shell is a user program that interprets commands.

షెల్ అనేది ఆదేశాలను అర్థం చేసుకునే వినియోగదారు ప్రోగ్రామ్.


The redirection of output is a common feature in shells.

అవుట్‌పుట్ మళ్లింపు షెల్స్‌లో ఒక సాధారణ లక్షణం.


The operating system's role is to manage hardware resources efficiently.

ఆపరేటింగ్ సిస్టమ్ యొక్క పాత్ర హార్డ్‌వేర్ వనరులను సమర్థవంతంగా నిర్వహించడం.


The combination of fork() and exec() provides a powerful way to create and manipulate processes.

ఫోర్క్() మరియు ఎగ్జెక్()ల కలయిక ప్రక్రియలను సృష్టించడానికి మరియు మార్చడానికి ఒక శక్తివంతమైన మార్గాన్ని అందిస్తుంది.


The CPU scheduler determines which process gets to run at any given time.

ఏ సమయంలోనైనా ఏ ప్రక్రియను అమలు చేయాలో CPU షెడ్యూలర్ నిర్ణయిస్తుంది.


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

ఈ రన్ లో, మేము 100,000 ఇన్పుట్ విలువను ఇచ్చినప్పుడు, 200,000 తుది విలువను పొందడానికి బదులుగా, మొదట 143,012 ని పొందుతున్నాము.


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

అప్పుడు, మనం ప్రోగ్రామ్‌ను రెండవసారి అమలు చేసినప్పుడు, మనం మళ్ళీ తప్పు విలువను పొందడమే కాకుండా, చివరిసారి కంటే భిన్నమైన విలువను కూడా పొందుతాము.


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

వాస్తవానికి, మీరు ప్రోగ్రామ్‌ను లూప్‌ల యొక్క అధిక విలువలతో పదేపదే అమలు చేస్తే, కొన్నిసార్లు మీరు సరైన సమాధానం కూడా పొందవచ్చు!


అయితే ఇది ఎందుకు జరుగుతోంది?


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

ఇది ఎలా జరుగుతుందంటే, ఈ విచిత్రమైన మరియు అసాధారణ ఫలితాలకు కారణం సూచనలు ఎలా అమలు చేయబడతాయో దానితో ముడిపడి ఉంది, ఇది ఒకేసారి జరుగుతుంది.


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

దురదృష్టవశాత్తు, పైన ఉన్న ప్రోగ్రామ్ యొక్క ముఖ్యమైన భాగం, ఇక్కడ షేర్డ్ కౌంటర్ పెరుగుతుంది, మూడు సూచనలను తీసుకుంటుంది: కౌంటర్ విలువను మెమరీ నుండి రిజిస్టర్‌లోకి లోడ్ చేయడానికి ఒకటి, దానిని పెంచడానికి ఒకటి మరియు దానిని తిరిగి మెమరీలో నిల్వ చేయడానికి ఒకటి.


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

ఈ మూడు సూచనలు పరమాణువుగా అమలు చేయబడవని (అన్నీ ఒకేసారి), విచిత్రమైన విషయాలు జరగవచ్చు.


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

ఈ పుస్తకం యొక్క రెండవ భాగంలో మనం వివరంగా చర్చించబోయే సమస్య ఇది.


The third major theme of the course is persistence.

కోర్సు యొక్క మూడవ ప్రధాన అంశం నిలకడ.


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

సిస్టమ్ మెమరీలో, DRAM వంటి పరికరాలు అస్థిర పద్ధతిలో విలువలను నిల్వ చేస్తాయి కాబట్టి డేటాను సులభంగా కోల్పోవచ్చు; విద్యుత్ పోయినప్పుడు లేదా సిస్టమ్ క్రాష్ అయినప్పుడు, మెమరీలోని ఏదైనా డేటా పోతుంది.


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

అందువల్ల, డేటాను శాశ్వతంగా నిల్వ చేయడానికి మనకు హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్ అవసరం; వినియోగదారులు తమ డేటా గురించి చాలా శ్రద్ధ చూపుతారు కాబట్టి, అటువంటి నిల్వ ఏదైనా సిస్టమ్‌కు చాలా కీలకం.


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

హార్డ్‌వేర్ ఏదో ఒక రకమైన ఇన్‌పుట్/అవుట్‌పుట్ లేదా I/O పరికరం రూపంలో వస్తుంది; ఆధునిక వ్యవస్థలలో, హార్డ్ డ్రైవ్ అనేది ఎక్కువ కాలం ఉండే సమాచారం కోసం ఒక సాధారణ రిపోజిటరీ, అయితే సాలిడ్-స్టేట్ డ్రైవ్‌లు (SSDs) కూడా ఈ రంగంలో పురోగతి సాధిస్తున్నాయి.


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

సాధారణంగా డిస్క్‌ను నిర్వహించే ఆపరేటింగ్ సిస్టమ్‌లోని సాఫ్ట్‌వేర్‌ను ఫైల్ సిస్టమ్ అంటారు; ఇది వినియోగదారు సృష్టించే ఫైల్‌లను సిస్టమ్ డిస్క్‌లలో నమ్మదగిన మరియు సమర్థవంతమైన పద్ధతిలో నిల్వ చేయడానికి బాధ్యత వహిస్తుంది.


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

CPU మరియు మెమరీ కోసం OS అందించే అబ్‌స్ట్రాక్షన్‌ల వలె కాకుండా, OS ప్రతి అప్లికేషన్ కోసం ఒక ప్రైవేట్, వర్చువలైజ్డ్ డిస్క్‌ను సృష్టించదు.


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

బదులుగా, చాలాసార్లు, వినియోగదారులు ఫైల్‌లలో ఉన్న సమాచారాన్ని పంచుకోవాలనుకుంటారని భావించబడుతుంది.


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

ఉదాహరణకు, C ప్రోగ్రామ్‌ను వ్రాసేటప్పుడు, మీరు మొదట C ఫైల్‌ను (emacs -nw main.c) సృష్టించడానికి మరియు సవరించడానికి ఎడిటర్ (ఉదా., Emacs)ని ఉపయోగించవచ్చు.


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

ఒకసారి పూర్తయిన తర్వాత, మీరు సోర్స్ కోడ్‌ను ఎగ్జిక్యూటబుల్‌గా మార్చడానికి కంపైలర్‌ను ఉపయోగించవచ్చు (ఉదా., gcc -o main main.c).


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

మీరు పూర్తి చేసినప్పుడు, మీరు కొత్త ఎగ్జిక్యూటబుల్‌ను అమలు చేయవచ్చు (ఉదా., ./main).


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

అందువల్ల, వివిధ ప్రక్రియలలో ఫైల్‌లు ఎలా భాగస్వామ్యం చేయబడతాయో మీరు చూడవచ్చు.


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

ఫైల్ సిస్టమ్ అనేది శాశ్వత డేటాను నిర్వహించే OS భాగం.


The 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.

సిస్టమ్ కాల్ యొక్క ఖర్చును కొలవడం చాలా సులభం.


The lmbench benchmark does so by running two processes on a single CPU.

ఒకే CPUలో రెండు ప్రక్రియలను అమలు చేయడం ద్వారా lmbench బెంచ్‌మార్క్ అలా చేస్తుంది.


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

ఈ విధంగా పదేపదే కమ్యూనికేట్ చేసే ఖర్చును కొలవడం ద్వారా, lmbench సందర్భ మార్పిడి ఖర్చును బాగా అంచనా వేయగలదు.


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

అదృష్టవశాత్తూ, చాలా ఆపరేటింగ్ సిస్టమ్‌లు ఒక నిర్దిష్ట ప్రాసెసర్‌కు ఒక ప్రక్రియను బంధించడానికి కాల్‌లను కలిగి ఉంటాయి.


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

ఇప్పటివరకు, నడుస్తున్న ప్రక్రియల యొక్క తక్కువ-స్థాయి విధానాలు స్పష్టంగా ఉండాలి.


We will now do just that, presenting a series of scheduling policies.

మేము ఇప్పుడు అదే చేస్తాము, షెడ్యూలింగ్ విధానాల శ్రేణిని అందిస్తున్నాము.


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

షెడ్యూలింగ్ యొక్క మూలాలు, వాస్తవానికి, కంప్యూటర్ సిస్టమ్‌లకు ముందున్నాయి.


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

షెడ్యూలింగ్ విధానాల గురించి ఆలోచించడానికి మనం ఎలా ప్రాథమిక ఫ్రేమ్‌వర్క్‌ను అభివృద్ధి చేయాలి?


Determining the workload is a critical part of building policies.

వర్క్‌లోడ్‌ను నిర్ణయించడం విధానాలను రూపొందించడంలో ఒక ముఖ్యమైన భాగం.


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.

ఒక పని యొక్క టర్నరౌండ్ సమయం అనేది పని పూర్తయిన సమయం మైనస్ పని సిస్టమ్‌లోకి వచ్చిన సమయంగా నిర్వచించబడుతుంది.


This fact will change as we relax the aforementioned assumptions.

మేము పైన పేర్కొన్న ఊహలను సడలించినప్పుడు ఈ వాస్తవం మారుతుంది.


ఆసక్తి కలిగించే మరొక కొలమానం న్యాయం.


The most basic algorithm a scheduler can implement is known as First In, First Out (FIFO) scheduling.

షెడ్యూలర్ అమలు చేయగల అత్యంత ప్రాథమిక అల్గారిథం ఫస్ట్ ఇన్, ఫస్ట్ అవుట్ (FIFO) షెడ్యూలింగ్ అని పిలువబడుతుంది.


FIFO has a number of positive properties.

FIFO అనేక సానుకూల లక్షణాలను కలిగి ఉంది.


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

A, B మరియు C అనే మూడు పనులు దాదాపు ఒకే సమయంలో సిస్టమ్‌లోకి వస్తాయని ఊహించండి.


What will the average turnaround time be for these jobs?

ఈ ఉద్యోగాలకు సగటు టర్నరౌండ్ సమయం ఎంత ఉంటుంది?


This problem is generally referred to as the convoy effect.

ఈ సమస్యను సాధారణంగా కాన్వాయ్ ప్రభావం అని పిలుస్తారు.


ఈ పేపర్ లాటరీ షెడ్యూలింగ్ గురించి చర్చిస్తుంది.


Lottery scheduling is a simple randomized algorithm.

లాటరీ షెడ్యూలింగ్ అనేది ఒక సాధారణ యాదృచ్ఛిక అల్గారిథం.


This thesis outlines lottery and stride scheduling.

ఈ సిద్ధాంతం లాటరీ మరియు స్ట్రైడ్ షెడ్యూలింగ్‌ను వివరిస్తుంది.


If you're thinking of writing a Ph.D. dissertation, this is a good example.

మీరు పి.హెచ్.డి సిద్ధాంతం రాయాలని ఆలోచిస్తున్నట్లయితే, ఇది మంచి ఉదాహరణ.


The paper discusses 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 ఉద్యోగాలతో అనుకరణల కోసం పరిష్కారాలను లెక్కించండి.


What happens when the number of tickets is so imbalanced?

టిక్కెట్ల సంఖ్య అసమతుల్యంగా ఉంటే ఏమి జరుగుతుంది?


Multi-threaded applications can run faster with more CPU resources.

మల్టీ-త్రెడెడ్ అప్లికేషన్లు ఎక్కువ CPU వనరులతో వేగంగా అమలు చేయగలవు.


This chapter will introduce the basics of multiprocessor scheduling.

ఈ అధ్యాయం మల్టీప్రాసెసర్ షెడ్యూలింగ్ యొక్క ప్రాథమికాలను పరిచయం చేస్తుంది.


Multiprocessor systems are increasingly commonplace.

మల్టీప్రాసెసర్ సిస్టమ్స్ ఎక్కువగా సాధారణం అవుతున్నాయి.


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

మల్టీకోర్ ప్రాసెసర్ పెరుగుదల ఈ విస్తరణకు మూలం.


A typical application only uses a single CPU.

ఒక సాధారణ అప్లికేషన్ ఒకే CPU ని ఉపయోగిస్తుంది.


Multi-threaded applications can spread work across multiple CPUs.

మల్టీ-త్రెడెడ్ అప్లికేషన్లు బహుళ CPU లలో పనిని విస్తరించగలవు.


How should the OS schedule jobs on multiple CPUs?

OS బహుళ CPU లలో ఉద్యోగాలను ఎలా షెడ్యూల్ చేయాలి?


This difference centers around the use of hardware caches.

ఈ వ్యత్యాసం హార్డ్‌వేర్ కాష్‌ల వాడకం చుట్టూ కేంద్రీకృతమై ఉంది.


కాష్‌లు చిన్నవి, వేగవంతమైన జ్ఞాపకాలు.


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

సిస్టమ్ పెద్ద, నెమ్మదిగా నడిచే మెమరీని వేగవంతమైనదిగా కనిపించేలా చేయగలదు.


Caches are thus based on the notion of locality.

కాష్‌లు స్థానికత భావనపై ఆధారపడి ఉంటాయి.


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

ఒకే సిస్టమ్‌లో బహుళ ప్రాసెసర్‌లు ఉన్నప్పుడు ఏమి జరుగుతుంది?


The scheduler decides which process gets to use the CPU.

షెడ్యూలర్ ఏ ప్రక్రియ CPUని ఉపయోగించాలో నిర్ణయిస్తుంది.


MLFQ aims to optimize turnaround time and response time.

MLFQ టర్నరౌండ్ సమయం మరియు ప్రతిస్పందన సమయాన్ని ఆప్టిమైజ్ చేయడానికి లక్ష్యంగా పెట్టుకుంటుంది.


Interactive jobs should get run frequently.

ఇంటరాక్టివ్ ఉద్యోగాలు తరచుగా అమలు చేయబడాలి.


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

OS సాధారణంగా ప్రతి పని యొక్క పొడవు గురించి చాలా తక్కువ తెలుసుకుంటుంది.


We need to build a scheduler that behaves like SJF/STCF.

SJF/STCF లాగా ప్రవర్తించే షెడ్యూలర్‌ను మనం నిర్మించాలి.


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

మొదటిది మిగిలిన అతి చిన్న పనిని నడుపుతుంది మరియు తద్వారా టర్నరౌండ్ సమయాన్ని ఆప్టిమైజ్ చేస్తుంది.


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

రెండవది అన్ని ఉద్యోగాల మధ్య మారుతుంది మరియు తద్వారా ప్రతిస్పందన సమయాన్ని ఆప్టిమైజ్ చేస్తుంది.


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

మనం I/Oని చిత్రంలోకి ఎలా చేర్చవచ్చో కూడా చూశాము.


The scheduler uses the recent past to predict the future.

షెడ్యూలర్ భవిష్యత్తును అంచనా వేయడానికి ఇటీవలి గతాన్ని ఉపయోగిస్తుంది.


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

ఈ షెడ్యూలర్‌ను మల్టీ-లెవెల్ ఫీడ్‌బ్యాక్ క్యూ అని పిలుస్తారు.


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

MLFQ పరిష్కరించడానికి ప్రయత్నించే ప్రాథమిక సమస్య రెండు రెట్లు.


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

MLFQ ఒక సిస్టమ్ ఇంటరాక్టివ్ వినియోగదారులకు ప్రతిస్పందించేలా చేయడానికి ఇష్టపడుతుంది.


How can we build a scheduler to achieve these goals?

ఈ లక్ష్యాలను సాధించడానికి మనం షెడ్యూలర్‌ను ఎలా నిర్మించగలం?


How can the scheduler learn the characteristics of the jobs?

షెడ్యూలర్ ఉద్యోగాల లక్షణాలను ఎలా తెలుసుకోవచ్చు?


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

MLFQ దాని పరిశీలించిన ప్రవర్తన ఆధారంగా ఒక పని యొక్క ప్రాధాన్యతను మారుస్తుంది.


If a job repeatedly relinquishes the CPU, MLFQ will keep its priority high.

ఒక పని పదేపదే CPUని వదిలివేస్తే, MLFQ దాని ప్రాధాన్యతను ఎక్కువగా ఉంచుతుంది.


If a job uses the CPU intensively for long periods of time, MLFQ will reduce its priority.

ఒక పని ఎక్కువ కాలం పాటు CPUని తీవ్రంగా ఉపయోగిస్తే, MLFQ దాని ప్రాధాన్యతను తగ్గిస్తుంది.


MLFQ will try to learn about processes as they run.

MLFQ అవి నడుస్తున్నప్పుడు ప్రక్రియల గురించి తెలుసుకోవడానికి ప్రయత్నిస్తుంది.


The key to MLFQ scheduling lies in how the scheduler sets priorities.

MLFQ షెడ్యూలింగ్‌కు కీలకం షెడ్యూలర్ ప్రాధాన్యతలను ఎలా సెట్ చేస్తుందనే దానిలో ఉంది.


We now must decide how MLFQ is going to change the priority level of a job.

ఇప్పుడు MLFQ ఒక పని యొక్క ప్రాధాన్యత స్థాయిని ఎలా మార్చబోతుందో మనం నిర్ణయించుకోవాలి.


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

ఆపరేటింగ్ సిస్టమ్ ప్రతి ప్రక్రియకు ఏది ఉత్తమమో చాలా అరుదుగా తెలుసుకుంటుంది.


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

షెడ్యూలర్‌తో సహా, OS యొక్క అనేక భాగాలలో ఇటువంటి సూచనలు ఉపయోగపడతాయి.


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

నిబంధన 1: ప్రాధాన్యత(A)>ప్రాధాన్యత(B) అయితే, A రన్ అవుతుంది (B కాదు).


After some time period S, move all the jobs in the system to the topmost queue.

కొంత సమయం తర్వాత, సిస్టమ్‌లోని అన్ని ఉద్యోగాలను అత్యున్నత క్యూకి తరలించండి.


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

MLFQ ఆసక్తికరంగా ఉంటుంది ఎందుకంటే ఇది ఉద్యోగం యొక్క అమలును గమనిస్తుంది మరియు తదనుగుణంగా ప్రాధాన్యతనిస్తుంది.


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

అనేక వ్యవస్థలు వాటి బేస్ షెడ్యూలర్‌గా MLFQ యొక్క రూపాన్ని ఉపయోగిస్తాయి.


A great short set of notes by one of the authors on the details of the Solaris scheduler.

సోలారిస్ షెడ్యూలర్ వివరాలపై రచయితలలో ఒకరిచే వ్రాయబడిన గొప్ప చిన్న నోట్స్.


One of the classic old books on how a real UNIX operating system is built.

నిజమైన UNIX ఆపరేటింగ్ సిస్టమ్‌ను ఎలా నిర్మిస్తారనే దానిపై క్లాసిక్ పాత పుస్తకాలలో ఇది ఒకటి.


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

ప్రాథమిక ఆలోచన చాలా సులభం: టిక్కెట్లు మీ వాటాను సూచిస్తాయి.


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

A మరియు B అనే రెండు ప్రక్రియలను ఊహించుకోండి, A వద్ద 75 టిక్కెట్లు ఉండగా, B వద్ద 25 మాత్రమే ఉన్నాయి.


The scheduler then picks a winning ticket, which is a number from 0 to 99.

అప్పుడు షెడ్యూలర్ ఒక విజేత టికెట్‌ను ఎంచుకుంటాడు, ఇది 0 నుండి 99 వరకు ఉన్న సంఖ్య.


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 transfers, a process can temporarily hand off its tickets to another process.

బదిలీలతో, ఒక ప్రక్రియ తాత్కాలికంగా దాని టిక్కెట్‌లను మరొక ప్రక్రియకు అందజేయవచ్చు.


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

ద్రవ్యోల్బణంతో, ఒక ప్రక్రియ తాత్కాలికంగా దాని స్వంత టిక్కెట్‌ల సంఖ్యను పెంచవచ్చు లేదా తగ్గించవచ్చు.


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

లాటరీ షెడ్యూలింగ్ గురించి అత్యంత అద్భుతమైన విషయం ఏమిటంటే దాని అమలు యొక్క సరళత.


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

షెడ్యూలింగ్ నిర్ణయం తీసుకోవడానికి, మనం మొదట ఒక యాదృచ్ఛిక సంఖ్యను ఎంచుకోవాలి.


As you can see from the graph, when the job length is not very long, average unfairness can be quite severe.

గ్రాఫ్ నుండి మీరు చూడగలిగినట్లుగా, ఉద్యోగం యొక్క పొడవు చాలా పొడవుగా లేనప్పుడు, సగటు అన్యాయం చాలా తీవ్రంగా ఉంటుంది.


Although both are conceptually interesting, they have not achieved wide-spread adoption as CPU schedulers.

రెండు భావనాత్మకంగా ఆసక్తికరంగా ఉన్నప్పటికీ, అవి CPU షెడ్యూలర్‌లుగా విస్తృతంగా ఆమోదం పొందలేదు.


ఆపరేటింగ్ సిస్టమ్ CPUని వర్చువలైజ్ చేస్తుంది.


The student learned a few things about OS virtualization.

విద్యార్థి OS వర్చువలైజేషన్ గురించి కొన్ని విషయాలు నేర్చుకున్నాడు.


The OS wants to stay in charge of the machine.

OS యంత్రాంగాన్ని తన అధీనంలో ఉంచుకోవాలని కోరుకుంటుంది.


OS చాలా భయంతో ఉంటుంది.


The OS wants a program to run as efficiently as possible.

ఒక ప్రోగ్రామ్ వీలైనంత సమర్థవంతంగా అమలు కావాలని OS కోరుకుంటుంది.


OS ఒక వనరుల నిర్వాహకుడు.


Building a real scheduler seems difficult.

నిజమైన షెడ్యూలర్‌ను నిర్మించడం కష్టంగా అనిపిస్తుంది.


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

ఏ షెడ్యూలర్‌ను ఉపయోగించాలనే దానిపై ఇప్పటికీ వివాదం ఉంది.


మంచి ఇంజనీరింగ్ ఆ విధంగా ఉండవచ్చు.


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

OS ప్రతి ప్రోగ్రామ్‌కు దాని స్వంత పెద్ద మరియు వ్యక్తిగత మెమరీని కలిగి ఉన్నట్లు చూపిస్తుంది.


OS మెమరీని వర్చువలైజ్ చేస్తోంది.


The program uses a stack to keep track of where it is in the function call chain.

ప్రోగ్రామ్ ఫంక్షన్ కాల్ చైన్‌లో ఎక్కడ ఉందో ట్రాక్ చేయడానికి ఒక స్టాక్‌ను ఉపయోగిస్తుంది.


The heap is used for dynamically-allocated, user-managed memory.

డైనమిక్‌గా కేటాయించిన, వినియోగదారు-నిర్వహించే మెమరీ కోసం హీప్ ఉపయోగించబడుతుంది.


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

ప్రోగ్రామ్ కోడ్ అడ్రస్ స్పేస్ పైభాగంలో ఉంటుంది.


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

వర్చువలైజేషన్‌ను వీలైనంత సమర్థవంతంగా చేయడానికి OS ప్రయత్నించాలి.


The OS should protect processes from one another.

OS ఒకదానికొకటి ప్రక్రియలను రక్షించాలి.


The OS will do this for many processes at once.

OS దీన్ని ఒకేసారి అనేక ప్రక్రియల కోసం చేస్తుంది.


The program behaves as if it has its own private physical memory.

ప్రోగ్రామ్ దాని స్వంత వ్యక్తిగత భౌతిక మెమరీని కలిగి ఉన్నట్లుగా ప్రవర్తిస్తుంది.


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

పెద్ద, స్పార్స్, ప్రైవేట్ అడ్రస్ స్పేస్ యొక్క భ్రమను అందించడానికి OS బాధ్యత వహిస్తుంది.


The OS will turn virtual memory references into physical addresses.

OS వర్చువల్ మెమరీ సూచనలను భౌతిక చిరునామాలుగా మారుస్తుంది.


The OS, with a little hardware support, tries its best to get out of the way of the running program.

కొద్దిగా హార్డ్‌వేర్ సహాయంతో, OS రన్నింగ్ ప్రోగ్రామ్ నుండి దూరంగా ఉండటానికి తన వంతు ప్రయత్నం చేస్తుంది.


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

ఎఫిషియెన్సీ మరియు నియంత్రణ రెండూ ఏదైనా ఆధునిక ఆపరేటింగ్ సిస్టమ్ యొక్క ప్రధాన లక్ష్యాలు.


In virtualizing memory, we will pursue a similar strategy, attaining both efficiency and control.

మెమరీని వర్చువలైజ్ చేయడంలో, మేము ఇలాంటి వ్యూహాన్ని అనుసరిస్తాము, సామర్థ్యం మరియు నియంత్రణ రెండింటినీ సాధిస్తాము.


Efficiency dictates that we make use of hardware support.

సామర్థ్యం ఏమిటంటే మనం హార్డ్‌వేర్ మద్దతును ఉపయోగించుకోవాలి.


Control implies that the OS ensures that no application is allowed to access any memory but its own.

నియంత్రణ అంటే OS ఏ అప్లికేషన్‌ను దాని స్వంతం తప్ప మరేదైనా మెమరీని యాక్సెస్ చేయడానికి అనుమతించదని నిర్ధారిస్తుంది.


We will need help from the hardware here too.

ఇక్కడ కూడా హార్డ్‌వేర్ నుండి మనకు సహాయం అవసరం.


We’d like for programs to be able to use their address spaces in whatever way they would like.

ప్రోగ్రామ్‌లు తమ అడ్రస్ స్పేస్‌లను వారు కోరుకున్న విధంగా ఉపయోగించగలగాలని మేము కోరుకుంటున్నాము.


How can we build an efficient virtualization of memory?

మెమరీ యొక్క సమర్థవంతమైన వర్చువలైజేషన్‌ను మనం ఎలా నిర్మించగలం?


How do we provide the flexibility needed by applications?

అప్లికేషన్‌లకు అవసరమైన సౌలభ్యాన్ని మనం ఎలా అందిస్తాము?


How do we maintain control over which memory locations an application can access?

ఒక అప్లికేషన్ ఏ మెమరీ స్థానాలను యాక్సెస్ చేయగలదో దానిపై మనం ఎలా నియంత్రణను కొనసాగించాలి?


With address translation, the hardware transforms each memory access.

చిరునామా అనువాదంతో, హార్డ్‌వేర్ ప్రతి మెమరీ యాక్సెస్‌ను మారుస్తుంది.


The hardware transforms each memory access, changing the virtual address.

హార్డ్‌వేర్ ప్రతి మెమరీ యాక్సెస్‌ను మారుస్తుంది, వర్చువల్ చిరునామాను మారుస్తుంది.


The virtual address provided by the instruction to a physical address.

సూచన ద్వారా అందించబడిన వర్చువల్ చిరునామాను భౌతిక చిరునామాకు మారుస్తుంది.


The desired information is actually located.

కావలసిన సమాచారం వాస్తవానికి ఉంది.


Thus, the hardware transforms each memory access.

అందువల్ల, హార్డ్‌వేర్ ప్రతి మెమరీ యాక్సెస్‌ను మారుస్తుంది.


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

మేము పరిష్కరించే ప్రధాన సమస్య ఇది: CRUX: మెమరీని ఎలా కేటాయించాలి మరియు నిర్వహించాలి.


In UNIX/C programs, understanding how to allocate and manage memory is critical.

UNIX/C ప్రోగ్రామ్‌లలో, మెమరీని ఎలా కేటాయించాలో మరియు నిర్వహించాలో అర్థం చేసుకోవడం చాలా కీలకం.


ఏ ఇంటర్‌ఫేస్‌లను సాధారణంగా ఉపయోగిస్తారు?


ఏ తప్పులను నివారించాలి?


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

C ప్రోగ్రామ్‌ను అమలు చేస్తున్నప్పుడు, రెండు రకాల మెమరీ కేటాయించబడతాయి.


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

OS మెమరీని నిర్వహించాలి, ఏ స్థానాలు ఖాళీగా ఉన్నాయి మరియు ఏవి వాడుకలో ఉన్నాయి అనే విషయాన్ని ట్రాక్ చేస్తూ ఉండాలి.


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

వర్చువలైజేషన్ ద్వారా, OS అసహ్యకరమైన యంత్ర వాస్తవికతను ఉపయోగకరమైన, శక్తివంతమైన మరియు ఉపయోగించడానికి సులభమైన అమూర్తంగా మారుస్తుంది.


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

ప్రస్తుతానికి, వినియోగదారు చిరునామా స్థలం భౌతిక మెమరీలో నిరంతరం ఉంచబడాలి అని మేము భావిస్తాము.


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

చిరునామా అనువాదాన్ని అమలు చేయడానికి మనం ఏమి చేయాలో బాగా అర్థం చేసుకోవడానికి, ఒక సాధారణ ఉదాహరణను చూద్దాం.


The compiler turns this line of code into assembly, which might look something like this.

కంపైలర్ ఈ కోడ్ లైన్‌ను అసెంబ్లీగా మారుస్తుంది, ఇది ఇలా కనిపిస్తుంది.


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

ప్రక్రియ ద్వారా ఉత్పత్తి చేయబడిన ప్రతి మెమరీ సూచన ఒక వర్చువల్ చిరునామా.


The hardware adds the contents of the base register to this address and the result is a physical 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 bounds register is there to help with protection.

రక్షణ కోసం బౌండ్స్ రిజిస్టర్ అక్కడ ఉంది.


The OS must take action when a process is created.

ఒక ప్రక్రియ సృష్టించబడినప్పుడు OS చర్య తీసుకోవాలి.


The OS must take action when a process is terminated.

ఒక ప్రక్రియ ముగిసినప్పుడు OS చర్య తీసుకోవాలి.


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

సందర్భ మార్పిడి జరిగినప్పుడు OS కూడా చర్య తీసుకోవాలి.


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

OS నడుస్తున్న ప్రక్రియను పునరుద్ధరించినప్పుడు, అది CPUలో బేస్ మరియు బౌండ్స్ విలువలను సెట్ చేయాలి.


In this chapter, we have extended the concept of limited direct execution with a specific mechanism used in virtual memory.

ఈ అధ్యాయంలో, మేము వర్చువల్ మెమరీలో ఉపయోగించే ఒక నిర్దిష్ట విధానంతో పరిమిత ప్రత్యక్ష అమలు భావనను విస్తరించాము.


With address translation, the OS can control each and every memory access from a process.

చిరునామా అనువాదంతో, OS ఒక ప్రక్రియ నుండి ప్రతి మెమరీ యాక్సెస్‌ను నియంత్రించగలదు.


Key to the efficiency of this technique is hardware support.

ఈ సాంకేతికత యొక్క సామర్థ్యానికి కీలకం హార్డ్‌వేర్ మద్దతు.


బేస్-అండ్-బౌండ్స్ రక్షణను కూడా అందిస్తుంది.


We are going to need more sophisticated machinery, to try to better utilize physical memory.

భౌతిక మెమరీని మెరుగ్గా ఉపయోగించుకోవడానికి, మనకు మరింత అధునాతన యంత్రాలు అవసరం.


Imagine, however, a 32-bit address space (4 GB in size).

అయితే, 32-బిట్ చిరునామా స్థలాన్ని (4 GB పరిమాణంలో) ఊహించుకోండి.


The total free space available is 20 bytes.

మొత్తం ఖాళీ స్థలం 20 బైట్లు అందుబాటులో ఉంది.


15 బైట్‌ల కోసం చేసిన అభ్యర్థన విఫలమవుతుంది.


ఖాళీ స్థలాన్ని ఎలా నిర్వహించాలి?


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.

ఈ లైబ్రరీ నిర్వహించే స్థలాన్ని చారిత్రాత్మకంగా హీప్ అని పిలుస్తారు.


This structure contains references to all of the free chunks of space.

ఈ నిర్మాణం ఖాళీ స్థలం యొక్క అన్ని ముక్కలకు సంబంధించిన సూచనలను కలిగి ఉంది.


We are concerned with external fragmentation.

మేము బాహ్య విచ్ఛిన్నత గురించి ఆందోళన చెందుతున్నాము.


Allocators could also have the problem of internal 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 first cover some common mechanisms used in most allocators.

అలకేటర్లలో ఉపయోగించే కొన్ని సాధారణ విధానాలను మనం మొదట కవర్ చేస్తాము.


A request for anything greater than 10 bytes will fail.

10 బైట్‌ల కంటే ఎక్కువ ఏదైనా కోసం చేసిన అభ్యర్థన విఫలమవుతుంది.


The allocator will perform an action known as splitting.

అలకేటర్ స్ప్లిటింగ్ అని పిలువబడే ఒక చర్యను నిర్వహిస్తుంది.


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

అనేక అలకేటర్లలో కనిపించే ఒక అనుబంధ విధానం ఖాళీ స్థలం యొక్క కోలేసింగ్‌గా పిలువబడుతుంది.


What happens when an application calls free(10)?

ఒక అప్లికేషన్ free(10) అని పిలిస్తే ఏమి జరుగుతుంది?


The library must be able to figure out how big a chunk of memory is.

మెమరీ ముక్క ఎంత పెద్దదో లైబ్రరీ తెలుసుకోవాలి.


Most allocators store a little bit of extra information in a header block.

అధిక అలకేటర్లు హెడర్ బ్లాక్‌లో కొంచెం అదనపు సమాచారాన్ని నిల్వ చేస్తారు.


The library can easily determine whether the magic number matches.

లైబ్రరీ మ్యాజిక్ నంబర్ సరిపోతుందో లేదో సులభంగా నిర్ణయించగలదు.


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.

ఒక విభాగం అనేది ఒక నిర్దిష్ట పొడవు యొక్క చిరునామా స్థలం యొక్క అనుసంధాన భాగం.


In our canonical address space, we have three logically-different segments: code, stack, and heap.

మన ప్రామాణిక చిరునామా స్థలంలో, మనకు మూడు తార్కికంగా-విభిన్న విభాగాలు ఉన్నాయి: కోడ్, స్టాక్ మరియు హీప్.


What segmentation allows the OS to do is to place each one of those segments in different parts of physical memory, and thus avoid filling physical memory with unused virtual address space.

విభజన OS చేయడానికి అనుమతించేది ఏమిటంటే, ఆ విభాగాలలో ప్రతి ఒక్కటి భౌతిక మెమరీ యొక్క వివిధ భాగాలలో ఉంచడం, తద్వారా ఉపయోగించని వర్చువల్ చిరునామా స్థలంతో భౌతిక మెమరీని నింపకుండా ఉండటం.


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

మనం ఫిగర్ 16.1 నుండి చిరునామా స్థలాన్ని భౌతిక మెమరీలో ఉంచాలనుకుంటున్నాము అని అనుకుందాం.


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

ఒక విభాగం ప్రకారం బేస్ మరియు బౌండ్స్ జతతో, మనం ప్రతి విభాగాన్ని స్వతంత్రంగా భౌతిక మెమరీలో ఉంచవచ్చు.


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

మీరు రేఖాచిత్రంలో చూడగలిగినట్లుగా, ఉపయోగించిన మెమరీ మాత్రమే భౌతిక మెమరీలో స్థలాన్ని కేటాయించబడుతుంది.


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

విభజనకు మద్దతు ఇవ్వడానికి అవసరమైన మన MMUలోని హార్డ్‌వేర్ నిర్మాణం మీరు ఊహించినదే.


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

కోడ్ విభాగం భౌతిక చిరునామా 32KB వద్ద ఉంచబడిందని మరియు 2KB పరిమాణాన్ని కలిగి ఉందని మీరు పట్టిక నుండి చూడవచ్చు.


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

ఫిగర్ 16.1 లోని చిరునామా స్థలాన్ని ఉపయోగించి, ఒక ఉదాహరణ అనువాదం చేద్దాం.


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

వర్చువల్ చిరునామా 100 (ఇది కోడ్ విభాగంలో ఉంది)కి సూచన చేయబడిందని అనుకుందాం.


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

సూచన జరిగినప్పుడు (ఒక సూచనను పొందడం వంటివి), హార్డ్‌వేర్ బేస్ విలువను ఈ విభాగంలోకి ఆఫ్‌సెట్‌కు జోడిస్తుంది.


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

విభజన లోపం లేదా ఉల్లంఘన అనే పదం విభజించబడిన మెషీన్‌లో చట్టవిరుద్ధమైన చిరునామాకు మెమరీని యాక్సెస్ చేయడం నుండి వస్తుంది.


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

ఇప్పుడు హీప్‌లోని చిరునామాను చూద్దాం, వర్చువల్ చిరునామా 4200.


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

మనం మొదట చేయవలసింది ఏమిటంటే హీప్‌లోకి ఆఫ్‌సెట్‌ను సంగ్రహించడం, అంటే, ఈ విభాగంలోని ఏ బైట్(లు) చిరునామాను సూచిస్తాయి.


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

హీప్ వర్చువల్ చిరునామా 4KB (4096) వద్ద ప్రారంభమవుతుంది కాబట్టి, 4200 యొక్క ఆఫ్‌సెట్ వాస్తవానికి 4200 – 4096 లేదా 104.


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

హీప్ ముగింపుకు మించి ఉన్న 7KB వంటి చట్టవిరుద్ధమైన చిరునామాను సూచించడానికి ప్రయత్నిస్తే ఏమి జరుగుతుంది?


The hardware uses segment registers during translation.

అనువాదం సమయంలో హార్డ్‌వేర్ సెగ్మెంట్ రిజిస్టర్‌లను ఉపయోగిస్తుంది.


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

ఒక సాధారణ విధానం, కొన్నిసార్లు స్పష్టమైన విధానంగా సూచిస్తారు, వర్చువల్ చిరునామా యొక్క పై కొన్ని బిట్‌ల ఆధారంగా చిరునామా స్థలాన్ని విభాగాలలోకి విభజించడం.


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

మన ఉదాహరణలో, మొదటి రెండు బిట్‌లు 00 అయితే, హార్డ్‌వేర్ వర్చువల్ చిరునామా కోడ్ విభాగంలో ఉందని తెలుసుకుంటుంది.


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

మొదటి సూచన విలువ సున్నాను వర్చువల్ మెమరీ చిరునామాలోకి తరలిస్తుంది.


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

శ్రేణి పూర్ణాంకాల శ్రేణి, ఒక్కొక్కటి నాలుగు బైట్ల పరిమాణం కలిగి ఉంటాయి.


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

%eax లో ఉంచబడిన శ్రేణి సూచికను రెండవ సూచన పెంచుతుంది.


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

పోలిక రెండు విలువలు ఇంకా సమానం కాదని చూపిస్తే, నాల్గవ సూచన లూప్ పైకి తిరిగి వెళుతుంది.


We assume a virtual address space of size 64KB.

మేము 64KB పరిమాణం గల వర్చువల్ చిరునామా స్థలాన్ని ఊహిస్తాము.


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

ఈ దశాంశ శ్రేణి కోసం వర్చువల్ పేజీలు VPN=39 ... VPN=42.


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

ఇది అమలులో ఉన్నప్పుడు, ప్రతి సూచన ఫెచ్ రెండు మెమరీ సూచనలను ఉత్పత్తి చేస్తుంది.


The bottom most graph shows the instruction memory references.

అడుగున ఉన్న గ్రాఫ్ సూచన మెమరీ సూచనలను చూపుతుంది.


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

ఈ దృశ్యీకరణలో కనిపించే నమూనాలకు మీరు అర్థం చేసుకోగలరేమో చూడండి.


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

వర్చువలైజింగ్ మెమరీ యొక్క సవాలుకు పరిష్కారంగా మేము పేజింగ్ భావనను పరిచయం చేసాము.


Paging has many advantages over previous approaches.

మునుపటి విధానాలతో పోలిస్తే పేజింగ్ చాలా ప్రయోజనాలను కలిగి ఉంది.


First, it does not lead to external fragmentation.

మొదట, ఇది బాహ్య ముక్కలకు దారి తీయదు.


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

రెండవది, ఇది చాలా సౌకర్యవంతంగా ఉంటుంది, వర్చువల్ చిరునామా స్థలాల అరుదైన వినియోగాన్ని ఇది అనుమతిస్తుంది.


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

అయితే, జాగ్రత్త లేకుండా పేజింగ్ మద్దతును అమలు చేయడం నెమ్మదిగా పనిచేసే యంత్రానికి దారి తీస్తుంది.


మెమరీని వర్చువలైజ్ చేసే సవాలుకు పరిష్కారంగా పేజింగ్ భావనను మేము పరిచయం చేసాము.


Paging requires an extra memory lookup for each virtual address generated by the program.

ప్రోగ్రామ్ ద్వారా ఉత్పత్తి చేయబడిన ప్రతి వర్చువల్ చిరునామా కోసం పేజింగ్ అదనపు మెమరీ లుకప్ అవసరం.


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

చిరునామా అనువాదాన్ని మనం ఎలా వేగవంతం చేయవచ్చు మరియు సాధారణంగా పేజింగ్ అవసరమయ్యే అదనపు మెమరీ సూచనను ఎలా నివారించవచ్చు?


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

చిరునామా అనువాదాన్ని వేగవంతం చేయడానికి, మేము ట్రాన్స్లేషన్-లుకసైడ్ బఫర్ లేదా TLB అని పిలువబడేదాన్ని జోడించబోతున్నాము.


A TLB is part of the chip’s memory-management unit (MMU), and is simply a hardware cache of popular virtual-to-physical address translations.

TLB అనేది చిప్ యొక్క మెమరీ-మేనేజ్‌మెంట్ యూనిట్ (MMU)లో భాగం, మరియు ఇది సాధారణంగా ప్రసిద్ధ వర్చువల్-టు-ఫిజికల్ చిరునామా అనువాదాల హార్డ్‌వేర్ కాష్.


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

ప్రతి వర్చువల్ మెమరీ సూచనపై, కావలసిన అనువాదం అందులో ఉందో లేదో తెలుసుకోవడానికి హార్డ్‌వేర్ మొదట TLBని తనిఖీ చేస్తుంది.


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.

స్లాబ్ కేటాయింపుదారుడు ఉచిత వస్తువులను జాబితాలలో ముందుగా ప్రారంభించిన స్థితిలో ఉంచడం ద్వారా చాలా విభజించబడిన జాబితా విధానాలకు మించి వెళతాడు.


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.

మెమరీ కోసం అభ్యర్థన చేసినప్పుడు, అభ్యర్థనను స్వీకరించడానికి తగినంత పెద్ద బ్లాక్ కనుగొనబడే వరకు ఉచిత స్థలం కోసం శోధన పునరావృతంగా ఉచిత స్థలాన్ని రెండు భాగాలుగా విభజిస్తుంది.


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

ఉదాహరణలో, ఎడమవైపున ఉన్న 8KB బ్లాక్ కేటాయించబడుతుంది మరియు వినియోగదారునికి తిరిగి ఇవ్వబడుతుంది.


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

ఆ బ్లాక్ విడుదలైనప్పుడు ఏమి జరుగుతుందో బడ్డీ కేటాయింపు యొక్క అందం కనుగొనబడుతుంది.


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

8KB బ్లాక్‌ను ఉచిత జాబితాకు తిరిగి ఇచ్చినప్పుడు, కేటాయింపుదారుడు “బడ్డీ” 8KB ఉచితంగా ఉందో లేదో తనిఖీ చేస్తాడు.


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

బడ్డీ కేటాయింపు బాగా పనిచేయడానికి కారణం ఏమిటంటే, ఒక నిర్దిష్ట బ్లాక్ యొక్క బడ్డీని గుర్తించడం సులభం.


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

పైన ఉన్న ఉచిత స్థలంలోని బ్లాక్‌ల చిరునామాల గురించి ఆలోచించండి.


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లో కూడా అలాంటి కేటాయింపుదారులు ప్రతిచోటా ఉన్నారు.


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

అనేక వ్యవస్థల వలె, అలాంటి వ్యవస్థను నిర్మించడంలో చాలా రాజీలు చేయవలసి ఉంటుంది.


The system can form the physical address and request the memory system.

సిస్టమ్ భౌతిక చిరునామాను ఏర్పరచగలదు మరియు మెమరీ సిస్టమ్‌ను అభ్యర్థించగలదు.


Multi-level page tables can be useful in managing memory.

మెమరీని నిర్వహించడంలో బహుళ-స్థాయి పేజీ పట్టికలు ఉపయోగపడతాయి.


A deeper tree structure is sometimes needed for page tables.

పేజీ పట్టికల కోసం కొన్నిసార్లు లోతైన చెట్టు నిర్మాణం అవసరం.


The virtual address has a virtual page number and an offset.

వర్చువల్ చిరునామాకు వర్చువల్ పేజీ సంఖ్య మరియు ఆఫ్‌సెట్ ఉంటాయి.


Each piece of the page table should fit within a single page.

పేజీ పట్టికలోని ప్రతి భాగం ఒకే పేజీలో సరిపోయేలా ఉండాలి.


What if the page directory gets too big?

పేజీ డైరెక్టరీ చాలా పెద్దదిగా ఉంటే ఏమిటి?


We can split the page directory into multiple pages.

మేము పేజీ డైరెక్టరీని బహుళ పేజీలుగా విభజించవచ్చు.


The upper-level page directory uses the top bits of the virtual address.

ఎగువ-స్థాయి పేజీ డైరెక్టరీ వర్చువల్ చిరునామా యొక్క పై బిట్‌లను ఉపయోగిస్తుంది.


The TLB is checked before accessing the page table.

పేజీ పట్టికను యాక్సెస్ చేయడానికి ముందు TLBని తనిఖీ చేస్తారు.


హార్డ్‌వేర్ మొదట TLBని తనిఖీ చేస్తుంది.


A TLB hit avoids accessing the page table.

TLB హిట్ పేజీ పట్టికను యాక్సెస్ చేయకుండా నిరోధిస్తుంది.


A TLB miss requires a full multi-level lookup.

TLB మిస్ కోసం పూర్తి బహుళ-స్థాయి శోధన అవసరం.


ఇన్వర్టెడ్ పేజీ పట్టికలు స్థలాన్ని ఆదా చేస్తాయి.


పేజీ పట్టికలు కేవలం డేటా నిర్మాణాలు మాత్రమే.


కొన్ని సిస్టమ్‌లు పేజీ పట్టికలను డిస్క్‌కు మార్చుతాయి.


The right structure depends on the environment.

సరైన నిర్మాణం పర్యావరణంపై ఆధారపడి ఉంటుంది.


Small structures make sense in memory-constrained systems.

మెమరీ-నియంత్రిత వ్యవస్థలలో చిన్న నిర్మాణాలు అర్ధవంతంగా ఉంటాయి.


A bigger table might speed up TLB misses.

పెద్ద పట్టిక TLB మిస్‌లను వేగవంతం చేయవచ్చు.


The OS innovator can come up with new structures.

OS ఆవిష్కర్త కొత్త నిర్మాణాలతో ముందుకు రావచ్చు.


We need to support large address spaces.

మనం పెద్ద చిరునామా స్థలాలకు మద్దతు ఇవ్వాలి.


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!

వందలాది క్రియాశీల ప్రక్రియలతో (ఆధునిక వ్యవస్థలో అసాధారణం కాదు), మేము పేజీ పట్టికల కోసం వందల మెగాబైట్ల మెమరీని కేటాయిస్తాము!


Simple array-based page tables (usually called linear pagetables) are too big, taking up far too much memory on typical systems.

సాధారణ శ్రేణి-ఆధారిత పేజీ పట్టికలు (సాధారణంగా లీనియర్ పేజీటెబుల్స్ అని పిలుస్తారు) చాలా పెద్దవిగా ఉంటాయి, ఇవి సాధారణ వ్యవస్థలలో చాలా ఎక్కువ మెమరీని తీసుకుంటాయి.


పేజీ పట్టికలను మనం ఎలా చిన్నదిగా చేయవచ్చు?


ముఖ్యమైన ఆలోచనలు ఏమిటి?


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

ఈ కొత్త డేటా నిర్మాణాల ఫలితంగా ఏమి లోపాలు ఏర్పడతాయి?


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

ఒక సాధారణ మార్గంలో పేజీ పట్టిక పరిమాణాన్ని తగ్గించవచ్చు: పెద్ద పేజీలను ఉపయోగించండి.


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

అయితే, ఈ విధానంతో ప్రధాన సమస్య ఏమిటంటే, పెద్ద పేజీలు ప్రతి పేజీలో వృధాకు దారి తీస్తాయి, దీనిని అంతర్గత ముక్కలుగా విభజించడం అంటారు.


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

అప్లికేషన్‌లు పేజీలను కేటాయిస్తాయి కానీ వాటిలో కొద్ది భాగాన్ని మాత్రమే ఉపయోగిస్తాయి, మరియు మెమరీ ఈ అధిక-పెద్ద పేజీలతో త్వరగా నిండిపోతుంది.


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

అందువల్ల, చాలా సిస్టమ్‌లు సాధారణ సందర్భంలో చిన్న పేజీ పరిమాణాలను ఉపయోగిస్తాయి: 4KB (x86లో వలె) లేదా 8KB (SPARCv9లో వలె).


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

జీవితంలో ఏదైనా రెండు సహేతుకమైన కానీ భిన్నమైన విధానాలు ఉన్నప్పుడు, మీరు రెండింటినీ కలిపి రెండింటిలోనూ ఉత్తమమైనదాన్ని పొందగలరా అని ఎల్లప్పుడూ పరిశీలించాలి.


అటువంటి కలయికను మేము హైబ్రిడ్ అని పిలుస్తాము.


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

ఉదాహరణకు, మీరు రీస్ యొక్క పీనట్ బటర్ కప్ అని పిలువబడే మనోహరమైన హైబ్రిడ్‌లో రెండింటినీ కలపగలిగినప్పుడు, కేవలం చాక్లెట్ లేదా సాధారణ పీనట్ బటర్‌ను ఎందుకు తినాలి?


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

ముఖ్యంగా, పేజీ పట్టికల యొక్క మెమరీ ఓవర్‌హెడ్‌ను తగ్గించడానికి డెన్నిస్ పేజింగ్ మరియు విభజనను కలపాలనే ఆలోచనను కలిగి ఉన్నాడు.


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

చిత్రంలో చూసినట్లుగా, పేజీ పట్టికలో ఎక్కువ భాగం ఉపయోగించబడలేదు, చెల్లని ఎంట్రీలతో నిండి ఉంది.


What a waste! And this is for a tiny 16KB address space.

ఎంత వృధా! మరియు ఇది చిన్న 16KB అడ్రస్ స్పేస్ కోసం.


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?

అందువల్ల, మా హైబ్రిడ్ విధానం: ప్రక్రియ యొక్క మొత్తం అడ్రస్ స్పేస్ కోసం ఒకే పేజీ పట్టికను కలిగి ఉండటానికి బదులుగా, ప్రతి తార్కిక విభాగం కోసం ఒకటి ఎందుకు ఉండకూడదు?


The operating system manages the computer's resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ వనరులను నిర్వహిస్తుంది.


దయచేసి మీ పేరు మరియు చిరునామాను అందించండి.


వార్తాపత్రికలో పెద్ద భూకంపం గురించి నివేదించబడింది.


నేను ఈ రోజు చాలా సంతోషంగా ఉన్నాను.


The company announced a new product launch.

కంపెనీ కొత్త ఉత్పత్తి ప్రారంభించనున్నట్లు ప్రకటించింది.


The algorithm efficiently sorts the data.

అల్గారిథం డేటాను సమర్ధవంతంగా క్రమబద్ధీకరిస్తుంది.


The government implemented new policies to boost the economy.

ఆర్థిక వ్యవస్థను ప్రోత్సహించడానికి ప్రభుత్వం కొత్త విధానాలను అమలు చేసింది.


Could you please explain the concept in more detail?

దయచేసి ఈ భావనను మరింత వివరంగా వివరించగలరా?


The research paper explores the impact of climate change.

పరిశోధనా పత్రం వాతావరణ మార్పుల ప్రభావాన్ని అన్వేషిస్తుంది.


Despite the challenges, the team achieved its goals.

సవాళ్లు ఎదురైనా, జట్టు తన లక్ష్యాలను సాధించింది.


The complex system requires careful analysis.

సంక్లిష్టమైన వ్యవస్థ జాగ్రత్తగా విశ్లేషణ అవసరం.


The philosophical debate centered on the nature of reality.

తత్వశాస్త్ర చర్చ వాస్తవికత స్వభావంపై కేంద్రీకరించబడింది.


The economic downturn significantly affected global markets.

ఆర్థిక మాంద్యం ప్రపంచ మార్కెట్లను గణనీయంగా ప్రభావితం చేసింది.


The intricate design of the software was impressive.

సాఫ్ట్‌వేర్ యొక్క సంక్లిష్టమైన డిజైన్ ఆకట్టుకునేలా ఉంది.


The implications of the new law are far-reaching.

కొత్త చట్టం యొక్క పరిణామాలు చాలా దూరం వరకు ఉంటాయి.


The company's strategic plan involves significant restructuring.

కంపెనీ వ్యూహాత్మక ప్రణాళికలో గణనీయమైన పునర్నిర్మాణం ఉంది.


The scientific community is debating the ethical considerations.

నైతిక పరిగణనలపై శాస్త్రీయ సమాజం చర్చించుకుంటోంది.


The historical context is crucial for understanding the events.

సంఘటనలను అర్థం చేసుకోవడానికి చారిత్రక సందర్భం చాలా ముఖ్యం.


The intricate details of the mechanism were difficult to comprehend.

విధానం యొక్క క్లిష్టమైన వివరాలను అర్థం చేసుకోవడం కష్టం.


The long-term consequences of the policy are still uncertain.

విధానం యొక్క దీర్ఘకాలిక పరిణామాలు ఇంకా అనిశ్చితంగా ఉన్నాయి.


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

బెర్క్లీలో డేవిడ్ పాటర్సన్ మరియు స్టాన్ఫోర్డ్లో జాన్ హెన్నెస్సీ RISC వైపునకు మార్గదర్శకులుగా ఉన్నారు.


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

CISC సూచన సెట్‌లలో చాలా సూచనలు ఉంటాయి మరియు ప్రతి సూచన చాలా శక్తివంతమైనది.


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

ఉదాహరణకు, మీరు స్ట్రింగ్ కాపీని చూడవచ్చు, ఇది రెండు పాయింటర్లను మరియు పొడవును తీసుకుంటుంది మరియు మూలం నుండి గమ్యానికి బైట్‌లను కాపీ చేస్తుంది.


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

CISC వెనుక ఉన్న ఆలోచన ఏమిటంటే, అసెంబ్లీ భాషను ఉపయోగించడం సులభతరం చేయడానికి మరియు కోడ్‌ను మరింత కాంపాక్ట్‌గా చేయడానికి సూచనలు ఉన్నత స్థాయి ప్రాథమికాంశాలుగా ఉండాలి.


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

RISC వెనుక ఉన్న ముఖ్యమైన పరిశీలన ఏమిటంటే, సూచన సెట్‌లు నిజంగా కంపైలర్ లక్ష్యాలు మరియు అన్ని కంపైలర్‌లు నిజంగా కోరుకునేవి కొన్ని సాధారణ ప్రాథమికాంశాలు, ఇవి అధిక-పనితీరు గల కోడ్‌ను రూపొందించడానికి ఉపయోగించవచ్చు.


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

ప్రారంభ రోజుల్లో, RISC చిప్‌లు చాలా ప్రభావాన్ని చూపించాయి, ఎందుకంటే అవి చాలా వేగంగా ఉన్నాయి.


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

అయితే, కాలక్రమేణా, ఇంటెల్ వంటి CISC తయారీదారులు అనేక RISC పద్ధతులను తమ ప్రాసెసర్ల కోర్లలోకి చేర్చారు.


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

చివరి ఫలితం ఏమిటంటే చర్చ ముగిసింది మరియు నేడు రెండు రకాల ప్రాసెసర్‌లను వేగంగా అమలు చేయవచ్చు.


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

హార్డ్‌వేర్ TLB యొక్క విషయాలను మరింత వివరంగా చూద్దాం.


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

ఒక సాధారణ TLB 32, 64 లేదా 128 ఎంట్రీలను కలిగి ఉండవచ్చు మరియు పూర్తిగా అనుబంధంగా పిలువబడుతుంది.


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

బేసిక్గా, దీని అర్థం ఏమిటంటే, ఏదైనా అనువాదం TLBలో ఎక్కడైనా ఉండవచ్చు మరియు కావలసిన అనువాదాన్ని కనుగొనడానికి హార్డ్‌వేర్ మొత్తం TLBని సమాంతరంగా శోధిస్తుంది.


A typical TLB entry might look like this: VPN PFN other bits

ఒక సాధారణ TLB ఎంట్రీ ఇలా ఉండవచ్చు: VPN PFN ఇతర బిట్స్


Note that both the VPN and PFN are present in each entry, as a translation could end up in any of these locations.

VPN మరియు PFN రెండూ ప్రతి ఎంట్రీలో ఉన్నాయని గమనించండి, ఎందుకంటే అనువాదం ఈ స్థానాల్లో దేనికైనా చేరుకోవచ్చు.


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

TLBలో కనుగొనబడిన చెల్లుబాటు అయ్యే బిట్‌లను పేజీ పట్టికలో కనుగొనబడిన వాటితో గందరగోళానికి గురిచేయడం ఒక సాధారణ తప్పు.


In a page table, when a page-table entry (PTE) is marked invalid, it means that the page has not been allocated by the process, and should not be accessed by a correctly-working program.

పేజీ పట్టికలో, పేజీ-పట్టిక ఎంట్రీ (PTE) చెల్లనిదిగా గుర్తించబడినప్పుడు, పేజీని ప్రాసెస్ కేటాయించలేదని దీని అర్థం మరియు సరిగ్గా పనిచేసే ప్రోగ్రామ్ ద్వారా యాక్సెస్ చేయకూడదు.


The TLB valid bit, in contrast, simply refers to whether a TLB entry has a valid translation within it.

దీనికి విరుద్ధంగా, TLB చెల్లుబాటు బిట్, TLB ఎంట్రీలో చెల్లుబాటు అయ్యే అనువాదం ఉందా లేదా అని సూచిస్తుంది.


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

ఉదాహరణకు, సిస్టమ్ బూట్ అయినప్పుడు, ప్రతి TLB ఎంట్రీకి సాధారణ ప్రారంభ స్థితి చెల్లనిదిగా సెట్ చేయబడుతుంది, ఎందుకంటే అక్కడ ఇంకా చిరునామా అనువాదాలు ఏవీ కాష్ చేయబడలేదు.


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

అన్ని TLB ఎంట్రీలను చెల్లనిదిగా సెట్ చేయడం ద్వారా, సిస్టమ్, అమలు చేయడానికి సిద్ధంగా ఉన్న ప్రాసెస్ ప్రమాదవశాత్తు మునుపటి ప్రాసెస్ నుండి వర్చువల్-టు-ఫిజికల్ అనువాదాన్ని ఉపయోగించకుండా చూసుకోవచ్చు.


మరింత ఆసక్తికరమైనవి “ఇతర బిట్స్”.


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

ఉదాహరణకు, TLB సాధారణంగా చెల్లుబాటు అయ్యే బిట్‌ను కలిగి ఉంటుంది, ఇది ఎంట్రీకి చెల్లుబాటు అయ్యే అనువాదం ఉందా లేదా అని చెబుతుంది.


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

స్థానికత సూత్రం ఏమిటంటే, ఇటీవల యాక్సెస్ చేయబడిన పేజీలను త్వరలో మళ్ళీ యాక్సెస్ చేసే అవకాశం ఉంది.


LRU (Least Recently Used) replaces the page that was accessed least recently.

LRU (అతి తక్కువగా ఇటీవల ఉపయోగించినది) ఇటీవల యాక్సెస్ చేయబడిన పేజీని భర్తీ చేస్తుంది.


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

ప్రోగ్రామ్‌లు తరచుగా రెండు రకాల స్థానికతను ప్రదర్శిస్తాయి: స్పేషియల్ మరియు టెంపరల్.


The 80-20 workload demonstrates that 80% of references go to 20% of the pages.

80-20 వర్క్‌లోడ్ 80% సూచనలు 20% పేజీలకు వెళ్తాయని చూపిస్తుంది.


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

లూపింగ్-సీక్వెన్షియల్ వర్క్‌లోడ్‌లో, LRU మరియు FIFO సరిగ్గా పని చేయవు.


Implementing LRU perfectly requires significant overhead.

LRUని ఖచ్చితంగా అమలు చేయడానికి గణనీయమైన ఓవర్‌హెడ్ అవసరం.


Approximating LRU is more feasible from a computational standpoint.

గణనపరంగా LRUని అంచనా వేయడం మరింత ఆచరణాత్మకం.


The clock algorithm is a method to approximate LRU.

గడియారపు అల్గారిథం LRUని అంచనా వేయడానికి ఒక పద్ధతి.


The use bit is set to 1 when a page is referenced.

ఒక పేజీని సూచించినప్పుడు ఉపయోగించే బిట్ 1కి సెట్ చేయబడుతుంది.


Dirty pages must be written back to disk before eviction.

తొలగించే ముందు మురికి పేజీలను డిస్క్‌కి తిరిగి రాయాలి.


The OS decides when to bring a page into memory.

ఒక పేజీని ఎప్పుడు మెమరీలోకి తీసుకురావాలో OS నిర్ణయిస్తుంది.


Demand paging brings pages into memory when accessed.

డిమాండ్ పేజింగ్ యాక్సెస్ చేసినప్పుడు పేజీలను మెమరీలోకి తెస్తుంది.


Prefetching can improve performance by bringing pages in advance.

ముందుగానే పేజీలను తీసుకురావడం ద్వారా ప్రిఫెచింగ్ పనితీరును మెరుగుపరుస్తుంది.


Clustering writes improves disk efficiency.

క్లస్టరింగ్ రైట్‌లు డిస్క్ సామర్థ్యాన్ని మెరుగుపరుస్తాయి.


Thrashing occurs when memory is oversubscribed.

మెమరీని ఎక్కువగా సబ్‌స్క్రైబ్ చేసినప్పుడు త్రాషింగ్ జరుగుతుంది.


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

ప్రక్రియల సంఖ్యను పరిమితం చేయడం ద్వారా ప్రవేశ నియంత్రణ త్రాషింగ్‌ను నిరోధించవచ్చు.


Modern systems use scan-resistant algorithms.

ఆధునిక వ్యవస్థలు స్కాన్-రెసిస్టెంట్ అల్గారిథమ్‌లను ఉపయోగిస్తాయి.


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

VAX/VMS ఆపరేటింగ్ సిస్టమ్ బాగా రూపొందించబడిన వర్చువల్ మెమరీ మేనేజర్.


డేవ్ కట్లేర్ VMS యొక్క ముఖ్యమైన ఆర్కిటెక్ట్.


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

అధిక పేజింగ్‌కు ఉత్తమ పరిష్కారం ఏమిటంటే ఎక్కువ మెమరీని కొనడం.


The operating system manages the computer's resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ వనరులను నిర్వహిస్తుంది.


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

వర్చువల్ మెమరీ భౌతికంగా అందుబాటులో ఉన్న దానికంటే ఎక్కువ మెమరీని ఉపయోగించడానికి సిస్టమ్‌ను అనుమతిస్తుంది.


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

VAX/VMS ఆపరేటింగ్ సిస్టమ్ దాని అధునాతన మెమరీ నిర్వహణ పద్ధతులకు ప్రసిద్ధి చెందింది.


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

వర్చువల్ చిరునామాలను భౌతిక చిరునామాలకు అనువదించడానికి పేజీ పట్టికలు చాలా ముఖ్యమైనవి.


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

TLB (ట్రాన్స్‌లేషన్ లుక్‌సైడ్ బఫర్) చిరునామా అనువాదాన్ని వేగవంతం చేస్తుంది.


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

వివిధ కారణాల వల్ల కెర్నల్ ప్రతి చిరునామా స్థలంలోకి మ్యాప్ చేయబడుతుంది.


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

కాపీ-ఆన్-రైట్ అనేది అనేక ఆపరేటింగ్ సిస్టమ్‌లలో ఉపయోగించే ఒక ఆప్టిమైజేషన్ టెక్నిక్.


Demand zeroing is a lazy optimization that improves performance.

డిమాండ్ జీరోయింగ్ అనేది పనితీరును మెరుగుపరిచే ఒక సోమరితనం ఆప్టిమైజేషన్.


The VMS operating system used segmented FIFO for page replacement.

VMS ఆపరేటింగ్ సిస్టమ్ పేజీ రీప్లేస్‌మెంట్ కోసం సెగ్మెంటెడ్ FIFOని ఉపయోగించింది.


Understanding how virtual memory works is crucial for system programmers.

వర్చువల్ మెమరీ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడం సిస్టమ్ ప్రోగ్రామర్‌లకు చాలా ముఖ్యం.


The curse of generality can affect operating system design.

సాధారణత యొక్క శాపం ఆపరేటింగ్ సిస్టమ్ డిజైన్‌ను ప్రభావితం చేస్తుంది.


The VAX architecture had some inherent flaws that VMS addressed.

VAX ఆర్కిటెక్చర్‌లో కొన్ని లోపాలు ఉన్నాయి, వాటిని VMS పరిష్కరించింది.


The OS must handle a wide range of systems effectively.

OS విస్తృత శ్రేణి వ్యవస్థలను సమర్థవంతంగా నిర్వహించాలి.


The address space is a complex structure in modern operating systems.

చిరునామా స్థలం ఆధునిక ఆపరేటింగ్ సిస్టమ్‌లలో ఒక సంక్లిష్టమైన నిర్మాణం.


The kernel's role is to provide essential services to user programs.

కెర్నల్ పాత్ర వినియోగదారు ప్రోగ్రామ్‌లకు అవసరమైన సేవలను అందించడం.


Memory management is a critical function of any operating system.

మెమరీ నిర్వహణ ఏదైనా ఆపరేటింగ్ సిస్టమ్ యొక్క కీలకమైన పని.


The VMS designers aimed to avoid overwhelming memory with page tables.

పేజీ పట్టికలతో మెమరీని ముంచెత్తకుండా ఉండాలని VMS రూపకర్తలు లక్ష్యంగా పెట్టుకున్నారు.


The hardware TLBs help speed up virtual address translation.

హార్డ్‌వేర్ TLBలు వర్చువల్ చిరునామా అనువాదాన్ని వేగవంతం చేయడానికి సహాయపడతాయి.


The OS uses protection levels to secure system data and code.

సిస్టమ్ డేటా మరియు కోడ్‌ను సురక్షితంగా ఉంచడానికి OS రక్షణ స్థాయిలను ఉపయోగిస్తుంది.


The segmented FIFO algorithm was used for page replacement in VMS.

VMSలో పేజీ రీప్లేస్‌మెంట్ కోసం సెగ్మెంటెడ్ FIFO అల్గారిథమ్‌ను ఉపయోగించారు.


ప్రాథమిక విధానాలు చాలా స్పష్టంగా ఉన్నాయి.


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.

సరే, బహుశా దీన్ని చేయడానికి మంచి మార్గాన్ని అభివృద్ధి చేయండి.


The best kind of approach would be fast and correct, probably.

అత్యుత్తమ విధానం వేగంగా మరియు సరిగ్గా ఉంటుంది, బహుశా.


మీరు నిజంగా ఆకట్టుకోవడం ప్రారంభించారు.


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

నిజానికి, సమాంతరత గురించి మనం తెలుసుకోవలసిన ప్రతిదీ మీరు మాకు చెప్పారు!


ఒకరు ఎప్పుడూ కాంక్రీట్‌ను మరచిపోకూడదు.


There are certain types of programs that we call multi-threaded applications.

మనం మల్టీ-థ్రెడెడ్ అప్లికేషన్‌లు అని పిలిచే కొన్ని రకాల ప్రోగ్రామ్‌లు ఉన్నాయి.


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

త్రెడ్‌ల మధ్య మెమరీకి యాక్సెస్‌ను సమన్వయం చేయకపోతే, ప్రోగ్రామ్ అనుకున్న విధంగా పని చేయదు.


The operating system manages computer hardware and software resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్ వనరులను నిర్వహిస్తుంది.


Concurrency allows multiple tasks to appear to run simultaneously.

సమకాలీనత బహుళ పనులను ఏకకాలంలో నడుస్తున్నట్లుగా కనిపించేలా చేస్తుంది.


Threads share the same address space, making communication efficient.

థ్రెడ్‌లు ఒకే చిరునామా స్థలాన్ని పంచుకుంటాయి, ఇది కమ్యూనికేషన్‌ను సమర్థవంతంగా చేస్తుంది.


Synchronization primitives are essential for managing shared resources.

భాగస్వామ్య వనరులను నిర్వహించడానికి సమకాలీకరణ ఆదిమలు అవసరం.


Locks prevent race conditions by ensuring exclusive access to critical sections.

కీలక విభాగాలకు ప్రత్యేక ప్రాప్యతను నిర్ధారించడం ద్వారా లాక్‌లు రేస్ పరిస్థితులను నివారిస్తాయి.


Condition variables enable threads to wait for specific conditions to become true.

నిర్దిష్ట పరిస్థితులు నిజమయ్యే వరకు వేచి ఉండటానికి కండిషన్ వేరియబుల్స్ థ్రెడ్‌లను ప్రారంభిస్తాయి.


The program uses atomic operations to ensure data integrity.

డేటా సమగ్రతను నిర్ధారించడానికి ప్రోగ్రామ్ అటామిక్ కార్యకలాపాలను ఉపయోగిస్తుంది.


Understanding thread APIs is crucial for developing multi-threaded applications.

బహుళ-థ్రెడెడ్ అప్లికేషన్‌లను అభివృద్ధి చేయడానికి థ్రెడ్ APIలను అర్థం చేసుకోవడం చాలా ముఖ్యం.


The operating system schedules processes to optimize CPU usage.

CPU వినియోగాన్ని ఆప్టిమైజ్ చేయడానికి ఆపరేటింగ్ సిస్టమ్ ప్రక్రియలను షెడ్యూల్ చేస్తుంది.


File systems manage the storage and retrieval of data on disk.

డిస్క్‌లో డేటాను నిల్వ చేయడానికి మరియు తిరిగి పొందడానికి ఫైల్ సిస్టమ్‌లు నిర్వహిస్తాయి.


The professor explained the concept of mutual exclusion in detail.

ప్రొఫెసర్ పరస్పర మినహాయింపు భావనను వివరంగా వివరించారు.


The student struggled to understand the complexities of concurrency.

విద్యార్థి సమకాలీనత యొక్క సంక్లిష్టతలను అర్థం చేసుకోవడానికి కష్టపడ్డాడు.


The software engineer implemented a solution to the deadlock problem.

సాఫ్ట్‌వేర్ ఇంజనీర్ డెడ్‌లాక్ సమస్యకు పరిష్కారాన్ని అమలు చేశారు.


The system administrator configured the server for optimal performance.

సిస్టమ్ నిర్వాహకుడు సరైన పనితీరు కోసం సర్వర్‌ను కాన్ఫిగర్ చేసారు.


The application crashed due to a race condition.

రేస్ పరిస్థితి కారణంగా అప్లికేషన్ క్రాష్ అయింది.


The program uses threads to speed up the processing of large datasets.

పెద్ద డేటాసెట్‌ల ప్రాసెసింగ్‌ను వేగవంతం చేయడానికి ప్రోగ్రామ్ థ్రెడ్‌లను ఉపయోగిస్తుంది.


The operating system provides an abstraction layer for hardware.

ఆపరేటింగ్ సిస్టమ్ హార్డ్‌వేర్ కోసం ఒక అమూర్తత పొరను అందిస్తుంది.


The programmer debugged the code to fix a synchronization issue.

సమకాలీకరణ సమస్యను పరిష్కరించడానికి ప్రోగ్రామర్ కోడ్‌ను డీబగ్ చేసారు.


The concept of atomicity is fundamental to concurrent programming.

సమకాలీన ప్రోగ్రామింగ్‌కు అటామిసిటీ భావన ప్రాథమికమైనది.


The team discussed the best approach to handle thread creation and management.

థ్రెడ్ సృష్టి మరియు నిర్వహణను నిర్వహించడానికి ఉత్తమ విధానం గురించి బృందం చర్చించింది.


The test-and-set instruction returns the old value pointed to by the pointer.

టెస్ట్-అండ్-సెట్ సూచన పాయింటర్ ద్వారా సూచించబడిన పాత విలువను అందిస్తుంది.


This sequence of operations is performed atomically.

ఆపరేషన్ల యొక్క ఈ శ్రేణి పరమాణువుగా నిర్వహించబడుతుంది.


The thread will spin and spin until the lock is finally released.

లాక్ చివరకు విడుదలయ్యే వరకు థ్రెడ్ తిరుగుతూనే ఉంటుంది.


Spin locks don’t provide any fairness guarantees.

స్పిన్ లాక్‌లు ఎటువంటి న్యాయ హామీలను అందించవు.


Imagine threads competing for the lock on a single processor.

ఒకే ప్రాసెసర్‌లో లాక్ కోసం థ్రెడ్‌లు పోటీపడుతున్నాయని ఊహించండి.


The compare-and-swap instruction tests whether the value at the address is equal to expected.

కంపేర్-అండ్-స్వాప్ సూచన చిరునామా వద్ద ఉన్న విలువ ఊహించిన దానితో సమానంగా ఉందో లేదో పరీక్షిస్తుంది.


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

అలా అయితే, కొత్త విలువతో ptr ద్వారా సూచించబడిన మెమరీ స్థానాన్ని నవీకరించండి.


With the compare-and-swap instruction, we can build a lock.

కంపేర్-అండ్-స్వాప్ సూచనతో, మనం లాక్‌ను నిర్మించవచ్చు.


The key difference comes with the store-conditional.

ముఖ్యమైన వ్యత్యాసం స్టోర్-కండిషనల్‌తో వస్తుంది.


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

లోడ్-లింక్డ్ సాధారణ లోడ్ సూచనలాగే పనిచేస్తుంది.


Once a thread is assigned its ticket value, it will be scheduled.

ఒక థ్రెడ్‌కు దాని టికెట్ విలువ కేటాయించబడిన తర్వాత, అది షెడ్యూల్ చేయబడుతుంది.


Unlock is accomplished simply by incrementing the turn.

అన్‌లాక్ చేయడం టర్న్‌ను పెంచడం ద్వారా జరుగుతుంది.


These solutions can be quite inefficient.

ఈ పరిష్కారాలు చాలా అసమర్థంగా ఉండవచ్చు.


The problem gets worse with N threads contending for a lock.

లాక్ కోసం N థ్రెడ్‌లు పోటీ పడుతున్నప్పుడు సమస్య మరింత తీవ్రమవుతుంది.


How can we develop a lock that doesn’t needlessly waste time spinning on the CPU?

CPUలో అనవసరంగా సమయాన్ని వృథా చేయని లాక్‌ను మనం ఎలా అభివృద్ధి చేయవచ్చు?


Our first try is a simple and friendly approach.

మా మొదటి ప్రయత్నం ఒక సాధారణ మరియు స్నేహపూర్వక విధానం.


If a thread happens to call lock and find a lock held, it will simply yield the CPU.

ఒక థ్రెడ్ లాక్‌ను పిలిచి, లాక్ హోల్డ్ చేయబడితే, అది CPUని వదిలివేస్తుంది.


The cost of a context switch can be substantial.

సందర్భ మార్పిడి యొక్క వ్యయం గణనీయంగా ఉంటుంది.


We must explicitly exert some control over who gets to acquire the lock next.

తదుపరి లాక్‌ను ఎవరు పొందుతారో దానిపై మనం స్పష్టంగా కొంత నియంత్రణను కలిగి ఉండాలి.


We will need a little more OS support, as well as a queue.

మనకు కొంచెం ఎక్కువ OS మద్దతు, అలాగే క్యూ కూడా అవసరం.


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 signaling (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 స్టేట్‌మెంట్ బదులుగా, వైల్ లూప్‌లో కండిషన్‌ను మళ్లీ తనిఖీ చేస్తుంది.


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.

భవిష్యత్ అధ్యాయంలో కండిషన్ వేరియబుల్స్‌ను అధ్యయనం చేసేటప్పుడు మేము ఈ సమస్యను వివరంగా చర్చిస్తాము, కానీ సాధారణంగా, వైల్ లూప్‌ను ఉపయోగించడం సులభమైన మరియు సురక్షితమైన పని.


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

అది కండిషన్‌ను మళ్లీ తనిఖీ చేసినప్పటికీ (బహుశా కొంచెం ఓవర్‌హెడ్‌ను జోడిస్తుంది), కొన్ని pthread అమలులు వేచి ఉన్న థ్రెడ్‌ను తప్పుగా మేల్కొలపవచ్చు; అటువంటి సందర్భంలో, మళ్లీ తనిఖీ చేయకుండా, కండిషన్ మారనప్పటికీ అది మారిందని వేచి ఉన్న థ్రెడ్ అనుకుంటుంది.


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

కాబట్టి మేల్కొనడాన్ని ఖచ్చితమైన వాస్తవం కంటే ఏదో మారి ఉండవచ్చు అనే సూచనగా చూడటం సురక్షితం.


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

కొన్నిసార్లు కండిషన్ వేరియబుల్ మరియు అనుబంధిత లాక్‌కు బదులుగా రెండు థ్రెడ్‌ల మధ్య సిగ్నల్ చేయడానికి సాధారణ ఫ్లాగ్‌ను ఉపయోగించడం ఆకర్షణీయంగా ఉంటుంది.


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

కారణాల వల్ల దీన్ని ఎప్పుడూ చేయవద్దు.


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

ముందుగా, ఇది చాలా సందర్భాల్లో సరిగ్గా పని చేయదు (చాలా కాలం పాటు స్పిన్నింగ్ చేయడం CPU చక్రాలను వృధా చేస్తుంది).


రెండవది, ఇది లోపాలకు గురవుతుంది.


The code uses locks to protect shared data structures.

కోడ్ షేర్డ్ డేటా స్ట్రక్చర్లను రక్షించడానికి లాక్‌లను ఉపయోగిస్తుంది.


Two-phase locks can improve performance in certain scenarios.

రెండు-దశల లాక్‌లు కొన్ని సందర్భాల్లో పనితీరును మెరుగుపరుస్తాయి.


The operating system uses futexes for efficient locking.

సమర్థవంతమైన లాకింగ్ కోసం ఆపరేటింగ్ సిస్టమ్ ఫ్యూటెక్స్‌లను ఉపయోగిస్తుంది.


Understanding concurrency is crucial for building robust systems.

దృఢమైన వ్యవస్థలను నిర్మించడానికి ఏకకాలంలో పనిచేయడం అర్థం చేసుకోవడం చాలా ముఖ్యం.


Sloppy counters offer a trade-off between accuracy and performance.

సరిగ్గా లెక్కించడంలో మరియు పనితీరులో రాజీ పడటానికి వదులుగా ఉండే కౌంటర్లు సహాయపడతాయి.


Adding locks to data structures makes them thread-safe.

డేటా స్ట్రక్చర్లకు లాక్‌లను జోడించడం వలన అవి థ్రెడ్-సురక్షితంగా మారతాయి.


The performance of a synchronized counter scales poorly.

సమకాలీకరించబడిన కౌంటర్ పనితీరు సరిగ్గా ఉండదు.


Hand-over-hand locking is a technique for concurrent linked lists.

హ్యాండ్-ఓవర్-హ్యాండ్ లాకింగ్ అనేది ఏకకాలంలో లింక్ చేయబడిన జాబితాల కోసం ఒక సాంకేతికత.


Concurrent queues are commonly used in multi-threaded applications.

ఏకకాలంలో క్యూలు సాధారణంగా బహుళ-త్రెడెడ్ అప్లికేషన్లలో ఉపయోగించబడతాయి.


The Michael and Scott queue design uses two locks.

మైఖేల్ మరియు స్కాట్ క్యూ డిజైన్ రెండు లాక్‌లను ఉపయోగిస్తుంది.


Hash tables are a widely applicable concurrent data structure.

హాష్ పట్టికలు విస్తృతంగా వర్తించే ఏకకాల డేటా నిర్మాణం.


The code needs to be carefully designed to avoid deadlocks.

డెడ్‌లాక్‌లను నివారించడానికి కోడ్‌ను జాగ్రత్తగా రూపొందించాలి.


Performance is a key consideration when designing concurrent systems.

ఏకకాలంలో పనిచేసే వ్యవస్థలను రూపొందించేటప్పుడు పనితీరు ఒక ముఖ్యమైన అంశం.


The threshold value affects the performance of sloppy counters.

థ్రెషోల్డ్ విలువ వదులుగా ఉండే కౌంటర్ల పనితీరును ప్రభావితం చేస్తుంది.


Understanding the trade-offs is essential for good design.

మంచి రూపకల్పన కోసం రాజీలను అర్థం చేసుకోవడం చాలా అవసరం.


The insert routine acquires a lock upon entry.

ప్రవేశించినప్పుడు ఇన్సర్ట్ రొటీన్ లాక్‌ను పొందుతుంది.


The lookup routine searches for a specific key in the list.

లుకప్ రొటీన్ జాబితాలో నిర్దిష్ట కీ కోసం వెతుకుతుంది.


The sloppy counter uses local and global counters.

వదులుగా ఉండే కౌంటర్ స్థానిక మరియు గ్లోబల్ కౌంటర్లను ఉపయోగిస్తుంది.


Concurrency control is a complex topic in operating systems.

ఆపరేటింగ్ సిస్టమ్‌లలో ఏకకాల నియంత్రణ ఒక సంక్లిష్టమైన అంశం.


The goal is to build scalable and efficient data structures.

స్కేలబుల్ మరియు సమర్థవంతమైన డేటా నిర్మాణాలను నిర్మించడం లక్ష్యం.


The operating system manages computer hardware and software resources.

ఆపరేటింగ్ సిస్టమ్ కంప్యూటర్ హార్డ్‌వేర్ మరియు సాఫ్ట్‌వేర్ వనరులను నిర్వహిస్తుంది.


Please provide the necessary documentation for the project.

దయచేసి ప్రాజెక్ట్ కోసం అవసరమైన డాక్యుమెంటేషన్ అందించండి.


The company announced a new product launch next month.

కంపెనీ వచ్చే నెలలో కొత్త ఉత్పత్తిని ప్రారంభించనున్నట్లు ప్రకటించింది.


He is a very talented musician and composer.

అతను చాలా ప్రతిభావంతుడైన సంగీత విద్వాంసుడు మరియు స్వరకర్త.


The algorithm efficiently sorts the data in ascending order.

అల్గారిథం డేటాను సమర్థవంతంగా పెరుగుతున్న క్రమంలో క్రమబద్ధీకరిస్తుంది.


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

సవాళ్లు ఎదురైనా, బృందం ప్రాజెక్ట్‌ను సకాలంలో పూర్తి చేసింది.


The government implemented new policies to boost economic growth.

ఆర్థిక వృద్ధిని పెంచడానికి ప్రభుత్వం కొత్త విధానాలను అమలు చేసింది.


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

పరిశోధనా పత్రం జీవవైవిధ్యంపై వాతావరణ మార్పుల ప్రభావాన్ని అన్వేషిస్తుంది.


The complex system requires careful analysis and design.

సంక్లిష్టమైన వ్యవస్థకు జాగ్రత్తగా విశ్లేషణ మరియు రూపకల్పన అవసరం.


The philosophical debate centered on the nature of consciousness.

తత్వ చర్చ స్పృహ స్వభావంపై కేంద్రీకరించబడింది.


The intricate details of the artwork captivated the audience.

ఆర్ట్‌వర్క్ యొక్క క్లిష్టమైన వివరాలు ప్రేక్షకులను ఆకట్టుకున్నాయి.


The company's innovative approach revolutionized the industry.

కంపెనీ యొక్క వినూత్న విధానం పరిశ్రమలో విప్లవాత్మక మార్పులు తెచ్చింది.


The economic downturn significantly affected global markets.

ఆర్థిక మాంద్యం ప్రపంచ మార్కెట్‌లను గణనీయంగా ప్రభావితం చేసింది.


The scientist conducted experiments to validate the hypothesis.

శాస్త్రవేత్త పరికల్పనను ధృవీకరించడానికి ప్రయోగాలు నిర్వహించారు.


The ancient civilization left behind a rich cultural heritage.

పురాతన నాగరికత గొప్ప సాంస్కృతిక వారసత్వాన్ని వదిలివేసింది.


The software update includes several bug fixes and performance improvements.

సాఫ్ట్‌వేర్ అప్‌డేట్‌లో అనేక బగ్ పరిష్కారాలు మరియు పనితీరు మెరుగుదలలు ఉన్నాయి.


The political situation remains highly volatile and unpredictable.

రాజకీయ పరిస్థితి చాలా అస్థిరంగా మరియు ఊహించలేనిదిగా ఉంది.


The intricate network of neurons allows for complex cognitive functions.

న్యూరాన్‌ల యొక్క క్లిష్టమైన నెట్‌వర్క్ సంక్లిష్టమైన అభిజ్ఞా విధులను అనుమతిస్తుంది.


The artist's unique perspective transformed the way we see the world.

కళాకారుడి ప్రత్యేకమైన దృక్పథం ప్రపంచాన్ని మనం చూసే విధానాన్ని మార్చివేసింది.


The company's strategic decisions will determine its future success.

కంపెనీ యొక్క వ్యూహాత్మక నిర్ణయాలు దాని భవిష్యత్తు విజయాన్ని నిర్ణయిస్తాయి.


వినియోగదారుడు తిరిగి నిద్రలోకి వెళ్తాడు.


Thanks to Mesa semantics, a simple rule to remember with condition variables is to always use while loops.

మెసా అర్థశాస్త్రానికి ధన్యవాదాలు, కండిషన్ వేరియబుల్స్‌తో గుర్తుంచుకోవలసిన సాధారణ నియమం ఏమిటంటే ఎల్లప్పుడూ వైల్ లూప్‌లను ఉపయోగించడం.


The problem occurs when two consumers run first.

సమస్య ఏమిటంటే ఇద్దరు వినియోగదారులు మొదట నడుస్తారు.


Signaling is clearly needed, but must be more directed.

సిగ్నలింగ్ స్పష్టంగా అవసరం, కానీ మరింత నిర్దేశితంగా ఉండాలి.


A consumer should not wake other consumers, only producers, and vice-versa.

వినియోగదారుడు ఇతర వినియోగదారులను మేల్కొలపకూడదు, కేవలం ఉత్పత్తిదారులను మాత్రమే మేల్కొలపాలి మరియు దీనికి విరుద్ధంగా.


The solution here is once again a small one: use two condition variables, instead of one.

ఇక్కడ పరిష్కారం మరోసారి చిన్నది: ఒకదానికి బదులుగా రెండు కండిషన్ వేరియబుల్స్‌ను ఉపయోగించండి.


A producer only sleeps if all buffers are currently filled.

అన్ని బఫర్‌లు ప్రస్తుతం నిండినప్పుడు మాత్రమే ఉత్పత్తిదారుడు నిద్రపోతాడు.


When checking for a condition in a multi-threaded program, using a while loop is always correct.

బహుళ-త్రెడెడ్ ప్రోగ్రామ్‌లో ఒక పరిస్థితిని తనిఖీ చేస్తున్నప్పుడు, వైల్ లూప్‌ను ఉపయోగించడం ఎల్లప్పుడూ సరైనది.


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

కొన్ని థ్రెడ్ ప్యాకేజీలలో, ఒకే సిగ్నల్ జరిగినా, రెండు థ్రెడ్‌లు మేల్కొనడం సాధ్యమవుతుంది.


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

వారు ఎదుర్కొన్న సమస్యను సాధారణ ఉదాహరణ ద్వారా ఉత్తమంగా చూపవచ్చు.


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

తెలివైన పాఠకుడు ఈ విధానాన్ని మనం ఇంతకు ముందే ఉపయోగించి ఉండవచ్చని కూడా గమనించి ఉండవచ్చు.


We have seen the introduction of another important synchronization primitive beyond locks: condition variables.

లాక్‌లకు మించి మరొక ముఖ్యమైన సమకాలీకరణ ఆదిమతను మనం చూశాము: కండిషన్ వేరియబుల్స్.


A semaphore is as an object with an integer value that we can manipulate with two routines.

ఒక సెమాఫోర్ అనేది రెండు రొటీన్‌లతో మనం మార్చగల ఒక పూర్ణాంక విలువ కలిగిన వస్తువు.


Because the initial value of the semaphore determines its behavior, before calling any other routine to interact with the semaphore, we must first initialize it to some value.

సెమాఫోర్ యొక్క ప్రారంభ విలువ దాని ప్రవర్తనను నిర్ణయిస్తుంది కాబట్టి, సెమాఫోర్‌తో పరస్పర చర్య చేయడానికి ఏదైనా ఇతర రొటీన్‌ను పిలిచే ముందు, మనం మొదట దానిని కొంత విలువకు ప్రారంభించాలి.


After a semaphore is initialized, we can call one of two functions to interact with it, sem_wait() or sem_post().

సెమాఫోర్‌ను ప్రారంభించిన తర్వాత, దానితో పరస్పర చర్య చేయడానికి మేము రెండు ఫంక్షన్‌లలో ఒకదాన్ని పిలవచ్చు, sem_wait() లేదా sem_post().


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() వెంటనే తిరిగి వస్తుందని లేదా తదుపరి పోస్ట్ కోసం వేచి ఉంటూ కాలింగ్‌ను సస్పెండ్ చేస్తుందని మనం చూడవచ్చు.


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

రెండవది, sem_post() sem_wait() చేసినట్లుగా కొన్ని నిర్దిష్ట పరిస్థితులు ఏర్పడే వరకు వేచి ఉండదని మనం చూడవచ్చు.


ఇప్పుడు మేము సెమాఫోర్‌ను ఉపయోగించడానికి సిద్ధంగా ఉన్నాము.


Critical to making this work, though, is the initial value of the semaphore.

దీన్ని పని చేయడానికి కీలకం ఏమిటంటే, సెమాఫోర్ యొక్క ప్రారంభ విలువ.


Semaphores are also useful when a thread wants to halt its progress waiting for a condition to become true.

ఒక పరిస్థితి నిజమయ్యే వరకు వేచి ఉంటూ ఒక థ్రెడ్ దాని పురోగతిని నిలిపివేయాలనుకున్నప్పుడు సెమాఫోర్‌లు కూడా ఉపయోగపడతాయి.


The consumer waits for a buffer to become filled before using it.

వినియోగదారుడు ఉపయోగించే ముందు బఫర్ నింపబడే వరకు వేచి ఉంటాడు.


Imagine there are two threads, a producer and a consumer.

ఒక తయారీదారుడు మరియు వినియోగదారుడు అనే రెండు థ్రెడ్‌లు ఉన్నాయని ఊహించండి.


The producer will put a data value into the first entry of buffer.

తయారీదారుడు డేటా విలువను బఫర్ యొక్క మొదటి ఎంట్రీలో ఉంచుతాడు.


This is a no-no; we don’t want any data from the producer to be lost.

ఇది కుదరదు; తయారీదారు నుండి వచ్చే డేటా ఏదీ కోల్పోకూడదనుకుంటున్నాము.


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

మీరు చూడగలిగినట్లుగా, మనం ఇక్కడ మరచిపోయినది పరస్పర మినహాయింపు.


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

వినియోగదారుడు మ్యూటెక్స్‌ను కలిగి ఉన్నాడు మరియు పూర్తి సిగ్నల్ కోసం ఎదురు చూస్తున్నాడు.


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

ఈ సమస్యను పరిష్కరించడానికి, మనం లాక్ పరిధిని తగ్గించాలి.


Reader-writer locks should be used with some caution.

రీడర్-రైటర్ లాక్‌లను కొంత జాగ్రత్తతో ఉపయోగించాలి.


The basic setup for the problem is this: assume there are five philosophers sitting around a table.

సమస్యకు సంబంధించిన ప్రాథమిక అమరిక ఇది: ఒక టేబుల్ చుట్టూ ఐదుగురు తత్వవేత్తలు కూర్చున్నారని అనుకోండి.


In order to eat, a philosopher needs two forks, both the one on their left and the one on their right.

తినడానికి, ఒక తత్వవేత్తకు రెండు ఫోర్కులు అవసరం, ఎడమ వైపున ఉన్నది మరియు కుడి వైపున ఉన్నది.


The key challenge, then, is to write the routines getforks() and putforks() such that there is no deadlock.

అప్పుడు, కీలకమైన సవాలు ఏమిటంటే, ఎలాంటి డెడ్‌లాక్ లేకుండా getforks() మరియు putforks() అనే రొటీన్‌లను రాయడం.


If each philosopher happens to grab the fork on their left before any philosopher can grab the fork on their right, each will be stuck.

ప్రతి తత్వవేత్త తమ కుడివైపున ఉన్న ఫోర్క్‌ను పట్టుకునే ముందు ఎడమవైపున ఉన్న ఫోర్క్‌ను పట్టుకుంటే, ప్రతి ఒక్కరూ ఇరుక్కుపోతారు.


The simplest way to attack this problem is to change how forks are acquired by at least one of the philosophers.

ఈ సమస్యను ఎదుర్కోవటానికి సులభమైన మార్గం ఏమిటంటే, కనీసం ఒక తత్వవేత్త ద్వారా ఫోర్కులు ఎలా పొందబడతాయో మార్చడం.


There are other “famous” problems like this one, e.g., the cigarette smoker’s problem or the sleeping barber problem.

ఈ సమస్య లాంటి ఇతర “ప్రసిద్ధ” సమస్యలు ఉన్నాయి, ఉదాహరణకు, సిగరెట్ స్మోకర్ సమస్య లేదా నిద్రపోయే బార్బర్ సమస్య.


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

సమాంతర ప్రోగ్రామ్‌లను వ్రాయడానికి సెమాఫోర్‌లు శక్తివంతమైన మరియు సౌకర్యవంతమైన ప్రాథమిక అంశాలు.


Some programmers use them exclusively, shunning locks and condition variables, due to their simplicity and utility.

కొంతమంది ప్రోగ్రామర్లు వాటిని ప్రత్యేకంగా ఉపయోగిస్తారు, వాటి సరళత మరియు వినియోగం కారణంగా లాక్‌లు మరియు కండిషన్ వేరియబుల్స్‌ను విస్మరిస్తారు.


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

ఈ అధ్యాయంలో, మేము కొన్ని క్లాసిక్ సమస్యలు మరియు పరిష్కారాలను అందించాము.


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

సమాంతర లోపాలు సాధారణ నమూనాలలో వస్తాయి.


Knowing which ones to look out for is the first step to writing more robust, correct concurrent code.

దేని కోసం వెతకాలో తెలుసుకోవడం మరింత దృఢమైన, సరైన సమాంతర కోడ్‌ను వ్రాయడానికి మొదటి దశ.


Researchers have spent a great deal of time and effort looking into concurrency bugs over many years.

పరిశోధకులు చాలా సంవత్సరాలుగా సమాంతర లోపాలపై దృష్టి సారించడానికి చాలా సమయం మరియు కృషిని వెచ్చించారు.


The study focuses on four major and important open-source applications.

ఈ అధ్యయనం నాలుగు ప్రధానమైన మరియు ముఖ్యమైన ఓపెన్ సోర్స్ అప్లికేషన్లపై దృష్టి పెడుతుంది.


MySQL is a popular database management system.

MySQL ఒక ప్రసిద్ధ డేటాబేస్ నిర్వహణ వ్యవస్థ.


The authors examine concurrency bugs that have been found and fixed.

రచయితలు కనుగొనబడిన మరియు పరిష్కరించబడిన సమాంతర లోపాలను పరిశీలిస్తారు.


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

ఈ ఫలితాలను అర్థం చేసుకోవడం వలన వాస్తవానికి ఎలాంటి సమస్యలు వస్తాయో అర్థం చేసుకోవడానికి మీకు సహాయపడుతుంది.


Table 32.1 shows a summary of the bugs Lu and colleagues studied.

పట్టిక 32.1 లో లు మరియు సహచరులు అధ్యయనం చేసిన లోపాల సారాంశం ఉంది.


From the table, you can see that there were 105 total bugs.

పట్టిక నుండి, మొత్తం 105 లోపాలు ఉన్నాయని మీరు చూడవచ్చు.


We now dive into these different classes of bugs a bit more deeply.

ఇప్పుడు మనం ఈ వివిధ రకాల లోపాల గురించి మరింత లోతుగా చర్చిద్దాం.