A large fraction of non-deadlock bugs are either atomicity or order violations.

નોન-ડેડલોક બગ્સનો એક મોટો ભાગ કાં તો એટોમિસિટી અથવા ઓર્ડર ઉલ્લંઘન છે.


પુસ્તક ટેબલ પર છે.


હું બજારમાં જઈ રહ્યો છું.


આજનું હવામાન સુખદ છે.


કૃપા કરીને મને મીઠું આપો.


કંપનીએ એક નવું ઉત્પાદન જાહેર કર્યું.


The government is discussing new policies.

સરકાર નવી નીતિઓ પર ચર્ચા કરી રહી છે.


તે એક ખૂબ જ પ્રતિભાશાળી સંગીતકાર છે.


પ્રોજેક્ટ સમયસર પૂર્ણ થયો.


તે તેની પરીક્ષાઓ માટે અભ્યાસ કરી રહી છે.


The algorithm efficiently sorts the data.

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


The economic forecast predicts a recession.

આર્થિક આગાહી મંદીની આગાહી કરે છે.


The research paper explores the impact of climate change.

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


The company's innovative approach revolutionized the industry.

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


Despite the challenges, they persevered and succeeded.

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


The event-based concurrency addresses two-fold problem.

ઘટના આધારિત એકસાથે થતી ક્રિયા બેવડા પ્રશ્નને સંબોધે છે.


The basic approach is called event-based concurrency.

મૂળભૂત અભિગમને ઘટના આધારિત એકસાથે થતી ક્રિયા કહેવામાં આવે છે.


This style, known as event-based concurrency, has become popular in some modern systems.

આ શૈલી, જે ઘટના આધારિત એકસાથે થતી ક્રિયા તરીકે ઓળખાય છે, તે કેટલીક આધુનિક સિસ્ટમમાં લોકપ્રિય બની છે.


The programmer simply creates threads and then hopes that the underlying OS schedules them.

પ્રોગ્રામર ફક્ત થ્રેડો બનાવે છે અને પછી આશા રાખે છે કે અંતર્ગત OS તેમને શેડ્યૂલ કરે.


Event-based servers give control of scheduling to the application itself.

ઘટના આધારિત સર્વર્સ શેડ્યુલિંગનું નિયંત્રણ એપ્લિકેશનને જ આપે છે.


સરનામું 0x1F3 = LBA નીચલો બાઈટ


સરનામું 0x1F4 = LBA મધ્ય બાઈટ


સરનામું 0x1F5 = LBA ઉચ્ચ બાઈટ


ડ્રાઈવ તૈયાર થાય તેની રાહ જુઓ.


કમાન્ડ રજિસ્ટરમાં પરિમાણો લખો.


I/O શરૂ કરો.


અંતરાયોને સંભાળો.


After each operation, read the status register.

દરેક કામગીરી પછી, સ્થિતિ રજિસ્ટર વાંચો.


If the ERROR bit is on, read the error register for details.

જો ERROR બીટ ચાલુ હોય, તો વિગતો માટે ભૂલ રજિસ્ટર વાંચો.


The basic protocol to interact with the device is as follows.

ઉપકરણ સાથે ક્રિયાપ્રતિક્રિયા કરવા માટેનો મૂળભૂત પ્રોટોકોલ નીચે મુજબ છે.


The drive consists of a large number of sectors.

ડ્રાઇવમાં મોટી સંખ્યામાં સેક્ટર હોય છે.


મલ્ટિ-સેક્ટર કામગીરી શક્ય છે.


The basic interface for all modern drives is straightforward.

બધા આધુનિક ડ્રાઇવ્સ માટેનું મૂળભૂત ઇન્ટરફેસ સીધું છે.


The sectors are numbered from 0 to n-1 on a disk with n sectors.

n સેક્ટરવાળી ડિસ્ક પર સેક્ટર 0 થી n-1 સુધી ક્રમાંકિત છે.


One can usually assume that accessing two blocks that are near one-another within the drive’s address space will be faster.

સામાન્ય રીતે એવું માની શકાય છે કે ડ્રાઇવના એડ્રેસ સ્પેસમાં એકબીજાની નજીક હોય તેવા બે બ્લોક્સને ઍક્સેસ કરવું ઝડપી હશે.


Let’s start to understand some of the components of a modern disk.

આધુનિક ડિસ્કના કેટલાક ઘટકોને સમજવાનું શરૂ કરીએ.


We start with a platter, a circular hard surface on which data is stored persistently.

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


ડિસ્કમાં એક અથવા વધુ પ્લેટર હોઈ શકે છે.


The rate of rotation is often measured in rotations per minute (RPM).

ભ્રમણની ગતિ ઘણીવાર પ્રતિ મિનિટ ભ્રમણ (RPM) માં માપવામાં આવે છે.


Data is encoded on each surface in concentric circles of sectors.

ડેટા દરેક સપાટી પર સેક્ટરના કેન્દ્રિત વર્તુળોમાં એન્કોડ કરવામાં આવે છે.


A pioneering paper on how to structure web servers in the then-burgeoning Internet era.

તે સમયના વિકસતા ઈન્ટરનેટ યુગમાં વેબ સર્વરને કેવી રીતે માળખું આપવું તે અંગેનું એક અગ્રણી પેપર.


If there is some detail you need to know, it is in here.

જો તમારે કોઈ વિગત જાણવાની જરૂર હોય, તો તે અહીં છે.


A paper about how to make threads work at extreme scale; a counter to all the event-based work ongoing at the time.

એક પેપર કે જે થ્રેડોને અત્યંત સ્કેલ પર કેવી રીતે કામ કરવું તે વિશે છે; તે સમયે ચાલી રહેલા તમામ ઇવેન્ટ-આધારિત કાર્યનો વિરોધ.


A nice twist on event-based serving that combines threads, queues, and event-based handling into one streamlined whole.

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


Some of these ideas have found their way into the infrastructures of companies such as Google, Amazon, and elsewhere.

આમાંના કેટલાક વિચારોએ Google, Amazon અને અન્યત્ર જેવી કંપનીઓના ઇન્ફ્રાસ્ટ્રક્ચરમાં પોતાનો માર્ગ શોધી કાઢ્યો છે.


તો, શું હવે તારું માથું દુખે છે?


Indeed it is. I am always amazed at how so few line of code, when concurrent execution is involved, can become nearly impossible to understand.

ખરેખર તે છે. મને હંમેશા આશ્ચર્ય થાય છે કે જ્યારે એકસાથે અમલ સામેલ હોય ત્યારે કોડની કેટલી ઓછી લાઇન સમજવી લગભગ અશક્ય બની શકે છે.


અરે, બહુ ખરાબ ન લાગે.


પ્રોફેસરો ... ઉહ ... ખોટા હોઈ શકે?


Well that is the real question, isn’t it?

ઠીક છે, તે જ સાચો પ્રશ્ન છે, ખરું ને?


સૌ પ્રથમ, તેને સરળ રાખો!


Avoid complex interactions between threads, and use well-known and tried-and-true ways to manage thread interactions.

થ્રેડો વચ્ચે જટિલ ક્રિયાપ્રતિક્રિયાઓ ટાળો, અને થ્રેડ ક્રિયાપ્રતિક્રિયાઓનું સંચાલન કરવા માટે જાણીતી અને અજમાવી અને સાચી રીતોનો ઉપયોગ કરો.


Like simple locking, and maybe a producer-consumer queue?

સરળ લોકીંગ જેવું, અને કદાચ ઉત્પાદક-ગ્રાહક કતાર?


Those are common paradigms, and you should be able to produce the working solutions given what you’ve learned.

તે સામાન્ય પરિમાણો છે, અને તમે જે શીખ્યા છો તે જોતાં તમે કાર્યકારી ઉકેલો ઉત્પન્ન કરી શકશો.


Second, only use concurrency when absolutely needed; avoid it if at all possible.

બીજું, જ્યારે સંપૂર્ણપણે જરૂરી હોય ત્યારે જ એકસાથે ઉપયોગ કરો; જો શક્ય હોય તો તેને ટાળો.


There is nothing worse than premature optimization of a program.

પ્રોગ્રામના અકાળ ઑપ્ટિમાઇઝેશન કરતાં ખરાબ કંઈ નથી.


I see – why add threads if you don’t need them?

હું જોઉં છું - જો તમને તેની જરૂર ન હોય તો થ્રેડો શા માટે ઉમેરવા?


Third, if you really need parallelism, seek it in other simplified forms.

ત્રીજું, જો તમને ખરેખર સમાંતરતાની જરૂર હોય, તો તેને અન્ય સરળ સ્વરૂપોમાં શોધો.


Good! You should. In the end, you’ll have to do a lot of that, as what we learn together can only serve as the barest introduction to the wealth of knowledge that is out there.

સરસ! તમારે કરવું જોઈએ. આખરે, તમારે તેમાંથી ઘણું બધું કરવું પડશે, કારણ કે આપણે સાથે જે શીખીએ છીએ તે જ્ઞાનની સંપત્તિનો માત્ર સૌથી નાનો પરિચય આપી શકે છે જે ત્યાં છે.


And thus we reach the third of our four ... err... three pillars of operating systems:persistence.

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


The Cheetah 15K.5 is a high-performance SCSI drive.

ચીતા 15K.5 એક ઉચ્ચ-પ્રદર્શન SCSI ડ્રાઇવ છે.


The Barracuda is a drive built for capacity.

બેરકૂડા ક્ષમતા માટે બનેલી ડ્રાઇવ છે.


Details on both are found in Table 37.1.

બંનેની વિગતો કોષ્ટક 37.1 માં મળી શકે છે.


As you can see, the drives have quite different characteristics.

તમે જોઈ શકો છો તેમ, ડ્રાઇવ્સમાં તદ્દન અલગ લાક્ષણિકતાઓ છે.


The first is the “high performance” drive market.

પ્રથમ “ઉચ્ચ પ્રદર્શન” ડ્રાઇવ બજાર છે.


બીજું “ક્ષમતા” બજાર છે.


From these numbers, we can start to calculate how well the drives would do.

આ આંકડાઓ પરથી, આપણે ગણતરી શરૂ કરી શકીએ છીએ કે ડ્રાઇવ્સ કેટલું સારું પ્રદર્શન કરશે.


Let’s start by looking at the random workload.

ચાલો રેન્ડમ વર્કલોડને જોઈને શરૂઆત કરીએ.


Assuming each 4 KB read occurs at a random location on disk.

ધારી રહ્યા છીએ કે દરેક 4 KB વાંચન ડિસ્ક પર રેન્ડમ સ્થાન પર થાય છે.


We can calculate how long each such read would take.

આપણે ગણતરી કરી શકીએ છીએ કે આવા દરેક વાંચનમાં કેટલો સમય લાગશે.


On the Cheetah: T seek = 4ms, T rotation = 2ms, T transfer = 30microsecs

ચીતા પર: T seek = 4ms, T rotation = 2ms, T transfer = 30microsecs


The average seek time (4 milliseconds) is just taken as the average time reported by the manufacturer.

સરેરાશ શોધ સમય (4 મિલિસેકન્ડ) ઉત્પાદક દ્વારા અહેવાલ કરાયેલ સરેરાશ સમય તરીકે લેવામાં આવે છે.


The average rotational delay is calculated from the RPM directly.

સરેરાશ પરિભ્રમણ વિલંબ સીધા RPM પરથી ગણવામાં આવે છે.


Finally, the transfer time is just the size of the transfer over the peak transfer rate.

છેલ્લે, ટ્રાન્સફર સમય એ પીક ટ્રાન્સફર રેટ પર ટ્રાન્સફરનું કદ છે.


Thus, from our equation above, T I/O for the Cheetah roughly equals 6 ms.

આમ, ઉપરોક્ત સમીકરણ પરથી, ચીતા માટે T I/O આશરે 6 ms ની બરાબર છે.


To compute the rate of I/O, we just divide the size of the transfer by the average time.

I/O નો દર ગણવા માટે, આપણે ફક્ત ટ્રાન્સફરના કદને સરેરાશ સમયથી વિભાજીત કરીએ છીએ.


The same calculation for the Barracuda yields a T I/O of about 13.2 ms.

બેરકૂડા માટે સમાન ગણતરી લગભગ 13.2 ms ની T I/O આપે છે.


Now let’s look at the sequential workload.

હવે ચાલો સિક્વન્શિયલ વર્કલોડ જોઈએ.


Here we can assume there is a single seek and rotation before a very long transfer.

અહીં આપણે ધારી શકીએ છીએ કે ખૂબ લાંબા ટ્રાન્સફર પહેલાં એક જ શોધ અને પરિભ્રમણ છે.


કોષ્ટક 37.2 આ આંકડાઓનો સારાંશ આપે છે.


RAID systems can tolerate the loss of a disk and keep operating.

RAID સિસ્ટમ્સ એક ડિસ્ક ગુમાવી શકે છે અને કામ કરવાનું ચાલુ રાખી શકે છે.


Administrators could install a SCSI-based RAID storage array instead of a SCSI disk.

વહીવટકર્તાઓ SCSI ડિસ્કને બદલે SCSI-આધારિત RAID સ્ટોરેજ એરે ઇન્સ્ટોલ કરી શકે છે.


RAID just looks like a big disk to the host system.

RAID હોસ્ટ સિસ્ટમને એક મોટી ડિસ્ક જેવું જ દેખાય છે.


The operating system and client applications continue to operate without modification.

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


Transparency greatly improves the deployability of RAID.

પારદર્શિતા RAID ની જમાવટક્ષમતામાં ઘણો સુધારો કરે છે.


We now discuss some of the important aspects of RAIDs.

હવે આપણે RAID ના કેટલાક મહત્વપૂર્ણ પાસાઓની ચર્ચા કરીશું.


A RAID looks like a big, fast, and reliable disk to a file system.

RAID ફાઇલ સિસ્ટમને એક મોટી, ઝડપી અને ભરોસાપાત્ર ડિસ્ક જેવું લાગે છે.


The RAID internally must calculate which disk to access.

RAID આંતરિક રીતે કઈ ડિસ્કને ઍક્સેસ કરવી તે ગણતરી કરવી જ જોઈએ.


Consider a RAID that keeps two copies of each block.

એક RAID ને ધ્યાનમાં લો જે દરેક બ્લોકની બે નકલો રાખે છે.


A RAID system is often built as a separate hardware box.

RAID સિસ્ટમ ઘણીવાર અલગ હાર્ડવેર બોક્સ તરીકે બનાવવામાં આવે છે.


RAID આંતરિક રીતે એકદમ જટિલ છે.


RAIDs are designed to detect and recover from certain kinds of disk faults.

RAID ને ચોક્કસ પ્રકારની ડિસ્ક ખામીઓ શોધવા અને તેમાંથી પુનઃપ્રાપ્ત કરવા માટે ડિઝાઇન કરવામાં આવ્યા છે.


In this model, a disk can be in exactly one of two states: working or failed.

આ મોડેલમાં, એક ડિસ્ક બેમાંથી એક જ સ્થિતિમાં હોઈ શકે છે: કામ કરતી અથવા નિષ્ફળ.


આપણે ધારીએ છીએ કે આ સરળતાથી શોધી શકાય છે.


We will evaluate each RAID design along three axes.

આપણે ત્રણ ધરીઓ પર દરેક RAID ડિઝાઇનનું મૂલ્યાંકન કરીશું.


પ્રથમ ધરી ક્ષમતા છે.


Different schemes tend to fall in between.

વિવિધ યોજનાઓ વચ્ચે આવવાનું વલણ ધરાવે છે.


The second axis of evaluation is reliability.

મૂલ્યાંકનની બીજી ધરી વિશ્વસનીયતા છે.


અંતે, ત્રીજી ધરી કામગીરી છે.


We now consider three important RAID designs.

હવે આપણે ત્રણ મહત્વપૂર્ણ RAID ડિઝાઇનની ચર્ચા કરીએ છીએ.


The directory 'foo' would have an entry ('foo', '10').

ડિરેક્ટરી 'foo' માં એક એન્ટ્રી ('foo', '10') હશે.


Each entry in a directory refers to either files or other directories.

ડિરેક્ટરીમાંની દરેક એન્ટ્રી ફાઇલો અથવા અન્ય ડિરેક્ટરીઓનો સંદર્ભ આપે છે.


Users are able to build an arbitrary directory tree.

વપરાશકર્તાઓ મનસ્વી ડિરેક્ટરી ટ્રી બનાવી શકે છે.


The directory hierarchy starts at a root directory.

ડિરેક્ટરી વંશવેલો રુટ ડિરેક્ટરીથી શરૂ થાય છે.


For example, if a user created a directory 'foo' in the root directory.

ઉદાહરણ તરીકે, જો કોઈ વપરાશકર્તાએ રુટ ડિરેક્ટરીમાં 'foo' નામની ડિરેક્ટરી બનાવી હોય.


We could refer to the file by its absolute pathname.

આપણે ફાઇલને તેના સંપૂર્ણ પાથનામથી સંદર્ભિત કરી શકીએ છીએ.


Directories and files can have the same name as long as they are in different locations.

ડિરેક્ટરીઓ અને ફાઇલોના નામ સમાન હોઈ શકે છે, જ્યાં સુધી તે અલગ-અલગ સ્થાનો પર હોય.


Naming is an important aspect of computer systems.

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


In UNIX systems, virtually everything is named through the file system.

UNIX સિસ્ટમમાં, લગભગ બધું જ ફાઇલ સિસ્ટમ દ્વારા નામ આપવામાં આવે છે.


This uniformity of naming eases your conceptual model of the system.

નામકરણની આ એકરૂપતા સિસ્ટમના તમારા ખ્યાલના મોડેલને સરળ બનાવે છે.


Think carefully about what names you are using.

તમે કયા નામોનો ઉપયોગ કરી રહ્યા છો તે વિશે કાળજીપૂર્વક વિચારો.


The first part is an arbitrary name, whereas the second part indicates the type of the file.

પ્રથમ ભાગ એક મનસ્વી નામ છે, જ્યારે બીજો ભાગ ફાઇલના પ્રકારને સૂચવે છે.


Names are important in systems as the first step to accessing any resource.

કોઈપણ સંસાધનને ઍક્સેસ કરવા માટેનું પ્રથમ પગલું હોવાથી સિસ્ટમમાં નામો મહત્વપૂર્ણ છે.


The file system provides a unified way to access files.

ફાઇલ સિસ્ટમ ફાઇલોને ઍક્સેસ કરવાની એકીકૃત રીત પૂરી પાડે છે.


Let’s now discuss the file system interface in more detail.

ચાલો હવે ફાઇલ સિસ્ટમ ઇન્ટરફેસની વધુ વિગતવાર ચર્ચા કરીએ.


We’ll start with the basics of creating, accessing, and deleting files.

આપણે ફાઇલો બનાવવાની, ઍક્સેસ કરવાની અને કાઢી નાખવાની મૂળભૂત બાબતોથી શરૂઆત કરીશું.


This can be accomplished with the open system call.

આ ઓપન સિસ્ટમ કૉલ દ્વારા પૂર્ણ કરી શકાય છે.


પ્રોગ્રામ નવી ફાઇલ બનાવી શકે છે.


The older way of creating a file is to call creat().

ફાઇલ બનાવવાની જૂની રીત creat() ને બોલાવવાની છે.


A file descriptor is just an integer, private per process.

ફાઇલ ડિસ્ક્રિપ્ટર ફક્ત એક પૂર્ણાંક છે, જે દરેક પ્રક્રિયા માટે ખાનગી છે.


I want to call stat() on each file to get more information.

હું દરેક ફાઇલ પર stat() ને બોલાવવા માંગુ છું જેથી દરેક વિશે વધુ માહિતી મેળવી શકાય.


Indeed, this is exactly what ls does when you pass it the -l flag.

ખરેખર, જ્યારે તમે તેને -l ફ્લેગ આપો છો, ત્યારે ls બરાબર આ જ કરે છે.


Try trace on ls with and without that flag to see for yourself.

તમે જાતે જ જોવા માટે તે ફ્લેગ સાથે અને વગર ls પર ટ્રેસ કરવાનો પ્રયાસ કરો.


Finally, you can delete a directory with a call to rmdir().

છેવટે, તમે rmdir() ને બોલાવીને ડિરેક્ટરીને કાઢી શકો છો.


Unlike file deletion, however, removing directories is more dangerous.

જો કે, ફાઇલ ડિલીટ કરવાથી વિપરીત, ડિરેક્ટરીઓ દૂર કરવી વધુ જોખમી છે.


Thus, rmdir() has the requirement that the directory be empty.

આમ, rmdir() ને એ જરૂરીયાત છે કે ડિરેક્ટરી ખાલી હોવી જોઈએ.


If you try to delete a non-empty directory, the call to rmdir() simply will fail.

જો તમે ખાલી ન હોય તેવી ડિરેક્ટરીને કાઢી નાખવાનો પ્રયાસ કરો છો, તો rmdir() ને બોલાવવામાં નિષ્ફળતા મળશે.


We now come back to the mystery of why removing a file is performed via unlink().

હવે આપણે ફાઇલને અનલિંક() દ્વારા દૂર કરવાનું રહસ્ય શું છે તેના પર પાછા આવીએ છીએ.


The link() system call takes two arguments, an old pathname and a new one.

લિંક() સિસ્ટમ કૉલ બે દલીલો લે છે, એક જૂનો પાથનામ અને એક નવો.


When you “link” a new file name to an old one, you essentially create another way to refer to the same file.

જ્યારે તમે કોઈ જૂના ફાઇલનામને “લિંક” કરો છો, ત્યારે તમે મૂળભૂત રીતે તે જ ફાઇલનો સંદર્ભ આપવાની બીજી રીત બનાવો છો.


The command-line program ln is used to do this.

આ કરવા માટે કમાન્ડ-લાઇન પ્રોગ્રામ ln નો ઉપયોગ થાય છે.


Here we created a file with the word “hello” in it, and called the file file2.

અહીં, અમે તેમાં “hello” શબ્દ સાથે એક ફાઇલ બનાવી છે, અને ફાઇલને file2 નામ આપ્યું છે.


We then create a hard link to that file using the ln program.

પછી અમે ln પ્રોગ્રામનો ઉપયોગ કરીને તે ફાઇલની હાર્ડ લિંક બનાવીએ છીએ.


After this, we can examine the file by either opening file or file2.

આ પછી, અમે file અથવા file2 ખોલીને ફાઇલની તપાસ કરી શકીએ છીએ.


The way link works is that it simply creates another name in the directory you are creating the link to.

લિંક જે રીતે કામ કરે છે તે એ છે કે તે તમે જે ડિરેક્ટરીમાં લિંક બનાવી રહ્યા છો તેમાં બીજું નામ બનાવે છે.


The file is not copied in any way; rather, you now just have two human names (file and file2) that both refer to the same file.

ફાઇલને કોઈપણ રીતે કૉપિ કરવામાં આવતી નથી; તેના બદલે, તમારી પાસે હવે ફક્ત બે માનવ નામો (file અને file2) છે જે બંને તે જ ફાઇલનો સંદર્ભ આપે છે.


We can even see this in the directory itself, by printing out the inode number of each file.

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


By passing the -i flag to ls, it prints out the inode number of each file.

ls ને -i ફ્લેગ પાસ કરીને, તે દરેક ફાઇલની આઇનોડ સંખ્યા પ્રિન્ટ કરે છે.


When you create a file, you are really doing two things.

જ્યારે તમે ફાઇલ બનાવો છો, ત્યારે તમે ખરેખર બે વસ્તુઓ કરો છો.


First, you are making a structure (the inode) that will track virtually all relevant information about the file.

પ્રથમ, તમે એક માળખું (આઇનોડ) બનાવી રહ્યા છો જે ફાઇલ વિશેની લગભગ બધી સંબંધિત માહિતીને ટ્રેક કરશે.


The inode is a data structure that stores metadata about a file.

આઈનોડ એ એક ડેટા સ્ટ્રક્ચર છે જે ફાઇલ વિશેની મેટાડેટા સંગ્રહિત કરે છે.


File systems use inodes to manage and organize files on a storage device.

ફાઇલ સિસ્ટમ્સ સ્ટોરેજ ડિવાઇસ પર ફાઇલોને મેનેજ અને ગોઠવવા માટે આઇનોડનો ઉપયોગ કરે છે.


The inode number is used to index into an array of inodes.

આઇનોડ નંબરનો ઉપયોગ આઇનોડ્સની એરેમાં ઇન્ડેક્સ કરવા માટે થાય છે.


Each inode contains information such as file size, permissions, and data block locations.

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


The file system must traverse the pathname to locate the desired inode.

ફાઇલ સિસ્ટમે ઇચ્છિત આઇનોડને શોધવા માટે પાથનામને પાર કરવું આવશ્યક છે.


Reading a file involves accessing the inode to find the data blocks.

ફાઇલ વાંચવામાં ડેટા બ્લોક્સ શોધવા માટે આઇનોડને ઍક્સેસ કરવાનો સમાવેશ થાય છે.


Writing to a file may involve allocating new data blocks and updating the inode.

ફાઇલમાં લખવામાં નવા ડેટા બ્લોક્સ ફાળવવા અને આઇનોડને અપડેટ કરવાનો સમાવેશ થઈ શકે છે.


Creating a new file requires allocating an inode and updating directory entries.

નવી ફાઇલ બનાવવા માટે આઇનોડ ફાળવવાની અને ડિરેક્ટરી એન્ટ્રીઓને અપડેટ કરવાની જરૂર છે.


The root directory's inode number is typically well-known.

રુટ ડિરેક્ટરીનો આઇનોડ નંબર સામાન્ય રીતે જાણીતો છે.


File systems use bitmaps to track free and used inodes and data blocks.

ફાઇલ સિસ્ટમ્સ ફ્રી અને વપરાયેલ આઇનોડ્સ અને ડેટા બ્લોક્સને ટ્રેક કરવા માટે બિટમેપ્સનો ઉપયોગ કરે છે.


આઇનોડ ફાઇલના મેટાડેટા સંગ્રહિત કરે છે.


The file system's performance depends on efficient inode management.

ફાઇલ સિસ્ટમની કામગીરી કાર્યક્ષમ આઇનોડ મેનેજમેન્ટ પર આધારિત છે.


An indirect pointer is used to point to a block that contains more pointers.

ઇનડાયરેક્ટ પોઇન્ટરનો ઉપયોગ એવા બ્લોક તરફ નિર્દેશ કરવા માટે થાય છે જેમાં વધુ પોઇન્ટર્સ હોય છે.


The multi-level index approach is used to support larger files.

મોટી ફાઇલોને સપોર્ટ કરવા માટે મલ્ટિ-લેવલ ઇન્ડેક્સ અભિગમનો ઉપયોગ થાય છે.


Extents are used instead of pointers in some file systems.

કેટલીક ફાઇલ સિસ્ટમ્સમાં પોઇન્ટર્સને બદલે એક્સટેન્ટ્સનો ઉપયોગ થાય છે.


The file system must ensure data consistency.

ફાઇલ સિસ્ટમે ડેટાની સુસંગતતા સુનિશ્ચિત કરવી આવશ્યક છે.


The open() system call is used to open a file.

ફાઇલ ખોલવા માટે open() સિસ્ટમ કૉલનો ઉપયોગ થાય છે.


The read() system call is used to read data from a file.

ફાઇલમાંથી ડેટા વાંચવા માટે read() સિસ્ટમ કૉલનો ઉપયોગ થાય છે.


The write() system call is used to write data to a file.

ફાઇલમાં ડેટા લખવા માટે write() સિસ્ટમ કૉલનો ઉપયોગ થાય છે.


File creation involves multiple I/O operations.

ફાઇલ બનાવવામાં બહુવિધ I/O ઓપરેશન્સ સામેલ છે.


The disk transfer rate improves rapidly.

ડિસ્કની ટ્રાન્સફર રેટ ઝડપથી સુધરે છે.


Mechanical aspects of drives improve slowly.

ડ્રાઇવના યાંત્રિક પાસા ધીમે ધીમે સુધરે છે.


The file system was extremely worried about small files.

ફાઇલ સિસ્ટમ નાના ફાઇલો વિશે ખૂબ જ ચિંતિત હતી.


This internal fragmentation could lead to wasted disk space.

આ આંતરિક વિભાજન બગાડાયેલી ડિસ્ક જગ્યા તરફ દોરી શકે છે.


તેઓએ પેટા-બ્લોક્સ રજૂ કરવાનું નક્કી કર્યું.


The file system will allocate 512-byte blocks.

ફાઇલ સિસ્ટમ 512-બાઇટ બ્લોક્સ ફાળવશે.


FFS introduced a disk layout optimized for performance.

FFS એ પ્રદર્શન માટે ઑપ્ટિમાઇઝ કરેલ ડિસ્ક લેઆઉટ રજૂ કર્યું.


Modern disks internally read the entire track.

આધુનિક ડિસ્ક આંતરિક રીતે આખા ટ્રેકને વાંચે છે.


Abstraction and higher-level interfaces can be a good thing.

એબ્સ્ટ્રેક્શન અને ઉચ્ચ-સ્તરના ઇન્ટરફેસ સારી બાબત હોઈ શકે છે.


FFS એ લાંબા ફાઇલ નામોને મંજૂરી આપી.


Symbolic links allow an alias to any other file.

પ્રતીકાત્મક લિંક્સ કોઈપણ અન્ય ફાઇલ માટે ઉપનામની મંજૂરી આપે છે.


Usability improvements gained FFS a stronger user base.

ઉપયોગીતા સુધારણાએ FFS ને મજબૂત વપરાશકર્તા આધાર મેળવ્યો.


The introduction of FFS was a watershed moment.

FFS ની રજૂઆત એક મહત્વપૂર્ણ ક્ષણ હતી.


File management was one of the most interesting issues.

ફાઇલ મેનેજમેન્ટ એ સૌથી રસપ્રદ મુદ્દાઓમાંથી એક હતું.


ડિસ્કને ડિસ્ક તરીકે ગણો.


Modern versions are a little more complex.

આધુનિક સંસ્કરણો થોડા વધુ જટિલ છે.


File system data structures must persist.

ફાઇલ સિસ્ટમ ડેટા સ્ટ્રક્ચર્સ ચાલુ રહેવા જોઈએ.


A major challenge is how to update persistent data.

એક મોટો પડકાર એ છે કે કાયમી ડેટાને કેવી રીતે અપડેટ કરવો.


સિસ્ટમ ક્રેશ થઈ શકે છે અથવા પાવર ગુમાવી શકે છે.


We’ll begin by examining the approach taken by older file systems.

આપણે જૂની ફાઇલ સિસ્ટમ્સ દ્વારા અપનાવેલ અભિગમની તપાસ કરીને શરૂઆત કરીશું.


Even the simplest of operations like opening, reading, or writing a file incurs a huge number of I/O operations, scattered over the disk.

ફાઇલ ખોલવા, વાંચવા અથવા લખવા જેવી સૌથી સરળ કામગીરી પણ મોટી સંખ્યામાં I/O કામગીરીઓ કરે છે, જે ડિસ્ક પર પથરાયેલી હોય છે.


What can a file system do to reduce the high costs of doing so many I/Os?

આટલા બધા I/O કરવાના ઊંચા ખર્ચને ઘટાડવા માટે ફાઇલ સિસ્ટમ શું કરી શકે?


To remedy what would clearly be a huge performance problem, most file systems aggressively use system memory (DRAM) to cache important blocks.

જે સ્પષ્ટપણે એક વિશાળ પ્રદર્શન સમસ્યા હશે તેને સુધારવા માટે, મોટાભાગની ફાઇલ સિસ્ટમ્સ મહત્વપૂર્ણ બ્લોક્સને કેશ કરવા માટે આક્રમક રીતે સિસ્ટમ મેમરી (DRAM) નો ઉપયોગ કરે છે.


Imagine the open example above: without caching, every file open would require at least two reads for every level in the directory hierarchy.

ઉપરના ઓપન ઉદાહરણની કલ્પના કરો: કેશિંગ વગર, દરેક ફાઇલ ખોલવા માટે ડિરેક્ટરી વંશવેલાના દરેક સ્તર માટે ઓછામાં ઓછા બે રીડની જરૂર પડશે.


With a long pathname (e.g., /1/2/3/ ... /100/file.txt), the file system would literally perform hundreds of reads just to open the file!

લાંબા પાથનામ સાથે (દા.ત., /1/2/3/ ... /100/file.txt), ફાઇલ સિસ્ટમ ફાઇલ ખોલવા માટે શાબ્દિક રીતે સેંકડો રીડ કરશે!


Early file systems thus introduced a fix-sized cache to hold popular blocks.

આમ, પ્રારંભિક ફાઇલ સિસ્ટમ્સ લોકપ્રિય બ્લોક્સને પકડી રાખવા માટે નિશ્ચિત-કદની કેશ રજૂ કરે છે.


Modern systems integrate virtual memory pages and file system pages into a unified page cache.

આધુનિક સિસ્ટમ્સ વર્ચ્યુઅલ મેમરી પૃષ્ઠો અને ફાઇલ સિસ્ટમ પૃષ્ઠોને એકીકૃત પૃષ્ઠ કેશમાં એકીકૃત કરે છે.


The first open may generate a lot of I/O traffic to read in directory inode and data, but subsequent file opens of that same file will mostly hit in the cache and thus no I/O is needed.

પ્રથમ ઓપન ડિરેક્ટરી આઇનોડ અને ડેટા વાંચવા માટે ઘણાં I/O ટ્રાફિક જનરેટ કરી શકે છે, પરંતુ તે જ ફાઇલના અનુગામી ફાઇલ ઓપન્સ મોટે ભાગે કેશમાં આવશે અને તેથી કોઈ I/O ની જરૂર નથી.


Whereas read I/O can be avoided altogether with a sufficiently large cache, write traffic has to go to disk in order to become persistent.

જ્યારે પૂરતી મોટી કેશ સાથે રીડ I/O ને સંપૂર્ણપણે ટાળી શકાય છે, ત્યારે લખેલા ટ્રાફિકને કાયમી થવા માટે ડિસ્ક પર જવું પડે છે.


First, by delaying writes, the file system can batch some updates into a smaller set of I/Os.

પ્રથમ, લખવામાં વિલંબ કરીને, ફાઇલ સિસ્ટમ કેટલાક અપડેટ્સને I/Os ના નાના સમૂહમાં બેચ કરી શકે છે.


Second, by buffering a number of writes in memory, the system can then schedule the subsequent I/Os and thus increase performance.

બીજું, મેમરીમાં સંખ્યાબંધ લેખનને બફર કરીને, સિસ્ટમ પછીના I/Os ને શેડ્યૂલ કરી શકે છે અને આમ પ્રદર્શનમાં વધારો કરી શકે છે.


Finally, some writes are avoided altogether by delaying them; for example, if an application creates a file and then deletes it, delaying the writes to reflect the file creation to disk avoids them entirely.

છેવટે, કેટલાક લેખનને વિલંબ કરીને સંપૂર્ણપણે ટાળવામાં આવે છે; ઉદાહરણ તરીકે, જો કોઈ એપ્લિકેશન ફાઇલ બનાવે છે અને પછી તેને કાઢી નાખે છે, તો ફાઇલ બનાવટને ડિસ્ક પર પ્રતિબિંબિત કરવા માટે લેખનને વિલંબિત કરવાથી તે સંપૂર્ણપણે ટાળી શકાય છે.


In this case, laziness (in writing blocks to disk) is a virtue.

આ કિસ્સામાં, આળસ (ડિસ્ક પર બ્લોક્સ લખવામાં) એક સદ્ગુણ છે.


For the reasons above, most modern file systems buffer writes in memory for anywhere between five and thirty seconds.

ઉપરોક્ત કારણોસર, મોટાભાગની આધુનિક ફાઇલ સિસ્ટમ્સ પાંચથી ત્રીસ સેકન્ડની વચ્ચે ગમે ત્યાં મેમરીમાં લખે છે.


Some applications (such as databases) don’t enjoy this trade-off.

કેટલીક એપ્લિકેશન્સ (જેમ કે ડેટાબેસેસ) આ વેપાર-બંધનોનો આનંદ માણતી નથી.


We have seen the basic machinery required in building a file system.

આપણે ફાઇલ સિસ્ટમ બનાવવા માટે જરૂરી મૂળભૂત મશીનરી જોઈ છે.


There needs to be some information about each file (metadata), usually stored in a structure called an inode.

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


Directories are just a specific type of file that store name→inode-number mappings.

ડિરેક્ટરીઓ એ ફક્ત એક ચોક્કસ પ્રકારની ફાઇલ છે જે નામ→આઇનોડ-નંબર મેપિંગ્સ સંગ્રહિત કરે છે.


સમસ્યા: પ્રદર્શન ભયાનક હતું.


The main issue was that the old UNIX file system treated the disk like it was a random-access memory.

મુખ્ય મુદ્દો એ હતો કે જૂની UNIX ફાઇલ સિસ્ટમ ડિસ્ક સાથે વર્તે છે જાણે તે રેન્ડમ-એક્સેસ મેમરી હોય.


The allocated blocks and read the entire directory tree may take many minutes or hours.

ફાળવેલા બ્લોક્સ અને સંપૂર્ણ ડિરેક્ટરી ટ્રી વાંચવામાં ઘણા મિનિટો અથવા કલાકો લાગી શકે છે.


Performance offsck, as disks grew in capacity and RAIDs grew in popularity, became prohibitive.

ડિસ્કની ક્ષમતા અને RAID ની લોકપ્રિયતા વધતાં, કામગીરીની ખામીઓ પ્રતિબંધક બની ગઈ.


Consider our example above, where just three blocks are written to the disk.

ઉપરના અમારા ઉદાહરણને ધ્યાનમાં લો, જ્યાં ફક્ત ત્રણ બ્લોક્સ ડિસ્ક પર લખાયેલા છે.


This situation is akin to dropping your keys on the floor in your bedroom.

આ સ્થિતિ તમારા બેડરૂમમાં ફ્લોર પર તમારી ચાવીઓ પાડવા જેવી છે.


Thus, as disks (and RAIDs) grew, researchers and practitioners started to look for other solutions.

આમ, જેમ જેમ ડિસ્ક (અને RAID) વધ્યા, સંશોધકો અને પ્રેક્ટિશનરોએ અન્ય ઉકેલો શોધવાનું શરૂ કર્યું.


Probably the most popular solution to the consistent update problem is to steal an idea from the world of database management systems.

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


That idea, known as write-ahead logging, was invented to address exactly this type of problem.

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


In file systems, we usually call write-ahead logging journaling for historical reasons.

ફાઇલ સિસ્ટમમાં, અમે સામાન્ય રીતે ઐતિહાસિક કારણોસર રાઈટ-એહેડ લોગિંગને જર્નલિંગ કહીએ છીએ.


મૂળભૂત વિચાર નીચે મુજબ છે.


When updating the disk, before overwriting the structures in place, first write down a little note describing what you are about to do.

ડિસ્કને અપડેટ કરતી વખતે, જગ્યાએ રહેલી રચનાઓને ઓવરરાઇટ કરતા પહેલા, તમે શું કરવા જઈ રહ્યા છો તેનું વર્ણન કરતી એક નાની નોંધ લખો.


Writing this note is the “write ahead” part, and we write it to a structure that we organize as a “log”.

આ નોંધ લખવી એ “રાઈટ અહેડ” ભાગ છે, અને અમે તેને એક એવી રચનામાં લખીએ છીએ જેને આપણે “લોગ” તરીકે ગોઠવીએ છીએ.


By writing the note to disk, you are guaranteeing that if a crash takes places during the update, you can go back and look at the note you made and try again.

નોંધને ડિસ્ક પર લખીને, તમે ખાતરી કરો છો કે જો અપડેટ દરમિયાન ક્રેશ થાય છે, તો તમે પાછા જઈ શકો છો અને તમે બનાવેલી નોંધ જોઈ શકો છો અને ફરીથી પ્રયાસ કરી શકો છો.


By design, journaling thus adds a bit of work during updates to greatly reduce the amount of work required during recovery.

ડિઝાઇન દ્વારા, જર્નલિંગ આમ અપડેટ્સ દરમિયાન થોડું કામ ઉમેરે છે જેથી પુનઃપ્રાપ્તિ દરમિયાન જરૂરી કામની માત્રામાં મોટા પ્રમાણમાં ઘટાડો થાય.


We’ll now describe how Linux ext3, a popular journaling file system, incorporates journaling into the file system.

હવે આપણે વર્ણવીશું કે કેવી રીતે Linux ext3, એક લોકપ્રિય જર્નલિંગ ફાઇલ સિસ્ટમ, ફાઇલ સિસ્ટમમાં જર્નલિંગનો સમાવેશ કરે છે.


Most of the on-disk structures are identical to Linux ext2.

ડિસ્ક પરની મોટાભાગની રચનાઓ Linux ext2 જેવી જ છે.


The new key structure is the journal itself, which occupies some small amount of space within the partition or on another device.

નવી કી સ્ટ્રક્ચર પોતે જર્નલ છે, જે પાર્ટીશનની અંદર અથવા અન્ય ઉપકરણ પર થોડી જગ્યા રોકે છે.


The real difference is just the presence of the journal, and of course, how it is used.

વાસ્તવિક તફાવત ફક્ત જર્નલની હાજરી છે, અને અલબત્ત, તેનો ઉપયોગ કેવી રીતે થાય છે.


Let’s look at a simple example to understand how data journaling works.

ડેટા જર્નલિંગ કેવી રીતે કાર્ય કરે છે તે સમજવા માટે ચાલો એક સરળ ઉદાહરણ જોઈએ.


Data journaling is available as a mode with the Linux ext3 filesystem, from which much of this discussion is based.

ડેટા જર્નલિંગ Linux ext3 ફાઇલસિસ્ટમ સાથે એક મોડ તરીકે ઉપલબ્ધ છે, જેના પર આ ચર્ચા આધારિત છે.


Say we have our canonical update again, where we wish to write the ‘inode (I[v2]), bitmap (B[v2]), and data block (Db) to disk again.

ધારો કે અમારી પાસે ફરીથી અમારું પ્રમાણભૂત અપડેટ છે, જ્યાં અમે ‘inode (I[v2]), બિટમેપ (B[v2]), અને ડેટા બ્લોક (Db) ને ફરીથી ડિસ્ક પર લખવા માંગીએ છીએ.


The system replays everything in the log during recovery.

પુનઃપ્રાપ્તિ દરમિયાન સિસ્ટમ લોગમાંની દરેક વસ્તુને ફરીથી ચલાવે છે.


આ એક સાચી પુનઃપ્રાપ્તિ ક્રિયા નથી.


One could, for example, never reuse blocks until the delete of said blocks is checkpointed out of the journal.

ઉદાહરણ તરીકે, કોઈ પણ બ્લોક્સનો ફરીથી ઉપયોગ કરી શકશે નહીં જ્યાં સુધી તે બ્લોક્સને જર્નલમાંથી ચેકપોઇન્ટ ન કરવામાં આવે.


What Linux ext3 does instead is to add a new type of record to the journal, known as a revoke record.

તેના બદલે, Linux ext3 જર્નલમાં એક નવો પ્રકારનો રેકોર્ડ ઉમેરે છે, જેને રિવોક રેકોર્ડ તરીકે ઓળખવામાં આવે છે.


When replaying the journal, the system first scans for such revoke records.

જર્નલને ફરીથી ચલાવતી વખતે, સિસ્ટમ પ્રથમ આવા રિવોક રેકોર્ડ્સ માટે સ્કેન કરે છે.


Any such revoked data is never replayed, thus avoiding the problem mentioned above.

આમ, કોઈપણ રદ કરાયેલ ડેટાને ક્યારેય ફરીથી ચલાવવામાં આવતો નથી, આમ ઉપર જણાવેલ સમસ્યાને ટાળે છે.


We summarize the protocols we have discussed with timelines depicting each of them.

અમે સમયરેખા સાથે ચર્ચા કરેલા પ્રોટોકોલનો સારાંશ આપીએ છીએ જે તેમાંના દરેકને દર્શાવે છે.


In each table, time increases in the downward direction.

દરેક કોષ્ટકમાં, સમય નીચેની દિશામાં વધે છે.


The writes of the transaction begin block (TxB) and the contents of the transaction can logically be issued at the same time.

ટ્રાન્ઝેક્શન બ્લોક (TxB) ની શરૂઆત અને ટ્રાન્ઝેક્શનની સામગ્રીને તાર્કિક રીતે એક જ સમયે જારી કરી શકાય છે.


The checkpoint-ing writes to data and metadata blocks cannot begin until the transaction end block has committed.

ડેટા અને મેટાડેટા બ્લોક્સ પર ચેકપોઇન્ટ-ઇંગ લખવાનું શરૂ કરી શકાતું નથી જ્યાં સુધી ટ્રાન્ઝેક્શન એન્ડ બ્લોક કમિટ ન થાય.


Horizontal dashed lines show where write-ordering requirements must be obeyed.

આડી તૂટક રેખાઓ બતાવે છે કે જ્યાં લખવાના ઓર્ડરની આવશ્યકતાઓનું પાલન કરવું આવશ્યક છે.


The data write can logically be issued at the same time as the writes to the transaction begin and the contents of the journal.

ડેટા લખવાનું તાર્કિક રીતે ટ્રાન્ઝેક્શનની શરૂઆત અને જર્નલની સામગ્રી પર લખવાની સાથે જ જારી કરી શકાય છે.


In a real system, completion time is determined by the I/O subsystem, which may reorder writes to improve performance.

વાસ્તવિક સિસ્ટમમાં, પૂર્ણ થવાનો સમય I/O સબસિસ્ટમ દ્વારા નક્કી કરવામાં આવે છે, જે કામગીરી સુધારવા માટે લખવાનું ફરીથી ગોઠવી શકે છે.


We’ve thus far described two options in keeping file system metadata consistent.

આમ, અમે ફાઇલ સિસ્ટમ મેટાડેટાને સુસંગત રાખવા માટે બે વિકલ્પોનું વર્ણન કર્યું છે.


This approach carefully orders all writes to the file system to ensure that the on-disk structures are never left in an inconsistent state.

આ અભિગમ ફાઇલ સિસ્ટમમાંના તમામ લખાણોને કાળજીપૂર્વક ગોઠવે છે જેથી ખાતરી થાય કે ડિસ્ક પરની રચનાઓ ક્યારેય અસંગત સ્થિતિમાં ન રહે.


Implementing Soft Updates can be a challenge, however.

જો કે, સોફ્ટ અપડેટ્સનો અમલ કરવો એક પડકાર બની શકે છે.


This technique never overwrites files or directories in place.

આ તકનીક ક્યારેય ફાઇલો અથવા ડિરેક્ટરીઓને તે જ જગ્યાએ ઓવરરાઇટ કરતી નથી.


After a number of updates are completed, COW file systems flip the root structure of the file system.

અપડેટ્સની સંખ્યા પૂર્ણ થયા પછી, COW ફાઇલ સિસ્ટમ ફાઇલ સિસ્ટમની રૂટ સ્ટ્રક્ચરને ફ્લિપ કરે છે.


We have introduced the problem of crash consistency, and discussed various approaches to attacking this problem.

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


Journaling reduces recovery time from O(size-of-the-disk-volume) to O(size-of-the- log), thus speeding recovery substantially after a crash and restart.

જર્નલિંગ પુનઃપ્રાપ્તિ સમયને O(size-of-the-disk-volume) થી O(size-of-the-log) સુધી ઘટાડે છે, આમ ક્રેશ અને પુનઃપ્રારંભ પછી પુનઃપ્રાપ્તિને નોંધપાત્ર રીતે ઝડપી બનાવે છે.


To the imap, and hence performance would suffer.

આઇમેપને કારણે, અને તેથી કામગીરી ઘટશે.


Instead, LFS places chunks of the inode map right next to where it is writing all of the other new information.

તેના બદલે, LFS ઇનોડ નકશાના ટુકડાઓને તે બધી અન્ય નવી માહિતી લખી રહ્યું છે તેની બાજુમાં મૂકે છે.


Thus, when appending a data block to a filek, LFS actually writes the new data block, its inode, and a piece of the inode map all together onto the disk.

આમ, જ્યારે ફાઇલk માં ડેટા બ્લોક ઉમેરવામાં આવે છે, ત્યારે LFS વાસ્તવમાં નવો ડેટા બ્લોક, તેનો ઇનોડ અને ઇનોડ નકશાનો એક ભાગ બધાને એકસાથે ડિસ્ક પર લખે છે.


How do we find the inode map, now that pieces of it are alsonow spread across the disk?

આપણે ઇનોડ નકશો કેવી રીતે શોધી શકીએ, હવે તેના ટુકડાઓ પણ ડિસ્ક પર ફેલાયેલા છે?


LFS has just such a fixed place on disk for this, known as thecheck- point region (CR).

LFS પાસે આ માટે ડિસ્ક પર એક નિશ્ચિત સ્થાન છે, જેને ચેક-પોઇન્ટ ક્ષેત્ર (CR) તરીકે ઓળખવામાં આવે છે.


The checkpoint region contains pointers to (i.e., ad- dresses of) the latest pieces of the inode map, and thus the inode map pieces can be found by reading the CR first.

ચેકપોઇન્ટ ક્ષેત્રમાં ઇનોડ નકશાના તાજેતરના ટુકડાઓ (એટલે કે, સરનામાં) તરફના પોઇન્ટર્સ છે, અને તેથી ઇનોડ નકશાના ટુકડાઓ પ્રથમ CR વાંચીને શોધી શકાય છે.


Note the checkpoint region is only updated periodically (say every 30 seconds or so), and thus perfor- mance is not ill-affected.

ધ્યાન રાખો કે ચેકપોઇન્ટ ક્ષેત્ર ફક્ત સમયાંતરે અપડેટ થાય છે (કહો કે દર 30 સેકન્ડ કે તેથી વધુ), અને તેથી કામગીરી પર ખરાબ અસર થતી નથી.


Here is an example of the checkpoint region (note it is all theway at the beginning of the disk, at address 0), and a single imap chunk, inode, and data block.

અહીં ચેકપોઇન્ટ ક્ષેત્રનું એક ઉદાહરણ છે (નોંધ લો કે તે ડિસ્કના શરૂઆતમાં, સરનામાં 0 પર છે), અને એક જ ઇમેપ ચંક, ઇનોડ અને ડેટા બ્લોક.


To make sure you understand how LFS works, let us now walk through what must happen to read a file from disk.

તમે LFS કેવી રીતે કામ કરે છે તે સમજો છો તેની ખાતરી કરવા માટે, ચાલો હવે ડિસ્કમાંથી ફાઇલ વાંચવા માટે શું થવું જોઈએ તે જોઈએ.


The first on-disk data structure we must readis the checkpoint region.

પ્રથમ ઓન-ડિસ્ક ડેટા સ્ટ્રક્ચર જે આપણે વાંચવું જોઈએ તે ચેકપોઇન્ટ ક્ષેત્ર છે.


After this point, when given an inode number of a file, LFS simply looks up the inode-number to inode-disk- address mapping in the imap, and reads in the most recent version of the inode.

આ બિંદુ પછી, જ્યારે ફાઇલનો ઇનોડ નંબર આપવામાં આવે છે, ત્યારે LFS ફક્ત imap માં ઇનોડ-નંબરથી ઇનોડ-ડિસ્ક-એડ્રેસ મેપિંગને જુએ છે અને ઇનોડનું સૌથી તાજેતરનું સંસ્કરણ વાંચે છે.


In the common case, LFS should perform the same number of I/Os as a typical file system when reading a file from disk; the entire imap is cached and thus the extra work LFS does during a read is to look up the inode’s address in the imap.

સામાન્ય કિસ્સામાં, LFS એ ડિસ્કમાંથી ફાઇલ વાંચતી વખતે સામાન્ય ફાઇલ સિસ્ટમ જેટલી જ સંખ્યામાં I/Os કરવી જોઈએ; આખું imap કેશ કરવામાં આવે છે અને આમ વાંચન દરમિયાન LFS જે વધારાનું કામ કરે છે તે imap માં ઇનોડનું સરનામું જોવાનું છે.


However, to access a file in a file system (such as /home/remzi/foo, one of our favorite fake file names), some directo- ries must be accessed too.

જો કે, ફાઇલ સિસ્ટમમાં ફાઇલને ઍક્સેસ કરવા માટે (જેમ કે /home/remzi/foo, અમારા મનપસંદ નકલી ફાઇલ નામોમાંથી એક), કેટલીક ડિરેક્ટરીઓને પણ ઍક્સેસ કરવી આવશ્યક છે.


Fortunately, directory structure is basically identical to classic UNIX file systems, in that a directory is just a collection of (name, inode number) mappings.

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


For example, when creating a file on disk, LFS must both write a new inode, some data, as well as the directory data and its inode that refer to this file.

ઉદાહરણ તરીકે, જ્યારે ડિસ્ક પર ફાઇલ બનાવવામાં આવે છે, ત્યારે LFS એ નવો ઇનોડ, કેટલાક ડેટા તેમજ ડિરેક્ટરી ડેટા અને તેના ઇનોડ બંને લખવા આવશ્યક છે જે આ ફાઇલનો સંદર્ભ આપે છે.


Remember that LFS will do so sequentially on the disk (after buffering the updates for some time).

યાદ રાખો કે LFS આમ ડિસ્ક પર ક્રમિક રીતે કરશે (થોડા સમય માટે અપડેટ્સને બફર કર્યા પછી).


Thus, creatinga filefooin a directory would lead to the following new structures on disk:

આમ, ડિરેક્ટરીમાં ફાઇલફોઓ બનાવવાથી ડિસ્ક પર નીચેના નવા માળખાં બનશે:


There is one other serious problem in LFS that the inode map solves, known as therecursive update problem[Z+12].

LFS માં બીજી એક ગંભીર સમસ્યા છે જે ઇનોડ નકશો ઉકેલે છે, જેને પુનરાવર્તિત અપડેટ સમસ્યા[Z+12] તરીકે ઓળખવામાં આવે છે.


You may have noticed another problem with LFS; it keeps writing newer version of a file, its inode, and in fact all data to new parts of the disk.

તમે LFS સાથે બીજી એક સમસ્યા નોંધી હશે; તે ફાઇલનું નવું સંસ્કરણ, તેનો ઇનોડ અને હકીકતમાં તમામ ડેટા ડિસ્કના નવા ભાગોમાં લખવાનું ચાલુ રાખે છે.


આવા જૂના માલને આપણે કચરો કહીએ છીએ.


It turns out that the file systems are quite complex.

એવું લાગે છે કે ફાઇલ સિસ્ટમ્સ ખૂબ જટિલ છે.


We found numerous bugs in the file system.

અમે ફાઇલ સિસ્ટમમાં અસંખ્ય ભૂલો શોધી કાઢી.


This paper discusses how to build fault-tolerant services.

આ પેપર ખામી-સહિષ્ણુ સેવાઓ કેવી રીતે બનાવવી તે અંગે ચર્ચા કરે છે.


Memory contents disappear if your machine crashes.

જો તમારું મશીન ક્રેશ થાય, તો મેમરીની સામગ્રી અદૃશ્ય થઈ જાય છે.


હંમેશ માટે એક લાંબો સમય છે.


Updating a persistent storage device is complicated.

કાયમી સ્ટોરેજ ઉપકરણને અપડેટ કરવું જટિલ છે.


મેં ડિસ્ક શેડ્યુલિંગ વિશે પણ શીખ્યા.


Check out some of the latest on erasure codes.

ઇરેઝર કોડ્સ પરના કેટલાક નવીનતમ તપાસો.


Even with Flash, all of this stuff is still relevant.

ફ્લેશ સાથે પણ, આ બધું હજી પણ સંબંધિત છે.


Flash Translation Layers (FTLs) use log-structuring internally.

ફ્લેશ ટ્રાન્સલેશન લેયર્સ (FTLs) આંતરિક રીતે લોગ-સ્ટ્રક્ચરિંગનો ઉપયોગ કરે છે.


Thinking about locality is always useful.

સ્થાનિકતા વિશે વિચારવું હંમેશા ઉપયોગી છે.


Distributed systems have changed the face of the world.

વિતરિત સિસ્ટમોએ વિશ્વનો ચહેરો બદલી નાખ્યો છે.


When you contact a modern web service such as Google or Facebook, you are not just interacting with a single machine.

જ્યારે તમે Google અથવા Facebook જેવી આધુનિક વેબ સેવાઓનો સંપર્ક કરો છો, ત્યારે તમે ફક્ત એક જ મશીન સાથે ક્રિયાપ્રતિક્રિયા કરતા નથી.


Machines, disks, networks, and software all fail from time to time.

મશીનો, ડિસ્ક, નેટવર્ક અને સોફ્ટવેર બધા સમયાંતરે નિષ્ફળ જાય છે.


How can we build a working system out of parts that don’t work correctly all the time?

આપણે એવા ભાગોમાંથી કાર્યકારી સિસ્ટમ કેવી રીતે બનાવી શકીએ જે હંમેશાં યોગ્ય રીતે કામ કરતા નથી?


સંચાર સ્વાભાવિક રીતે અવિશ્વસનીય છે.


Packets sometimes do not reach their destination.

કેટલીકવાર પેકેટો તેમના ગંતવ્ય સુધી પહોંચતા નથી.


Bit corruption, down or non-working links and machines, and lack of buffer space for incoming packets all lead to the same result.

બિટ ભ્રષ્ટાચાર, ડાઉન અથવા બિન-કાર્યકારી લિંક્સ અને મશીનો અને આવનારા પેકેટો માટે બફર જગ્યાનો અભાવ, આ બધા એક જ પરિણામ તરફ દોરી જાય છે.


To build reliable services atop such unreliable networks, we must consider techniques that can cope with packet loss.

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


The sender sends a message to the receiver; the receiver then sends a short message back to acknowledge its receipt.

મોકલનાર રીસીવરને સંદેશ મોકલે છે; રીસીવર પછી તેની રસીદને સ્વીકારવા માટે એક ટૂંકો સંદેશ પાછો મોકલે છે.


The system should use the redundancy mechanism to return the correct data.

સિસ્ટમે સાચા ડેટાને પરત કરવા માટે રિડન્ડન્સી પદ્ધતિનો ઉપયોગ કરવો જોઈએ.


When a storage system tries to access a block, and the disk returns an error, the storage system should simply use whatever redundancy mechanism it has to return the correct data.

જ્યારે કોઈ સ્ટોરેજ સિસ્ટમ કોઈ બ્લોકને ઍક્સેસ કરવાનો પ્રયાસ કરે છે, અને ડિસ્ક ભૂલ આપે છે, ત્યારે સ્ટોરેજ સિસ્ટમે સાચો ડેટા પરત કરવા માટે તેની પાસે જે પણ રિડન્ડન્સી પદ્ધતિ છે તેનો ઉપયોગ કરવો જોઈએ.


In a mirrored RAID, the system should access the alternate copy.

મિરર્ડ RAID માં, સિસ્ટમે વૈકલ્પિક કૉપિને ઍક્સેસ કરવી જોઈએ.


The growing prevalence of LSEs has influenced RAID designs over the years.

LSEs ની વધતી જતી પ્રચલિતતાએ વર્ષોથી RAID ડિઝાઇન્સને પ્રભાવિત કરી છે.


How can we prevent users from getting bad data when corruption arises?

જ્યારે ભ્રષ્ટાચાર થાય છે, ત્યારે આપણે વપરાશકર્તાઓને ખરાબ ડેટા મેળવતા કેવી રીતે અટકાવી શકીએ?


The primary mechanism used by modern storage systems to preserve data integrity is called the checksum.

ડેટાની અખંડિતતા જાળવવા માટે આધુનિક સ્ટોરેજ સિસ્ટમ્સ દ્વારા ઉપયોગમાં લેવાતી પ્રાથમિક પદ્ધતિને ચેકસમ કહેવામાં આવે છે.


A checksum is simply the result of a function that takes a chunk of data as input.

ચેકસમ એ એક ફંક્શનનું પરિણામ છે જે ઇનપુટ તરીકે ડેટાનો એક ભાગ લે છે.


There’s No Such Thing As A Free Lunch, or TNSTAAFL for short.

એક પણ મફત લંચ જેવું કશું જ નથી, અથવા ટૂંકમાં TNSTAAFL.


A trade-off that is common in systems arises here: usually, the more protection you get, the costlier it is.

અહીં સિસ્ટમ્સમાં સામાન્ય રીતે એક વેપાર-બંધ છે: સામાન્ય રીતે, તમે જેટલું વધુ રક્ષણ મેળવો છો, તેટલું જ તે ખર્ચાળ છે.


One simple checksum function that some use is based on exclusive or (XOR).

એક સરળ ચેકસમ ફંક્શન જેનો કેટલાક ઉપયોગ કરે છે તે એક્સક્લુઝિવ ઓર (XOR) પર આધારિત છે.


XOR is a reasonable checksum but has its limitations.

XOR એક વાજબી ચેકસમ છે પરંતુ તેની મર્યાદાઓ છે.


Another simple checksum function is addition.

બીજું એક સરળ ચેકસમ ફંક્શન ઉમેરણ છે.


This approach has the advantage of being fast.

આ અભિગમ ઝડપી હોવાનો ફાયદો ધરાવે છે.


A slightly more complex algorithm is known as the Fletcher checksum.

થોડો વધુ જટિલ અલ્ગોરિધમને ફ્લેચર ચેકસમ તરીકે ઓળખવામાં આવે છે.


One final commonly-used checksum is known as acyclic redundancy check (CRC).

એક છેલ્લું સામાન્ય રીતે ઉપયોગમાં લેવાતું ચેકસમ એ એસાયક્લિક રિડન્ડન્સી ચેક (CRC) તરીકે ઓળખાય છે.


The remainder of this division is the value of the CRC.

આ વિભાગનો શેષ CRC નું મૂલ્ય છે.


In choosing a good checksum function, we are thus trying to find one that minimizes the chance of collisions.

એક સારા ચેકસમ ફંક્શનની પસંદગીમાં, અમે આમ એક એવું શોધવાનો પ્રયાસ કરી રહ્યા છીએ જે અથડામણની સંભાવનાને ઓછી કરે.


The most basic approach simply stores a checksum with each disk sector.

સૌથી મૂળભૂત અભિગમ ફક્ત દરેક ડિસ્ક સેક્ટર સાથે ચેકસમને સંગ્રહિત કરે છે.


When reading a block, the client also reads its checksum from disk.

બ્લોક વાંચતી વખતે, ક્લાયંટ તેની ચેકસમને ડિસ્કમાંથી પણ વાંચે છે.


If they do not match, this implies the data has changed since the time it was stored.

જો તેઓ મેળ ખાતા નથી, તો આ સૂચવે છે કે ડેટા સંગ્રહિત થયો ત્યારથી બદલાઈ ગયો છે.


In DSM systems, some accesses are inexpensive, but others cause page faults.

DSM સિસ્ટમમાં, અમુક એક્સેસ સસ્તા હોય છે, પરંતુ અન્ય પેજ ફોલ્ટનું કારણ બને છે.


Imagine a linked list where a next pointer points into a portion of the address space that is gone.

એક લિંક્ડ લિસ્ટની કલ્પના કરો જ્યાં આગલું પોઇન્ટર એડ્રેસ સ્પેસના એવા ભાગ તરફ નિર્દેશ કરે છે જે અદૃશ્ય થઈ ગયું છે.


Though much research was performed in this space, there was little practical impact.

આ ક્ષેત્રમાં ઘણું સંશોધન કરવામાં આવ્યું હોવા છતાં, વ્યવહારિક અસર ઓછી હતી.


Remote procedure call packages all have a simple goal: to make the process of executing code on a remote machine as simple and straightforward as calling a local function.

રિમોટ પ્રોસિજર કૉલ પેકેજોનો એક સરળ ધ્યેય છે: રિમોટ મશીન પર કોડ ચલાવવાની પ્રક્રિયાને સ્થાનિક ફંક્શનને કૉલ કરવા જેટલી સરળ અને સીધી બનાવવી.


The stub generator’s job is simple: to remove some of the pain of packing function arguments and results into messages by automating it.

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


The input to such a compiler is simply the set of calls a server wishes to export to clients.

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


For the client, a client stub is generated, which contains each of the functions specified in the interface.

ક્લાયન્ટ માટે, એક ક્લાયન્ટ સ્ટબ જનરેટ થાય છે, જેમાં ઇન્ટરફેસમાં ઉલ્લેખિત દરેક ફંક્શન હોય છે.


એક સંદેશ બફર બનાવો.


Pack the needed information into the message buffer.

જરૂરી માહિતીને સંદેશ બફરમાં પેક કરો.


Send the message to the destination RPC server.

સંદેશને ગંતવ્ય RPC સર્વર પર મોકલો.


જવાબની રાહ જુઓ.


રીટર્ન કોડ અને અન્ય દલીલોને અનપેક કરો.


કૉલર પર પાછા ફરો.


સંદેશને અનપેક કરો.


વાસ્તવિક ફંક્શનમાં કૉલ કરો.


પરિણામોને પેકેજ કરો.


એક સામાન્ય સંસ્થા થ્રેડ પૂલ છે.


The run-time library handles much of the heavy lifting in an RPC system.

રન-ટાઇમ લાઇબ્રેરી RPC સિસ્ટમમાં મોટાભાગના ભારે લિફ્ટિંગને સંભાળે છે.


This problem, of naming, is a common one in distributed systems.

નામકરણની આ સમસ્યા, વિતરિત સિસ્ટમ્સમાં સામાન્ય છે.


The server crashed before writing the data to disk.

ડેટાને ડિસ્ક પર લખતા પહેલા સર્વર ક્રેશ થઈ ગયું.


NFS servers must commit each write to stable storage before informing the client of success.

NFS સર્વર્સે ક્લાયન્ટને સફળતાની જાણ કરતા પહેલા દરેક લેખનને સ્થિર સ્ટોરેજમાં કમિટ કરવું આવશ્યક છે.


ક્લાયન્ટને તેની સફળતાની જાણ કરવામાં આવી હતી.


Imagine the following sequence of writes as issued by a client.

નીચેના લેખનો ક્રમ ક્લાયન્ટ દ્વારા જારી કરવામાં આવ્યો છે, તેની કલ્પના કરો.


આ એક જટિલ સમસ્યા છે.


ફાઇલની સામગ્રી આના જેવી દેખાય છે.


સર્વર ઝડપથી પુનઃપ્રારંભ થાય છે.


The client can safely replay a failed operation.

ક્લાયન્ટ સુરક્ષિત રીતે નિષ્ફળ ઓપરેશનને ફરીથી ચલાવી શકે છે.


We have seen the introduction of the NFS distributed file system.

આપણે NFS વિતરિત ફાઇલ સિસ્ટમની રજૂઆત જોઈ છે.


Security in early NFS implementations was remarkably lax.

પ્રારંભિક NFS અમલીકરણોમાં સુરક્ષા નોંધપાત્ર રીતે ઢીલી હતી.


The original NFS paper; though a bit of a challenging read.

મૂળ NFS પેપર; જોકે થોડું પડકારજનક વાંચન છે.


The main goal of this project was simple: scale.

આ પ્રોજેક્ટનો મુખ્ય ધ્યેય સરળ હતો: સ્કેલ.


AFS પણ NFS થી અલગ છે.


When you open a file, the entire file is fetched.

જ્યારે તમે ફાઇલ ખોલો છો, ત્યારે આખી ફાઇલ મેળવવામાં આવે છે.


Subsequent read and write operations are redirected to the local file system.

ત્યારબાદના વાંચન અને લેખન ઓપરેશન્સને સ્થાનિક ફાઇલ સિસ્ટમ પર રીડાયરેક્ટ કરવામાં આવે છે.


ચાલો થોડા વધુ વિગતોમાં જઈએ.


The client-side code would then cache the file.

પછી ક્લાયન્ટ-સાઇડ કોડ ફાઇલને કેશ કરશે.


આવા પ્રયોગો સારી બાબત છે.


Measurement is the key to understanding how systems work.

માપન એ સિસ્ટમ કેવી રીતે કાર્ય કરે છે તે સમજવાની ચાવી છે.


The server CPU became the bottleneck of the system.

સર્વર CPU સિસ્ટમનું બોટલનેક બની ગયું.


The client application will want to call open(), read(), write(), close() and other standard API calls to access files and directories.

ક્લાયન્ટ એપ્લિકેશન ફાઇલો અને ડિરેક્ટરીઓને ઍક્સેસ કરવા માટે open(), read(), write(), close() અને અન્ય પ્રમાણભૂત API કૉલ્સ કરવા માંગશે.


Imagine the server crashes after the first read completes, but before the client has issued the second one.

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


In this example, the file descriptor is a piece of shared state between the client and the server.

આ ઉદાહરણમાં, ફાઇલ ડિસ્ક્રિપ્ટર ક્લાયન્ટ અને સર્વર વચ્ચેના શેર કરેલા સ્ટેટનો એક ભાગ છે.


Shared state, as we hinted above, complicates crash recovery.

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


For these reasons, the designers of NFS decided to pursue a stateless approach.

આ કારણોસર, NFS ના ડિઝાઇનરોએ સ્ટેટલેસ અભિગમ અપનાવવાનું નક્કી કર્યું.


How can we define the network protocol to enable stateless operation?

સ્ટેટલેસ ઓપરેશનને સક્ષમ કરવા માટે આપણે નેટવર્ક પ્રોટોકોલને કેવી રીતે વ્યાખ્યાયિત કરી શકીએ?


File handles are used to uniquely describe the file or directory a particular operation is going to operate upon.

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


You can think of a file handle as having three important components: a volume identifier, an inode number, and a generation number.

તમે ફાઇલ હેન્ડલને ત્રણ મહત્વપૂર્ણ ઘટકો ધરાવતા તરીકે વિચારી શકો છો: વોલ્યુમ ઓળખકર્તા, આઇનોડ નંબર અને જનરેશન નંબર.


The volume identifier informs the server which file system the request refers to.

વોલ્યુમ ઓળખકર્તા સર્વરને જણાવે છે કે વિનંતી કઈ ફાઇલ સિસ્ટમને સંદર્ભિત કરે છે.


The client passes a directory file handle and name of a file to look up.

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


Once a file handle is available, the client can issue READ and WRITE protocol messages on a file to read or write the file, respectively.

એકવાર ફાઇલ હેન્ડલ ઉપલબ્ધ થઈ જાય, પછી ક્લાયન્ટ ફાઇલને વાંચવા અથવા લખવા માટે, અનુક્રમે, ફાઇલ પર READ અને WRITE પ્રોટોકોલ સંદેશાઓ જારી કરી શકે છે.


The READ protocol message requires the protocol to pass along the file handle of the file along with the offset within the file and number of bytes to read.

READ પ્રોટોકોલ સંદેશ માટે પ્રોટોકોલને ફાઇલના ફાઇલ હેન્ડલને ફાઇલની અંદરના ઑફસેટ અને વાંચવાના બાઇટ્સની સંખ્યા સાથે પસાર કરવાની જરૂર છે.


The client-side file system tracks open files, and generally translates application requests into the relevant set of protocol messages.

ક્લાયન્ટ-સાઇડ ફાઇલ સિસ્ટમ ખુલ્લી ફાઇલોને ટ્રેક કરે છે, અને સામાન્ય રીતે એપ્લિકેશન વિનંતીઓને સંબંધિત પ્રોટોકોલ સંદેશાઓના સમૂહમાં અનુવાદિત કરે છે.


The server simply responds to each protocol message, each of which has all the information needed to complete request.

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


When an operation can be issued more than once, it is much easier to handle failure of the operation; you can just retry it.

જ્યારે કોઈ ઑપરેશન એક કરતા વધુ વખત જારી કરી શકાય છે, ત્યારે ઑપરેશનની નિષ્ફળતાને હેન્ડલ કરવી ખૂબ સરળ છે; તમે તેને ફરીથી અજમાવી શકો છો.


An operation is called idempotent when the effect of performing the operation multiple times is equivalent to the effect of performing the operating a single time.

જ્યારે કોઈ ઑપરેશનને ઘણી વખત કરવાના પરિણામો એક જ વાર ઑપરેશન કરવાના પરિણામોની સમકક્ષ હોય, ત્યારે તે ઑપરેશનને આઇડેમ્પોટન્ટ કહેવામાં આવે છે.


If, for example, a WRITE fails, the client can simply retry it.

ઉદાહરણ તરીકે, જો WRITE નિષ્ફળ જાય, તો ક્લાયન્ટ તેને ફરીથી અજમાવી શકે છે.


The client will retry it, the server will perform the write, and all will be well.

ક્લાયન્ટ તેને ફરીથી અજમાવશે, સર્વર લખશે, અને બધું બરાબર થઈ જશે.


The NFS client-side file system caches file data (and metadata) that it has read from the server in client memory.

NFS ક્લાયન્ટ-સાઇડ ફાઇલ સિસ્ટમ ફાઇલ ડેટા (અને મેટાડેટા) કે જે તેણે સર્વરમાંથી ક્લાયન્ટ મેમરીમાં વાંચ્યું છે તેને કેશ કરે છે.


The system uses time sharing to manage resources.

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


Virtualization is a key concept in modern operating systems.

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


The operating system handles the virtual address space.

ઓપરેટિંગ સિસ્ટમ વર્ચ્યુઅલ એડ્રેસ સ્પેસને સંભાળે છે.


થ્રેડો સમાન એડ્રેસ સ્પેસ શેર કરે છે.


The timer interrupt is essential for scheduling.

સમયચક્ર વિક્ષેપ શેડ્યુલિંગ માટે જરૂરી છે.


The TLB helps speed up address translation.

TLB એડ્રેસ અનુવાદને ઝડપી બનાવવામાં મદદ કરે છે.


એક વ્યવહાર ડેટાની અખંડિતતા સુનિશ્ચિત કરે છે.


સિસ્ટમ રાઈટ-એહેડ લોગનો ઉપયોગ કરે છે.


Virtual memory is crucial for multitasking.

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


The system provides transparency to the user.

સિસ્ટમ વપરાશકર્તાને પારદર્શિતા પ્રદાન કરે છે.


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


સિસ્ટમ એક પેજ ટેબલનો ઉપયોગ કરે છે.


The program encountered a segmentation fault.

પ્રોગ્રામને સેગમેન્ટેશન ફોલ્ટનો અનુભવ થયો.


The system uses caching to improve performance.

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


ફાઇલ સિસ્ટમ ડેટા સ્ટોરેજનું સંચાલન કરે છે.


સિસ્ટમ વિક્ષેપોને સંભાળે છે.


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


The system uses atomic operations for synchronization.

સિસ્ટમ સિંક્રનાઇઝેશન માટે અણુ કામગીરીનો ઉપયોગ કરે છે.


Understanding time-space trade-offs is important.

સમય-સ્થાન વેપાર-બંધોને સમજવું મહત્વપૂર્ણ છે.


સિસ્ટમ ટ્રેપ હેન્ડલરનો ઉપયોગ કરે છે.


The server checks if its cached copy of the file is valid.

સર્વર તપાસે છે કે તેની ફાઇલની કેશ્ડ નકલ માન્ય છે કે નહીં.


If the cached copy is valid, the client can use it.

જો કેશ્ડ નકલ માન્ય હોય, તો ક્લાયન્ટ તેનો ઉપયોગ કરી શકે છે.


If not, the client should fetch the newer version from the server.

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


Server recovery after a crash is more complicated.

ક્રેશ પછી સર્વરની પુનઃપ્રાપ્તિ વધુ જટિલ છે.


કોલબેક મેમરીમાં રાખવામાં આવે છે.


The server has no idea which client machine has which files after reboot.

રીબૂટ થયા પછી સર્વરને ખબર નથી હોતી કે કયા ક્લાયન્ટ મશીનમાં કઈ ફાઇલો છે.


Each client must realize that the server has crashed.

દરેક ક્લાયન્ટે સમજવું જોઈએ કે સર્વર ક્રેશ થયું છે.


Clients must treat all of their cache contents as suspect.

ક્લાયન્ટ્સે તેમની બધી કેશ સામગ્રીને શંકાસ્પદ ગણવી જોઈએ.


Clients must reestablish the validity of a file before using it.

ક્લાયન્ટ્સે તેનો ઉપયોગ કરતા પહેલા ફાઇલની માન્યતા ફરીથી સ્થાપિત કરવી આવશ્યક છે.


સર્વર ક્રેશ એ એક મોટી ઘટના છે.


Each client must be aware of the crash in a timely manner.

દરેક ક્લાયન્ટને સમયસર ક્રેશની જાણ હોવી જોઈએ.


ક્લાયન્ટ્સ જૂની ફાઇલને ઍક્સેસ કરવાનું જોખમ લે છે.


The server can send a message to each client.

સર્વર દરેક ક્લાયન્ટને સંદેશ મોકલી શકે છે.


The message says, “don’t trust your cache contents!”

સંદેશ કહે છે, “તમારી કેશ સામગ્રી પર વિશ્વાસ ન કરો!”


Clients can check that the server is alive periodically.

ક્લાયન્ટ્સ સમયાંતરે ચકાસી શકે છે કે સર્વર જીવંત છે કે નહીં.


ક્લાયન્ટ્સ હાર્ટબીટ સંદેશનો ઉપયોગ કરી શકે છે.


Building a scalable caching model has a cost.

સ્કેલેબલ કેશિંગ મોડેલ બનાવવાની કિંમત છે.


With NFS, clients hardly noticed a server crash.

NFS સાથે, ક્લાયન્ટ્સે ભાગ્યે જ સર્વર ક્રેશની નોંધ લીધી.


AFSv2 was found to be much more scalable than the original version.

એવું જાણવા મળ્યું છે કે AFSv2 મૂળ સંસ્કરણ કરતાં ઘણું વધારે સ્કેલેબલ છે.


Each server could support about 50 clients.

દરેક સર્વર લગભગ 50 ક્લાયન્ટને સપોર્ટ કરી શકે છે.