A semaphore is as an object with an integer value that we can manipulate with two routines.

രണ്ട് റൂട്ടീനുകൾ ഉപയോഗിച്ച് നമുക്ക് കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന ഒരു പൂർണ്ണസംഖ്യാ മൂല്യമുള്ള ഒരു വസ്തുവാണ് സെമാഫോർ.


Because the initial value of the semaphore determines its behavior, before calling any other routine to interact with the semaphore, we must first initialize it to some value.

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


After a semaphore is initialized, we can call one of two functions to interact with it, sem_wait() or sem_post().

ഒരു സെമാഫോർ ആരംഭിച്ച ശേഷം, അതിലൂടെ സംവദിക്കാൻ രണ്ട് ഫംഗ്ഷനുകളിൽ ഒന്ന് വിളിക്കാം, sem_wait() അല്ലെങ്കിൽ sem_post().


First, we can see that sem_wait() will either return right away or it will cause the caller to suspend execution waiting for a subsequent post.

ആദ്യം, sem_wait() ഉടനടി മടങ്ങിവരുമെന്ന് നമുക്ക് കാണാൻ കഴിയും അല്ലെങ്കിൽ തുടർന്നുള്ള പോസ്റ്റിനായി കാത്തിരുന്ന് കോളറെ എക്സിക്യൂഷൻ സസ്പെൻഡ് ചെയ്യാൻ ഇത് കാരണമാകും.


Second, we can see that sem_post() does not wait for some particular condition to hold like sem_wait() does.

രണ്ടാമതായി, sem_wait() ചെയ്യുന്നത് പോലെ ചില പ്രത്യേക അവസ്ഥ നിലനിൽക്കാൻ sem_post() കാത്തിരിക്കുന്നില്ലെന്ന് നമുക്ക് കാണാൻ കഴിയും.


ഇപ്പോൾ ഒരു സെമാഫോർ ഉപയോഗിക്കാൻ തയ്യാറാണ്.


Critical to making this work, though, is the initial value of the semaphore.

ഇത് പ്രവർത്തിപ്പിക്കുന്നതിന് നിർണായകമാണ്, എന്നിരുന്നാലും, സെമാഫോറിന്റെ പ്രാരംഭ മൂല്യം.


The study focuses on four major and important open-source applications.

ഈ പഠനം പ്രധാനപ്പെട്ട നാല് ഓപ്പൺ സോഴ്സ് ആപ്ലിക്കേഷനുകളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.


Understanding these results can help you understand what types of problems actually occur in mature code bases.

ഈ ഫലങ്ങൾ മനസ്സിലാക്കുന്നത്, മെച്യൂർ കോഡ് ബേസുകളിൽ എങ്ങനെയുള്ള പ്രശ്നങ്ങളാണ് ഉണ്ടാകുന്നതെന്ന് മനസ്സിലാക്കാൻ സഹായിക്കും.


Table 32.1 shows a summary of the bugs Lu and colleagues studied.

പട്ടിക 32.1 ൽ, ലുവും സഹപ്രവർത്തകരും പഠിച്ച ബഗുകളുടെ സംഗ്രഹം നൽകുന്നു.


From the table, you can see that there were 105 total bugs.

പട്ടികയിൽ നിന്ന്, മൊത്തം 105 ബഗുകൾ ഉണ്ടായിരുന്നു എന്ന് കാണാം.


We now dive into these different classes of bugs a bit more deeply.

നമ്മൾ ഇപ്പോൾ ഈ വ്യത്യസ്ത തരം ബഗുകളെക്കുറിച്ച് കുറച്ചുകൂടി ആഴത്തിൽ പഠിക്കാൻ പോകുന്നു.


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-ൽ കണ്ടെത്തിയ ഒരു ലളിതമായ ഉദാഹരണം ഇതാ.


The more formal definition of an atomicity violation is this.

ആറ്റോമിസിറ്റി ലംഘനത്തിന്റെ കൂടുതൽ ഔദ്യോഗികമായ നിർവചനം ഇതാ.


Finding a fix for this type of problem is often straightforward.

ഇത്തരം പ്രശ്നങ്ങൾക്ക് പരിഹാരം കണ്ടെത്തുന്നത് പലപ്പോഴും ലളിതമാണ്.


Another common type of non-deadlock bug found is known as an order violation.

കണ്ടെത്തുന്ന മറ്റൊരു സാധാരണ തരം നോൺ-ഡെഡ്‌ലോക്ക് ബഗ് ഓർഡർ ലംഘനമാണ്.


As you probably figured out, the code in Thread 2 seems to assume that the variable mThread has already been initialized.

നിങ്ങൾ ഊഹിച്ചതുപോലെ, Thread 2-ലെ കോഡ് mThread എന്ന വേരിയബിൾ ഇതിനകം തന്നെ ആരംഭിച്ചു എന്ന് കരുതുന്നു.


The fix to this type of bug is generally to enforce ordering.

ഇത്തരം ബഗുകൾ പരിഹരിക്കാനുള്ള വഴി സാധാരണയായി ഓർഡർ നടപ്പിലാക്കുക എന്നതാണ്.


When ordering matters between threads, condition variables can come to the rescue.

ത്രെഡുകൾക്കിടയിൽ ഓർഡർ പ്രാധാന്യമുള്ളപ്പോൾ, കണ്ടീഷൻ വേരിയബിളുകൾ സഹായകമാകും.


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

പഠിച്ച നോൺ-ഡെഡ്‌ലോക്ക് ബഗുകളിൽ ഭൂരിഭാഗവും ആറ്റോമിസിറ്റി അല്ലെങ്കിൽ ഓർഡർ ലംഘനങ്ങളാണ്.


Beyond the concurrency bugs mentioned above, a classic problem that arises is known as deadlock.

മുകളിൽ പറഞ്ഞ കൺകറൻസി ബഗുകൾക്ക് പുറമെ, ഉണ്ടാകുന്ന ഒരു ക്ലാസിക് പ്രശ്നമാണ് ഡെഡ്‌ലോക്ക്.


Deadlock occurs, for example, when a thread is holding a lock and waiting for another one.

ഒരു ത്രെഡ് ഒരു ലോക്ക് കൈവശം വെക്കുകയും മറ്റൊന്നിനായി കാത്തിരിക്കുകയും ചെയ്യുമ്പോൾ, ഡെഡ്‌ലോക്ക് സംഭവിക്കുന്നു.


How should we build systems to prevent, avoid, or at least detect and recover from deadlock?

ഡെഡ്‌ലോക്ക് തടയാനും ഒഴിവാക്കാനും അല്ലെങ്കിൽ കണ്ടെത്താനും വീണ്ടെടുക്കാനും എങ്ങനെയാണ് സിസ്റ്റങ്ങൾ ഉണ്ടാക്കേണ്ടത്?


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.

മൾട്ടി-ത്രെഡ് പ്രോഗ്രാമുകളിൽ സാധാരണയായി ഉപയോഗിക്കുന്ന ഒരു പാറ്റേണാണ് ലളിതവും, പ്രവർത്തിക്കുന്നതുമായ ബൗണ്ടഡ് ബഫർ.


Reader-writer locks should be used with some caution.

റീഡർ-റൈറ്റർ ലോക്കുകൾ ചില ജാഗ്രതയോടെ ഉപയോഗിക്കണം.


They often add more overhead and thus do not end up speeding up performance.

അവ പലപ്പോഴും കൂടുതൽ ഓവർഹെഡ് ചേർക്കുന്നു, അതുവഴി പ്രകടനം വേഗത്തിലാക്കുന്നില്ല.


The dining philosopher’s problem is fun and somewhat intellectually interesting.

ഡൈനിംഗ് ഫിലോസഫർ പ്രശ്നം രസകരവും, ബുദ്ധിപരമായി ആകർഷകവുമാണ്.


In order to eat, a philosopher needs two forks.

ഭക്ഷണം കഴിക്കുന്നതിന്, ഒരു തത്ത്വചിന്തകന് രണ്ട് ഫോർക്കുകൾ ആവശ്യമാണ്.


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

ഈ പ്രശ്നം പരിഹരിക്കാനുള്ള ഏറ്റവും ലളിതമായ മാർഗ്ഗം, കുറഞ്ഞത് ഒരു തത്ത്വചിന്തകനെങ്കിലും ഫോർക്കുകൾ നേടുന്ന രീതി മാറ്റുക എന്നതാണ്.


We use just one lock and one condition variable, plus a state variable to track the value of the semaphore.

സെമാഫോറിൻ്റെ മൂല്യം ട്രാക്ക് ചെയ്യാൻ, ഒരൊറ്റ ലോക്കും, ഒരു കണ്ടീഷൻ വേരിയബിളും, ഒരു സ്റ്റേറ്റ് വേരിയബിളും ഞങ്ങൾ ഉപയോഗിക്കുന്നു.


Semaphores are a powerful and flexible primitive for writing concurrent programs.

സമാന്തര പ്രോഗ്രാമുകൾ എഴുതുന്നതിനുള്ള ശക്തവും, വളരെ ഉപയോഗപ്രദവുമായ ഒരു അടിസ്ഥാന ഘടകമാണ് സെമാഫോറുകൾ.


Some programmers use them exclusively, shunning locks and condition variables.

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


In this chapter, we have presented just a few classic problems and solutions.

ഈ അധ്യായത്തിൽ, ഞങ്ങൾ കുറച്ച് ക്ലാസിക് പ്രശ്നങ്ങളും, പരിഹാരങ്ങളും അവതരിപ്പിച്ചു.


Knowing which ones to look out for is the first step to writing more robust, correct concurrent code.

ഏതൊക്കെയാണ് ശ്രദ്ധിക്കേണ്ടതെന്ന് അറിയുന്നത് കൂടുതൽ ശക്തവും, ശരിയായതുമായ കോഡ് എഴുതുന്നതിനുള്ള ആദ്യപടിയാണ്.


പുസ്തകം മേശപ്പുറത്താണ്.


ഇന്നത്തെ കാലാവസ്ഥ സുഖകരമാണ്.


ഞാൻ കമ്പോളത്തിലേക്ക് പോകുന്നു.


വാതിൽ അടക്കുക.


കമ്പനി ഒരു പുതിയ ഉൽപ്പന്നം പ്രഖ്യാപിച്ചു.


The government is discussing the new policy.

പുതിയ നയത്തെക്കുറിച്ച് സർക്കാർ ചർച്ച ചെയ്യുന്നു.


The research team is working on a new project.

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


The algorithm efficiently sorts the data.

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


സോഫ്റ്റ്‌വെയറിന് പതിവായ അപ്‌ഡേറ്റുകൾ ആവശ്യമാണ്.


വെല്ലുവിളികൾ ഉണ്ടായിരുന്നിട്ടും, അവർ വിജയിച്ചു.


The economic situation is improving gradually.

സാമ്പത്തിക സ്ഥിതി ക്രമേണ മെച്ചപ്പെടുന്നു.


The complex system requires careful analysis.

സങ്കീർണ്ണമായ ഈ സിസ്റ്റത്തിന് സൂക്ഷ്മമായ വിശകലനം ആവശ്യമാണ്.


The implications of the decision are far-reaching.

തീരുമാനത്തിന്റെ അനന്തരഫലങ്ങൾ വളരെ ദൂരവ്യാപകമാണ്.


The theoretical framework is based on several assumptions.

സിദ്ധാന്തപരമായ ചട്ടക്കൂട് നിരവധി അനുമാനങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


The company's innovative approach revolutionized the industry.

കമ്പനിയുടെ നൂതനമായ സമീപനം വ്യവസായത്തിൽ വിപ്ലവം സൃഷ്ടിച്ചു.


The algorithm's efficiency is a key factor in its success.

അൽഗോരിതത്തിന്റെ കാര്യക്ഷമത അതിന്റെ വിജയത്തിൽ ഒരു പ്രധാന ഘടകമാണ്.


The philosophical debate centered on the nature of reality.

തത്ത്വചിന്താപരമായ സംവാദം യാഥാർത്ഥ്യത്തിന്റെ സ്വഭാവത്തെ കേന്ദ്രീകരിച്ചുള്ളതായിരുന്നു.


The intricate design of the system required extensive testing.

സിസ്റ്റത്തിന്റെ സങ്കീർണ്ണമായ രൂപകൽപ്പന വിപുലമായ പരിശോധന ആവശ്യമായിരുന്നു.


The implications of climate change are becoming increasingly evident.

കാലാവസ്ഥാ വ്യതിയാനത്തിന്റെ അനന്തരഫലങ്ങൾ വർധിച്ചു വരുന്നു.


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.

തീവ്രമായ തോതിലുള്ള ത്രെഡുകൾ എങ്ങനെ പ്രവർത്തിപ്പിക്കാം എന്നതിനെക്കുറിച്ചുള്ള ഒരു പ്രബന്ധം; അക്കാലത്ത് നടന്നുകൊണ്ടിരുന്ന എല്ലാ ഇവൻ്റ് അടിസ്ഥാനമാക്കിയുള്ള പ്രവർത്തനങ്ങൾക്കുമുള്ള ഒരു പ്രതിവിധി.


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

ഈ ആശയങ്ങളിൽ ചിലത് ഗൂഗിൾ, ആമസോൺ തുടങ്ങിയ കമ്പനികളുടെ അടിസ്ഥാന സൗകര്യങ്ങളിൽ ഇടം നേടിയിട്ടുണ്ട്.


അപ്പോൾ, നിങ്ങളുടെ തലയ്ക്ക് ഇപ്പോൾ വേദനയുണ്ടോ?


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.

തീർച്ചയായും ഉണ്ട്. വളരെ കുറഞ്ഞ കോഡ് ലൈനുകൾ, ഒരേസമയം പ്രവർത്തിക്കുമ്പോൾ, മനസ്സിലാക്കാൻ ഏറെക്കുറെ അസാധ്യമാകുന്നതെങ്ങനെയെന്ന് ഞാൻ എപ്പോഴും അത്ഭുതപ്പെടുന്നു.


Oh, don’t feel too badly. If you look through the first papers on con- current algorithms, they are sometimes wrong!

അയ്യോ, അത്രയധികം വിഷമിക്കേണ്ട. കൺകറൻ്റ് അൽഗോരിതങ്ങളെക്കുറിച്ചുള്ള ആദ്യകാല പ്രബന്ധങ്ങൾ പരിശോധിച്ചാൽ, അവ ചിലപ്പോൾ തെറ്റായിരിക്കും!


അധ്യാപകർക്ക് ... ഉം ... തെറ്റുപറ്റുമോ?


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

അതാണ് ശരിയായ ചോദ്യം, അല്ലേ?


ഒന്നാമതായി, ലളിതമാക്കുക!


Second, only use con- currency 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 sim- plified 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.

അങ്ങനെ നമ്മുടെ നാല് ... ശരി ... ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളുടെ മൂന്ന് സ്തംഭങ്ങളിൽ മൂന്നാമത്തേതിൽ എത്തിച്ചേരുന്നു: നിലനിൽപ്പ്.


Did you say there were three pillars, or four? What is the fourth?

നിങ്ങൾ മൂന്ന് സ്തംഭങ്ങൾ എന്നാണോ അതോ നാല് സ്തംഭങ്ങൾ എന്നാണോ പറഞ്ഞത്? നാലാമത്തേത് എന്താണ്?


Actually, you probably know what it means in the traditionalsense, right?

വാസ്തവത്തിൽ, പരമ്പരാഗത അർത്ഥത്തിൽ ഇതിനർത്ഥമെന്താണെന്ന് നിങ്ങൾക്ക് അറിയുമായിരിക്കും, അല്ലേ?


Imagine you are outside, in a field, and you pick a –

നിങ്ങൾ ഒരു വയലിൽ പുറത്തായിരിക്കുമ്പോൾ, നിങ്ങൾ ഒന്ന് തിരഞ്ഞെടുക്കുന്നു എന്ന് കരുതുക -


Winter is hard and cruel in Wisconsin, after all.

വിസ്കോൺസിനിൽ, എല്ലാത്തിനുമുപരി, ശീതകാലം കഠിനവും ക്രൂരവുമാണ്.


വിലാസം 0x1F3 = LBA കുറഞ്ഞ ബൈറ്റ്


വിലാസം 0x1F4 = LBA മധ്യ ബൈറ്റ്


വിലാസം 0x1F5 = LBA ഉയർന്ന ബൈറ്റ്


Address 0x1F6 = 1B1D TOP4LBA: B=LBA, D=drive

വിലാസം 0x1F6 = 1B1D TOP4LBA: B=LBA, D=ഡ്രൈവ്


ഡ്രൈവ് റെഡിയാകുന്നതുവരെ കാത്തിരിക്കുക.


കമാൻഡ് രജിസ്റ്ററുകളിലേക്ക് പാരാമീറ്ററുകൾ എഴുതുക.


Start the I/O.by issuing read/write to command register.

കമാൻഡ് രജിസ്റ്ററിലേക്ക് റീഡ്/റൈറ്റ് നൽകി I/O ആരംഭിക്കുക.


ഇടവേളകൾ കൈകാര്യം ചെയ്യുക.


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

ERROR ബിറ്റ് ഓണായിരിക്കുകയാണെങ്കിൽ, വിശദാംശങ്ങൾക്കായി എറർ രജിസ്റ്റർ വായിക്കുക.


Most of this protocol is found in the xv6 IDE driver.

ഈ പ്രോട്ടോക്കോളിന്റെ ഭൂരിഭാഗവും xv6 IDE ഡ്രൈവറിൽ കാണാം.


The first iside rw(), which queues a request.

ആദ്യത്തേത് ide rw() ആണ്, ഇത് ഒരു അഭ്യർത്ഥന ക്യൂ ചെയ്യുന്നു.


The second iside startrequest(), which is used to send a request.

രണ്ടാമത്തേത് ide startrequest() ആണ്, ഇത് ഒരു അഭ്യർത്ഥന അയയ്ക്കാൻ ഉപയോഗിക്കുന്നു.


The start request routine uses the third function, ide waitready().

ആരംഭ അഭ്യർത്ഥന പതിവ് മൂന്നാമത്തെ ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു, ide waitready().


Finally, ide intr() is invoked when an interrupt takes place.

അവസാനമായി, ഒരു തടസ്സം ഉണ്ടാകുമ്പോൾ ide intr() വിളിക്കപ്പെടുന്നു.


Interrupts are an ancient idea, existing on the earliest of machines.

തടസ്സങ്ങൾ പുരാതനമായ ഒരു ആശയമാണ്, ഇത് ആദ്യകാല യന്ത്രങ്ങളിൽ നിലനിന്നിരുന്നു.


The basic interface for all modern drives is straightforward.

എല്ലാ ആധുനിക ഡ്രൈവുകളുടെയും അടിസ്ഥാന ഇന്റർഫേസ് ലളിതമാണ്.


The drive consists of a large number of sectors (512-byte blocks).

ഡ്രൈവിൽ ധാരാളം സെക്ടറുകൾ (512-ബൈറ്റ് ബ്ലോക്കുകൾ) ഉണ്ട്.


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

n സെക്ടറുകളുള്ള ഒരു ഡിസ്കിലെ സെക്ടറുകൾ 0 മുതൽ n-1 വരെ നമ്പറിട്ടിരിക്കുന്നു.


മൾട്ടി-സെക്ടർ പ്രവർത്തനങ്ങൾ സാധ്യമാണ്.


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

ആധുനിക ഡിസ്കിന്റെ ചില ഘടകങ്ങൾ മനസ്സിലാക്കാൻ തുടങ്ങാം.


The system administrator needs to configure the server.

സിസ്റ്റം അഡ്മിനിസ്ട്രേറ്റർ സെർവർ കോൺഫിഗർ ചെയ്യേണ്ടതുണ്ട്.


The news reported a major earthquake in the region.

പ്രദേശത്ത് വലിയ ഭൂകമ്പം ഉണ്ടായതായി വാർത്തയിൽ പറയുന്നു.


ഒന്ന് ഉപ്പ് തരുമോ?


The company announced a new product launch next month.

അടുത്ത മാസം പുതിയ ഉൽപ്പന്നം പുറത്തിറക്കുമെന്ന് കമ്പനി അറിയിച്ചു.


He is studying computer science at the university.

അയാൾ യൂണിവേഴ്സിറ്റിയിൽ കമ്പ്യൂട്ടർ സയൻസ് പഠിക്കുന്നു.


The weather forecast predicts heavy rain tomorrow.

നാളെ കനത്ത മഴ പെയ്യുമെന്ന് കാലാവസ്ഥാ പ്രവചനം.


She enjoys reading novels in her free time.

അവൾ ഒഴിവുസമയങ്ങളിൽ നോവലുകൾ വായിക്കാൻ ഇഷ്ടപ്പെടുന്നു.


The algorithm efficiently sorts the data.

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


The government is implementing new policies.

സർക്കാർ പുതിയ നയങ്ങൾ നടപ്പാക്കുകയാണ്.


വിശ്രമമെടുക്കാൻ ഡോക്ടർ ഉപദേശിച്ചു.


The research paper explores the impact of climate change.

കാലാവസ്ഥാ വ്യതിയാനത്തിന്റെ ആഘാതം ഈ ഗവേഷണ പ്രബന്ധം പരിശോധിക്കുന്നു.


The team is working hard to achieve their goals.

ലക്ഷ്യങ്ങൾ നേടുന്നതിന് ടീം കഠിനമായി പരിശ്രമിക്കുന്നു.


മ്യൂസിയത്തിൽ പുരാതന വസ്തുക്കൾ പ്രദർശിപ്പിച്ചിരിക്കുന്നു.


The software update includes several bug fixes.

സോഫ്റ്റ്‌വെയർ അപ്‌ഡേറ്റിൽ നിരവധി ബഗ് പരിഹാരങ്ങൾ ഉൾപ്പെടുന്നു.


The artist's painting is displayed in the gallery.

ചിത്രകാരന്റെ ചിത്രം ഗാലറിയിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു.


The economic situation is improving gradually.

സാമ്പത്തിക സ്ഥിതി ക്രമേണ മെച്ചപ്പെടുന്നു.


The teacher explained the concept clearly.

അധ്യാപകൻ ആശയം വ്യക്തമായി വിശദീകരിച്ചു.


The company is facing financial difficulties.

കമ്പനി സാമ്പത്തിക പ്രതിസന്ധി നേരിടുകയാണ്.


The scientist conducted an experiment in the lab.

ശാസ്ത്രജ്ഞൻ ലാബിൽ ഒരു പരീക്ഷണം നടത്തി.


The negotiations are ongoing between the two countries.

രണ്ട് രാജ്യങ്ങൾ തമ്മിലുള്ള ചർച്ചകൾ ഇപ്പോഴും നടക്കുന്നു.


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


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.

ഓരോ റീഡിനും എത്ര സമയമെടുക്കുമെന്ന് നമുക്ക് കണക്കാക്കാം.


The average seek time is just taken as the average time reported by the manufacturer.

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


Transfer data to and from disks in a sequential manner.

ഒരു നിശ്ചിത രീതിയിൽ ഡിസ്കുകളിലേക്ക് ഡാറ്റ കൈമാറുക.


If sequential is not possible, at least think about transferring data in large chunks.

തുടർച്ചയായ രീതിയിൽ സാധ്യമല്ലെങ്കിൽ, വലിയ ഭാഗങ്ങളായി ഡാറ്റ കൈമാറ്റം ചെയ്യാൻ ശ്രമിക്കുക.


The average rotational delay is calculated from the RPM directly.

ശരാശരി ഭ്രമണ കാലതാമസം RPM-ൽ നിന്ന് നേരിട്ട് കണക്കാക്കുന്നു.


The rates of I/O are thus very nearly the peak transfer rates.

അതിനാൽ, I/O-യുടെ നിരക്ക് ഏതാണ്ട് പരമാവധി കൈമാറ്റ നിരക്കിനോട് അടുത്താണ്.


First, and most importantly, there is a huge gap in drive performance.

ഒന്നാമതായി, ഏറ്റവും പ്രധാനമായി, ഡ്രൈവ് പ്രകടനത്തിൽ വലിയൊരു വിGapമുണ്ട്.


Imagine the disk as a set of tracks, from 0 to N.

ഡിസ്കിനെ 0 മുതൽ N വരെയുള്ള ട്രാക്കുകളുടെ ഒരു കൂട്ടമായി സങ്കൽപ്പിക്കുക.


SSTF orders the queue of I/O requests by track.

SSTF, I/O അഭ്യർത്ഥനകളുടെ ക്യൂ ട്രാക്ക് അനുസരിച്ച് ഓർഡർ ചെയ്യുന്നു.


SSTF works well in this example, seeking to the middle track first.

SSTF ഈ ഉദാഹരണത്തിൽ നന്നായി പ്രവർത്തിക്കുന്നു, ആദ്യം മധ്യ ട്രാക്കിലേക്ക് തിരയുന്നു.


Imagine in our example above if there were a steady stream of requests to the inner track.

മുകളിലുള്ള ഉദാഹരണത്തിൽ, ഉൾവശത്തെ ട്രാക്കിലേക്ക് സ്ഥിരമായി അഭ്യർത്ഥനകൾ വരുന്നു എന്ന് കരുതുക.


For each stripe of data, a single parity block is added to store redundant information.

ഓരോ ഡാറ്റാ സ്ട്രൈപ്പിനും, അധിക വിവരങ്ങൾ സംഭരിക്കുന്നതിന് ഒരു സിംഗിൾ പാരിറ്റി ബ്ലോക്ക് ചേർക്കുന്നു.


Parity block P1 contains redundant information calculated from blocks 4, 5, 6, and 7.

പാരിറ്റി ബ്ലോക്ക് P1-ൽ ബ്ലോക്കുകൾ 4, 5, 6, 7 എന്നിവയിൽ നിന്ന് കണക്കാക്കിയ അധിക വിവരങ്ങൾ അടങ്ങിയിരിക്കുന്നു.


To compute parity, the XOR function is used.

പാരിറ്റി കണക്കാക്കാൻ, XOR ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു.


The XOR of bits returns 0 if there are an even number of 1's.

ബിറ്റുകളുടെ XOR, 1-ൻ്റെ ഇരട്ട സംഖ്യയുണ്ടെങ്കിൽ 0 നൽകുന്നു.


The XOR of bits returns 1 if there are an odd number of 1's.

ബിറ്റുകളുടെ XOR, 1-ൻ്റെ ഒറ്റ സംഖ്യയുണ്ടെങ്കിൽ 1 നൽകുന്നു.


RAID-4 ഒരു ഡിസ്ക് പരാജയം സഹിക്കും.


RAID-4 uses one disk for parity information for every group of disks it is protecting.

RAID-4, ഇത് പരിരക്ഷിക്കുന്ന ഓരോ ഡിസ്ക് ഗ്രൂപ്പിനും പാരിറ്റി വിവരങ്ങൾക്കായി ഒരു ഡിസ്ക് ഉപയോഗിക്കുന്നു.


Sequential read performance can utilize all of the disks except for the parity disk.

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


Full-stripe writes are the most efficient way for RAID-4 to write to disk.

RAID-4-ൽ ഡിസ്കിലേക്ക് എഴുതാനുള്ള ഏറ്റവും മികച്ച മാർഗ്ഗം പൂർണ്ണ-സ്ട്രിപ്പ് റൈറ്റുകളാണ്.


Random writes present the most interesting case for RAID-4.

റാൻഡം റൈറ്റുകൾ RAID-4-ന് ഏറ്റവും രസകരമായ കേസ് നൽകുന്നു.


Additive parity requires reading all other data blocks in the stripe.

കൂട്ടിച്ചേർക്കുന്ന പാരിറ്റി, സ്ട്രൈപ്പിലെ മറ്റ് എല്ലാ ഡാറ്റാ ബ്ലോക്കുകളും വായിക്കേണ്ടതുണ്ട്.


The subtractive method involves comparing old and new data.

കുറയ്ക്കൽ രീതി പഴയതും പുതിയതുമായ ഡാറ്റ താരതമ്യം ചെയ്യുന്നു.


The parity disk is a bottleneck under this type of workload.

ഈ തരത്തിലുള്ള വർക്ക്ലോഡിന് കീഴിൽ പാരിറ്റി ഡിസ്ക് ഒരു തടസ്സമാണ്.


RAID-5 rotates the parity block across drives.

RAID-5, ഡ്രൈവുകളിലുടനീളം പാരിറ്റി ബ്ലോക്ക് റൊട്ടേറ്റ് ചെയ്യുന്നു.


RAID-5 allows for parallelism across requests.

RAID-5, അഭ്യർത്ഥനകളിലുടനീളം സമാന്തരത അനുവദിക്കുന്നു.


RAID-5 has almost completely replaced RAID-4 in the marketplace.

RAID-5, വിപണിയിൽ RAID-4-നെ ഏതാണ്ട് പൂർണ്ണമായും മാറ്റിസ്ഥാപിച്ചു.


If you want random I/O performance and reliability, mirroring is the best.

നിങ്ങൾക്ക് റാൻഡം I/O പ്രകടനവും വിശ്വാസ്യതയും വേണമെങ്കിൽ, മിററിംഗ് ആണ് ഏറ്റവും മികച്ചത്.


Picking a RAID and setting its parameters properly is challenging.

ഒരു RAID തിരഞ്ഞെടുക്കുന്നതും അതിൻ്റെ പാരാമീറ്ററുകൾ ശരിയായി സജ്ജീകരിക്കുന്നതും വെല്ലുവിളിയാണ്.


A file is simply a linear array of bytes.

ഒരു ഫയൽ എന്നത് ലളിതമായി പറഞ്ഞാൽ ബൈറ്റുകളുടെ ഒരു രേഖീയ ശ്രേണിയാണ്.


A directory contains a list of (user-readable name, low-level name) pairs.

ഒരു ഡയറക്ടറിയിൽ (ഉപയോക്താവിന് വായിക്കാൻ കഴിയുന്ന പേര്, താഴ്ന്ന നിലയിലുള്ള പേര്) ജോഡികളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു.


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

ഓരോ ഫയലിനും stat() വിളിച്ച് അതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ നേടാൻ ഞാൻ ആഗ്രഹിക്കുന്നു.


This is exactly what ls does when you pass it the -l flag.

-l ഫ്ലാഗ് നൽകുമ്പോൾ ls ചെയ്യുന്നത് ഇതാണ്.


You can delete a directory with a call to rmdir().

rmdir() എന്ന കോൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ഡയറക്ടറി ഇല്ലാതാക്കാൻ കഴിയും.


Removing directories is more dangerous, as you could potentially delete a large amount of data.

ഡയറക്ടറികൾ നീക്കം ചെയ്യുന്നത് കൂടുതൽ അപകടകരമാണ്, കാരണം നിങ്ങൾക്ക് ധാരാളം ഡാറ്റ ഇല്ലാതാക്കാൻ സാധ്യതയുണ്ട്.


The directory must be empty before it is deleted.

ഡയറക്ടറി നീക്കം ചെയ്യുന്നതിന് മുമ്പ് ശൂന്യമായിരിക്കണം.


The link() system call takes two arguments.

link() സിസ്റ്റം കോളിന് രണ്ട് ആർഗ്യുമെന്റുകൾ ആവശ്യമാണ്.


You essentially create another way to refer to the same file.

ഒരേ ഫയലിനെ പരാമർശിക്കാൻ നിങ്ങൾ അടിസ്ഥാനപരമായി മറ്റൊരു വഴി ഉണ്ടാക്കുന്നു.


We can examine the file by either opening file or file2.

file അല്ലെങ്കിൽ file2 തുറന്ന് ഫയൽ പരിശോധിക്കാൻ കഴിയും.


ഫയൽ ഒരു തരത്തിലും പകർത്തുന്നില്ല.


You now just have two human names that both refer to the same file.

ഒരേ ഫയലിനെ പരാമർശിക്കുന്ന രണ്ട് പേരുകൾ ഇപ്പോൾ നിങ്ങൾക്കുണ്ട്.


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

ls-ലേക്ക് -i ഫ്ലാഗ് നൽകുമ്പോൾ, അത് ഇൻ‌നോഡ് നമ്പർ പ്രിന്റ് ചെയ്യുന്നു.


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

നിങ്ങൾ ഒരു ഫയൽ ഉണ്ടാക്കുമ്പോൾ, നിങ്ങൾ ശരിക്കും രണ്ട് കാര്യങ്ങളാണ് ചെയ്യുന്നത്.


First, you are making a structure that will track information about the file.

ആദ്യം, ഫയലിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ട്രാക്ക് ചെയ്യുന്ന ഒരു ഘടന നിങ്ങൾ ഉണ്ടാക്കുന്നു.


To remove a file from the file system, we call unlink().

ഒരു ഫയൽ ഫയൽ സിസ്റ്റത്തിൽ നിന്ന് നീക്കം ചെയ്യാൻ, നമ്മൾ unlink() എന്ന് വിളിക്കുന്നു.


When the file system unlinks file, it checks a reference count within the inode number.

ഫയൽ സിസ്റ്റം ഫയൽ അൺലിങ്ക് ചെയ്യുമ്പോൾ, അത് ഇൻ‌നോഡ് നമ്പറിനുള്ളിലെ ഒരു റഫറൻസ് എണ്ണം പരിശോധിക്കുന്നു.


You can see the reference count of a file using stat().

stat() ഉപയോഗിച്ച് ഒരു ഫയലിന്റെ റഫറൻസ് എണ്ണം നിങ്ങൾക്ക് കാണാൻ കഴിയും.


There is one other type of link that is really useful, and it is called a symbolic link.

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


നിങ്ങൾക്ക് ഒരെണ്ണം ഡയറക്ടറിയിലേക്ക് ഉണ്ടാക്കാൻ കഴിയില്ല.


Creating a soft link looks much the same.

ഒരു സോഫ്റ്റ് ലിങ്ക് ഉണ്ടാക്കുന്നത് ഏതാണ്ട് അതുപോലെ തന്നെയാണ്.


Symbolic links are actually quite different from hard links.

ചിഹ്നപരമായ ലിങ്കുകൾ, ഹാർഡ് ലിങ്കുകളിൽ നിന്ന് വ്യത്യസ്തമാണ്.


The directory hierarchy starts at a root directory.

ഡയറക്ടറി ശ്രേണി ആരംഭിക്കുന്നത് ഒരു റൂട്ട് ഡയറക്ടറിയിൽ നിന്നാണ്.


For example, if a user created a directory foo in the root directory, and then created a file bar.txt in the directory foo, we could refer to the file by its absolute pathname, which in this case would be /foo/bar.txt.

ഉദാഹരണത്തിന്, ഒരു ഉപയോക്താവ് റൂട്ട് ഡയറക്ടറിയിൽ foo എന്നൊരു ഡയറക്ടറിയും, തുടർന്ന് foo എന്ന ഡയറക്ടറിയിൽ bar.txt എന്നൊരു ഫയലും ഉണ്ടാക്കിയാൽ, ഈ ഫയലിനെ അതിന്റെ കേവല പാത്ത്‌നാമം ഉപയോഗിച്ച് നമുക്ക് പരാമർശിക്കാം, അതായത് /foo/bar.txt.


Naming is an important aspect of computer systems.

കമ്പ്യൂട്ടർ സിസ്റ്റങ്ങളുടെ ഒരു പ്രധാന ഘടകമാണ് പേരിടൽ.


In UNIX systems, virtually everything that you can think of is named through the file system.

UNIX സിസ്റ്റങ്ങളിൽ, നിങ്ങൾക്ക് ചിന്തിക്കാൻ കഴിയുന്നതെല്ലാം ഫയൽ സിസ്റ്റത്തിലൂടെയാണ് പേര് നൽകിയിരിക്കുന്നത്.


This uniformity of naming eases your conceptual model of the system, and makes the system simpler and more modular.

ഈ പേരിടലിന്റെ ഏകീകരണം നിങ്ങളുടെ സിസ്റ്റത്തിന്റെ ആശയപരമായ മാതൃകയെ എളുപ്പമാക്കുകയും സിസ്റ്റത്തെ ലളിതവും കൂടുതൽ മോഡുലാർ ആക്കുകയും ചെയ്യുന്നു.


Thus, whenever creating a system or interface, think carefully about what names you are using.

അതുകൊണ്ട്, ഒരു സിസ്റ്റം അല്ലെങ്കിൽ ഇന്റർഫേസ് ഉണ്ടാക്കുമ്പോൾ, നിങ്ങൾ ഉപയോഗിക്കുന്ന പേരുകളെക്കുറിച്ച് ശ്രദ്ധാപൂർവ്വം ചിന്തിക്കുക.


The first part is an arbitrary name, whereas the second part of the file name is usually used to indicate the type of the file.

ആദ്യ ഭാഗം ഒരു ഏകപക്ഷീയമായ പേരാണ്, അതേസമയം ഫയൽ നാമത്തിന്റെ രണ്ടാം ഭാഗം സാധാരണയായി ഫയലിന്റെ തരം സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു.


Thus, we can see one great thing provided by the file system: a convenient way to name all the files we are interested in.

അതിനാൽ, ഫയൽ സിസ്റ്റം നൽകുന്ന ഒരു മികച്ച കാര്യം നമുക്ക് കാണാൻ കഴിയും: നമുക്ക് ആവശ്യമുള്ള എല്ലാ ഫയലുകൾക്കും പേര് നൽകാനുള്ള സൗകര്യപ്രദമായ മാർഗ്ഗം.


Names are important in systems as the first step to accessing any resource is being able to name it.

ഏത് വിഭവവും ആക്സസ് ചെയ്യുന്നതിനുള്ള ആദ്യപടി അതിന് പേര് നൽകാൻ കഴിയുക എന്നതാണ്, അതിനാൽ പേരുകൾ സിസ്റ്റങ്ങളിൽ പ്രധാനമാണ്.


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; by calling open() and passing it the O_CREAT flag, a program can create a new file.

open സിസ്റ്റം കോൾ ഉപയോഗിച്ച് ഇത് ചെയ്യാൻ കഴിയും; open() എന്ന് വിളിച്ച് O_CREAT ഫ്ലാഗ് നൽകുന്നതിലൂടെ, ഒരു പ്രോഗ്രാമിന് ഒരു പുതിയ ഫയൽ ഉണ്ടാക്കാൻ കഴിയും.


The routine open() takes a number of different flags.

open() എന്ന routine വ്യത്യസ്തമായ നിരവധി ഫ്ലാഗുകൾ എടുക്കുന്നു.


In this example, the program creates the file (O_CREAT), can only write to that file while opened in this manner (O_WRONLY), and, if the file already exists, first truncate it to a size of zero bytes thus removing any existing content (O_TRUNC).

ഈ ഉദാഹരണത്തിൽ, പ്രോഗ്രാം ഫയൽ ഉണ്ടാക്കുന്നു (O_CREAT), ഈ രീതിയിൽ തുറക്കുമ്പോൾ മാത്രമേ ആ ഫയലിലേക്ക് എഴുതാൻ കഴിയൂ (O_WRONLY), കൂടാതെ, ഫയൽ ഇതിനകം നിലവിലുണ്ടെങ്കിൽ, നിലവിലുള്ള ഏതെങ്കിലും ഉള്ളടക്കം നീക്കം ചെയ്യുന്നതിലൂടെ അത് പൂജ്യമായി ചുരുക്കുന്നു (O_TRUNC).


You can think of creat() as open() with the following flags: O_CREAT | O_WRONLY | O_TRUNC.

creat() നെ താഴെ പറയുന്ന ഫ്ലാഗുകളുള്ള open() ആയി കണക്കാക്കാം: O_CREAT | O_WRONLY | O_TRUNC.


One important aspect of open() is what it returns: a file descriptor.

open() ന്റെ ഒരു പ്രധാന വശം അത് എന്താണ് നൽകുന്നത് എന്നതാണ്: ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ.


A file descriptor is just an integer, private per process, and is used in UNIX systems to access files.

ഒരു ഫയൽ ഡിസ്ക്രിപ്റ്റർ എന്നത് ഒരു പൂർണ്ണസംഖ്യയാണ്, ഓരോ പ്രോസസിനും സ്വകാര്യമാണ്, കൂടാതെ ഫയലുകൾ ആക്സസ് ചെയ്യാൻ UNIX സിസ്റ്റങ്ങളിൽ ഇത് ഉപയോഗിക്കുന്നു.


Once we have some files, of course we might like to read or write them.

നമ്മുടെ കയ്യിൽ കുറച്ച് ഫയലുകൾ ഉണ്ടെങ്കിൽ, തീർച്ചയായും അവ വായിക്കാനോ എഴുതാനോ നമ്മൾ ആഗ്രഹിക്കും.


Let’s start by reading an existing file.

ഒരു നിലവിലുള്ള ഫയൽ വായിക്കുന്നതിലൂടെ നമുക്ക് ആരംഭിക്കാം.


If we were typing at a command line, we might just use the program cat to dump the contents of the file to the screen.

കമാൻഡ് ലൈനിൽ ടൈപ്പ് ചെയ്യുകയാണെങ്കിൽ, ഫയലിന്റെ ഉള്ളടക്കം സ്ക്രീനിൽ കാണിക്കാൻ cat എന്ന പ്രോഗ്രാം ഉപയോഗിക്കാം.


The inode is a structure that holds metadata for a file.

ഒരു ഫയലിനായുള്ള മെറ്റാഡാറ്റ സൂക്ഷിക്കുന്ന ഒരു ഘടനയാണ് ഇൻ്റേഡ്.


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

ഓൺ-ഡിസ്ക് ഇൻ്റേഡുകളുടെ ഒരു ശ്രേണിയിലേക്ക് സൂചിക നൽകാൻ ഇൻ്റേഡ് നമ്പർ ഉപയോഗിക്കുന്നു.


Most modern systems have a structure like this for every file they track.

ആധുനിക സംവിധാനങ്ങളിൽ മിക്കതിനും ട്രാക്ക് ചെയ്യുന്ന എല്ലാ ഫയലുകൾക്കും ഇതുപോലൊരു ഘടനയുണ്ട്.


Each inode is implicitly referred to by a number, the i-number.

ഓരോ ഇൻ്റേഡിനെയും സൂചിപ്പിക്കുന്നത് i-നമ്പർ എന്ന സംഖ്യ ഉപയോഗിച്ചാണ്.


In vsfs, you should directly be able to calculate where on the disk the corresponding inode is located.

vsfs-ൽ, അനുബന്ധ ഇൻ്റേഡ് ഡിസ്കിൽ എവിടെയാണുള്ളതെന്ന് നിങ്ങൾക്ക് നേരിട്ട് കണക്കാക്കാൻ കഴിയും.


The inode table is 20-KB in size and consists of 80 inodes.

ഇൻ്റേഡ് പട്ടികയുടെ വലുപ്പം 20-KB ആണ്, കൂടാതെ 80 ഇൻ്റേഡുകൾ ഇതിൽ അടങ്ങിയിരിക്കുന്നു.


To read inode number 32, the file system would calculate the offset into the inode region.

ഇൻ്റേഡ് നമ്പർ 32 വായിക്കാൻ, ഫയൽ സിസ്റ്റം ഇൻ്റേഡ് മേഖലയിലേക്കുള്ള ഓഫ്‌സെറ്റ് കണക്കാക്കും.


Disks are not byte addressable, but rather consist of sectors.

ഡിസ്കുകൾ ബൈറ്റ് വിലാസമില്ലാത്തവയാണ്, മറിച്ച് സെക്ടറുകൾ ഉൾക്കൊള്ളുന്നു.


Inside each inode is virtually all of the information you need about a file.

ഓരോ ഇൻ്റേഡിനുള്ളിലും ഒരു ഫയലിനെക്കുറിച്ച് നിങ്ങൾക്ക് ആവശ്യമായ എല്ലാ വിവരങ്ങളും ഉണ്ട്.


The inode contains information about the file's type, size, and permissions.

ഒരു ഫയലിൻ്റെ തരം, വലുപ്പം, അനുമതികൾ എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഇൻ്റേഡിൽ അടങ്ങിയിരിക്കുന്നു.


One simple approach would be to have direct pointers inside the inode.

ഒരു ലളിതമായ സമീപനം ഇൻ്റേഡിനുള്ളിൽ നേരിട്ടുള്ള പോയിൻ്ററുകൾ ഉണ്ടായിരിക്കുക എന്നതാണ്.


An indirect pointer points to a block that contains more pointers.

ഒരു ഇൻഡയറക്‌ട് പോയിൻ്റർ കൂടുതൽ പോയിൻ്ററുകൾ അടങ്ങിയ ഒരു ബ്ലോക്കിലേക്ക് ചൂണ്ടിക്കാണിക്കുന്നു.


The multi-level index approach is used to point to file blocks.

ഫയൽ ബ്ലോക്കുകളിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ മൾട്ടി-ലെവൽ ഇൻഡെക്സ് സമീപനം ഉപയോഗിക്കുന്നു.


Most files are small, which influences inode design.

മിക്ക ഫയലുകളും ചെറുതാണ്, ഇത് ഇൻ്റേഡ് രൂപകൽപ്പനയെ സ്വാധീനിക്കുന്നു.


Directories have a simple organization in vsfs.

vsfs-ൽ ഡയറക്ടറികൾക്ക് ലളിതമായ ഒരു ഘടനയുണ്ട്.


A directory contains a list of (entry name, inode number) pairs.

ഒരു ഡയറക്ടറിയിൽ (എൻട്രി പേര്, ഇൻ്റേഡ് നമ്പർ) ജോഡികളുടെ ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു.


Deleting a file can leave empty space in the middle of the directory.

ഒരു ഫയൽ ഇല്ലാതാക്കുന്നത് ഡയറക്ടറിയുടെ മധ്യഭാഗത്ത് ശൂന്യമായ ഇടം അവശേഷിപ്പിക്കും.


File systems treat directories as a special type of file.

ഫയൽ സിസ്റ്റങ്ങൾ ഡയറക്ടറികളെ ഒരു പ്രത്യേക തരം ഫയലായി കണക്കാക്കുന്നു.


A file system must track which inodes and data blocks are free.

ഏതൊക്കെ ഇൻ്റേഡുകളും ഡാറ്റാ ബ്ലോക്കുകളും സൗജന്യമാണെന്ന് ഒരു ഫയൽ സിസ്റ്റം ട്രാക്ക് ചെയ്യണം.


When a new file is allocated, the system finds space for it.

ഒരു പുതിയ ഫയൽ അനുവദിക്കുമ്പോൾ, സിസ്റ്റം അതിനായി ഇടം കണ്ടെത്തുന്നു.


The file system uses caching to improve performance.

ഫയൽ സിസ്റ്റം പ്രകടനം മെച്ചപ്പെടുത്താൻ കാഷിംഗ് ഉപയോഗിക്കുന്നു.


Reading and writing files can be expensive due to I/O operations.

I/O പ്രവർത്തനങ്ങൾ കാരണം ഫയലുകൾ വായിക്കുന്നതും എഴുതുന്നതും ചെലവേറിയതാകാം.


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

ആധുനിക സിസ്റ്റങ്ങൾ വെർച്വൽ മെമ്മറി പേജുകളും ഫയൽ സിസ്റ്റം പേജുകളും ഒരു ഏകീകൃത പേജ് കാഷിലേക്ക് സംയോജിപ്പിക്കുന്നു.


Caching helps to avoid read I/O altogether.

കാഷിംഗ് റീഡ് I/O പൂർണ്ണമായും ഒഴിവാക്കാൻ സഹായിക്കുന്നു.


Write buffering can improve performance by batching updates.

റൈറ്റ് ബഫറിംഗ് അപ്‌ഡേറ്റുകൾ കൂട്ടമായി ചേർക്കുന്നതിലൂടെ പ്രകടനം മെച്ചപ്പെടുത്തും.


Some applications force writes to disk to avoid data loss.

ഡാറ്റ നഷ്ടപ്പെടാതിരിക്കാൻ ചില ആപ്ലിക്കേഷനുകൾ റൈറ്റുകൾ ഡിസ്കിലേക്ക് നിർബന്ധിക്കുന്നു.


The file system stores metadata about each file.

ഓരോ ഫയലിനെക്കുറിച്ചുമുള്ള മെറ്റാഡാറ്റ ഫയൽ സിസ്റ്റം സംഭരിക്കുന്നു.


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

ഡയറക്ടറികൾ എന്നത് പേര്-ഐനോഡ്-നമ്പർ മാപ്പിംഗുകൾ സംഭരിക്കുന്ന ഒരു പ്രത്യേക തരം ഫയലാണ്.


File systems often use bitmaps to track free or allocated inodes and data blocks.

സൗജന്യ അല്ലെങ്കിൽ അനുവദിച്ച ഐനോഡുകളും ഡാറ്റാ ബ്ലോക്കുകളും ട്രാക്ക് ചെയ്യാൻ ഫയൽ സിസ്റ്റങ്ങൾ സാധാരണയായി ബിറ്റ്‌മാപ്പുകൾ ഉപയോഗിക്കുന്നു.


The old UNIX file system had poor performance.

പഴയ UNIX ഫയൽ സിസ്റ്റത്തിന് മോശം പ്രകടനം ഉണ്ടായിരുന്നു.


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

പ്രധാന പ്രശ്നം പഴയ UNIX ഫയൽ സിസ്റ്റം ഡിസ്കിനെ റാൻഡം-ആക്സസ് മെമ്മറിയായി കണക്കാക്കി എന്നതാണ്.


FFS was designed to be 'disk aware' to improve performance.

പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനായി FFS 'ഡിസ്ക് അവബോധമുള്ള' രീതിയിലാണ് രൂപകൽപ്പന ചെയ്തത്.


FFS divides the disk into cylinder groups.

FFS ഡിസ്കിനെ സിലിണ്ടർ ഗ്രൂപ്പുകളായി വിഭജിക്കുന്നു.


Each cylinder group contains a copy of the super block.

ഓരോ സിലിണ്ടർ ഗ്രൂപ്പിലും സൂപ്പർ ബ്ലോക്കിന്റെ ഒരു പകർപ്പ് അടങ്ങിയിരിക്കുന്നു.


The inode bitmap and data bitmap track free inodes and data blocks.

ഐനോഡ് ബിറ്റ്‌മാപ്പും ഡാറ്റാ ബിറ്റ്‌മാപ്പും സൗജന്യ ഐനോഡുകളും ഡാറ്റാ ബ്ലോക്കുകളും ട്രാക്ക് ചെയ്യുന്നു.


FFS places related files and directories together.

FFS ബന്ധപ്പെട്ട ഫയലുകളും ഡയറക്ടറികളും ഒരുമിപ്പിക്കുന്നു.


FFS allocates the data blocks of a file in the same group as its inode.

FFS ഒരു ഫയലിന്റെ ഡാറ്റാ ബ്ലോക്കുകൾ അതിന്റെ ഐനോഡിന്റെ അതേ ഗ്രൂപ്പിൽ അനുവദിക്കുന്നു.


For large files, FFS places chunks of the file in different block groups.

വലിയ ഫയലുകൾക്കായി, FFS ഫയലിന്റെ ഭാഗങ്ങൾ വ്യത്യസ്ത ബ്ലോക്ക് ഗ്രൂപ്പുകളിൽ സ്ഥാപിക്കുന്നു.


ഈ സമീപനത്തെ അമോർട്ടൈസേഷൻ എന്ന് വിളിക്കുന്നു.


The file system's design significantly impacts performance.

ഫയൽ സിസ്റ്റത്തിന്റെ രൂപകൽപ്പന പ്രകടനത്തെ വളരെയധികം സ്വാധീനിക്കുന്നു.


The file system manages data structures to implement abstractions like files and directories.

ഫയലുകളും ഡയറക്ടറികളും പോലുള്ള ആശയങ്ങൾ നടപ്പിലാക്കാൻ ഫയൽ സിസ്റ്റം ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യുന്നു.


Power loss or system crashes can lead to inconsistent data structures on disk.

വൈദ്യുതി തകരാറോ സിസ്റ്റം തകർച്ചയോ സംഭവിച്ചാൽ ഡിസ്കിലെ ഡാറ്റാ ഘടനകൾക്ക് സ്ഥിരത നഷ്ടപ്പെടാൻ സാധ്യതയുണ്ട്.


The crash-consistency problem is a key challenge in file system design.

ഫയൽ സിസ്റ്റം രൂപകൽപ്പനയിലെ ഒരു പ്രധാന വെല്ലുവിളിയാണ് ക്രാഷ്-സ്ഥിരത പ്രശ്നം.


Fsck is a tool used to find and repair inconsistencies in older file systems.

പഴയ ഫയൽ സിസ്റ്റങ്ങളിൽ പൊരുത്തക്കേടുകൾ കണ്ടെത്തി നന്നാക്കാൻ ഉപയോഗിക്കുന്ന ഒരു ഉപകരണമാണ് fsck.


Journaling is a technique that improves crash recovery speed.

ക്രാഷ് വീണ്ടെടുക്കലിന്റെ വേഗത വർദ്ധിപ്പിക്കുന്ന ഒരു സാങ്കേതികതയാണ് ജേർണലിംഗ്.


The system may crash between any two writes, leaving the on-disk state partially updated.

ഏതെങ്കിലും രണ്ട് എഴുത്തുകൾക്കിടയിൽ സിസ്റ്റം തകരാറിലാകാം, ഇത് ഓൺ-ഡിസ്ക് അവസ്ഥ ഭാഗികമായി അപ്‌ഡേറ്റ് ചെയ്യാൻ ഇടയാക്കും.


A crash can occur after one or two writes, but not all three, leaving the file system in a funny state.

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


If only the data block is written, it's as if the write never occurred.

ഡാറ്റാ ബ്ലോക്ക് മാത്രമേ എഴുതുന്നുള്ളെങ്കിൽ, എഴുതിയതുപോലെ സംഭവിക്കുകയില്ല.


If the updated inode is written, the inode may point to garbage data.

അപ്‌ഡേറ്റ് ചെയ്ത ഐനോഡ് എഴുതിയാൽ, ഐനോഡിന് മാലിന്യ ഡാറ്റയിലേക്ക് ചൂണ്ടിക്കാണിക്കാൻ കഴിയും.


Fsck operates in phases to check and repair the file system.

ഫയൽ സിസ്റ്റം പരിശോധിക്കാനും നന്നാക്കാനും fsck ഘട്ടങ്ങളായി പ്രവർത്തിക്കുന്നു.


Fsck checks the superblock to ensure it's reasonable.

സൂപ്പർബ്ലോക്ക് ന്യായമാണെന്ന് ഉറപ്പാക്കാൻ fsck പരിശോധിക്കുന്നു.


Fsck scans inodes and indirect blocks to understand allocated blocks.

അലോട്ട് ചെയ്ത ബ്ലോക്കുകൾ മനസ്സിലാക്കാൻ fsck ഐനോഡുകളും, ഇൻഡയറക്ട് ബ്ലോക്കുകളും സ്കാൻ ചെയ്യുന്നു.


Fsck verifies the link count of each allocated inode.

ഓരോ അലോട്ട് ചെയ്ത ഐനോഡിന്റെയും ലിങ്ക് എണ്ണം fsck പരിശോധിക്കുന്നു.


Fsck checks for duplicate pointers and bad blocks.

ഡ്യൂപ്ലിക്കേറ്റ് പോയിന്ററുകളും മോശം ബ്ലോക്കുകളും fsck പരിശോധിക്കുന്നു.


Fsck performs directory checks to ensure integrity.

സമഗ്രത ഉറപ്പാക്കാൻ fsck ഡയറക്ടറി പരിശോധനകൾ നടത്തുന്നു.


Fsck can be slow on very large disk volumes.

വലിയ ഡിസ്ക് വോള്യങ്ങളിൽ fsck വളരെ വേഗത കുറഞ്ഞതാകാം.


Journaling file systems offer faster crash recovery.

ജേർണലിംഗ് ഫയൽ സിസ്റ്റങ്ങൾ വേഗത്തിലുള്ള ക്രാഷ് വീണ്ടെടുക്കൽ വാഗ്ദാനം ചെയ്യുന്നു.


The append operation involves updating the inode, data block, and bitmap.

അപെൻഡ് പ്രവർത്തനത്തിൽ ഐനോഡ്, ഡാറ്റാ ബ്ലോക്ക്, ബിറ്റ്മാപ്പ് എന്നിവ അപ്‌ഡേറ്റ് ചെയ്യുന്നത് ഉൾപ്പെടുന്നു.


A crash during an append can lead to inconsistencies.

ഒരു അപെൻഡിംഗിനിടയിലുള്ള തകർച്ച പൊരുത്തക്കേടുകളിലേക്ക് നയിച്ചേക്കാം.


Modern file systems often use journaling to ensure data integrity.

ആധുനിക ഫയൽ സിസ്റ്റങ്ങൾ സാധാരണയായി ഡാറ്റയുടെ സമഗ്രത ഉറപ്പാക്കാൻ ജേർണലിംഗ് ഉപയോഗിക്കുന്നു.


The system crashed during the file operation.

ഫയൽ ഓപ്പറേഷൻ നടക്കുമ്പോൾ സിസ്റ്റം തകർന്നു.


Journaling helps to recover data after a crash.

ഒരു തകർച്ചയ്ക്ക് ശേഷം ഡാറ്റ വീണ്ടെടുക്കാൻ ജേർണലിംഗ് സഹായിക്കുന്നു.


The recovery process replays everything in the log.

വീണ്ടെടുക്കൽ പ്രക്രിയ ലോഗിലെ എല്ലാം വീണ്ടും പ്ലേ ചെയ്യുന്നു.


ഇതൊരു ശരിയായ വീണ്ടെടുക്കൽ നടപടിയല്ല.


One solution is to never reuse blocks until the delete is checkpointed.

ഒഴിവാക്കൽ ചെക്ക്പോയിന്റ് ചെയ്യുന്നത് വരെ ബ്ലോക്കുകൾ വീണ്ടും ഉപയോഗിക്കാതിരിക്കുക എന്നതാണ് ഒരു പരിഹാരം.


Linux ext3 ഒരു റദ്ദാക്കൽ റെക്കോർഡ് ഉപയോഗിക്കുന്നു.


The system first scans for revoke records.

സിസ്റ്റം ആദ്യം റദ്ദാക്കൽ റെക്കോർഡുകൾക്കായി സ്കാൻ ചെയ്യുന്നു.


റദ്ദാക്കിയ ഡാറ്റ ഒരിക്കലും വീണ്ടും പ്ലേ ചെയ്യില്ല.


We summarize the protocols with timelines.

സമയം രേഖപ്പെടുത്തി ഞങ്ങൾ പ്രോട്ടോക്കോളുകൾ സംഗ്രഹിക്കുന്നു.


Time increases in the downward direction.

സമയം താഴേക്ക് ദിശയിൽ വർദ്ധിക്കുന്നു.


The writes can logically be issued at the same time.

എഴുത്തുകൾക്ക് ഒരേ സമയം ലോജിക്കലായി നൽകാൻ കഴിയും.


The checkpointing writes cannot begin until the transaction end block has committed.

ഇടപാട് അവസാന ബ്ലോക്ക് കമ്മീറ്റ് ചെയ്യുന്നത് വരെ ചെക്ക്പോയിൻ്റിംഗ് എഴുത്ത് ആരംഭിക്കാൻ കഴിയില്ല.


The completion time is determined by the I/O subsystem.

പൂർത്തീകരണ സമയം I/O ഉപസിസ്റ്റം നിർണ്ണയിക്കുന്നു.


We have two options for keeping file system metadata consistent.

ഫയൽ സിസ്റ്റം മെറ്റാഡാറ്റ സ്ഥിരത നിലനിർത്താൻ ഞങ്ങൾക്ക് രണ്ട് ഓപ്ഷനുകളുണ്ട്.


ജേർണലിംഗ് കൂടുതൽ സജീവമായ ഒരു സമീപനമാണ്.


Soft Updates carefully orders all writes.

സോഫ്റ്റ് അപ്‌ഡേറ്റുകൾ എല്ലാ എഴുത്തുകളും ശ്രദ്ധാപൂർവ്വം ഓർഡർ ചെയ്യുന്നു.


Implementing Soft Updates can be a challenge.

സോഫ്റ്റ് അപ്‌ഡേറ്റുകൾ നടപ്പിലാക്കുന്നത് ഒരു വെല്ലുവിളിയാണ്.


COW file systems flip the root structure.

COW ഫയൽ സിസ്റ്റങ്ങൾ റൂട്ട് ഘടന മാറ്റുന്നു.


We will be learning more about this technique later.

ഈ സാങ്കേതികവിദ്യയെക്കുറിച്ച് ഞങ്ങൾ പിന്നീട് കൂടുതൽ പഠിക്കും.


Backpointer-based consistency does not enforce ordering.

ബാക്ക്പോയിന്റർ അടിസ്ഥാനമാക്കിയുള്ള സ്ഥിരത ഓർഡർ നടപ്പാക്കുന്നില്ല.


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.

ഡിസ്ക് അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ, നിലവിലുള്ള ഘടനകൾ തിരുത്തുന്നതിന് മുമ്പ്, നിങ്ങൾ ചെയ്യാൻ പോകുന്നതിനെക്കുറിച്ച് ഒരു ചെറിയ കുറിപ്പ് എഴുതുക.


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.

ഈ കുറിപ്പ് ഡിസ്കിലേക്ക് എഴുതുന്നതിലൂടെ, അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ ഒരു തകരാർ സംഭവിച്ചാൽ, നിങ്ങൾക്ക് തിരികെ പോയി ആ കുറിപ്പ് പരിശോധിക്കാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.


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, എങ്ങനെയാണ് ജേർണലിംഗ് ഫയൽ സിസ്റ്റത്തിലേക്ക് ഉൾക്കൊള്ളിക്കുന്നത് എന്ന് നമുക്ക് നോക്കാം.


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.

ഈ ചർച്ചയുടെ significant ഭാഗവും ഉൾക്കൊള്ളുന്നത് 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) എന്നിവ വീണ്ടും ഡിസ്കിലേക്ക് എഴുതാൻ ആഗ്രഹിക്കുന്നു.


Before writing them to their final disk locations, we are now first going to write them to the log (a.k.a. journal).

അവയുടെ അവസാന ഡിസ്ക് സ്ഥാനത്തേക്ക് എഴുതുന്നതിന് മുമ്പ്, ഞങ്ങൾ ഇപ്പോൾ അവ ലോഗിലേക്ക് (അതായത് ജേർണൽ) എഴുതാൻ പോകുന്നു.


The transaction begin (TxB) tells us about this update, including information about the pending update to the file system.

ഈ അപ്‌ഡേറ്റിനെക്കുറിച്ച് ട്രാൻസാക്ഷൻ ആരംഭം (TxB) നമ്മോട് പറയുന്നു, ഫയൽ സിസ്റ്റത്തിലേക്കുള്ള തീർപ്പാക്കാത്ത അപ്‌ഡേറ്റിനെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഉൾപ്പെടെ.


When accessing a seemingly-working disk, it may return an error.

പ്രവർത്തിക്കുന്നതായി തോന്നുന്ന ഒരു ഡിസ്കിലേക്ക് പ്രവേശിക്കുമ്പോൾ, അത് ഒരു പിശക് നൽകിയേക്കാം.


അത് തെറ്റായ ഡാറ്റ നൽകിയേക്കാം.


Both of these types of faults are somewhat rare.

ഈ തരം തകരാറുകൾ രണ്ടും വളരെ കുറവാണ്.


The table shows the percent of drives that exhibited at least one LSE or block corruption.

ഒരു LSE അല്ലെങ്കിൽ ബ്ലോക്ക് കേടുപാടുകൾ എങ്കിലും കാണിച്ച ഡ്രൈവുകളുടെ ശതമാനം പട്ടികയിൽ കാണിക്കുന്നു.


Buying better drives reduces the frequency of both types of problem.

മികച്ച ഡ്രൈവുകൾ വാങ്ങുന്നത് രണ്ട് തരത്തിലുള്ള പ്രശ്നങ്ങളുടെയും ആവൃത്തി കുറയ്ക്കുന്നു.


They still happen often enough that you need to think carefully about them.

അവ ഇപ്പോഴും സംഭവിക്കാറുണ്ട്, അതിനാൽ നിങ്ങൾ അവയെക്കുറിച്ച് ശ്രദ്ധാപൂർവ്വം ചിന്തിക്കേണ്ടതുണ്ട്.


Costly drives with more than one LSE are as likely to develop additional errors as cheaper drives.

ഒന്നിലധികം LSE-യുള്ള വിലകൂടിയ ഡ്രൈവുകളിൽ, വില കുറഞ്ഞ ഡ്രൈവുകളിൽ സംഭവിക്കുന്നതുപോലെ അധിക പിശകുകൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്.


ഡിസ്കിന്റെ വലുപ്പം കൂടുന്തോറും LSE-കളും വർദ്ധിക്കുന്നു.


LSE-യുള്ള മിക്ക ഡിസ്കുകളിലും 50-ൽ താഴെയാണ്.


Disks with LSEs are more likely to develop additional LSEs.

LSE-യുള്ള ഡിസ്കുകളിൽ കൂടുതൽ LSE-കൾ ഉണ്ടാകാൻ സാധ്യതയുണ്ട്.


ഡിസ്ക് സ്ക്രബ്ബിംഗ് ഉപയോഗപ്രദമാണ്.


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.

ഒരു ചെക്ക്സം എന്നത് ഒരു ഫംഗ്ഷന്റെ ഫലമാണ്.


The goal of such a computation is to enable a system to detect if data has somehow been corrupted.

ഡാറ്റ ഏതെങ്കിലും വിധത്തിൽ കേടായാൽ കണ്ടെത്താൻ ഒരു സിസ്റ്റത്തെ പ്രാപ്തമാക്കുക എന്നതാണ് അത്തരം കണക്കുകൂട്ടലിന്റെ ലക്ഷ്യം.


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

സൗജന്യ ഉച്ചഭക്ഷണമില്ല, ചുരുക്കത്തിൽ TNSTAAFL.


A trade-off that is common in systems arises here.

സിസ്റ്റങ്ങളിൽ സാധാരണയായി കാണുന്ന ഒരു വിട്ടുവീഴ്ച ഇവിടെയുണ്ട്.


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

ചിലർ ഉപയോഗിക്കുന്ന ഒരു ലളിതമായ ചെക്ക്സം ഫംഗ്ഷൻ എക്സ്ക്ലൂസീവ് ഓർ (XOR) അടിസ്ഥാനമാക്കിയുള്ളതാണ്.


If two bits in the same position within each checksummed unit change, the checksum will not detect the corruption.

ഓരോ ചെക്ക്സം ചെയ്ത യൂണിറ്റിലെയും ഒരേ സ്ഥാനത്തുള്ള രണ്ട് ബിറ്റുകൾ മാറിയാൽ, ചെക്ക്സം കേടുപാടുകൾ കണ്ടെത്തുകയില്ല.


This approach has the advantage of being fast.

ഈ സമീപനത്തിന് വേഗതയെന്ന ഗുണമുണ്ട്.


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

ഒരു ബ്ലോക്ക് വായിക്കുമ്പോൾ, ക്ലയിന്റ് അതിന്റെ ചെക്ക്സം ഡിസ്കിൽ നിന്ന് റീഡ് ചെയ്യുന്നു.


It turns out that file systems can be quite complex.

ഫയൽ സിസ്റ്റങ്ങൾ വളരെ സങ്കീർണ്ണമായിരിക്കുമെന്ന് മനസ്സിലാക്കുന്നു.


The paper discusses how file systems handle failures.

ഫയൽ സിസ്റ്റങ്ങൾ പരാജയങ്ങൾ എങ്ങനെ കൈകാര്യം ചെയ്യുന്നു എന്ന് ഈ പേപ്പറിൽ പറയുന്നു.


We found numerous bugs and design flaws.

ഞങ്ങൾ നിരവധി ബഗുകളും ഡിസൈൻ വൈകല്യങ്ങളും കണ്ടെത്തി.


This work has helped improve file systems.

ഈ പ്രവർത്തി ഫയൽ സിസ്റ്റങ്ങളെ മെച്ചപ്പെടുത്താൻ സഹായിച്ചു.


The paper is about improving write performance.

എഴുത്ത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നതിനെക്കുറിച്ചാണ് ഈ പേപ്പർ.


This paper is a must-read for those building distributed systems.

വിതരണം ചെയ്ത സിസ്റ്റങ്ങൾ നിർമ്മിക്കുന്നവർക്ക് ഇത് തീർച്ചയായും വായിച്ചിരിക്കേണ്ട ഒന്നാണ്.


It talks about building fault-tolerant services.

തെറ്റുകൾ സഹിക്കാൻ കഴിവുള്ള സേവനങ്ങൾ എങ്ങനെ നിർമ്മിക്കാമെന്ന് ഇത് പറയുന്നു.


Our work adds data protection to the page cache.

ഞങ്ങളുടെ പ്രവർത്തി പേജ് കാഷെയിലേക്ക് ഡാറ്റാ സംരക്ഷണം ചേർക്കുന്നു.


File systems seem interesting, but complicated.

ഫയൽ സിസ്റ്റങ്ങൾ രസകരമാണെങ്കിലും സങ്കീർണ്ണമാണ്.


Managing data persistently is harder than managing data in memory.

സ്ഥിരമായി ഡാറ്റ കൈകാര്യം ചെയ്യുന്നത് മെമ്മറിയിലുള്ള ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനേക്കാൾ ബുദ്ധിമുട്ടാണ്.


എന്നെന്നും എന്നത് വളരെ ദൂരെയാണ്.


Even simple updates to storage are complicated.

സംഭരണ സ്ഥലത്തേക്കുള്ള ലളിതമായ അപ്‌ഡേറ്റുകൾ പോലും സങ്കീർണ്ണമാണ്.


വീണ്ടെടുക്കൽ ഒരു വലിയ കാര്യമാണ്.


Updates to persistent storage remain a challenging problem.

സ്ഥിരമായ സംഭരണത്തിലേക്കുള്ള അപ്‌ഡേറ്റുകൾ ഇപ്പോഴും ഒരു വെല്ലുവിളിയാണ്.


Disk scheduling and data protection techniques are cool.

ഡിസ്ക് ഷെഡ്യൂളിംഗും ഡാറ്റാ സംരക്ഷണ രീതികളും മികച്ചതാണ്.


എറൈസർ കോഡുകൾ നിങ്ങളുടെ തലവേദന ഉണ്ടാക്കും.


Technology-aware systems like FFS and LFS are neat.

FFS, LFS പോലുള്ള സാങ്കേതികവിദ്യയെക്കുറിച്ചുള്ള സിസ്റ്റങ്ങൾ മികച്ചതാണ്.


Even with Flash, these ideas are still relevant.

ഫ്ലാഷ് ഉപയോഗിക്കുമ്പോൾ പോലും, ഈ ആശയങ്ങൾ ഇപ്പോഴും പ്രസക്തമാണ്.


Flash Translation Layers use log-structuring internally.

ഫ്ലാഷ് ട്രാൻസ്ലേഷൻ ലെയറുകൾ ആന്തരികമായി ലോഗ്-സ്ട്രക്ചറിംഗ് ഉപയോഗിക്കുന്നു.


Many of the ideas we have studied will continue to be useful.

നമ്മൾ പഠിച്ച പല ആശയങ്ങളും തുടർന്നും ഉപയോഗപ്രദമാകും.


LFS has just such a fixed place on disk for this, known as the checkpoint region (CR).

ഇതിനായി LFS-ന് ഡിസ്കിൽ ഒരു നിശ്ചിത സ്ഥാനമുണ്ട്, അതിനെ ചെക്ക്പോയിന്റ് പ്രദേശം (CR) എന്ന് വിളിക്കുന്നു.


The checkpoint region contains pointers to (i.e., ad- dresses of) the latest pieces of the inode map.

ചെക്ക്പോയിന്റ് മേഖലയിൽ, iനോഡ് മാപ്പിന്റെ ഏറ്റവും പുതിയ ഭാഗങ്ങളിലേക്കുള്ള പോയിന്ററുകൾ (അതായത് വിലാസങ്ങൾ) അടങ്ങിയിരിക്കുന്നു.


The overall structure of the on-disk layout contains a checkpoint region.

ഓൺ-ഡിസ്ക് ലേഔട്ടിന്റെ മൊത്തത്തിലുള്ള ഘടനയിൽ ഒരു ചെക്ക്പോയിന്റ് പ്രദേശം അടങ്ങിയിരിക്കുന്നു.


A real file system would of course have a much bigger CR.

ഒരു യഥാർത്ഥ ഫയൽ സിസ്റ്റത്തിന് തീർച്ചയായും വളരെ വലിയ CR ഉണ്ടായിരിക്കും.


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

LFS എങ്ങനെ പ്രവർത്തിക്കുമെന്നും മനസ്സിലാക്കാൻ, ഒരു ഫയൽ ഡിസ്കിൽ നിന്ന് എങ്ങനെ വായിക്കുമെന്നും നമുക്ക് നോക്കാം.


Assume we have nothing in memory to begin.

ആരംഭിക്കുന്നതിന് മെമ്മറിയിൽ ഒന്നും തന്നെയില്ലെന്ന് കരുതുക.


The first on-disk data structure we must read is 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.

ഈ ഘട്ടത്തിനു ശേഷം, ഒരു ഫയലിന്റെ iനോഡ് നമ്പർ നൽകുമ്പോൾ, LFS imap-ൽ iനോഡ് നമ്പറും iനോഡ്-ഡിസ്ക് വിലാസവും തമ്മിലുള്ള മാപ്പിംഗ് പരിശോധിക്കുന്നു.


അപ്പോൾ LFS ഡയറക്ടറി ഡാറ്റ എങ്ങനെയാണ് സംഭരിക്കുന്നത്?


Fortunately, directory structure is basically identical to classic UNIX file systems.

ഭാഗ്യവശാൽ, ഡയറക്ടറി ഘടന ക്ലാസിക് UNIX ഫയൽ സിസ്റ്റങ്ങളുമായി അടിസ്ഥാനപരമായി സമാനമാണ്.


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 ഒരു പുതിയ iനോഡ്, ചില ഡാറ്റ, അതുപോലെ ഈ ഫയലിനെ പരാമർശിക്കുന്ന ഡയറക്ടറി ഡാറ്റയും അതിന്റെ iനോഡും എഴുതണം.


Remember that LFS will do so sequentially on the disk.

LFS ഇത് ഡിസ്കിൽ തുടർച്ചയായി ചെയ്യും എന്ന് ഓർക്കുക.


Thus, creating a file foo in a directory would lead to the following new structures on disk:

അതുകൊണ്ട്, ഒരു ഡയറക്ടറിയിൽ foo എന്ന ഫയൽ ഉണ്ടാക്കുന്നത് ഡിസ്കിൽ താഴെ പറയുന്ന പുതിയ ഘടനകൾക്ക് കാരണമാകും:


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-ൽ നിങ്ങൾ ശ്രദ്ധിച്ച മറ്റൊരു പ്രശ്നമുണ്ട്; ഇത് ഒരു ഫയലിന്റെയും, അതിന്റെ iനോഡിന്റെയും, വാസ്തവത്തിൽ എല്ലാ ഡാറ്റയുടെയും പുതിയ പതിപ്പുകൾ ഡിസ്കിന്റെ പുതിയ ഭാഗത്തേക്ക് എഴുതുന്നു.


അത്തരം പഴയ കാര്യങ്ങളെ ഞങ്ങൾ മാലിന്യം എന്ന് വിളിക്കുന്നു.


For example, let’s imagine the case where we have an existing file referred to by inode number k, which points to a single data block D0.

ഉദാഹരണത്തിന്, k എന്ന iനോഡ് നമ്പർ ഉപയോഗിച്ച് പരാമർശിക്കപ്പെടുന്ന നിലവിലുള്ള ഒരു ഫയൽ നമ്മുടെ പക്കലുണ്ടെന്ന് കരുതുക, ഇത് ഒരു ഡാറ്റാ ബ്ലോക്ക് D0-യിലേക്ക് പോയിന്റ് ചെയ്യുന്നു.


By the simple act of overwriting a data block, a number of new structures must be persisted by LFS, thus leaving old versions of said blocks on the disk.

ഒരു ഡാറ്റാ ബ്ലോക്ക് തിരുത്തുന്നതിലൂടെ, നിരവധി പുതിയ ഘടനകൾ LFS നിലനിർത്തണം, അതുവഴി പറഞ്ഞ ബ്ലോക്കുകളുടെ പഴയ പതിപ്പുകൾ ഡിസ്കിൽ അവശേഷിക്കുന്നു.


So what should we do with these older versions of inodes, datablocks, and so forth?

അപ്പോൾ ഈ പഴയ iനോഡുകൾ, ഡാറ്റാ ബ്ലോക്കുകൾ എന്നിവയും മറ്റും ഉപയോഗിച്ച് നമ്മൾ എന്തു ചെയ്യണം?


Cleaning became the focus of much controversy in LFS.

LFS-ൽ ശുചീകരണം വലിയ വിവാദങ്ങൾക്ക് കാരണമായി.


In this chapter, we focus on reliability once again.

ഈ അധ്യായത്തിൽ, നമ്മൾ വീണ്ടും വിശ്വാസ്യതയിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു.


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 സിസ്റ്റത്തിലെ ഭാരമേറിയ ജോലികൾ കൈകാര്യം ചെയ്യുന്നത് റൺ-ടൈം ലൈബ്രറിയാണ്.


One of the first challenges we must overcome is how to locate a remote service.

നമ്മൾ മറികടക്കേണ്ട ആദ്യത്തെ വെല്ലുവിളികളിലൊന്ന് ഒരു വിദൂര സേവനം എങ്ങനെ കണ്ടെത്താം എന്നതാണ്.


The system uses time sharing to manage resources.

സംവിധാനം വിഭവങ്ങൾ കൈകാര്യം ചെയ്യാൻ സമയ പങ്കിടൽ ഉപയോഗിക്കുന്നു.


Virtual memory is a key concept in modern operating systems.

ആധുനിക ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങളിൽ ഒരു പ്രധാന ആശയമാണ് വെർച്വൽ മെമ്മറി.


The operating system provides the illusion of many CPUs.

ഓപ്പറേറ്റിംഗ് സിസ്റ്റം നിരവധി CPU-കളുടെ ഒരു മിഥ്യ നൽകുന്നു.


How to efficiently virtualize the CPU with control?

നിയന്ത്രണത്തോടെ CPU-വിനെ എങ്ങനെ കാര്യക്ഷമമായി വെർച്വലൈസ് ചെയ്യാം?


സമയ-സ്ഥലത്തിന്റെ trade-offs മനസ്സിലാക്കുക.


The book was typeset using the LaTeX typesetting system.

പുസ്തകം ടൈപ്പ്‌സെറ്റ് ചെയ്തത് LaTeX ടൈപ്പ്‌സെറ്റിംഗ് സിസ്റ്റം ഉപയോഗിച്ചാണ്.


സമയം പങ്കിടൽ (സ്ഥലം പങ്കിടൽ) ഉപയോഗിക്കുക.


ഒരു അവസ്ഥയ്ക്കായി എങ്ങനെ കാത്തിരിക്കാം?


The system crashed due to a software bug.

ഒരു സോഫ്റ്റ്‌വെയർ ബഗ് കാരണം സിസ്റ്റം തകർന്നു.


പ്രോഗ്രാം ധാരാളം മെമ്മറി ഉപയോഗിക്കുന്നു.


The file system is designed for performance.

പ്രകടനം മെച്ചപ്പെടുത്തുന്ന രീതിയിലാണ് ഫയൽ സിസ്റ്റം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്.


എങ്ങനെയാണ് ഫ്രീ സ്പേസ് കൈകാര്യം ചെയ്യേണ്ടത്?


The operating system is responsible for resource allocation.

വിഭവങ്ങൾ വിതരണം ചെയ്യേണ്ടത് ഓപ്പറേറ്റിംഗ് സിസ്റ്റമാണ്.


The TLB helps speed up address translation.

വിലാസം വിവർത്തനം വേഗത്തിലാക്കാൻ TLB സഹായിക്കുന്നു.


The system uses a timer interrupt to regain control.

നിയന്ത്രണം വീണ്ടെടുക്കാൻ സിസ്റ്റം ഒരു ടൈമർ തടസ്സം ഉപയോഗിക്കുന്നു.


പ്രോഗ്രാം ഉപയോക്തൃ മോഡിൽ പ്രവർത്തിക്കുന്നു.


The system is designed to handle concurrency.

സമാന്തരത കൈകാര്യം ചെയ്യാൻ സിസ്റ്റം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നു.


The book discusses various operating system concepts.

പുസ്തകത്തിൽ വിവിധ ഓപ്പറേറ്റിംഗ് സിസ്റ്റം ആശയങ്ങൾ ചർച്ച ചെയ്യുന്നു.


സാധ്യമെങ്കിൽ സിസ്റ്റം കാഷിംഗ് ഉപയോഗിക്കുന്നു.


ഒരു വിതരണം ചെയ്ത ഫയൽ സിസ്റ്റം എങ്ങനെ നിർമ്മിക്കാം?


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.

ഒരു ക്ലയിന്റ് നൽകുന്ന എഴുത്തുകളുടെ ഈ ശ്രേണി സങ്കൽപ്പിക്കുക.


ഇതൊരു സങ്കീർണ്ണമായ സാങ്കേതിക ആശയമാണ്.


ഫയലിന്റെ ഉള്ളടക്കം ഇതുപോലെ കാണപ്പെടുന്നു.


To avoid this problem, NFS servers must commit each write to stable storage.

ഈ പ്രശ്നം ഒഴിവാക്കാൻ, NFS സെർവറുകൾ ഓരോ എഴുത്തും സ്ഥിരമായ സംഭരണത്തിലേക്ക് സമർപ്പിക്കണം.


The server quickly restarts and receives the third write request.

സെർവർ പെട്ടെന്ന് പുനരാരംഭിക്കുകയും മൂന്നാമത്തെ എഴുത്ത് അഭ്യർത്ഥന സ്വീകരിക്കുകയും ചെയ്യുന്നു.


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 Andrew File System was introduced by researchers.

ആൻഡ്രൂ ഫയൽ സിസ്റ്റം ഗവേഷകർ അവതരിപ്പിച്ചു.


Most important is the design of the protocol between clients and servers.

ഏറ്റവും പ്രധാനം ക്ലയിന്റുകളും സെർവറുകളും തമ്മിലുള്ള പ്രോട്ടോക്കോളിന്റെ രൂപകൽപ്പനയാണ്.


In AFS, cache consistency is simple and readily understood.

AFS-ൽ, കാഷെ സ്ഥിരത ലളിതവും എളുപ്പത്തിൽ മനസ്സിലാക്കാവുന്നതുമാണ്.


AFS-ന്റെ രണ്ട് പതിപ്പുകളെക്കുറിച്ച് നമ്മൾ ചർച്ച ചെയ്യും.


When you open() a file, the entire file is fetched from the server.

ഒരു ഫയൽ തുറക്കുമ്പോൾ, മുഴുവൻ ഫയലും സെർവറിൽ നിന്ന് എടുക്കുന്നു.


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

തുടർന്നുള്ള റീഡ്() കൂടാതെ റൈറ്റ്() പ്രവർത്തനങ്ങൾ പ്രാദേശിക ഫയൽ സിസ്റ്റത്തിലേക്ക് റീഡയറക്‌ട് ചെയ്യപ്പെടുന്നു.


The client-side code would then cache the file on the local disk.

അതിനുശേഷം ക്ലയിന്റ്-സൈഡ് കോഡ് ഫയൽ പ്രാദേശിക ഡിസ്കിൽ കാഷെ ചെയ്യും.


അത്തരം പരീക്ഷണങ്ങൾ നല്ലതാണ്.


The server checks if the cached file is valid.

സെർവർ കാഷെ ചെയ്ത ഫയൽ സാധുവാണോ എന്ന് പരിശോധിക്കുന്നു.


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

കാഷെ ചെയ്ത പകർപ്പ് സാധുവാണെങ്കിൽ, ക്ലയിന്റിന് ഇത് ഉപയോഗിക്കാം.


Otherwise, the client should fetch the newer version.

അല്ലാത്തപക്ഷം, ക്ലയിന്റ് പുതിയ പതിപ്പ് എടുക്കണം.


Server recovery after a crash is complicated.

ഒരു തകർച്ചയ്ക്ക് ശേഷമുള്ള സെർവർ വീണ്ടെടുക്കൽ സങ്കീർണ്ണമാണ്.


കോൾബാക്കുകൾ മെമ്മറിയിൽ സൂക്ഷിച്ചിരിക്കുന്നു.


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

പുനരാരംഭിച്ച ശേഷം ഏത് ക്ലയിന്റിലാണ് ഏതൊക്കെ ഫയലുകൾ ഉള്ളതെന്ന് സെർവറിന് അറിയില്ല.


Each client must realize the server has crashed.

സെർവർ തകർന്നുവെന്ന് ഓരോ ക്ലയിന്റും മനസ്സിലാക്കണം.


Clients must treat all cache contents as suspect.

എല്ലാ കാഷെ ഉള്ളടക്കങ്ങളെയും സംശയാസ്പദമായി ക്ലയിന്റുകൾ കണക്കാക്കണം.


Reestablish the validity of a file before using it.

ഉപയോഗിക്കുന്നതിന് മുമ്പ് ഒരു ഫയലിന്റെ സാധുത വീണ്ടും സ്ഥാപിക്കുക.


ഒരു സെർവർ തകർച്ച ഒരു വലിയ സംഭവമാണ്.


Ensure each client is aware of the crash.

ഓരോ ക്ലയിന്റും തകർച്ചയെക്കുറിച്ച് ബോധവാന്മാരായിരിക്കണം.


കാലഹരണപ്പെട്ട ഒരു ഫയൽ ആക്സസ് ചെയ്യുന്ന ഒരു ക്ലയിന്റിനെ അപകടത്തിലാക്കുക.


There are many ways to implement such recovery.

അത്തരം വീണ്ടെടുക്കൽ നടപ്പിലാക്കാൻ നിരവധി വഴികളുണ്ട്.


The server sends a message to each client.

സെർവർ ഓരോ ക്ലയിന്റിലേക്കും ഒരു സന്ദേശം അയയ്ക്കുന്നു.


Clients check that the server is alive periodically.

സെർവർ ഇപ്പോഴും പ്രവർത്തിക്കുന്നുണ്ടോ എന്ന് ക്ലയിന്റുകൾ ഇടയ്ക്കിടെ പരിശോധിക്കുന്നു.


There is a cost to building a scalable caching model.

ഒരു സ്കേലബിൾ കാഷിംഗ് മോഡൽ നിർമ്മിക്കുന്നതിന് ചിലവ് ഉണ്ട്.


With NFS, clients hardly noticed a server crash.

NFS ഉപയോഗിച്ച്, സെർവർ തകർന്നത് ക്ലയിന്റുകൾ ശ്രദ്ധിച്ചില്ല.


AFSv2 was found to be much more scalable.

AFSv2 വളരെ കൂടുതൽ സ്കേലബിൾ ആണെന്ന് കണ്ടെത്തി.


Each server could support about 50 clients.

ഓരോ സെർവറിനും ഏകദേശം 50 ക്ലയിന്റുകളെ പിന്തുണയ്ക്കാൻ കഴിയും.


Client-side performance came close to local performance.

ക്ലയിന്റ് സൈഡ് പ്രകടനം പ്രാദേശിക പ്രകടനത്തോട് അടുത്തെത്തി.


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.

ഏത് ഫയൽ സിസ്റ്റമാണ് അഭ്യർത്ഥനയെന്ന് വോളിയം ഐഡന്റിഫയർ സെർവറിനെ അറിയിക്കുന്നു.


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 പ്രോട്ടോക്കോൾ സന്ദേശം പ്രോട്ടോക്കോളിന് ഫയലിന്റെ ഫയൽ കൈകാര്യം ചെയ്യലും, ഫയലിനുള്ളിലെ ഓഫ്‌സെറ്റും, വായിക്കേണ്ട ബൈറ്റുകളുടെ എണ്ണവും കൈമാറേണ്ടതുണ്ട്.


WRITE is handled similarly, except the data is passed from the client to the server, and just a success code is returned.

WRITE സമാനമായി കൈകാര്യം ചെയ്യപ്പെടുന്നു, ഡാറ്റ ക്ലയിന്റിൽ നിന്ന് സെർവറിലേക്ക് കൈമാറുന്നു, കൂടാതെ ഒരു വിജയ കോഡ് മാത്രം തിരികെ നൽകുന്നു.


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.

ഓരോ പ്രോട്ടോക്കോൾ സന്ദേശത്തിനും സെർവർ പ്രതികരിക്കുന്നു, ഓരോന്നിനും അഭ്യർത്ഥന പൂർത്തിയാക്കാൻ ആവശ്യമായ എല്ലാ വിവരങ്ങളും ഉണ്ട്.


If an operation is not idempotent, life becomes more difficult.

ഒരു ഓപ്പറേഷൻ ഐഡംപോർട്ടന്റ് അല്ലെങ്കിൽ, ജീവിതം കൂടുതൽ ബുദ്ധിമുട്ടായിരിക്കും.


In NFSv2, a client handles all of these failures in a single, uniform, and elegant way: it simply retries the request.

NFSv2-ൽ, ഒരു ക്ലയിന്റ് ഈ പരാജയങ്ങളെല്ലാം ഒരൊറ്റ, ഏകീകൃതവും, മനോഹരവുമായ രീതിയിൽ കൈകാര്യം ചെയ്യുന്നു: അത് അഭ്യർത്ഥന വീണ്ടും ശ്രമിക്കുന്നു.


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.

ഒന്നിലധികം തവണ ഒരു ഓപ്പറേഷൻ നടപ്പിലാക്കുന്നതിന്റെ ഫലം ഒരൊറ്റ തവണ നടപ്പിലാക്കുന്നതിന് തുല്യമാകുമ്പോൾ ആ ഓപ്പറേഷനെ ഐഡംപോർട്ടന്റ് എന്ന് വിളിക്കുന്നു.


LOOKUP and READ requests are trivially idempotent, as they only read information from the file server and do not update it.

LOOKUP, READ അഭ്യർത്ഥനകൾ ഫയൽ സെർവറിൽ നിന്ന് വിവരങ്ങൾ വായിക്കുകയും അത് അപ്‌ഡേറ്റ് ചെയ്യാതിരിക്കുകയും ചെയ്യുന്നതിനാൽ ലളിതമായി ഐഡംപോർട്ടന്റാണ്.


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

NFS ക്ലയിന്റ്-സൈഡ് ഫയൽ സിസ്റ്റം സെർവറിൽ നിന്ന് വായിച്ച ഫയൽ ഡാറ്റയും (മെറ്റാഡാറ്റയും) ക്ലയിന്റ് മെമ്മറിയിൽ കാഷെ ചെയ്യുന്നു.


Adding caching into any sort of system with multiple client caches introduces a big and interesting challenge which we will refer to as the cache consistency problem.

ഒന്നിലധികം ക്ലയിന്റ് കാഷെകളുള്ള ഏതൊരു സിസ്റ്റത്തിലും കാഷിംഗ് ചേർക്കുന്നത് കാഷെ സ്ഥിരത പ്രശ്നം എന്ന് വിളിക്കപ്പെടുന്ന ഒരു വലിയതും രസകരവുമായ വെല്ലുവിളി അവതരിപ്പിക്കുന്നു.