ગૃહકાર્ય (માપન).


શેડ્યુલિંગ મેટ્રિક્સ.


પ્રથમ આવેલું, પ્રથમ બહાર (FIFO).


સૌથી ટૂંકું કાર્ય પ્રથમ (SJF).


રાઉન્ડ રોબિન.


I/O નો સમાવેશ.


હવે ઓરેકલ નહીં.


MLFQ: મૂળભૂત નિયમો.


પ્રાથમિકતા કેવી રીતે બદલવી.


પ્રાથમિકતા બૂસ્ટ.


વધુ સારું એકાઉન્ટિંગ.


MLFQ અને અન્ય સમસ્યાઓનું ટ્યુનિંગ.


Basic Concept: Tickets Represent Your Share.

મૂળભૂત ખ્યાલ: ટિકિટો તમારા શેરનું પ્રતિનિધિત્વ કરે છે.


ટિકિટ પદ્ધતિઓ.


ટિકિટો કેવી રીતે સોંપવી?


પૃષ્ઠભૂમિ: મલ્ટિપ્રોસેસર આર્કિટેક્ચર.


સિંક્રનાઇઝેશન ભૂલશો નહીં.


એક છેલ્લો મુદ્દો: કેશ એફિનિટી.


Key To Fast Crash Recovery: Statelessness.

ઝડપી ક્રેશ રિકવરીની ચાવી: સ્ટેટલેસનેસ.


NFSv2 પ્રોટોકોલ.


From Protocol to Distributed File System.

પ્રોટોકોલથી ડિસ્ટ્રિબ્યુટેડ ફાઇલ સિસ્ટમ સુધી.


Handling Server Failure with Idempotent Operations.

આઇડેમ્પોટન્ટ ઓપરેશન્સ સાથે સર્વર નિષ્ફળતાને હેન્ડલ કરવી.


Improving Performance: Client-side Caching.

પ્રદર્શનમાં સુધારો: ક્લાયન્ટ-સાઇડ કેશિંગ.


કેશ સુસંગતતાની સમસ્યા.


NFS કેશ સુસંગતતાનું મૂલ્યાંકન.


Implications on Server-Side Write Buffering.

સર્વર-સાઇડ રાઇટ બફરિંગ પર અસરો.


AFS આવૃત્તિ 1.


આવૃત્તિ 1 સાથે સમસ્યાઓ.


પ્રોટોકોલમાં સુધારો કરવો.


AFS આવૃત્તિ 2.


કેશ સુસંગતતા.


ક્રેશ રિકવરી.


AFSv2 નું સ્કેલ અને પ્રદર્શન.


AFS: અન્ય સુધારાઓ.


Simple Example: Code That Loops and Prints.

સરળ ઉદાહરણ: કોડ જે લૂપ કરે છે અને પ્રિન્ટ કરે છે.


એકસાથે ઘણા પ્રોગ્રામ ચલાવવા.


એક પ્રોગ્રામ જે મેમરીને ઍક્સેસ કરે છે.


Running The Memory Program Multiple Times.

મેમરી પ્રોગ્રામને ઘણી વખત ચલાવવું.


The operating system virtualizes resources.

ઓપરેટિંગ સિસ્ટમ સંસાધનોનું વર્ચ્યુઅલાઈઝેશન કરે છે.


એક પ્રોગ્રામ સૂચનાઓ ચલાવે છે.


The processor fetches instructions from memory.

પ્રોસેસર મેમરીમાંથી સૂચનાઓ મેળવે છે.


ઓપરેટિંગ સિસ્ટમ સિસ્ટમને વાપરવામાં સરળ બનાવે છે.


Virtualization transforms a physical resource into a virtual form.

વર્ચ્યુઅલાઈઝેશન ભૌતિક સંસાધનને વર્ચ્યુઅલ સ્વરૂપમાં રૂપાંતરિત કરે છે.


ઓપરેટિંગ સિસ્ટમ એપ્લિકેશનો માટે API પ્રદાન કરે છે.


ઓપરેટિંગ સિસ્ટમ એક સંસાધન વ્યવસ્થાપક છે.


Multiple programs can run at the same time.

એક જ સમયે બહુવિધ પ્રોગ્રામ્સ ચાલી શકે છે.


Each program has its own virtual address space.

દરેક પ્રોગ્રામનું પોતાનું વર્ચ્યુઅલ એડ્રેસ સ્પેસ છે.


Concurrency arises when working on many things at once.

એક સાથે ઘણી વસ્તુઓ પર કામ કરતી વખતે એકસાથે થતી ઘટનાઓ આવે છે.


Modern multi-threaded programs exhibit concurrency problems.

આધુનિક મલ્ટિ-થ્રેડેડ પ્રોગ્રામ્સ એકસાથે થતી ઘટનાઓની સમસ્યાઓ દર્શાવે છે.


The program prints the string passed on the command line.

પ્રોગ્રામ કમાન્ડ લાઇન પર પસાર થયેલ સ્ટ્રિંગ પ્રિન્ટ કરે છે.


The system has a very large number of virtual CPUs.

સિસ્ટમમાં મોટી સંખ્યામાં વર્ચ્યુઅલ CPU છે.


ઓપરેટિંગ સિસ્ટમ આ ભ્રમની જવાબદાર છે.


મેમરી ફક્ત બાઇટ્સની એરે છે.


Each process accesses its own private virtual address space.

દરેક પ્રક્રિયા તેના પોતાના ખાનગી વર્ચ્યુઅલ એડ્રેસ સ્પેસને ઍક્સેસ કરે છે.


ઓપરેટિંગ સિસ્ટમ ભૌતિક મેમરીનું સંચાલન કરે છે.


We will learn about virtualization, concurrency, and persistence.

આપણે વર્ચ્યુઅલાઈઝેશન, એકસાથે થતી ઘટનાઓ અને સ્થિરતા વિશે જાણીશું.


The operating system provides a standard library to applications.

ઓપરેટિંગ સિસ્ટમ એપ્લિકેશનોને એક પ્રમાણભૂત લાઇબ્રેરી પ્રદાન કરે છે.


The OS makes the system easy to use and efficient.

ઓપરેટિંગ સિસ્ટમ સિસ્ટમને વાપરવામાં સરળ અને કાર્યક્ષમ બનાવે છે.


Building a working spin lock requires careful consideration.

કાર્યકારી સ્પિન લોક બનાવવામાં કાળજીપૂર્વક વિચારણાની જરૂર છે.


Spin locks can lead to performance issues if not implemented correctly.

જો યોગ્ય રીતે અમલ ન કરવામાં આવે તો સ્પિન લોક કામગીરીની સમસ્યાઓ તરફ દોરી શકે છે.


Compare-And-Swap is a fundamental atomic operation.

સરખામણી-અને-સ્વેપ એ એક મૂળભૂત અણુ કામગીરી છે.


Load-linked and store-conditional instructions provide another way to achieve atomicity.

લોડ-લિંક્ડ અને સ્ટોર-કન્ડિશનલ સૂચનાઓ અણુતા પ્રાપ્ત કરવાની બીજી રીત પૂરી પાડે છે.


Fetch-And-Add is useful for incrementing counters in a concurrent environment.

ફેચ-એન્ડ-એડ એક સાથેના વાતાવરણમાં કાઉન્ટર્સ વધારવા માટે ઉપયોગી છે.


The summary highlights the challenges of using spin locks.

સારાંશ સ્પિન લોકનો ઉપયોગ કરવાના પડકારોને પ્રકાશિત કરે છે.


Yielding can be a simple approach to avoid excessive spinning.

વધુ પડતા સ્પિનિંગથી બચવા માટે ઉપજ એક સરળ અભિગમ હોઈ શકે છે.


Using queues can help in sleeping instead of spinning.

કતારોનો ઉપયોગ સ્પિનિંગને બદલે ઊંઘવામાં મદદ કરી શકે છે.


Different operating systems offer different levels of support.

વિવિધ ઓપરેટિંગ સિસ્ટમ્સ વિવિધ સ્તરનું સમર્થન આપે છે.


Two-phase locks provide a more structured approach to locking.

બે-તબક્કાના લોક લોકીંગ માટે વધુ માળખાગત અભિગમ પૂરો પાડે છે.


Concurrent counters need to be carefully managed.

એકસાથેના કાઉન્ટર્સને કાળજીપૂર્વક સંચાલિત કરવાની જરૂર છે.


Concurrent linked lists require special attention to avoid race conditions.

રેસની સ્થિતિને ટાળવા માટે એકસાથેની લિંક્ડ સૂચિમાં વિશેષ ધ્યાન આપવાની જરૂર છે.


Concurrent queues are essential for many multi-threaded applications.

ઘણી મલ્ટિ-થ્રેડેડ એપ્લિકેશનો માટે એકસાથેની કતારો આવશ્યક છે.


Concurrent hash tables offer efficient data access in a multi-threaded environment.

એકસાથેની હેશ કોષ્ટકો મલ્ટિ-થ્રેડેડ વાતાવરણમાં કાર્યક્ષમ ડેટા ઍક્સેસ પ્રદાન કરે છે.


Condition variables are used to synchronize threads.

થ્રેડોને સમન્વયિત કરવા માટે સ્થિતિ ચલોનો ઉપયોગ થાય છે.


The producer/consumer problem is a classic example of concurrency.

ઉત્પાદક/ગ્રાહક સમસ્યા એક સાથેતાનું એક ઉત્તમ ઉદાહરણ છે.


Semaphores provide a mechanism for mutual exclusion.

સેમાફોર્સ પરસ્પર બાકાત માટે એક પદ્ધતિ પૂરી પાડે છે.


બાઈનરી સેમાફોર્સ લોક તરીકે કાર્ય કરી શકે છે.


Reader-writer locks allow multiple readers or a single writer.

રીડર-રાઈટર લોક બહુવિધ રીડર્સ અથવા એક જ રાઈટરને મંજૂરી આપે છે.


The dining philosophers problem illustrates concurrency challenges.

ડાઇનિંગ ફિલોસોફર્સની સમસ્યા એક સાથેતાના પડકારોને દર્શાવે છે.


The book is called Operating Systems: Three Easy Pieces.

આ પુસ્તકનું નામ છે ઓપરેટિંગ સિસ્ટમ્સ: થ્રી ઇઝી પીસીસ.


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

અમે આશા રાખીએ છીએ કે તમને તે વાંચવામાં એટલું જ ગમશે જેટલું અમને તે લખવામાં ગમ્યું.


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

ત્રણ સરળ ભાગો એ ત્રણ મુખ્ય વિષયક તત્વોનો સંદર્ભ આપે છે જેના પર પુસ્તક ગોઠવાયેલું છે: વર્ચ્યુઅલાઈઝેશન, એકસાથે થવું, અને સ્થિરતા.


નવી વસ્તુઓ શીખવી મજાની છે, ખરું ને?


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

દરેક મુખ્ય ખ્યાલને પ્રકરણોના સમૂહમાં વિભાજિત કરવામાં આવ્યો છે, જેમાંથી મોટાભાગના ચોક્કસ સમસ્યા રજૂ કરે છે અને પછી તેને કેવી રીતે હલ કરવી તે બતાવે છે.


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

આ પુસ્તક લખવામાંનું એક અમારું લક્ષ્ય ઇતિહાસના માર્ગોને શક્ય તેટલા સ્પષ્ટ બનાવવાનું છે.


In this case, seeing how the sausage was made is nearly as important as understanding what the sausage is good for.

આ કિસ્સામાં, સોસેજ કેવી રીતે બનાવવામાં આવી તે જોવું એ સમજવા જેટલું જ મહત્વપૂર્ણ છે કે સોસેજ શેના માટે સારી છે.


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

પુસ્તકમાં આપણે ઉપયોગ કરીએ છીએ તેવા કેટલાક ઉપકરણો છે જે અહીં રજૂ કરવા યોગ્ય છે.


પ્રથમ સમસ્યાનો મુખ્ય મુદ્દો છે.


Anytime we are trying to solve a problem, we first try to state what the most important issue is.

જ્યારે પણ આપણે કોઈ સમસ્યા હલ કરવાનો પ્રયાસ કરીએ છીએ, ત્યારે આપણે પહેલા સૌથી મહત્વપૂર્ણ મુદ્દો શું છે તે જણાવવાનો પ્રયાસ કરીએ છીએ.


There are also numerous asides and tips throughout the text, adding a little color to the mainline presentation.

મુખ્ય પ્રસ્તુતિમાં થોડો રંગ ઉમેરતા, ટેક્સ્ટમાં ઘણી બધી બાજુની વાતો અને ટિપ્સ પણ છે.


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

બાજુની વાતો મુખ્ય ટેક્સ્ટ સાથે સંબંધિત (પરંતુ કદાચ આવશ્યક નથી) કંઈક ચર્ચા કરે છે.


Tips tend to be general lessons that can be applied to systems you build.

ટિપ્સ સામાન્ય પાઠો હોવાની સંભાવના છે જે તમે બનાવો છો તે સિસ્ટમ્સ પર લાગુ કરી શકાય છે.


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

પુસ્તકના અંતે એક અનુક્રમણિકા તમારી સુવિધા માટે આ બધી ટિપ્સ અને બાજુની વાતોની યાદી આપે છે.


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

આપણે પુસ્તકમાં સૌથી જૂની શિક્ષણ પદ્ધતિઓમાંથી એક, સંવાદનો ઉપયોગ કરીએ છીએ.


These are used to introduce the major thematic concepts, as well as to review material every now and then.

આનો ઉપયોગ મુખ્ય વિષયક ખ્યાલો રજૂ કરવા તેમજ સમયાંતરે સામગ્રીની સમીક્ષા કરવા માટે થાય છે.


They are also a chance to write in a more humorous style.

તેઓ વધુ રમૂજી શૈલીમાં લખવાની તક પણ છે.


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

દરેક મુખ્ય વિભાગની શરૂઆતમાં, અમે પહેલા એક અમૂર્તતા રજૂ કરીશું જે એક ઓપરેટિંગ સિસ્ટમ પ્રદાન કરે છે.


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

પ્રકરણો દરમિયાન, અમે શક્ય હોય ત્યાં વાસ્તવિક કોડ (સ્યુડોકોડ નહીં) વાપરવાનો પ્રયાસ કરીએ છીએ.


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

વાસ્તવિક સિસ્ટમ્સ પર વાસ્તવિક કોડ ચલાવવો એ ઓપરેટિંગ સિસ્ટમ્સ વિશે શીખવાનો શ્રેષ્ઠ માર્ગ છે.


પુસ્તક વાંચવા લાયક છે.


This is a great introduction to how computer systems work.

આ કોમ્પ્યુટર સિસ્ટમ કેવી રીતે કામ કરે છે તેનો ઉત્તમ પરિચય છે.


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

છેવટે, તમારું જ્ઞાન વધારવાનો એક સારો માર્ગ એ છે કે શક્ય તેટલા અન્ય દ્રષ્ટિકોણ સાંભળવા.


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

એટલાસે આધુનિક સિસ્ટમમાં તમે જે જુઓ છો તેમાંના ઘણાની શરૂઆત કરી.


A nice piece of history on the early development of computer systems.

કમ્પ્યુટર સિસ્ટમના પ્રારંભિક વિકાસ પર ઇતિહાસનો એક સરસ ભાગ.


મલ્ટિક્સનું એક મહાન વિહંગાવલોકન.


So many good ideas, and yet it was an over-designed system.

એટલા બધા સારા વિચારો, અને છતાં તે વધુ પડતી ડિઝાઇનવાળી સિસ્ટમ હતી.


One of our favorite intro to computing systems books.

કમ્પ્યુટિંગ સિસ્ટમ પુસ્તકોમાં અમારા મનપસંદ પરિચયોમાંનું એક.


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

કમ્પ્યુટિંગની દુનિયા પર કબજો જમાવતાની સાથે લખાયેલ યુનિક્સનો એક મહાન સારાંશ.


It is fascinating to read these old system documents.

આ જૂના સિસ્ટમ દસ્તાવેજો વાંચવા આકર્ષક છે.


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

તમારી પોતાની વર્ગની નોંધો લખવા વિશેની મહાન બાબત: તમે તમારા પોતાના સંશોધનની જાહેરાત કરી શકો છો.


કલ્પના કરો કે આપણી પાસે એક પીચ છે.


What we would like to present to each eater is their own peach.

અમે દરેક ખાનારને જે રજૂ કરવા માંગીએ છીએ તે છે તેમની પોતાની પીચ.


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

તો તમે પીચ શેર કરી રહ્યા છો, પણ તમને તે ખબર પણ નથી?


એક ખરાબ ઝુંબેશ સૂત્ર જેવું લાગે છે.


Let us take the most basic of resources, the CPU.

ચાલો સૌથી મૂળભૂત સંસાધનો, CPU લઈએ.


What virtualization does is take that single CPU and make it look like many virtual CPUs.

વર્ચ્યુઅલાઈઝેશન એ છે કે તે એક જ CPU લે છે અને તેને ઘણા વર્ચ્યુઅલ CPU જેવો દેખાવ આપે છે.


તે કેવી રીતે કામ કરે છે?


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

આ નોંધમાં, અમે સૌથી મૂળભૂત અમૂર્તતાઓમાંની એકની ચર્ચા કરીએ છીએ જે OS વપરાશકર્તાઓને પ્રદાન કરે છે: પ્રક્રિયા.


The OS creates this illusion by virtualizing the CPU.

OS CPU ને વર્ચ્યુઅલાઈઝ કરીને આ ભ્રમ બનાવે છે.


પ્રોગ્રામ યુઝર મોડમાં ચાલી રહ્યો છે.


The operating system manages the computer's resources.

ઓપરેટિંગ સિસ્ટમ કમ્પ્યુટરના સંસાધનોનું સંચાલન કરે છે.


Please read the manual pages for more information.

વધુ માહિતી માટે કૃપા કરીને મેન્યુઅલ પૃષ્ઠો વાંચો.


The child process is a copy of the parent process.

ચાઈલ્ડ પ્રોસેસ એ પેરેન્ટ પ્રોસેસની નકલ છે.


શેલ તમને આદેશો ચલાવવાની મંજૂરી આપે છે.


The fork() system call creates a new process.

fork() સિસ્ટમ કૉલ એક નવી પ્રક્રિયા બનાવે છે.


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

exec() સિસ્ટમ કૉલ વર્તમાન પ્રક્રિયાની છબીને બદલે છે.


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

wait() સિસ્ટમ કૉલ પેરેન્ટ પ્રોસેસને ચાઈલ્ડ પ્રોસેસની રાહ જોવાની મંજૂરી આપે છે.


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

CPU શેડ્યુલર નક્કી કરે છે કે આપેલ સમયે કઈ પ્રક્રિયા ચાલે છે.


The shell is a user program that interprets commands.

શેલ એ એક યુઝર પ્રોગ્રામ છે જે આદેશોનું અર્થઘટન કરે છે.


The operating system provides an interface for process creation and control.

ઓપરેટિંગ સિસ્ટમ પ્રક્રિયા નિર્માણ અને નિયંત્રણ માટે એક ઇન્ટરફેસ પ્રદાન કરે છે.


Understanding the fork() and exec() system calls is crucial for systems programming.

સિસ્ટમ પ્રોગ્રામિંગ માટે fork() અને exec() સિસ્ટમ કૉલ્સને સમજવું ખૂબ જ જરૂરી છે.


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

UNIX શેલ બનાવવા માટે fork() અને exec()નું વિભાજન જરૂરી છે.


The shell redirects output using file descriptors.

શેલ ફાઇલ વર્ણનકર્તાઓનો ઉપયોગ કરીને આઉટપુટને રીડાયરેક્ટ કરે છે.


The operating system uses hardware support to virtualize the CPU.

ઓપરેટિંગ સિસ્ટમ CPU ને વર્ચ્યુઅલાઈઝ કરવા માટે હાર્ડવેર સપોર્ટનો ઉપયોગ કરે છે.


The program's output is redirected to a file.

પ્રોગ્રામનું આઉટપુટ ફાઇલમાં રીડાયરેક્ટ કરવામાં આવે છે.


The system call 'kill()' sends signals to a process.

સિસ્ટમ કૉલ 'kill()' એક પ્રક્રિયાને સિગ્નલ મોકલે છે.


The 'top' command displays the processes and their resource usage.

'top' આદેશ પ્રક્રિયાઓ અને તેમના સંસાધન વપરાશને દર્શાવે છે.


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

પ્રક્રિયામાં ફેરફાર કરવા માટે fork() અને exec()નું સંયોજન શક્તિશાળી છે.


The shell uses fork() to create a child process to run a command.

શેલ આદેશ ચલાવવા માટે ચાઈલ્ડ પ્રોસેસ બનાવવા માટે fork() નો ઉપયોગ કરે છે.


The operating system manages the computer's resources.

ઓપરેટિંગ સિસ્ટમ કમ્પ્યુટરના સંસાધનોનું સંચાલન કરે છે.


System calls allow user programs to access kernel functionality.

સિસ્ટમ કૉલ્સ યુઝર પ્રોગ્રામ્સને કર્નલ કાર્યક્ષમતાને ઍક્સેસ કરવાની મંજૂરી આપે છે.


The hardware saves the caller’s register state.

હાર્ડવેર કૉલરની રજિસ્ટર સ્થિતિને સાચવે છે.


The kernel initializes the trap table at boot time.

કર્નલ બૂટ સમયે ટ્રેપ ટેબલને શરૂ કરે છે.


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

ઓએસએ હાર્ડવેરને આ ટ્રેપ હેન્ડલર્સના સ્થાનોની જાણ કરવી આવશ્યક છે.


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

ટાઈમર ઈન્ટરપ્ટ ઓએસને ફરીથી ચલાવવાની ક્ષમતા આપે છે.


The OS decides to stop one process and start another.

ઓએસ એક પ્રક્રિયાને રોકવાનું અને બીજી શરૂ કરવાનું નક્કી કરે છે.


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

ઓએસ સિસ્ટમ કૉલની રાહ જોઈને સીપીયુનું નિયંત્રણ પાછું મેળવે છે.


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

ઓએસ સુરક્ષિત અનુભવી શકે છે કે નિયંત્રણ આખરે તેને પરત કરવામાં આવશે.


The basic idea is straightforward: just run the program.

મૂળભૂત વિચાર સીધો છે: ફક્ત પ્રોગ્રામ ચલાવો.


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

ઓએસ ચાલી રહ્યું નથી, તે બિલકુલ કંઈપણ કેવી રીતે કરી શકે?


The OS has to be concerned as to what happens if, during interrupt or trap handling, another interrupt occurs.

ઓએસને ચિંતા કરવાની રહેશે કે જો, વિક્ષેપ અથવા ટ્રેપ હેન્ડલિંગ દરમિયાન, બીજો વિક્ષેપ થાય તો શું થાય છે.


ઓએસ સીપીયુને “બાળક પ્રૂફ” કરે છે.


The OS will then have control of the CPU again.

પછી ઓએસ ફરીથી સીપીયુનું નિયંત્રણ મેળવશે.


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

ટ્રેપ ચલાવતી વખતે હાર્ડવેરને થોડું સાવચેત રહેવાની જરૂર છે.


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

ઓએસ હાર્ડવેરને આ ટ્રેપ હેન્ડલર્સના સ્થાનોની જાણ કરે છે.


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

કર્નલે કાળજીપૂર્વક નિયંત્રિત કરવું આવશ્યક છે કે ટ્રેપ પર કયો કોડ એક્ઝિક્યુટ થાય છે.


ઓએસ સફાઈ કરે છે અને આપણે પૂરું કરીએ છીએ.


ઓએસ જે ઇચ્છે છે તે કરી શકે છે.


ઓએસ યુઝર પ્રોગ્રામ્સ ચલાવવા માટે મુક્ત છે.


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) નો ઉપયોગ કરી શકો છો (emacs -nw main.c).


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

એકવાર થઈ જાય, પછી તમે સોર્સ કોડને એક્ઝિક્યુટેબલમાં ફેરવવા માટે કમ્પાઇલરનો ઉપયોગ કરી શકો છો (દા.ત., gcc -o main main.c).


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

જ્યારે તમે પૂર્ણ કરી લો, ત્યારે તમે નવું એક્ઝિક્યુટેબલ ચલાવી શકો છો (દા.ત., ./main).


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

આમ, તમે જોઈ શકો છો કે ફાઇલો વિવિધ પ્રક્રિયાઓમાં કેવી રીતે શેર થાય છે.


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

ફાઇલ સિસ્ટમ એ OS નો ભાગ છે જે કાયમી ડેટાનું સંચાલન કરવા માટે જવાબદાર છે.


lmbench ડાઉનલોડ કરો અને તેનો પ્રયાસ કરો.


A classic paper on the nature of operating system performance.

ઓપરેટિંગ સિસ્ટમની કામગીરીના સ્વભાવ પર એક ક્લાસિક પેપર.


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

આ વાંચવું મુશ્કેલ અને પીડાદાયક છે, તેથી જો તમે કરી શકો તો તેનાથી બચો.


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

આ તકનીક દૂષિત હુમલાઓ સામે બચાવવાનું વધુ મુશ્કેલ બનાવે છે, અરે.


Measurement homeworks are small exercises where you write code to run on a real machine.

માપન હોમવર્ક એ નાના કસરતો છે જ્યાં તમે વાસ્તવિક મશીન પર ચલાવવા માટે કોડ લખો છો.


Measuring the cost of a system call is relatively easy.

સિસ્ટમ કૉલની કિંમત માપવી પ્રમાણમાં સરળ છે.


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

તમે ઉપયોગ કરી શકો તેવું એક લાક્ષણિક ટાઈમર gettimeofday() છે; વિગતો માટે મેન પેજ વાંચો.


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

સંદર્ભ સ્વિચની કિંમત માપવી થોડી મુશ્કેલ છે.


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

તમે અહીં પાઈપોનો ઉપયોગ કરીને અથવા યુનિક્સ સોકેટ્સ જેવા અન્ય કેટલાક સંચાર મિકેનિઝમનો ઉપયોગ કરીને કંઈક સમાન ફરીથી બનાવવાનો પ્રયાસ કરી શકો છો.


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

બંને પ્રક્રિયાઓ સમાન પ્રોસેસર પર છે તેની ખાતરી કરીને, તમે ખાતરી કરો છો કે OS એક પ્રક્રિયાને રોકવા અને સમાન CPU પર બીજી પુનઃસ્થાપિત કરવાની કિંમત માપી રહ્યા છો.


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

હવે પછી પ્રક્રિયાઓ ચલાવવાના નીચા-સ્તરના મિકેનિઝમ્સ (દા.ત., સંદર્ભ સ્વિચિંગ) સ્પષ્ટ હોવા જોઈએ.


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

આપણે હવે તે જ કરીશું, વિવિધ સ્માર્ટ અને મહેનતુ લોકોએ વર્ષોથી વિકસાવેલી શેડ્યુલિંગ નીતિઓની શ્રેણી રજૂ કરીશું.


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

શેડ્યુલિંગની ઉત્પત્તિ, હકીકતમાં, કમ્પ્યુટર સિસ્ટમ્સ પહેલાંની છે.


Determining the workload is a critical part of building policies.

વર્કલોડ નક્કી કરવું એ નીતિઓ બનાવવા માટેનો એક મહત્વપૂર્ણ ભાગ છે.


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

અમે સિસ્ટમમાં ચાલી રહેલી પ્રક્રિયાઓ, જેને કેટલીકવાર નોકરીઓ કહેવામાં આવે છે, તેના વિશે નીચેની ધારણાઓ કરીશું:


Each job runs for the same amount of time.

દરેક નોકરી સમાન સમય માટે ચાલે છે.


A metric is just something that we use to measure something, and there are a number of different metrics that make sense in scheduling.

એક મેટ્રિક એ ફક્ત એક એવી વસ્તુ છે જેનો ઉપયોગ આપણે કંઈક માપવા માટે કરીએ છીએ, અને ત્યાં ઘણાં વિવિધ મેટ્રિક્સ છે જે શેડ્યુલિંગમાં અર્થપૂર્ણ છે.


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

નોકરીનો ટર્નઅરાઉન્ડ સમય એ સમય તરીકે વ્યાખ્યાયિત કરવામાં આવે છે કે જેના પર નોકરી પૂર્ણ થાય છે તે સમય બાદ સિસ્ટમમાં નોકરી આવી.


FIFO has a number of positive properties: it is clearly very simple and thus easy to implement.

FIFO માં ઘણી સકારાત્મક ગુણધર્મો છે: તે સ્પષ્ટપણે ખૂબ જ સરળ છે અને તેથી અમલમાં મૂકવું સરળ છે.


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

કલ્પના કરો કે ત્રણ નોકરીઓ સિસ્ટમમાં આવે છે, A, B, અને C, લગભગ તે જ સમયે.


The scheduler decides which process gets to use the CPU.

શેડ્યુલર નક્કી કરે છે કે કયો પ્રોસેસ CPU નો ઉપયોગ કરી શકે છે.


Overlapping operations can maximize system utilization.

ઓવરલેપિંગ કામગીરી સિસ્ટમનો ઉપયોગ મહત્તમ કરી શકે છે.


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

ઓપરેટિંગ સિસ્ટમ સામાન્ય રીતે દરેક કાર્યની લંબાઈ વિશે બહુ ઓછું જાણે છે.


The scheduler incorporates I/O by treating each CPU burst as a job.

શેડ્યુલર દરેક CPU બર્સ્ટને એક કાર્ય તરીકે ગણીને I/O ને સમાવે છે.


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

મલ્ટિ-લેવલ ફીડબેક કતાર શેડ્યુલિંગ માટે જાણીતી પદ્ધતિ છે.


The OS would like to optimize turnaround time.

ઓપરેટિંગ સિસ્ટમ ટર્નઅરાઉન્ડ સમયને ઑપ્ટિમાઇઝ કરવા માંગે છે.


The scheduler learns from the past to predict the future.

શેડ્યુલર ભવિષ્યની આગાહી કરવા માટે ભૂતકાળમાંથી શીખે છે.


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

MLFQ તેના અવલોકન કરેલા વર્તન પર આધારિત કાર્યની અગ્રતામાં ફેરફાર કરે છે.


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

જો કોઈ કાર્ય આખા સમયના સ્લાઇસનો ઉપયોગ કરે છે, તો તેની અગ્રતા ઘટાડવામાં આવે છે.


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

જો કોઈ કાર્ય સમયનો સ્લાઇસ પૂરો થાય તે પહેલાં CPU છોડી દે છે, તો તે તે જ અગ્રતા સ્તર પર રહે છે.


The algorithm is susceptible to gaming the scheduler.

એલ્ગોરિધમ શેડ્યુલરને ગેમિંગ માટે સંવેદનશીલ છે.


The priority boost helps prevent starvation.

અગ્રતા વધારો ભૂખમરો અટકાવવામાં મદદ કરે છે.


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

શેડ્યુલરે દરેક સ્તર પર CPU સમયનો ટ્રૅક રાખવો જોઈએ.


The goal is to share the CPU fairly between long-running jobs.

ધ્યેય લાંબા સમયથી ચાલતા કાર્યો વચ્ચે CPU ને યોગ્ય રીતે વહેંચવાનો છે.


The system administrator can configure the scheduler.

સિસ્ટમ એડમિનિસ્ટ્રેટર શેડ્યુલરને ગોઠવી શકે છે.


The time slice lengths can vary across different queues.

સમયના સ્લાઇસની લંબાઈ વિવિધ કતારોમાં બદલાઈ શકે છે.


The high-priority queues are usually given short time slices.

ઉચ્ચ-અગ્રતા કતારોને સામાન્ય રીતે ટૂંકા સમયના સ્લાઇસ આપવામાં આવે છે.


The low-priority queues contain long-running jobs.

નીચી-અગ્રતા કતારોમાં લાંબા સમયથી ચાલતા કાર્યો હોય છે.


The administrator can tweak the table to make the scheduler behave differently.

એડમિનિસ્ટ્રેટર શેડ્યુલરને અલગ રીતે વર્તવા માટે ટેબલમાં ફેરફાર કરી શકે છે.


The FreeBSD scheduler uses a formula to calculate the current priority level.

FreeBSD શેડ્યુલર વર્તમાન અગ્રતા સ્તરની ગણતરી કરવા માટે એક સૂત્રનો ઉપયોગ કરે છે.


આ પેપર લોટરી શેડ્યુલિંગની ચર્ચા કરે છે.


Lottery scheduling is a flexible proportional-share resource management technique.

લોટરી શેડ્યુલિંગ એ લવચીક પ્રમાણસર-શેર સંસાધન વ્યવસ્થાપન તકનીક છે.


This thesis outlines lottery and stride scheduling.

આ થીસીસ લોટરી અને સ્ટ્રાઈડ શેડ્યુલિંગનું વર્ણન કરે છે.


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

આ પેપર VMware ESX સર્વરમાં મેમરી સંસાધન વ્યવસ્થાપન વિશે છે.


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?

જ્યારે ટિકિટોની સંખ્યા આટલી અસંતુલિત હોય ત્યારે શું થાય છે?


Will job 0 ever run before job 1 completes?

શું નોકરી 0 નોકરી 1 પૂર્ણ થાય તે પહેલાં ક્યારેય ચાલશે?


In general, what does such a ticket imbalance do to the behavior of lottery scheduling?

સામાન્ય રીતે, આવી ટિકિટ અસંતુલન લોટરી શેડ્યુલિંગના વર્તન પર શું અસર કરે છે?


શેડ્યુલર કેટલું અન્યાયી છે?


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

ક્વોન્ટમનું કદ મોટું થતાં અગાઉના પ્રશ્નનો તમારો જવાબ કેવી રીતે બદલાય છે?


This chapter will introduce the basics of multiprocessor scheduling.

આ પ્રકરણ મલ્ટિપ્રોસેસર શેડ્યુલિંગની મૂળભૂત બાબતોનો પરિચય કરાવશે.


Multiprocessor systems are increasingly commonplace.

મલ્ટિપ્રોસેસર સિસ્ટમ્સ વધુને વધુ સામાન્ય બની રહી છે.


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

મલ્ટિકોર પ્રોસેસરનો ઉદય આ પ્રસારનું કારણ છે.


We all now have a few CPUs available to us.

હવે આપણી પાસે થોડા CPU ઉપલબ્ધ છે.


A primary one is that 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 પર નોકરીઓ કેવી રીતે શેડ્યૂલ કરવી જોઈએ?


To understand the new issues surrounding multiprocessor scheduling, we have to understand a new and fundamental difference.

મલ્ટિપ્રોસેસર શેડ્યુલિંગની આસપાસના નવા મુદ્દાઓને સમજવા માટે, આપણે એક નવો અને મૂળભૂત તફાવત સમજવો પડશે.


ઓપરેટિંગ સિસ્ટમ સીપીયુને વર્ચ્યુઅલાઈઝ કરે છે.


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

પ્રોગ્રામ ફંક્શન કોલ્સનો ટ્રૅક રાખવા માટે એક સ્ટેકનો ઉપયોગ કરે છે.


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

ઓપરેટિંગ સિસ્ટમ ખાતરી કરવા માંગે છે કે તે મશીનનો હવાલો સંભાળે.


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

સારું એન્જિનિયરિંગ તે રીતે હોઈ શકે છે. અને તે ઉત્થાનકારક પણ હોઈ શકે છે!


ઓપરેટિંગ સિસ્ટમ એકદમ પરેનૉઇડ છે.


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

ઓપરેટિંગ સિસ્ટમ દરેક પ્રોગ્રામને એવો દૃષ્ટિકોણ આપશે કે તેની પોતાની મોટી અને ખાનગી મેમરી છે.


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

આપણે એવું નથી ઈચ્છતા કે કોઈ એક ભૂલભરેલો પ્રોગ્રામ બીજા કોઈ પ્રોગ્રામની મેમરીને વાંચી શકે, અથવા તો તેનાથી ખરાબ, તેને ઓવરરાઈટ કરી શકે, ખરું ને?


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

ઓપરેટિંગ સિસ્ટમે વર્ચ્યુઅલ મેમરીને એવી રીતે અમલમાં મૂકવી જોઈએ કે જે ચાલતા પ્રોગ્રામ માટે અદ્રશ્ય હોય.


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

પ્રોગ્રામ કોડ એડ્રેસ સ્પેસની ટોચ પર રહે છે.


ઓપરેટિંગ સિસ્ટમ મેમરીને વર્ચ્યુઅલાઈઝ કરી રહ્યું છે.


The program really isn’t in memory at physical addresses.

પ્રોગ્રામ ખરેખર ભૌતિક સરનામાં પર મેમરીમાં નથી.


The OS will do this for many processes at once.

ઓપરેટિંગ સિસ્ટમ આ એકસાથે ઘણી પ્રક્રિયાઓ માટે કરશે.


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

ઓપરેટિંગ સિસ્ટમે વર્ચ્યુઅલાઈઝેશનને શક્ય તેટલું કાર્યક્ષમ બનાવવા પ્રયત્ન કરવો જોઈએ.


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

પ્રોગ્રામ એવું વર્તન કરે છે કે જાણે તેની પોતાની ખાનગી ભૌતિક મેમરી છે.


The OS should make sure to protect processes from one another.

ઓપરેટિંગ સિસ્ટમે ખાતરી કરવી જોઈએ કે પ્રક્રિયાઓ એકબીજાથી સુરક્ષિત છે.


The address space of a process contains all of the memory state of the running program.

પ્રક્રિયાના એડ્રેસ સ્પેસમાં ચાલતા પ્રોગ્રામની તમામ મેમરી સ્થિતિ શામેલ છે.


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

હીપનો ઉપયોગ ગતિશીલ રીતે ફાળવેલ, વપરાશકર્તા-સંચાલિત મેમરી માટે થાય છે.


Life, for a programmer, becomes much more tricky if you have to worry about fitting all of your code data into a small, crowded memory.

પ્રોગ્રામર માટે જીવન વધુ મુશ્કેલ બની જાય છે જો તમારે તમારા બધા કોડ ડેટાને નાની, ભીડવાળી મેમરીમાં ફિટ કરવાની ચિંતા કરવી પડે.


The OS is just providing an illusion to each process.

ઓપરેટિંગ સિસ્ટમ ફક્ત દરેક પ્રક્રિયાને એક ભ્રમ પૂરું પાડે છે.


We’ll start simple, with very basic techniques like base/bounds.

આપણે બેઝ/બાઉન્ડ્સ જેવી ખૂબ જ મૂળભૂત તકનીકોથી, સરળ શરૂઆત કરીશું.


વધુ માહિતી માટે મેન પેજ જુઓ.


We have described a scheduling approach known as the Multi-Level Feedback Queue (MLFQ).

આપણે મલ્ટિ-લેવલ ફીડબેક કતાર (MLFQ) તરીકે ઓળખાતા શેડ્યુલિંગ અભિગમનું વર્ણન કર્યું છે.


History is its guide: pay attention to how jobs behave over time and treat them accordingly.

ઇતિહાસ તેનો માર્ગદર્શક છે: સમય જતાં નોકરીઓ કેવી રીતે વર્તે છે તેના પર ધ્યાન આપો અને તે મુજબ તેમની સાથે વર્તન કરો.


As the operating system rarely knows what is best for each and every process of the system, it is often useful to provide interfaces to allow users or administrators to provide some hints to the OS.

ઓપરેટિંગ સિસ્ટમ ભાગ્યે જ જાણે છે કે સિસ્ટમના દરેક અને દરેક પ્રોસેસ માટે શું શ્રેષ્ઠ છે, તેથી વપરાશકર્તાઓ અથવા સંચાલકોને OS ને કેટલીક ટીપ્સ પ્રદાન કરવાની મંજૂરી આપવા માટે ઇન્ટરફેસ પ્રદાન કરવું ઘણીવાર ઉપયોગી છે.


Such hints are useful in many parts of the OS, including the scheduler (e.g., with nice), memory manager (e.g., madvise), and file system (e.g., TIP [P+95]).

આવી ટીપ્સ OS ના ઘણા ભાગોમાં ઉપયોગી છે, જેમાં શેડ્યુલર (દા.ત., સરસ સાથે), મેમરી મેનેજર (દા.ત., મેડવાઇઝ), અને ફાઇલ સિસ્ટમ (દા.ત., TIP [P+95]) નો સમાવેશ થાય છે.


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

નિયમ 1: જો પ્રાથમિકતા(A)>પ્રાથમિકતા(B), A ચાલે છે (B નહીં).


Rule 2: If Priority(A)=Priority(B), A & B run in RR.

નિયમ 2: જો પ્રાથમિકતા(A)=પ્રાથમિકતા(B), A અને B RR માં ચાલે છે.


Rule 3: When a job enters the system, it is placed at the highest priority (the topmost queue).

નિયમ 3: જ્યારે કોઈ નોકરી સિસ્ટમમાં પ્રવેશે છે, ત્યારે તેને સૌથી વધુ પ્રાથમિકતા (સૌથી ઉપરની કતાર) પર મૂકવામાં આવે છે.


MLFQ is interesting because instead of demanding a priori knowledge of the nature of a job, it instead observes the execution of a job and prioritizes it accordingly.

MLFQ રસપ્રદ છે કારણ કે નોકરીની પ્રકૃતિના પૂર્વ જ્ઞાનની માંગ કરવાને બદલે, તે તેના બદલે નોકરીના અમલનું અવલોકન કરે છે અને તે મુજબ તેને પ્રાથમિકતા આપે છે.


For this reason, many systems, including BSD UNIX derivatives [LM+89, B86], Solaris [M06], and Windows NT and subsequent Windows operating systems [CS97] use a form of MLFQ as their base scheduler.

આ કારણોસર, ઘણા સિસ્ટમો, જેમાં BSD UNIX ડેરિવેટિવ્ઝ [LM+89, B86], સોલારિસ [M06], અને વિન્ડોઝ NT અને ત્યારબાદના વિન્ડોઝ ઓપરેટિંગ સિસ્ટમ્સ [CS97] તેમના બેઝ શેડ્યુલર તરીકે MLFQ ના એક સ્વરૂપનો ઉપયોગ કરે છે.


In this chapter, we’ll examine a different type of scheduler known as a proportional-share scheduler, also sometimes referred to as a fair-share scheduler.

આ પ્રકરણમાં, અમે એક અલગ પ્રકારના શેડ્યુલરની તપાસ કરીશું જેને પ્રમાણસર-શેર શેડ્યુલર તરીકે ઓળખવામાં આવે છે, જેને કેટલીકવાર ફેર-શેર શેડ્યુલર તરીકે પણ ઓળખવામાં આવે છે.


Proportional-share is based around a simple concept: instead of optimizing for turnaround or response time, a scheduler might instead try to guarantee that each job obtain a certain percentage of CPU time.

પ્રમાણસર-શેર એક સરળ ખ્યાલ પર આધારિત છે: ટર્નઅરાઉન્ડ અથવા પ્રતિભાવ સમય માટે ઑપ્ટિમાઇઝ કરવાને બદલે, શેડ્યુલર તેના બદલે ખાતરી કરવાનો પ્રયાસ કરી શકે છે કે દરેક નોકરી CPU સમયનો ચોક્કસ ટકાવારી મેળવે.


The basic idea is quite simple: every so often, hold a lottery to determine which process should get to run next; processes that should run more often should be given more chances to win the lottery.

મૂળભૂત વિચાર એકદમ સરળ છે: દર વખતે, કયો પ્રોસેસ આગળ ચાલવો જોઈએ તે નક્કી કરવા માટે લોટરી યોજો; જે પ્રોસેસ વધુ વખત ચાલવા જોઈએ તેમને લોટરી જીતવાની વધુ તકો મળવી જોઈએ.


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

કલ્પના કરો કે બે પ્રોસેસ છે, A અને B, અને વધુમાં A પાસે 75 ટિકિટ છે જ્યારે B પાસે માત્ર 25 છે.


Thus, what we would like is for A to receive 75% of the CPU and B the remaining 25%.

આમ, આપણે શું ઈચ્છીએ છીએ કે A ને CPUનો 75% અને B ને બાકીનો 25% મળે.


Lottery scheduling achieves this probabilistically (but not deterministically) by holding a lottery every so often (say, every timeslice).

લોટરી શેડ્યુલિંગ આને સંભાવનાપૂર્વક (પરંતુ નિશ્ચિતપણે નહીં) દર વખતે લોટરી યોજીને (કહો, દરેક ટાઇમસ્લાઇસ) પ્રાપ્ત કરે છે.


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

પછી શેડ્યુલર વિજેતા ટિકિટ પસંદ કરે છે, જે 0 થી 99 સુધીની સંખ્યા છે.


As you can see from the example, the use of randomness in lottery scheduling leads to a probabilistic correctness in meeting the desired proportion, but no guarantee.

જેમ તમે ઉદાહરણ પરથી જોઈ શકો છો, લોટરી શેડ્યુલિંગમાં રેન્ડમનેસનો ઉપયોગ ઇચ્છિત પ્રમાણને પહોંચી વળવામાં સંભાવનાપૂર્વક સાચો પરિણામ આપે છે, પરંતુ કોઈ ગેરંટી નથી.


One way is with the concept of ticket currency.

એક રસ્તો ટિકિટ ચલણની વિભાવના સાથે છે.


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

ટ્રાન્સફર સાથે, એક પ્રોસેસ તેની ટિકિટોને અસ્થાયી રૂપે બીજી પ્રોસેસને સોંપી શકે છે.


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

ઓપરેટિંગ સિસ્ટમ, થોડા હાર્ડવેર સપોર્ટ સાથે, કાર્યરત પ્રોગ્રામથી દૂર રહેવાનો શ્રેષ્ઠ પ્રયાસ કરે છે, જેથી કાર્યક્ષમ વર્ચ્યુઅલાઈઝેશન પ્રદાન કરી શકાય.


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 while providing the desired virtualization.

મેમરીને વર્ચ્યુઅલાઈઝ કરવામાં, અમે સમાન વ્યૂહરચના અપનાવીશું, ઇચ્છિત વર્ચ્યુઅલાઈઝેશન પ્રદાન કરતી વખતે કાર્યક્ષમતા અને નિયંત્રણ બંને પ્રાપ્ત કરીશું.


Efficiency dictates that we make use of hardware support, which at first will be quite rudimentary.

કાર્યક્ષમતા સૂચવે છે કે આપણે હાર્ડવેર સપોર્ટનો ઉપયોગ કરીએ, જે શરૂઆતમાં એકદમ પ્રાથમિક હશે.


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

નિયંત્રણ સૂચવે છે કે ઓપરેટિંગ સિસ્ટમ ખાતરી કરે છે કે કોઈપણ એપ્લિકેશનને તેની પોતાની સિવાયની કોઈપણ મેમરીને ઍક્સેસ કરવાની મંજૂરી નથી.


Thus, to protect applications from one another, and the OS from applications, we will need help from the hardware here too.

આમ, એપ્લિકેશનોને એકબીજાથી અને ઓપરેટિંગ સિસ્ટમને એપ્લિકેશનોથી બચાવવા માટે, આપણે અહીં પણ હાર્ડવેરની મદદની જરૂર પડશે.


Finally, we will need a little more from the VM system, in terms of flexibility.

છેવટે, આપણે લવચીકતાની દ્રષ્ટિએ VM સિસ્ટમમાંથી થોડું વધારે જોઈએ છીએ.


Specifically, we’d like for programs to be able to use their address spaces in whatever way they would like, thus making the system easier to program.

ખાસ કરીને, અમે ઇચ્છીએ છીએ કે પ્રોગ્રામ્સ તેમની એડ્રેસ સ્પેસનો ઉપયોગ તેઓ ઇચ્છે તે રીતે કરી શકે, આમ સિસ્ટમને પ્રોગ્રામ કરવાનું સરળ બનાવે છે.


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, and thus ensure that application memory accesses are properly restricted?

આપણે કયા મેમરી સ્થાનોને એપ્લિકેશન ઍક્સેસ કરી શકે છે તેના પર નિયંત્રણ કેવી રીતે જાળવીએ છીએ, અને આમ ખાતરી કરીએ છીએ કે એપ્લિકેશન મેમરીની ઍક્સેસ યોગ્ય રીતે પ્રતિબંધિત છે?


આપણે આ બધું કાર્યક્ષમ રીતે કેવી રીતે કરીએ?


The generic technique we will use is something that is referred to as hardware-based address translation, or just address translation for short.

આપણે જે સામાન્ય તકનીકનો ઉપયોગ કરીશું તે હાર્ડવેર-આધારિત એડ્રેસ ટ્રાન્સલેશન તરીકે ઓળખાય છે, અથવા ટૂંકમાં એડ્રેસ ટ્રાન્સલેશન.


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

એડ્રેસ ટ્રાન્સલેશન સાથે, હાર્ડવેર દરેક મેમરી એક્સેસને રૂપાંતરિત કરે છે, સૂચના દ્વારા પૂરા પાડવામાં આવેલ વર્ચ્યુઅલ એડ્રેસને ભૌતિક સરનામામાં બદલી નાખે છે.


Thus, the desired information is actually located.

આમ, ઇચ્છિત માહિતી વાસ્તવમાં સ્થિત છે.


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

ઉદાહરણ તરીકે, ચાલો કહીએ કે તમને ફંક્શન func() માં x નામના ઇન્ટીજર માટે થોડી જગ્યાની જરૂર છે.


To declare such a piece of memory, you just do something like this: void func() { int x; // declares an integer on the stack ... }

આવા મેમરીના ટુકડાને જાહેર કરવા માટે, તમે ફક્ત આના જેવું કંઈક કરો છો: void func() { int x; // સ્ટેક પર એક પૂર્ણાંક જાહેર કરે છે ... }


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

કમ્પાઇલર બાકીનું કામ કરે છે, જ્યારે તમે func() માં કૉલ કરો છો ત્યારે સ્ટેક પર જગ્યા બનાવવાની ખાતરી કરે છે.


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

જ્યારે તમે ફંક્શનમાંથી પાછા ફરો છો, ત્યારે કમ્પાઇલર તમારા માટે મેમરીને ડીએલોકેટ કરે છે.


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

લાંબા સમય સુધી ચાલતી મેમરીની આ જરૂરિયાત છે જે આપણને બીજા પ્રકારની મેમરી તરફ દોરી જાય છે, જેને હીપ મેમરી કહેવામાં આવે છે.


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

ઓએસ મેમરીનું સંચાલન કરવું જોઈએ, કયા સ્થાનો ખાલી છે અને કયા ઉપયોગમાં છે તેનો ટ્રૅક રાખવો જોઈએ.


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

વર્ચ્યુઅલાઈઝેશન દ્વારા, ઓએસ ખરાબ મશીન વાસ્તવિકતાને ઉપયોગી, શક્તિશાળી અને ઉપયોગમાં સરળ એબ્સ્ટ્રેક્શનમાં ફેરવે છે.


Don’t like the idea of the OS laughing at you? Well, you may be out of luck then; that’s just how the OS rolls.

ઓએસ તમને હસશે તે વિચાર ગમતો નથી? ઠીક છે, તો તમે કદાચ કમનસીબ હશો; ઓએસ આ રીતે જ કામ કરે છે.


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

આપણે એ પણ ધારીશું, સરળતા માટે, કે એડ્રેસ સ્પેસનું કદ બહુ મોટું નથી.


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

એડ્રેસ ટ્રાન્સલેશનને અમલમાં મૂકવા માટે આપણે શું કરવાની જરૂર છે તે વધુ સારી રીતે સમજવા માટે, ચાલો એક સરળ ઉદાહરણ જોઈએ.


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

કલ્પના કરો કે એક પ્રક્રિયા છે જેની એડ્રેસ સ્પેસ આકૃતિ 15.1 માં દર્શાવેલ છે.


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

કમ્પાઇલર આ કોડની લાઇનને એસેમ્બલીમાં ફેરવે છે, જે આના જેવી દેખાઈ શકે છે.


This code snippet is relatively straightforward.

આ કોડ સ્નિપેટ પ્રમાણમાં સીધો છે.


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

પ્રોગ્રામના દૃષ્ટિકોણથી, તેની એડ્રેસ સ્પેસ એડ્રેસ 0 થી શરૂ થાય છે અને વધુમાં વધુ 16 KB સુધી વધે છે.


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

આ પ્રક્રિયાને મેમરીમાં એવી રીતે કેવી રીતે ખસેડી શકીએ કે જે પ્રક્રિયા માટે પારદર્શક હોય?


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

આ પ્રક્રિયાની એડ્રેસ સ્પેસ મેમરીમાં મૂક્યા પછી ભૌતિક મેમરી કેવી દેખાઈ શકે છે તેનું એક ઉદાહરણ આકૃતિ 15.2 માં જોવા મળે છે.


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

આ આકૃતિમાં, તમે જોઈ શકો છો કે ઓએસ તેના માટે ભૌતિક મેમરીના પ્રથમ સ્લોટનો ઉપયોગ કરી રહ્યું છે.


Specifically, we’ll need two hardware registers within each CPU: one is called the base register, and the other the bounds.

ખાસ કરીને, આપણને દરેક CPU ની અંદર બે હાર્ડવેર રજિસ્ટરની જરૂર પડશે: એકને બેઝ રજિસ્ટર કહેવામાં આવે છે, અને બીજાને બાઉન્ડ્સ કહેવામાં આવે છે.


In this setup, each program is written and compiled as if it is loaded at address zero.

આ સેટઅપમાં, દરેક પ્રોગ્રામ એ રીતે લખવામાં અને કમ્પાઇલ કરવામાં આવે છે જાણે તે એડ્રેસ શૂન્ય પર લોડ થયેલ હોય.


Now, when any memory reference is generated by the process, it is translated by the processor in the following manner.

હવે, જ્યારે પણ પ્રક્રિયા દ્વારા કોઈપણ મેમરી સંદર્ભ જનરેટ થાય છે, ત્યારે તે નીચેની રીતે પ્રોસેસર દ્વારા અનુવાદિત થાય છે.


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

વર્ચ્યુઅલ એડ્રેસને ભૌતિક એડ્રેસમાં રૂપાંતરિત કરવું એ બરાબર તે જ તકનીક છે જેને આપણે એડ્રેસ ટ્રાન્સલેશન તરીકે ઓળખીએ છીએ.


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

ડાયનેમિક રિલોકેશન સાથે, આપણે જોઈ શકીએ છીએ કે થોડું હાર્ડવેર કેટલું આગળ જાય છે.


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

જ્યારે કોઈ પ્રક્રિયા બનાવવામાં આવે છે, ત્યારે ઓએસએ પગલાં લેવા જોઈએ, મેમરીમાં તેની એડ્રેસ સ્પેસ માટે જગ્યા શોધવી.


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

જ્યારે સંદર્ભ સ્વિચ થાય છે ત્યારે પણ ઓએસએ પગલાં લેવા જોઈએ.


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

આ પ્રકરણમાં, અમે વર્ચ્યુઅલ મેમરીમાં વપરાતી એક વિશિષ્ટ પદ્ધતિ સાથે મર્યાદિત ડાયરેક્ટ એક્ઝેક્યુશનની વિભાવનાને વિસ્તૃત કરી છે, જેને એડ્રેસ ટ્રાન્સલેશન તરીકે ઓળખવામાં આવે છે.


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

વિચાર સરળ છે: આપણા MMU માં એક જ બેઝ અને બાઉન્ડ્સની જોડી રાખવાને બદલે, શા માટે એડ્રેસ સ્પેસના દરેક લોજિકલ સેગમેન્ટ માટે બેઝ અને બાઉન્ડ્સની જોડી ન રાખવી?


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

એક સેગમેન્ટ એ ચોક્કસ લંબાઈની એડ્રેસ સ્પેસનો એક સતત ભાગ છે.


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

સેગ્મેન્ટેશન ઓએસને જે કરવાની મંજૂરી આપે છે તે એ છે કે તે ભૌતિક મેમરીના જુદા જુદા ભાગોમાં તે દરેક સેગમેન્ટને મૂકે છે.


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.

જ્યારે સંદર્ભ થાય છે (કહો, સૂચના મેળવવા પર), હાર્ડવેર બેઝ મૂલ્યને આ સેગમેન્ટમાં ઑફસેટમાં ઉમેરશે.


It will then check that the address is within bounds (100 is less than 2KB), find that it is, and issue the reference to physical memory address 32868.

પછી તે તપાસશે કે સરનામું બાઉન્ડ્સની અંદર છે (100 2KB કરતા ઓછું છે), તે શોધી કાઢશે અને ભૌતિક મેમરી સરનામાં 32868 નો સંદર્ભ જારી કરશે.


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.


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

જો આપણે વર્ચ્યુઅલ એડ્રેસ 4200 ને હીપના બેઝ (34KB) માં ઉમેરીએ, તો આપણને 39016 નું ભૌતિક સરનામું મળે છે, જે સાચું ભૌતિક સરનામું નથી.


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 છે.


We then take this offset (104) and add it to the base register physical address (34K or 34816) to get the desired result: 34920.

પછી અમે આ ઑફસેટ (104) લઈએ છીએ અને તેને બેઝ રજીસ્ટર ભૌતિક સરનામાં (34K અથવા 34816) માં ઉમેરીએ છીએ, ઇચ્છિત પરિણામ મેળવવા માટે: 34920.


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.

હાર્ડવેર અનુવાદ દરમિયાન સેગમેન્ટ રજીસ્ટરનો ઉપયોગ કરે છે.


The figure shows an example of this problem.

આ આકૃતિ આ સમસ્યાનું ઉદાહરણ દર્શાવે છે.


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

આ કિસ્સામાં, ઉપલબ્ધ કુલ ખાલી જગ્યા 20 બાઇટ્સ છે.


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

પરિણામે, 15 બાઇટ્સની વિનંતી નિષ્ફળ જશે, ભલે 20 બાઇટ્સ ખાલી હોય.


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

ચલ કદની વિનંતીઓને સંતોષતી વખતે ખાલી જગ્યાનું સંચાલન કેવી રીતે કરવું જોઈએ?


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

અમે માનીએ છીએ કે malloc() અને free() દ્વારા પ્રદાન કરવામાં આવેલ એક મૂળભૂત ઇન્ટરફેસ છે.


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

ખાસ કરીને, void * malloc(size t size) એક જ પરિમાણ, size લે છે.


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

પૂરક રૂટિન void free(void * ptr) એક પોઇન્ટર લે છે અને અનુરૂપ ભાગને મુક્ત કરે છે.


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

જગ્યા ખાલી કરતી વખતે, વપરાશકર્તા તેના કદ વિશે લાઇબ્રેરીને જાણ કરતો નથી.


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

આ લાઇબ્રેરી જે જગ્યાનું સંચાલન કરે છે તે ઐતિહાસિક રીતે હીપ તરીકે ઓળખાય છે.


We further assume that primarily we are concerned with external fragmentation.

વધુમાં, અમે એવું માનીએ છીએ કે મુખ્યત્વે આપણે બાહ્ય વિભાજનથી સંબંધિત છીએ.


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

એલોકેટર, અલબત્ત, આંતરિક વિભાજનની સમસ્યા પણ ધરાવી શકે છે.


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

અમે એ પણ ધારીશું કે એકવાર મેમરી ક્લાયન્ટને સોંપી દેવામાં આવે છે, તે ફરીથી સ્થાનાંતરિત થઈ શકતી નથી.


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

જો કે, વિભાજન સાથે વ્યવહાર કરવા માટે OS માં કોમ્પેક્શનનો ઉપયોગ કરી શકાય છે.


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

સૌ પ્રથમ, અમે મોટાભાગના એલોકેટર્સમાં વપરાતી કેટલીક સામાન્ય પદ્ધતિઓ પર ધ્યાન આપીશું.


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

એક ફ્રી લિસ્ટમાં એવા તત્વોનો સમૂહ છે જે ખાલી જગ્યાનું વર્ણન કરે છે.


A request for anything greater than 10 bytes will fail.

10 બાઇટ્સ કરતાં વધુની કોઈપણ વિનંતી નિષ્ફળ જશે.


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

ધારો કે અમારી પાસે માત્ર એક જ બાઇટ મેમરીની વિનંતી છે.


The allocator will perform an action known as splitting.

એલોકેટર સ્પ્લિટિંગ તરીકે ઓળખાતી ક્રિયા કરશે.


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

ઘણા એલોકેટર્સમાં જોવા મળતી એક પૂરક પદ્ધતિને ખાલી જગ્યાના કોએલેસિંગ તરીકે ઓળખવામાં આવે છે.


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

વિચાર સરળ છે: જ્યારે મેમરીમાં ફ્રી ચંક પાછો આપો, ત્યારે કાળજીપૂર્વક જુઓ.


Engineers like Jeff Bonwick are the heart of Silicon Valley.

જેફ બોનવિક જેવા ઇજનેરો સિલિકોન વેલીનું હૃદય છે.


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

લગભગ કોઈપણ મહાન ઉત્પાદન અથવા તકનીકીની પાછળ એક એવું માનવ છે જે સરેરાશથી ઘણું વધારે છે.


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

સખત મહેનત કરો અને તમે પણ એવા “100x” વ્યક્તિ બની શકો છો.


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 freed objects in a particular list in their initialized state, the slab allocator thus avoids frequent initialization and destruction cycles per object.

મુક્ત વસ્તુઓને તેમની પ્રારંભિક સ્થિતિમાં ચોક્કસ યાદીમાં રાખીને, સ્લેબ એલોકેટર આ રીતે ઑબ્જેક્ટ દીઠ વારંવાર પ્રારંભિકરણ અને વિનાશ ચક્રને ટાળે છે.


One good example is found in the binary buddy allocator.

એક સારું ઉદાહરણ બાઈનરી બડી એલોકેટરમાં જોવા મળે છે.


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

જ્યારે મેમરીની વિનંતી કરવામાં આવે છે, ત્યારે ખાલી જગ્યાની શોધ પુનરાવર્તિત રીતે ખાલી જગ્યાને બે ભાગમાં વહેંચે છે.


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

આ બિંદુએ, વિનંતી કરાયેલ બ્લોક વપરાશકર્તાને પરત કરવામાં આવે છે.


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

ઉદાહરણમાં, ડાબી બાજુનો 8KB બ્લોક ફાળવવામાં આવે છે અને વપરાશકર્તાને પરત કરવામાં આવે છે.


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

બડી એલોકેશનની સુંદરતા એ છે કે જ્યારે તે બ્લોક મુક્ત થાય છે ત્યારે શું થાય છે.


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

8KB બ્લોકને ફ્રી લિસ્ટમાં પરત કરતી વખતે, એલોકેટર તપાસે છે કે “બડી” 8KB ફ્રી છે કે નહીં.


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

બડી એલોકેશન આટલું સરસ રીતે કામ કરે છે તેનું કારણ એ છે કે કોઈ ચોક્કસ બ્લોકના બડીને નિર્ધારિત કરવું સરળ છે.


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

ઉપરની ખાલી જગ્યામાં બ્લોક્સના સરનામાંઓ વિશે વિચારો.


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.

ખાસ કરીને, યાદીઓ શોધવી ઘણી ધીમી હોઈ શકે છે.


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

આ પ્રકરણમાં, અમે મેમરી એલોકેટરના સૌથી પ્રાથમિક સ્વરૂપોની ચર્ચા કરી છે.


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

આવા એલોકેટર દરેક જગ્યાએ અસ્તિત્વમાં છે, જે તમે લખો છો તે દરેક C પ્રોગ્રામમાં લિંક થયેલ છે.


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

ઘણા સિસ્ટમની જેમ, આવી સિસ્ટમ બનાવવા માટે ઘણા વેપાર-બંધો છે.


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 (unrealistically small).

આપણે 64KB (અવાસ્તવિક રીતે નાનું) કદની વર્ચ્યુઅલ એડ્રેસ સ્પેસ ધારીએ છીએ.


આપણે 1 KB નું પેજ કદ પણ ધારીએ છીએ.


Let’s assume we have a linear (array-based) page table and that it is located at physical address 1 KB (1024).

ચાલો ધારીએ કે આપણી પાસે રેખીય (એરે-આધારિત) પેજ ટેબલ છે અને તે ભૌતિક સરનામાં 1 KB (1024) પર સ્થિત છે.


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

પ્રથમ, ત્યાં વર્ચ્યુઅલ પૃષ્ઠ છે જેના પર કોડ રહે છે.


Because the page size is 1 KB, virtual address 1024 resides on the the second page of the virtual address space.

કારણ કે પૃષ્ઠનું કદ 1 KB છે, વર્ચ્યુઅલ સરનામું 1024 વર્ચ્યુઅલ સરનામાંની જગ્યાના બીજા પૃષ્ઠ પર રહે છે.


Let’s assume these virtual-to- physical mappings for the example: (VPN 39→PFN 7), (VPN 40→PFN 8), (VPN 41→PFN 9), (VPN 42→PFN 10).

ચાલો આ ઉદાહરણ માટે વર્ચ્યુઅલ-થી-ભૌતિક મેપિંગ ધારીએ: (VPN 39→PFN 7), (VPN 40→PFN 8), (VPN 41→PFN 9), (VPN 42→PFN 10).


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

જ્યારે તે ચાલે છે, ત્યારે દરેક સૂચના ફેચ બે મેમરી સંદર્ભો ઉત્પન્ન કરશે.


In addition, there is one explicit memory reference in the form of the mov instruction.

વધુમાં, mov સૂચનાના સ્વરૂપમાં એક સ્પષ્ટ મેમરી સંદર્ભ છે.


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

પ્રથમ પાંચ લૂપ પુનરાવર્તનો માટેની સમગ્ર પ્રક્રિયા, આકૃતિ 18.7 માં દર્શાવવામાં આવી છે.


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

જુઓ કે શું તમે આ વિઝ્યુલાઇઝેશનમાં દેખાતી પેટર્નનો અર્થ સમજી શકો છો.


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

આપણે મેમરીને વર્ચ્યુઅલાઈઝ કરવાના અમારા પડકારના ઉકેલ તરીકે પેજિંગની વિભાવના રજૂ કરી છે.


Paging has many advantages over previous approaches (such as segmentation).

પેજિંગના અગાઉના અભિગમો (જેમ કે સેગ્મેન્ટેશન) કરતાં ઘણા ફાયદા છે.


First, it does not lead to external fragmentation, as paging (by design) divides memory into fixed-sized units.

પ્રથમ, તે બાહ્ય વિભાજન તરફ દોરી જતું નથી, કારણ કે પેજિંગ (ડિઝાઇન દ્વારા) મેમરીને નિશ્ચિત કદના એકમોમાં વિભાજિત કરે છે.


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

બીજું, તે એકદમ લવચીક છે, જે વર્ચ્યુઅલ એડ્રેસ સ્પેસના વિરલ ઉપયોગને સક્ષમ કરે છે.


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

જો કે, કાળજી વગર પેજિંગ સપોર્ટનો અમલ ધીમી મશીન તરફ દોરી જશે.


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

CISC પાછળનો વિચાર એ હતો કે સૂચનાઓ ઉચ્ચ-સ્તરની આદિમ હોવી જોઈએ.


RISC instruction sets are exactly the opposite.

RISC સૂચના સેટ બરાબર વિરુદ્ધ છે.


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

RISC પાછળનું મુખ્ય અવલોકન એ છે કે સૂચના સેટ ખરેખર કમ્પાઇલર લક્ષ્યો છે.


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

શરૂઆતના દિવસોમાં, RISC ચિપ્સે મોટો પ્રભાવ પાડ્યો, કારણ કે તે નોંધપાત્ર રીતે ઝડપી હતા.


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

અંતિમ પરિણામ એ છે કે ચર્ચા શાંત થઈ ગઈ, અને આજે બંને પ્રકારના પ્રોસેસર્સને ઝડપી ચલાવી શકાય છે.


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

એક લાક્ષણિક TLB માં 32, 64, અથવા 128 એન્ટ્રીઓ હોઈ શકે છે.


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

મૂળભૂત રીતે, આનો અર્થ એ છે કે કોઈપણ આપેલ અનુવાદ TLB માં ગમે ત્યાં હોઈ શકે છે.


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

એક લાક્ષણિક TLB એન્ટ્રી આના જેવી દેખાઈ શકે છે: VPN PFN અન્ય બીટ્સ


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

એક સામાન્ય ભૂલ એ છે કે TLB માં જોવા મળતા માન્ય બીટ્સને પેજ ટેબલમાં જોવા મળતા બીટ્સ સાથે મૂંઝવણ કરવી.


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

જ્યારે સિસ્ટમ બૂટ થાય છે, ઉદાહરણ તરીકે, દરેક TLB એન્ટ્રી માટે સામાન્ય પ્રારંભિક સ્થિતિ અમાન્ય પર સેટ થવાની છે.


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

સંદર્ભ સ્વિચ કરતી વખતે પણ TLB માન્ય બીટ ખૂબ જ ઉપયોગી છે.


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

બધી TLB એન્ટ્રીઓને અમાન્ય પર સેટ કરીને, સિસ્ટમ ખાતરી કરી શકે છે કે ચાલવાની પ્રક્રિયા અગાઉની પ્રક્રિયામાંથી વર્ચ્યુઅલ-ટુ-ફિઝિકલ અનુવાદનો આકસ્મિક ઉપયોગ કરતી નથી.


વધુ રસપ્રદ છે “અન્ય બીટ્સ”.


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

ઉદાહરણ તરીકે, TLB માં સામાન્ય રીતે એક માન્ય બીટ હોય છે, જે કહે છે કે એન્ટ્રીમાં માન્ય અનુવાદ છે કે નહીં.


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

TLB સાથે, પ્રક્રિયાઓ વચ્ચે સ્વિચ કરતી વખતે કેટલીક નવી સમસ્યાઓ ઊભી થાય છે.


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

ખાસ કરીને, TLB માં વર્ચ્યુઅલ-ટુ-ફિઝિકલ અનુવાદો છે જે ફક્ત હાલમાં ચાલી રહેલી પ્રક્રિયા માટે જ માન્ય છે.


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

જ્યારે એક પ્રક્રિયા (P1) ચાલી રહી છે, ત્યારે તે ધારે છે કે TLB એવા અનુવાદોને કેશ કરી શકે છે જે તેના માટે માન્ય છે.


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

જો બંને પ્રક્રિયાઓ માટેની એન્ટ્રીઓ TLB માં હોત, તો TLB ની સામગ્રી આ હશે:


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

પ્રક્રિયાઓ વચ્ચે સંદર્ભ-સ્વિચિંગ કરતી વખતે, છેલ્લી પ્રક્રિયા માટે TLB માંના અનુવાદો ચાલવાની પ્રક્રિયા માટે અર્થપૂર્ણ નથી.


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

એક અભિગમ એ છે કે સંદર્ભ સ્વિચ પર TLB ને સરળતાથી ફ્લશ કરવું, આમ આગામી પ્રક્રિયા ચલાવતા પહેલા તેને ખાલી કરવું.


સૌ પ્રથમ, હાર્ડવેર TLB તપાસે છે.


If the VPN is not found in the TLB, the hardware locates the page table in memory.

જો VPN TLB માં ન મળે, તો હાર્ડવેર મેમરીમાં પેજ ટેબલ શોધે છે.


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

પેજ ફોલ્ટને સેવા આપવા માટે OS એ પેજને મેમરીમાં સ્વેપ કરવાની જરૂર પડશે.


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

આધુનિક સિસ્ટમમાં, આ ભૂમિકા સામાન્ય રીતે હાર્ડ ડિસ્ક ડ્રાઇવ દ્વારા પૂરી પાડવામાં આવે છે.


The OS will be free to run other ready processes while the page fault is being serviced.

પેજ ફોલ્ટની સેવા આપવામાં આવી રહી હોય ત્યારે OS અન્ય તૈયાર પ્રક્રિયાઓ ચલાવવા માટે મુક્ત રહેશે.


We have now seen how real page tables are built.

હવે આપણે જોયું છે કે વાસ્તવિક પેજ ટેબલ કેવી રીતે બનાવવામાં આવે છે.


The program is called, perhaps unsurprisingly: paging-multilevel-translate.py.

પ્રોગ્રામને કહેવામાં આવે છે, કદાચ આશ્ચર્યજનક નથી: paging-multilevel-translate.py.


With a large address space, you don’t have to worry about if there is room enough in memory.

મોટા એડ્રેસ સ્પેસ સાથે, તમારે ચિંતા કરવાની જરૂર નથી કે મેમરીમાં પૂરતી જગ્યા છે કે નહીં.


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

OS એ આપેલ પેજનું ડિસ્ક એડ્રેસ યાદ રાખવાની જરૂર પડશે.


The size of the swap space is important.

સ્વેપ સ્પેસનું કદ મહત્વપૂર્ણ છે.


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

જો પ્રેઝન્ટ બીટ એક પર સેટ કરેલ હોય, તો તેનો અર્થ એ છે કે પેજ ભૌતિક મેમરીમાં હાજર છે.


The hardware first checks the TLB; upon a hit, the physical address is formed directly.

હાર્ડવેર સૌ પ્રથમ TLB તપાસે છે; હિટ થવા પર, ભૌતિક સરનામું સીધું જ બને છે.


The OS is invoked to service the page fault.

પેજ ફોલ્ટની સેવા આપવા માટે OS ને બોલાવવામાં આવે છે.


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

OS ડિસ્ક એડ્રેસ માટે પેજના PFN જેવા ડેટા માટે સામાન્ય રીતે ઉપયોગમાં લેવાતા PTE માંના બીટ્સનો ઉપયોગ કરી શકે છે.


When the disk I/O completes, the OS will then update the page table.

જ્યારે ડિસ્ક I/O પૂર્ણ થાય છે, ત્યારે OS પેજ ટેબલને અપડેટ કરશે.


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

પેજને બહાર કાઢવા અથવા બદલવાની પ્રક્રિયાને પેજ-રિપ્લેસમેન્ટ નીતિ તરીકે ઓળખવામાં આવે છે.


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

હાર્ડવેર સૌ પ્રથમ TLB તપાસે છે; હિટ થવા પર, ભૌતિક સરનામું પેજ ટેબલને બિલકુલ ઍક્સેસ કર્યા વિના સીધું જ બને છે.


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

મેમરી-પ્રતિબંધિત સિસ્ટમમાં, નાના માળખાં અર્થપૂર્ણ છે.


The OS will need a place to stash away portions of address spaces.

OS ને એડ્રેસ સ્પેસના ભાગોને છુપાવવા માટે એક સ્થાનની જરૂર પડશે.


The combination of multiprogramming and ease-of-use leads us to want to support using more memory than is physically available.

મલ્ટિપ્રોગ્રામિંગ અને ઉપયોગમાં સરળતાનું સંયોજન આપણને ભૌતિક રીતે ઉપલબ્ધ કરતાં વધુ મેમરીનો ઉપયોગ કરવા માંગે છે.


The operating system manages the computer's resources.

ઓપરેટિંગ સિસ્ટમ કમ્પ્યુટરના સંસાધનોનું સંચાલન કરે છે.


કૃપા કરીને એપ્લિકેશન બંધ કરો.


સમાચારોએ મોટા ભૂકંપની જાણ કરી.


I am going to the market to buy groceries.

હું કરિયાણું ખરીદવા બજારમાં જઈ રહ્યો છું.


The company announced its quarterly earnings.

કંપનીએ તેની ત્રિમાસિક કમાણીની જાહેરાત કરી.


The algorithm efficiently sorts the data.

અલ્ગોરિધમ ડેટાને કાર્યક્ષમ રીતે સૉર્ટ કરે છે.


The government implemented new policies to boost the economy.

સરકારે અર્થતંત્રને વેગ આપવા માટે નવી નીતિઓ લાગુ કરી.


Despite the challenges, they persevered and succeeded.

પડકારો હોવા છતાં, તેઓ ટકી રહ્યા અને સફળ થયા.


The research paper explores the impact of climate change.

સંશોધન પત્ર આબોહવા પરિવર્તનની અસરની ચર્ચા કરે છે.


The teacher explained the concept in detail.

શિક્ષકે વિભાવનાને વિગતવાર સમજાવી.


સોફ્ટવેર અપડેટએ ઘણા બગ્સને ઠીક કર્યા.


વાટાઘાટો એક ગતિરોધ પર પહોંચી.


The artist's work is known for its vibrant colors.

કલાકારનું કાર્ય તેના વાઇબ્રન્ટ રંગો માટે જાણીતું છે.


The complex system requires careful maintenance.

જટિલ સિસ્ટમ માટે સાવચેતીપૂર્વક જાળવણીની જરૂર છે.


The economic forecast predicts a period of growth.

આર્થિક આગાહી વૃદ્ધિના સમયગાળાની આગાહી કરે છે.


The philosophical debate explored the nature of reality.

તત્વજ્ઞાનની ચર્ચાએ વાસ્તવિકતાના સ્વભાવની ચર્ચા કરી.


The scientific study investigated the effects of the drug.

વૈજ્ઞાનિક અભ્યાસએ દવાની અસરોની તપાસ કરી.


The historical analysis revealed new insights into the past.

ઐતિહાસિક વિશ્લેષણે ભૂતકાળમાં નવી આંતરદૃષ્ટિ જાહેર કરી.


The intricate design of the building was admired by all.

બિલ્ડિંગની જટિલ ડિઝાઇનને બધાએ વખાણી.


The company's innovative approach revolutionized the industry.

કંપનીના નવીન અભિગમે ઉદ્યોગમાં ક્રાંતિ લાવી.


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.

સરળ એરે-આધારિત પેજ ટેબલ (સામાન્ય રીતે લિનિયર પેજટેબલ કહેવાય છે) ખૂબ મોટા છે, જે સામાન્ય સિસ્ટમ્સ પર ઘણી બધી મેમરી વાપરે છે.


આપણે પેજ ટેબલને કેવી રીતે નાનું બનાવી શકીએ?


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.

આમ, એપ્લિકેશન્સ પેજ ફાળવે છે પરંતુ તેમાંથી થોડાક જ ભાગનો ઉપયોગ કરે છે, અને મેમરી ઝડપથી આ વધુ પડતા મોટા પેજથી ભરાઈ જાય છે.


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

જ્યારે તમારી પાસે જીવનમાં કોઈ વસ્તુ માટે બે વાજબી પરંતુ અલગ-અલગ અભિગમ હોય, ત્યારે તમારે હંમેશા બંનેના સંયોજનની તપાસ કરવી જોઈએ કે શું તમે બંને વિશ્વનું શ્રેષ્ઠ મેળવી શકો છો.


આવા સંયોજનને આપણે હાઇબ્રિડ કહીએ છીએ.


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

ખાસ કરીને, ડેનિસને પેજ ટેબલના મેમરી ઓવરહેડને ઘટાડવા માટે પેજિંગ અને સેગ્મેન્ટેશનને જોડવાનો વિચાર આવ્યો.


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

32-બીટ એડ્રેસ સ્પેસના પેજ ટેબલની કલ્પના કરો અને તેમાં રહેલી તમામ સંભવિત બિનઉપયોગી જગ્યાની કલ્પના કરો!


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

આમ, અમારો હાઇબ્રિડ અભિગમ: પ્રક્રિયાની સમગ્ર એડ્રેસ સ્પેસ માટે એક જ પેજ ટેબલ રાખવાને બદલે, શા માટે દરેક લોજિકલ સેગમેન્ટ દીઠ એક ન રાખવું?


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

સંદર્ભ સ્વિચ પર, આ રજિસ્ટરને નવા ચાલતા પ્રોસેસના પેજ ટેબલના સ્થાનને પ્રતિબિંબિત કરવા માટે બદલવા આવશ્યક છે.


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

અમારી હાઇબ્રિડ યોજનામાં નિર્ણાયક તફાવત એ છે કે સેગમેન્ટ દીઠ બાઉન્ડ્સ રજિસ્ટરની હાજરી.


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

જ્યારે તમારી પાસે બે સારા અને દેખીતી રીતે વિરોધી વિચારો હોય, ત્યારે તમારે હંમેશા જોવું જોઈએ કે શું તમે તેમને એક હાઇબ્રિડમાં જોડી શકો છો જે બંને વિશ્વનું શ્રેષ્ઠ પ્રાપ્ત કરે છે.


First, it still requires us to use segmentation; as we discussed before, segmentation is not quite as flexible as we would like.

પ્રથમ, તે હજી પણ આપણને સેગ્મેન્ટેશનનો ઉપયોગ કરવાની જરૂર છે; જેમ આપણે પહેલા ચર્ચા કરી હતી, સેગ્મેન્ટેશન આપણે ઈચ્છીએ છીએ તેટલું લવચીક નથી.


A different approach doesn’t rely on segmentation but attacks the same problem: how to get rid of all those invalid regions in the page table instead of keeping them all in memory?

એક અલગ અભિગમ સેગ્મેન્ટેશન પર આધાર રાખતો નથી પરંતુ તે જ સમસ્યા પર હુમલો કરે છે: તે બધાને મેમરીમાં રાખવાને બદલે પેજ ટેબલમાં તે બધા અમાન્ય વિસ્તારોથી કેવી રીતે છુટકારો મેળવવો?


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

આપણે આ અભિગમને મલ્ટિ-લેવલ પેજ ટેબલ કહીએ છીએ, કારણ કે તે લિનિયર પેજ ટેબલને વૃક્ષ જેવું કંઈક બનાવે છે.


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

સ્થાનિકતાનો સિદ્ધાંત સૂચવે છે કે તાજેતરમાં ઍક્સેસ કરાયેલા પૃષ્ઠોને ફરીથી ઍક્સેસ થવાની સંભાવના છે.


LRU (Least Recently Used) replaces the least recently used page.

LRU (સૌથી ઓછું તાજેતરમાં વપરાયેલ) સૌથી તાજેતરમાં વપરાયેલ પૃષ્ઠને બદલે છે.


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

પ્રોગ્રામ્સ ઘણીવાર બે પ્રકારની સ્થાનિકતા દર્શાવે છે: અવકાશી અને અસ્થાયી.


The 80-20 workload shows that LRU performs better than FIFO.

80-20 વર્કલોડ દર્શાવે છે કે LRU FIFO કરતાં વધુ સારું પ્રદર્શન કરે છે.


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 by hardware when a page is referenced.

જ્યારે કોઈ પૃષ્ઠનો સંદર્ભ આપવામાં આવે છે ત્યારે હાર્ડવેર દ્વારા ઉપયોગ બીટ સેટ કરવામાં આવે છે.


Dirty pages must be written back to disk before eviction.

કાઢી નાખતા પહેલાં ડર્ટી પૃષ્ઠોને પાછા ડિસ્ક પર લખવા આવશ્યક છે.


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

OS એ પણ નક્કી કરે છે કે ક્યારે પૃષ્ઠને મેમરીમાં લાવવું.


Demand paging brings a page into memory when it is 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 best solution to excessive paging is often to buy more memory.

અતિશય પેજીંગનો શ્રેષ્ઠ ઉકેલ ઘણીવાર વધુ મેમરી ખરીદવાનો છે.


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

VAX/VMS ઓપરેટિંગ સિસ્ટમ એ સારી રીતે ડિઝાઇન કરાયેલ વર્ચ્યુઅલ મેમરી મેનેજર છે.


Dave Cutler was one of the primary architects of VMS.

ડેવ કટલર VMS ના મુખ્ય આર્કિટેક્ટ્સમાંના એક હતા.


The operating system manages the computer's resources.

ઓપરેટિંગ સિસ્ટમ કમ્પ્યુટરના સંસાધનોનું સંચાલન કરે છે.


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

વર્ચ્યુઅલ મેમરી સિસ્ટમને ભૌતિક રીતે ઉપલબ્ધ મેમરી કરતાં વધુ મેમરીનો ઉપયોગ કરવાની મંજૂરી આપે છે.


The kernel is the core of the operating system.

કર્નલ એ ઓપરેટિંગ સિસ્ટમનો મુખ્ય ભાગ છે.


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

પેજ ટેબલનો ઉપયોગ વર્ચ્યુઅલ એડ્રેસને ભૌતિક એડ્રેસમાં અનુવાદિત કરવા માટે થાય છે.


Context switching is the process of switching between different processes.

સંદર્ભ સ્વિચિંગ એ વિવિધ પ્રક્રિયાઓ વચ્ચે સ્વિચ કરવાની પ્રક્રિયા છે.


The CPU scheduler determines which process gets to run next.

CPU શેડ્યુલર નક્કી કરે છે કે કઈ પ્રક્રિયા આગળ ચાલશે.


File systems organize data on storage devices.

ફાઇલ સિસ્ટમ સંગ્રહ ઉપકરણો પર ડેટા ગોઠવે છે.


I am learning about operating systems in my computer science class.

હું મારા કમ્પ્યુટર સાયન્સના વર્ગમાં ઓપરેટિંગ સિસ્ટમ્સ વિશે શીખી રહ્યો છું.


The VAX/VMS operating system was a complex system.

VAX/VMS ઓપરેટિંગ સિસ્ટમ એક જટિલ સિસ્ટમ હતી.


Understanding how memory management works is crucial for system performance.

મેમરી મેનેજમેન્ટ કેવી રીતે કાર્ય કરે છે તે સમજવું સિસ્ટમની કામગીરી માટે મહત્વપૂર્ણ છે.


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

TLB (ટ્રાન્સલેશન લુકસાઇડ બફર) એડ્રેસ ટ્રાન્સલેશનને ઝડપી બનાવે છે.


Demand zeroing is a lazy optimization technique.

માંગ શૂન્ય એ એક આળસુ ઑપ્ટિમાઇઝેશન તકનીક છે.


Copy-on-write is used to optimize memory usage.

મેમરી વપરાશને ઑપ્ટિમાઇઝ કરવા માટે કોપી-ઓન-રાઇટનો ઉપયોગ થાય છે.


The operating system provides an abstraction of the hardware.

ઓપરેટિંગ સિસ્ટમ હાર્ડવેરનું અમૂર્ત સ્વરૂપ પૂરું પાડે છે.


Modern operating systems use multi-level page tables.

આધુનિક ઓપરેટિંગ સિસ્ટમ્સ મલ્ટિ-લેવલ પેજ ટેબલનો ઉપયોગ કરે છે.


The kernel manages the interaction between hardware and software.

કર્નલ હાર્ડવેર અને સોફ્ટવેર વચ્ચેની ક્રિયાપ્રતિક્રિયાનું સંચાલન કરે છે.


A process is an instance of a running program.

એક પ્રક્રિયા એ ચાલતા પ્રોગ્રામનું ઉદાહરણ છે.


The goal is to build a robust and efficient operating system.

ધ્યેય એક મજબૂત અને કાર્યક્ષમ ઓપરેટિંગ સિસ્ટમ બનાવવાનો છે.


The system uses virtual memory to handle large programs.

સિસ્ટમ મોટા પ્રોગ્રામ્સને હેન્ડલ કરવા માટે વર્ચ્યુઅલ મેમરીનો ઉપયોગ કરે છે.


Understanding the principles of operating systems is fundamental to computer science.

ઓપરેટિંગ સિસ્ટમના સિદ્ધાંતોને સમજવું એ કમ્પ્યુટર વિજ્ઞાન માટે મૂળભૂત છે.


મૂળભૂત નીતિઓ થોડી સ્પષ્ટ છે.


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.

અને આ રીતે આપણે ઓપરેટિંગ સિસ્ટમના ત્રણ સ્તંભોમાંના બીજા સ્તંભ પર પહોંચીએ છીએ: એકસાથે થવું.


કલ્પના કરો કે આપણી પાસે એક પીચ છે.


તમને અને પીચ સાથે શું છે?


Each eater first identifies a peach visually, and then tries to grab it and eat it.

દરેક ખાનાર પ્રથમ દૃષ્ટિથી પીચને ઓળખે છે, અને પછી તેને પકડવાનો અને ખાવાનો પ્રયાસ કરે છે.


Well, probably develop a better way of going about this.

સારું, કદાચ આ વિશે જવાનો વધુ સારો રસ્તો વિકસાવો.


તમે ખરેખર પ્રભાવિત કરવાનું શરૂ કરી રહ્યા છો.


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

હકીકતમાં, તમે હમણાં જ અમને એકસાથે થવા વિશે જાણવાની જરૂર છે તે બધું જ કહ્યું!


કોઈ પણ વ્યક્તિએ ક્યારેય કોંક્રિટને ભૂલવું જોઈએ નહીં.


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

એવા ચોક્કસ પ્રકારના પ્રોગ્રામ્સ છે જેને આપણે મલ્ટિ-થ્રેડેડ એપ્લિકેશન્સ કહીએ છીએ.


The OS must support multi-threaded applications.

ઓએસએ મલ્ટિ-થ્રેડેડ એપ્લિકેશન્સને સપોર્ટ કરવી આવશ્યક છે.


We introduce a new abstraction for a single running process: that of a thread.

આપણે એક જ ચાલતી પ્રક્રિયા માટે એક નવું અમૂર્ત રજૂ કરીએ છીએ: થ્રેડનું.


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

દરેક થ્રેડમાં તેના પોતાના ખાનગી રજિસ્ટરનો સમૂહ છે જેનો ઉપયોગ તે ગણતરી માટે કરે છે.


સરનામાંની જગ્યા સમાન રહે છે.


In a multi-threaded process, each thread runs independently.

મલ્ટિ-થ્રેડેડ પ્રક્રિયામાં, દરેક થ્રેડ સ્વતંત્ર રીતે ચાલે છે.


The operating system manages computer hardware and software resources.

ઓપરેટિંગ સિસ્ટમ કમ્પ્યુટર હાર્ડવેર અને સોફ્ટવેર સંસાધનોનું સંચાલન કરે છે.


Concurrency allows multiple tasks to appear to run simultaneously.

એકસાથે થતી ક્રિયાઓ બહુવિધ કાર્યોને એકસાથે ચાલતા હોવાનો દેખાવ આપે છે.


Threads often need to synchronize access to shared data.

થ્રેડોને વારંવાર શેર કરેલા ડેટાની ઍક્સેસને સમન્વયિત કરવાની જરૂર પડે છે.


Atomic operations ensure that a series of actions are treated as a single unit.

એટોમિક ઓપરેશન્સ ખાતરી કરે છે કે ક્રિયાઓની શ્રેણીને એક જ એકમ તરીકે ગણવામાં આવે છે.


The OS was the first concurrent program.

ઓપરેટિંગ સિસ્ટમ પ્રથમ એકસાથે ચાલતું પ્રોગ્રામ હતું.


File systems use techniques such as journaling.

ફાઇલ સિસ્ટમ્સ જર્નલિંગ જેવી તકનીકોનો ઉપયોગ કરે છે.


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

પ્રોગ્રામ તમને બતાવે છે કે કેવી રીતે વિવિધ થ્રેડ ઇન્ટરલીવિંગ રેસની સ્થિતિનું કારણ બને છે.


Use atomic operations to build computer systems.

કમ્પ્યુટર સિસ્ટમ બનાવવા માટે એટોમિક ઓપરેશન્સનો ઉપયોગ કરો.


The thread API is used for thread creation and control.

થ્રેડ એપીઆઈનો ઉપયોગ થ્રેડ બનાવવા અને નિયંત્રિત કરવા માટે થાય છે.


You can create new threads to write a multi-threaded program.

મલ્ટિ-થ્રેડેડ પ્રોગ્રામ લખવા માટે તમે નવા થ્રેડો બનાવી શકો છો.


The pthread_create function is used to create a new thread.

pthread_create ફંક્શનનો ઉપયોગ નવો થ્રેડ બનાવવા માટે થાય છે.


The thread will start running in the start_routine function.

થ્રેડ start_routine ફંક્શનમાં ચાલવાનું શરૂ કરશે.


The fourth argument is the argument to be passed to the function.

ચોથો આર્ગ્યુમેન્ટ એ ફંક્શનમાં પસાર થવાનો આર્ગ્યુમેન્ટ છે.


You need to call the routine pthread_join() to wait for a thread to complete.

થ્રેડ પૂર્ણ થવાની રાહ જોવા માટે તમારે રૂટિન pthread_join() ને કૉલ કરવાની જરૂર છે.


Locks provide mutual exclusion to a critical section.

લોક એક જટિલ વિભાગમાં પરસ્પર બાકાત પૂરા પાડે છે.


બધા લોકને યોગ્ય રીતે શરૂ કરવા આવશ્યક છે.


Use pthread_mutex_lock() and pthread_mutex_unlock() to protect critical sections.

જટિલ વિભાગોને સુરક્ષિત કરવા માટે pthread_mutex_lock() અને pthread_mutex_unlock() નો ઉપયોગ કરો.


Condition variables are useful when signaling must take place between threads.

જ્યારે થ્રેડો વચ્ચે સિગ્નલિંગ થવું જોઈએ ત્યારે શરત ચલો ઉપયોગી છે.


The main routines are pthread_cond_wait() and pthread_cond_signal().

મુખ્ય રૂટિન pthread_cond_wait() અને pthread_cond_signal() છે.


The compiler will likely complain when you write code like this.

જ્યારે તમે આના જેવો કોડ લખો છો ત્યારે સંકલક સંભવતઃ ફરિયાદ કરશે.


The program needs to initialize the mutex before use.

પ્રોગ્રામ વાપરતા પહેલાં મ્યુટેક્સને શરૂઆત કરવી જરૂરી છે.


Condition variables are used to signal between threads.

થ્રેડો વચ્ચે સંકેત આપવા માટે કન્ડિશન વેરિયેબલ્સનો ઉપયોગ થાય છે.


The lock protects the critical section of the code.

લોક કોડના નિર્ણાયક વિભાગને સુરક્ષિત કરે છે.


Spin-waiting wastes CPU cycles unnecessarily.

સ્પિન-વેઇટિંગ બિનજરૂરી રીતે CPU ચક્રનો વ્યય કરે છે.


Always check return codes when using pthreads.

pthread નો ઉપયોગ કરતી વખતે હંમેશાં રીટર્ન કોડ તપાસો.


The programmer must be careful with thread synchronization.

પ્રોગ્રામરે થ્રેડ સિંક્રનાઇઝેશન સાથે સાવચેત રહેવું જોઈએ.


Multiple threads can access shared resources concurrently.

બહુવિધ થ્રેડો એકસાથે શેર કરેલા સંસાધનોને ઍક્સેસ કરી શકે છે.


The operating system schedules threads for execution.

ઓપરેટિંગ સિસ્ટમ એક્ઝિક્યુશન માટે થ્રેડોનું શેડ્યૂલિંગ કરે છે.


Locks provide mutual exclusion to prevent race conditions.

રેસની સ્થિતિને રોકવા માટે લોક પરસ્પર બાકાત પ્રદાન કરે છે.


The test-and-set instruction is an atomic operation.

ટેસ્ટ-એન્ડ-સેટ સૂચના એ એક અણુ કામગીરી છે.


Understanding concurrency is crucial for writing correct code.

સાચો કોડ લખવા માટે એકસાથે થતી ક્રિયાને સમજવી ખૂબ જ જરૂરી છે.


The program uses a while loop to re-check the condition.

પ્રોગ્રામ શરતને ફરીથી તપાસવા માટે while લૂપનો ઉપયોગ કરે છે.


The thread waits for a signal from another thread.

થ્રેડ બીજા થ્રેડના સંકેતની રાહ જુએ છે.


The lock is released after the critical section is executed.

નિર્ણાયક વિભાગ ચલાવ્યા પછી લોક મુક્ત થાય છે.


The programmer should minimize thread interactions.

પ્રોગ્રામરે થ્રેડની ક્રિયાપ્રતિક્રિયાને ઓછી કરવી જોઈએ.


દરેક થ્રેડનું પોતાનું સ્ટેક હોય છે.


Using a simple flag for synchronization is error-prone.

સિંક્રનાઇઝેશન માટે સરળ ફ્લેગનો ઉપયોગ ભૂલભરેલો છે.


The manual pages provide detailed information about pthreads.

મેન્યુઅલ પૃષ્ઠો pthreads વિશે વિગતવાર માહિતી પ્રદાન કરે છે.


The code examples are relatively easy to compile and run.

કોડના ઉદાહરણો પ્રમાણમાં કમ્પાઇલ અને ચલાવવા માટે સરળ છે.


The main goal is to build robust and efficient multi-threaded programs.

મુખ્ય ધ્યેય મજબૂત અને કાર્યક્ષમ મલ્ટિ-થ્રેડેડ પ્રોગ્રામ્સ બનાવવાનું છે.


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

પ્રોગ્રામ 'નવું' ptr દ્વારા નિર્દેશિત મેમરી સ્થાનમાં સંગ્રહિત કરે છે.


The test-and-set instruction returns the old value and simultaneously updates the value to 'new'.

ટેસ્ટ-એન્ડ-સેટ સૂચના જૂનું મૂલ્ય પરત કરે છે અને તે જ સમયે મૂલ્યને 'નવું' માં અપડેટ કરે છે.


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

કલ્પના કરો કે એક થ્રેડ lock() ને બોલાવે છે અને બીજું કોઈ થ્રેડ હાલમાં લોક ધરાવતું નથી.


When the thread is finished with its critical section, it calls unlock() to set the flag back to zero.

જ્યારે થ્રેડ તેના નિર્ણાયક વિભાગ સાથે સમાપ્ત થાય છે, ત્યારે તે ફ્લેગને શૂન્ય પર પાછા સેટ કરવા માટે unlock() ને બોલાવે છે.


Spin locks are not fair and may lead to starvation.

સ્પિન લોક ન્યાયી નથી અને તેનાથી ભૂખમરો થઈ શકે છે.


On multiple CPUs, spin locks work reasonably well.

બહુવિધ CPUs પર, સ્પિન લોક યોગ્ય રીતે કામ કરે છે.


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

મૂળભૂત વિચાર એ છે કે compare-and-swap એ ચકાસવા માટે કે ptr દ્વારા નિર્દિષ્ટ સરનામાં પરનું મૂલ્ય અપેક્ષિત સમાન છે કે નહીં.


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

compare-and-swap સૂચના સાથે, અમે ટેસ્ટ-એન્ડ-સેટ સાથે તે રીતે જ લોક બનાવી શકીએ છીએ.


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

લોડ-લિંક્ડ સામાન્ય લોડ સૂચના જેવું જ કાર્ય કરે છે.


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

મુખ્ય તફાવત સ્ટોર-કન્ડિશનલ સાથે આવે છે, જે ફક્ત ત્યારે જ સફળ થાય છે જો સરનામાં પર કોઈ મધ્યવર્તી સ્ટોર ન થયો હોય.


Programmers tend to brag about how much code they wrote to do something.

પ્રોગ્રામરો કોઈક કાર્ય કરવા માટે તેમણે કેટલો કોડ લખ્યો છે તે વિશે બડાઈ મારતા હોય છે.


Short, concise code is always preferred; it is likely easier to understand and has fewer bugs.

ટૂંકો, સંક્ષિપ્ત કોડ હંમેશાં પસંદ કરવામાં આવે છે; તે સમજવામાં સરળ છે અને તેમાં ઓછા બગ્સ છે.


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: when you are going to spin, instead give up the CPU to another thread.

અમારો પ્રથમ પ્રયાસ એક સરળ અને મૈત્રીપૂર્ણ અભિગમ છે: જ્યારે તમે સ્પિન કરવા જઇ રહ્યા છો, તેના બદલે બીજા થ્રેડને CPU સોંપી દો.


In this simple case, the yielding approach works well.

આ સરળ કિસ્સામાં, ઉપજ આપવાનો અભિગમ સારી રીતે કામ કરે છે.


Worse, we have not tackled the starvation problem at all.

ખરાબ, અમે ભૂખમરાની સમસ્યાને બિલકુલ હલ કરી નથી.


Thus, we must explicitly exert some control over who gets to acquire the lock next after the current holder releases it.

આમ, આપણે સ્પષ્ટપણે નિયંત્રણ રાખવું જોઈએ કે વર્તમાન ધારક તેને મુક્ત કર્યા પછી કોણ આગળ લોક મેળવે છે.


We do a couple of interesting things in this example.

આ ઉદાહરણમાં આપણે કેટલીક રસપ્રદ બાબતો કરીએ છીએ.


Solaris solves this problem by adding a third system call: setpark().

સોલારિસ આ સમસ્યાને ત્રીજી સિસ્ટમ કૉલ ઉમેરીને હલ કરે છે: setpark().


Specifically, each futex has associated with it a specific physical memory location.

ખાસ કરીને, દરેક ફ્યુટેક્સ તેની સાથે એક વિશિષ્ટ ભૌતિક મેમરી સ્થાન ધરાવે છે.


The Linux approach has the flavor of an old approach.

લિનક્સનો અભિગમ જૂના અભિગમ જેવો જ છે.


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

બે-તબક્કાનું લોક સમજે છે કે સ્પિનિંગ ઉપયોગી થઈ શકે છે.


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

તેથી પ્રથમ તબક્કામાં, લોક થોડા સમય માટે સ્પિન થાય છે.


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

કૉલરને ઊંઘમાં મૂકવામાં આવે છે, અને જ્યારે લોક પછીથી ખાલી થાય છે ત્યારે જ જાગૃત થાય છે.


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

બે-તબક્કાના લોક હજુ પણ એક સંકર અભિગમનું બીજું ઉદાહરણ છે.


Making a single general-purpose lock, good for all possible use cases, is quite a challenge.

એક જ સામાન્ય-હેતુનું લોક બનાવવું, જે તમામ સંભવિત ઉપયોગના કેસો માટે સારું છે, તે એક પડકાર છે.


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

ઉપરોક્ત અભિગમ બતાવે છે કે આ દિવસોમાં વાસ્તવિક લોક કેવી રીતે બનાવવામાં આવે છે.


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

જો તમે વધુ વિગતો જોવા માંગતા હો, તો સોલારિસ અથવા લિનક્સ ઓપન સોર્સ કોડ બેઝ તપાસો.


There is even an undoubtedly bad book about Al Davis.

અલ ડેવિસ વિશે એક નિઃશંકપણે ખરાબ પુસ્તક પણ છે.


One of the early seminal papers in the area.

આ ક્ષેત્રના પ્રારંભિક સેમિનલ પેપર્સમાંનું એક.


A landmark paper introducing a different approach.

એક સીમાચિહ્નરૂપ પેપર જે એક અલગ અભિગમ રજૂ કરે છે.


મજા અને આંતરદૃષ્ટિથી ભરપૂર.


In particular, take a look at the nptl subdirectory.

ખાસ કરીને, nptl સબડિરેક્ટરી પર એક નજર નાખો.


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

આમ, RDLK એ પ્રારંભિક ટેસ્ટ-અને-સેટ પ્રિમિટિવ છે.


An excellent survey on different locking algorithms.

વિવિધ લોકીંગ અલ્ગોરિધમ્સ પર એક ઉત્તમ સર્વે.


Can you believe we referenced wikipedia?

શું તમે માનો છો કે અમે વિકિપીડિયાનો સંદર્ભ આપ્યો?


Adding locks to a data structure to make it usable by threads makes the structure thread safe.

ડેટા સ્ટ્રક્ચરમાં લોક ઉમેરવાથી તેને થ્રેડો દ્વારા વાપરી શકાય છે, જે સ્ટ્રક્ચરને થ્રેડ સુરક્ષિત બનાવે છે.


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

તેને યોગ્ય રીતે કામ કરવા માટે આપણે તેમાં લોક કેવી રીતે ઉમેરવા જોઈએ?


One of the simplest data structures is a counter.

સૌથી સરળ ડેટા સ્ટ્રક્ચરમાંનું એક કાઉન્ટર છે.


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

જો તમારું ડેટા સ્ટ્રક્ચર ખૂબ ધીમું છે, તો તમારે ફક્ત એક જ લોક ઉમેરવા કરતાં વધુ કરવું પડશે.


The consumer simply goes back to sleep if the buffer is empty.

જો બફર ખાલી હોય, તો ગ્રાહક સરળતાથી પાછો ઊંઘી જાય છે.


Thanks to Mesa semantics, always use while loops with condition variables.

મેસા સિમેન્ટીક્સને આભારી, હંમેશા કન્ડિશન ચલો સાથે while લૂપ્સનો ઉપયોગ કરો.


The problem occurs when two consumers run first and both go to sleep.

જ્યારે બે ગ્રાહકો પ્રથમ ચાલે છે અને બંને ઊંઘી જાય છે ત્યારે સમસ્યા થાય છે.


A consumer should not wake other consumers, only producers, and vice-versa.

ગ્રાહકે અન્ય ગ્રાહકોને જગાડવા જોઈએ નહીં, ફક્ત ઉત્પાદકોને, અને તેનાથી ઊલટું.


The final solution uses two condition variables.

અંતિમ સોલ્યુશન બે કન્ડિશન ચલોનો ઉપયોગ કરે છે.


Producers wait on the condition empty, and signals fill.

ઉત્પાદકો ખાલી સ્થિતિની રાહ જુએ છે, અને ભરો સંકેત આપે છે.


A producer only sleeps if all buffers are currently filled.

જો બધા બફર હાલમાં ભરેલા હોય તો જ ઉત્પાદક ઊંઘે છે.


Using a while loop is always correct when checking for a condition.

શરત તપાસતી વખતે while લૂપનો ઉપયોગ હંમેશા સાચો છે.


In some thread packages, spurious wakeups can occur.

કેટલાક થ્રેડ પેકેજોમાં, ખોટા જાગરણ થઈ શકે છે.


The cost is that too many threads might be woken.

ખર્ચ એ છે કે ઘણા બધા થ્રેડો જાગી શકે છે.


We have seen the introduction of condition variables.

આપણે કન્ડિશન ચલોનો પરિચય જોયો છે.


Semaphores can be used as both locks and condition variables.

સેમાફોર્સનો ઉપયોગ લોક અને કન્ડિશન ચલો બંને તરીકે થઈ શકે છે.


A semaphore is an object with an integer value.

સેમાફોર એ પૂર્ણાંક મૂલ્ય સાથેની એક વસ્તુ છે.


The initial value of the semaphore determines its behavior.

સેમાફોરનું પ્રારંભિક મૂલ્ય તેના વર્તનને નિર્ધારિત કરે છે.


sem_wait() will either return right away or suspend execution.

sem_wait() કાં તો તરત જ પાછું આવશે અથવા અમલને સ્થગિત કરશે.


sem_post() does not wait for some particular condition.

sem_post() કોઈ ચોક્કસ સ્થિતિની રાહ જોતો નથી.


The value of the semaphore, when negative, is equal to the number of waiting threads.

જ્યારે નકારાત્મક હોય, ત્યારે સેમાફોરનું મૂલ્ય રાહ જોઈ રહેલા થ્રેડોની સંખ્યા જેટલું હોય છે.


We are now ready to use a semaphore as a lock.

હવે આપણે સેમાફોરનો ઉપયોગ લોક તરીકે કરવા માટે તૈયાર છીએ.


Critical to making this work is the initial value of the semaphore.

આ કાર્યને સફળ બનાવવા માટે સેમાફોરનું પ્રારંભિક મૂલ્ય મહત્વપૂર્ણ છે.


Semaphores are also useful when a thread wants to wait for a condition.

જ્યારે કોઈ થ્રેડ કોઈ સ્થિતિની રાહ જોવા માંગે છે ત્યારે સેમાફોર્સ પણ ઉપયોગી છે.


સિસ્ટમ દરેક હેશ બકેટ માટે એક લોકનો ઉપયોગ કરે છે.


This enables many concurrent operations to take place.

આનાથી ઘણી સમકાલીન કામગીરી થઈ શકે છે.


હેશ ટેબલ અદભૂત રીતે સ્કેલ થાય છે.


અકાળે ઑપ્ટિમાઇઝેશન ટાળો.


Many operating systems added a single lock.

ઘણાં ઓપરેટિંગ સિસ્ટમમાં એક જ લોક ઉમેરવામાં આવ્યું.


We have introduced a sampling of concurrent data structures.

અમે સમકાલીન ડેટા સ્ટ્રક્ચરનું એક નમૂના રજૂ કર્યું છે.


Performance problems should only be remedied once they exist.

કાર્યક્ષમતાની સમસ્યાઓ ત્યારે જ સુધારવી જોઈએ જ્યારે તે અસ્તિત્વમાં હોય.


There is no value in making something faster if doing so will not improve the overall performance.

જો આમ કરવાથી એકંદર કામગીરીમાં સુધારો નહીં થાય, તો કોઈ વસ્તુને ઝડપી બનાવવામાં કોઈ મૂલ્ય નથી.


We have introduced a sampling of concurrent data structures, from counters, to lists and queues, and finally to the ubiquitous and heavily-used hash table.

અમે સમકાલીન ડેટા સ્ટ્રક્ચરનું એક નમૂના રજૂ કર્યું છે, કાઉન્ટર્સથી લઈને, યાદીઓ અને કતારો સુધી, અને છેવટે સર્વવ્યાપી અને ખૂબ ઉપયોગમાં લેવાતા હેશ ટેબલ સુધી.


In multi-threaded programs, it is often useful for a thread to wait for some condition to become true before proceeding.

મલ્ટિ-થ્રેડેડ પ્રોગ્રામ્સમાં, કોઈ થ્રેડ માટે આગળ વધતા પહેલાં કોઈ શરત સાચી થાય તેની રાહ જોવી ઘણીવાર ઉપયોગી છે.


A condition variable is an explicit queue that threads can put themselves on when some state of execution is not as desired.

શરત ચલ એ એક સ્પષ્ટ કતાર છે કે જેના પર થ્રેડો પોતાને મૂકી શકે છે જ્યારે અમલની કેટલીક સ્થિતિ ઇચ્છિત નથી.


To declare such a condition variable, one simply writes something like this: pthread_cond_t c;

આવા શરત ચલને જાહેર કરવા માટે, કોઈ ફક્ત આના જેવું કંઈક લખે છે: pthread_cond_t c;


The wait() call is executed when a thread wishes to put itself to sleep.

જ્યારે કોઈ થ્રેડ પોતાને ઊંઘવા માંગે છે ત્યારે wait() કૉલ એક્ઝિક્યુટ થાય છે.


The signal() call is executed when a thread has changed something in the program.

જ્યારે કોઈ થ્રેડે પ્રોગ્રામમાં કંઈક બદલ્યું છે ત્યારે signal() કૉલ એક્ઝિક્યુટ થાય છે.


We will often refer to these as wait() and signal() for simplicity.

સરળતા માટે, અમે વારંવાર આને wait() અને signal() તરીકે ઓળખીશું.


The parent creates the child thread but continues running itself.

માતાપિતા બાળ થ્રેડ બનાવે છે પરંતુ તે પોતાની જાતને ચલાવવાનું ચાલુ રાખે છે.


The producer/consumer problem is also known as the bounded buffer problem.

ઉત્પાદક/ગ્રાહક સમસ્યાને બાઉન્ડેડ બફર સમસ્યા તરીકે પણ ઓળખવામાં આવે છે.


Producers produce data items and wish to place them in a buffer.

ઉત્પાદકો ડેટા આઇટમ્સ ઉત્પન્ન કરે છે અને તેમને બફરમાં મૂકવા માંગે છે.


Consumers grab data items out of the buffer and consume them.

ગ્રાહકો બફરમાંથી ડેટા આઇટમ્સ લે છે અને તેનો ઉપયોગ કરે છે.


This arrangement occurs in many real systems.

આ વ્યવસ્થા ઘણી વાસ્તવિક સિસ્ટમમાં થાય છે.


The consumer waits for a buffer to become filled before using it.

ગ્રાહક તેનો ઉપયોગ કરતા પહેલા બફર ભરવાનું શરૂ થવાની રાહ જુએ છે.


Imagine there are two threads, a producer and a consumer.

કલ્પના કરો કે ત્યાં બે થ્રેડ છે, એક ઉત્પાદક અને એક ગ્રાહક.


The producer will put a data value into the first entry of buffer.

ઉત્પાદક ડેટા મૂલ્યને બફરની પ્રથમ એન્ટ્રીમાં મૂકશે.


This is a no-no; we don’t want any data from the producer to be lost.

આ યોગ્ય નથી; અમે ઉત્પાદકનો કોઈ ડેટા ગુમાવવા માંગતા નથી.


The filling of a buffer and incrementing of the index into the buffer is a critical section.

બફર ભરવું અને બફરમાં ઇન્ડેક્સ વધારવો એ એક નિર્ણાયક વિભાગ છે.


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

ગ્રાહક મ્યુટેક્સ મેળવે છે અને કોઈક પૂર્ણ થવાની રાહ જોઈ રહ્યો છે.


The producer could signal full but is waiting for the mutex.

ઉત્પાદક પૂર્ણ સિગ્નલ આપી શકે છે પરંતુ મ્યુટેક્સની રાહ જોઈ રહ્યો છે.


The result is a simple and working bounded buffer, a commonly-used pattern in multi-threaded programs.

પરિણામ એ એક સરળ અને કાર્યકારી બાઉન્ડેડ બફર છે, જે મલ્ટિ-થ્રેડેડ પ્રોગ્રામ્સમાં સામાન્ય રીતે ઉપયોગમાં લેવાતું પેટર્ન છે.


When acquiring a read lock, the reader first acquires lock and then increments the readers variable.

રીડ લોક મેળવતી વખતે, રીડર પ્રથમ લોક મેળવે છે અને પછી રીડર્સ વેરીએબલ વધારે છે.


They often add more overhead and thus do not end up speeding up performance.

તેઓ ઘણીવાર વધુ ઓવરહેડ ઉમેરે છે અને તેથી કામગીરીને ઝડપી બનાવતા નથી.


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

આ સમસ્યા પ્રખ્યાત છે કારણ કે તે મનોરંજક છે અને થોડું બૌદ્ધિક રીતે રસપ્રદ છે.


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.

સેમાફોર્સ સમકાલીન પ્રોગ્રામ્સ લખવા માટે એક શક્તિશાળી અને લવચીક પ્રિમિટિવ છે.


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

આ પ્રકરણમાં, અમે ફક્ત થોડી ક્લાસિક સમસ્યાઓ અને ઉકેલો રજૂ કર્યા છે.


Becoming a real concurrency expert takes years of effort.

એક વાસ્તવિક સમકાલીન નિષ્ણાત બનવામાં વર્ષોની મહેનત લાગે છે.


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

સમકાલીન ભૂલો સામાન્ય પેટર્નની વિવિધતામાં આવે છે.


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 લુ અને તેના સહકર્મીઓ દ્વારા અભ્યાસ કરાયેલા બગ્સનો સારાંશ દર્શાવે છે.


મોટાભાગના બગ્સ ડેડલોક ન હતા.


We now dive into these different classes of bugs a bit more deeply.

હવે આપણે આ વિવિધ પ્રકારના બગ્સમાં થોડા વધુ ઊંડા ઊતરીએ છીએ.


Non-deadlock bugs make up a majority of concurrency bugs.

નોન-ડેડલોક બગ્સ કોન્કરન્સી બગ્સનો મોટો ભાગ બનાવે છે.


તેઓ કેવી રીતે ઉદ્ભવે છે?


We now discuss the two major types of non-deadlock bugs.

હવે આપણે નોન-ડેડલોક બગ્સના બે મુખ્ય પ્રકારોની ચર્ચા કરીએ છીએ.


The first type of problem encountered is referred to as an atomicity violation.

સામનો કરવામાં આવેલી પ્રથમ પ્રકારની સમસ્યાને એટોમિસિટી ઉલ્લંઘન તરીકે ઓળખવામાં આવે છે.


Here is a simple example, found in MySQL.

અહીં એક સરળ ઉદાહરણ છે, જે MySQL માં જોવા મળે છે.


કોડમાં એટોમિસિટી ધારણા છે.


Finding a fix for this type of problem is often straightforward.

આ પ્રકારની સમસ્યા માટે સુધારો શોધવો ઘણીવાર સરળ હોય છે.


We simply add locks around the shared-variable references.

આપણે ફક્ત શેર કરેલા-ચલ સંદર્ભોની આસપાસ લોક ઉમેરીએ છીએ.


Another common type of non-deadlock bug found is known as an order violation.

બીજા એક સામાન્ય પ્રકારના નોન-ડેડલોક બગને ઓર્ડર ઉલ્લંઘન તરીકે ઓળખવામાં આવે છે.


The desired order between two memory accesses is flipped.

બે મેમરી એક્સેસ વચ્ચેનો ઇચ્છિત ક્રમ ઉલટાવી દેવામાં આવે છે.


The fix to this type of bug is generally to enforce ordering.

આ પ્રકારના બગને ઠીક કરવા માટે સામાન્ય રીતે ઓર્ડરિંગ લાગુ કરવું પડે છે.


When ordering matters between threads, condition variables can come to the rescue.

જ્યારે થ્રેડો વચ્ચે ઓર્ડરિંગ મહત્વનું છે, ત્યારે કન્ડિશનલ ચલો બચાવ માટે આવી શકે છે.