The government is discussing new policies.

ಸರ್ಕಾರವು ಹೊಸ ನೀತಿಗಳ ಬಗ್ಗೆ ಚರ್ಚಿಸುತ್ತಿದೆ.


The stock market is volatile these days.

ಷೇರು ಮಾರುಕಟ್ಟೆ ಇತ್ತೀಚಿನ ದಿನಗಳಲ್ಲಿ ಏರಿಳಿತ ಕಾಣುತ್ತಿದೆ.


The research team made a significant discovery.

ಸಂಶೋಧನಾ ತಂಡವು ಮಹತ್ವದ ಆವಿಷ್ಕಾರವನ್ನು ಮಾಡಿದೆ.


The software update will be released next week.

ಸಾಫ್ಟ್‌ವೇರ್ ನವೀಕರಣವನ್ನು ಮುಂದಿನ ವಾರ ಬಿಡುಗಡೆ ಮಾಡಲಾಗುವುದು.


The algorithm efficiently sorts the data.

ಅಲ್ಗಾರಿದಮ್ ದತ್ತಾಂಶವನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


The project requires careful planning and execution.

ಯೋಜನೆಗೆ ಎಚ್ಚರಿಕೆಯ ಯೋಜನೆ ಮತ್ತು ಅನುಷ್ಠಾನದ ಅಗತ್ಯವಿದೆ.


ಸವಾಲುಗಳ ಹೊರತಾಗಿಯೂ, ಅವರು ಯಶಸ್ವಿಯಾದರು.


The complexities of the situation are difficult to understand.

ಪರಿಸ್ಥಿತಿಯ ಸಂಕೀರ್ಣತೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕಷ್ಟಕರವಾಗಿದೆ.


The implications of the new technology are far-reaching.

ಹೊಸ ತಂತ್ರಜ್ಞಾನದ ಪರಿಣಾಮಗಳು ದೂರಗಾಮಿ ಆಗಿವೆ.


The economic forecast predicts a period of growth.

ಆರ್ಥಿಕ ಮುನ್ಸೂಚನೆಯು ಬೆಳವಣಿಗೆಯ ಅವಧಿಯನ್ನು ಊಹಿಸುತ್ತದೆ.


The philosophical debate centered on the nature of reality.

ತಾತ್ವಿಕ ಚರ್ಚೆಯು ವಾಸ್ತವದ ಸ್ವರೂಪದ ಮೇಲೆ ಕೇಂದ್ರೀಕೃತವಾಗಿತ್ತು.


The intricate design of the system required specialized knowledge.

ಸಿಸ್ಟಮ್‌ನ ಸಂಕೀರ್ಣ ವಿನ್ಯಾಸಕ್ಕೆ ವಿಶೇಷ ಜ್ಞಾನದ ಅಗತ್ಯವಿತ್ತು.


The company's strategic plan involves significant restructuring.

ಕಂಪನಿಯ ಕಾರ್ಯತಂತ್ರದ ಯೋಜನೆಯು ಮಹತ್ವದ ಪುನರ್ರಚನೆಯನ್ನು ಒಳಗೊಂಡಿದೆ.


The judge's ruling had a profound impact on the case.

ನ್ಯಾಯಾಧೀಶರ ತೀರ್ಪು ಪ್ರಕರಣದ ಮೇಲೆ ಆಳವಾದ ಪ್ರಭಾವ ಬೀರಿತು.


ವಿಳಾಸ 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 ಪ್ರಾರಂಭಿಸಿ.


ಅಡಚಣೆಗಳನ್ನು ನಿರ್ವಹಿಸಿ.


After each operation, read the status register.

ಪ್ರತಿ ಕಾರ್ಯಾಚರಣೆಯ ನಂತರ, ಸ್ಥಿತಿ ರೆಜಿಸ್ಟರ್ ಅನ್ನು ಓದಿ.


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

ದೋಷ ಬಿಟ್ ಆನ್ ಆಗಿದ್ದರೆ, ವಿವರಗಳಿಗಾಗಿ ದೋಷ ರೆಜಿಸ್ಟರ್ ಅನ್ನು ಓದಿ.


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

ಸಾಧನದೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಮೂಲ ಪ್ರೋಟೋಕಾಲ್ ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ.


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-ಬೈಟ್ ಬ್ಲಾಕ್‌ಗಳು) ಒಳಗೊಂಡಿದೆ.


Multi-sector operations are possible; indeed, many file systems will read or write 4KB at a time (or more).

ಬಹು-ವಲಯ ಕಾರ್ಯಾಚರಣೆಗಳು ಸಾಧ್ಯ; ವಾಸ್ತವವಾಗಿ, ಅನೇಕ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಒಂದು ಸಮಯದಲ್ಲಿ 4KB (ಅಥವಾ ಹೆಚ್ಚಿನ) ಓದುತ್ತವೆ ಅಥವಾ ಬರೆಯುತ್ತವೆ.


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 ಮತ್ತು ಇತರ ಕಂಪನಿಗಳ ಮೂಲಸೌಕರ್ಯಗಳಲ್ಲಿ ತಮ್ಮ ದಾರಿ ಕಂಡುಕೊಂಡಿವೆ.


ಹಾಗಾದರೆ, ಈಗ ನಿಮ್ಮ ತಲೆನೋವುತ್ತಿದೆಯೇ?


It’s hard to think about all the ways threads can interleave.

ಥ್ರೆಡ್‌ಗಳು ಹೇಗೆ ಪರಸ್ಪರ ಹೆಣೆದುಕೊಳ್ಳಬಹುದು ಎಂಬುದರ ಕುರಿತು ಯೋಚಿಸುವುದು ಕಷ್ಟ.


ಖಂಡಿತವಾಗಿಯೂ ಹೌದು.


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

ಸಹವರ್ತಿ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ ಒಳಗೊಂಡಿರುವಾಗ, ಕೆಲವೇ ಸಾಲುಗಳ ಕೋಡ್ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಬಹುತೇಕ ಅಸಾಧ್ಯವಾಗಬಹುದು ಎಂದು ನಾನು ಯಾವಾಗಲೂ ಆಶ್ಚರ್ಯ ಪಡುತ್ತೇನೆ.


ಪ್ರಾಧ್ಯಾಪಕರು ... ಉಹ್ ... ತಪ್ಪು ಮಾಡಬಹುದೇ?


ಹೌದು, ಇದು ನಿಜ.


Though don’t tell anybody – it’s one of our trade secrets.

ಆದರೆ ಯಾರಿಗೂ ಹೇಳಬೇಡಿ - ಇದು ನಮ್ಮ ವ್ಯಾಪಾರ ರಹಸ್ಯಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ.


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?

ಸರಳ ಲಾಕಿಂಗ್‌ನಂತೆ, ಮತ್ತು ಬಹುಶಃ ಉತ್ಪಾದಕ-ಗ್ರಾಹಕ ಸರತಿ ಸಾಲು?


Exactly! 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.

ಪ್ರೋಗ್ರಾಂನ ಅಕಾಲಿಕ ಆಪ್ಟಿಮೈಸೇಶನ್ಗಿಂತ ಕೆಟ್ಟದ್ದೇನೂ ಇಲ್ಲ.


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.

ಸರಾಸರಿ ಹುಡುಕಾಟ ಸಮಯವನ್ನು ತಯಾರಕರು ವರದಿ ಮಾಡಿದ ಸರಾಸರಿ ಸಮಯವೆಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.


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.

ಅಂತಿಮವಾಗಿ, ವರ್ಗಾವಣೆ ಸಮಯವು ಗರಿಷ್ಠ ವರ್ಗಾವಣೆ ದರದ ಮೇಲೆ ವರ್ಗಾವಣೆಯ ಗಾತ್ರವಾಗಿದೆ.


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

I/O ದರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ನಾವು ವರ್ಗಾವಣೆಯ ಗಾತ್ರವನ್ನು ಸರಾಸರಿ ಸಮಯದಿಂದ ಭಾಗಿಸುತ್ತೇವೆ.


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

ಇಲ್ಲಿ ನಾವು ಬಹಳ ದೀರ್ಘ ವರ್ಗಾವಣೆಗೆ ಮೊದಲು ಒಂದೇ ಹುಡುಕಾಟ ಮತ್ತು ತಿರುಗುವಿಕೆ ಇದೆ ಎಂದು ಭಾವಿಸಬಹುದು.


The table shows us a number of important things.

ಕೋಷ್ಟಕವು ನಮಗೆ ಹಲವಾರು ಪ್ರಮುಖ ವಿಷಯಗಳನ್ನು ತೋರಿಸುತ್ತದೆ.


There is a huge gap in drive performance between random and sequential workloads.

ಯಾದೃಚ್ಛಿಕ ಮತ್ತು ಅನುಕ್ರಮ ಕೆಲಸದ ಹೊರೆಯಲ್ಲಿ ಡ್ರೈವ್ ಕಾರ್ಯಕ್ಷಮತೆಯಲ್ಲಿ ದೊಡ್ಡ ಅಂತರವಿದೆ.


For this reason (and others), people are often willing to pay top dollar for the former.

ಈ ಕಾರಣಕ್ಕಾಗಿ (ಮತ್ತು ಇತರ ಕಾರಣಗಳಿಗಾಗಿ), ಜನರು ಸಾಮಾನ್ಯವಾಗಿ ಮೊದಲನೆಯದಕ್ಕೆ ಹೆಚ್ಚಿನ ಹಣವನ್ನು ಪಾವತಿಸಲು ಸಿದ್ಧರಾಗಿದ್ದಾರೆ.


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

ಡಿಸ್ಕ್ ಅನ್ನು 0 ರಿಂದ N ವರೆಗಿನ ಟ್ರ್ಯಾಕ್‌ಗಳ ಗುಂಪಾಗಿ ಊಹಿಸಿ.


The seek distance between any two tracks x and y is thus computed as the absolute value of the difference between them: |x−y|.

ಯಾವುದೇ ಎರಡು ಟ್ರ್ಯಾಕ್‌ಗಳ ನಡುವಿನ ಹುಡುಕಾಟದ ಅಂತರ x ಮತ್ತು y ಅನ್ನು ಅವುಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸದ ಸಂಪೂರ್ಣ ಮೌಲ್ಯವಾಗಿ ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ: |x−y|.


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 ಗಳ ಕೆಲವು ಪ್ರಮುಖ ಅಂಶಗಳನ್ನು ಚರ್ಚಿಸುತ್ತೇವೆ.


To a file system above, a RAID looks like a big, fast, and reliable disk.

ಮೇಲಿನ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ, 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 ವ್ಯವಸ್ಥೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಪ್ರತ್ಯೇಕ ಹಾರ್ಡ್‌ವೇರ್ ಬಾಕ್ಸ್‌ನಂತೆ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ.


RAIDs are fairly complex, consisting of a microcontroller.

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.

ಈ ಮಾದರಿಯಲ್ಲಿ, ಡಿಸ್ಕ್ ಎರಡು ಸ್ಥಿತಿಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿರಬಹುದು: ಕೆಲಸ ಮಾಡುವುದು ಅಥವಾ ವಿಫಲಗೊಳ್ಳುವುದು.


ನಾವು ಇದನ್ನು ಸುಲಭವಾಗಿ ಪತ್ತೆಹಚ್ಚಬಹುದು ಎಂದು ಭಾವಿಸುತ್ತೇವೆ.


How many disk faults can the given design tolerate?

ನೀಡಿದ ವಿನ್ಯಾಸವು ಎಷ್ಟು ಡಿಸ್ಕ್ ದೋಷಗಳನ್ನು ಸಹಿಸಿಕೊಳ್ಳಬಲ್ಲದು?


The first axis is capacity; given a set of N disks, how much useful capacity is available?

ಮೊದಲ ಅಕ್ಷವು ಸಾಮರ್ಥ್ಯವಾಗಿದೆ; N ಡಿಸ್ಕ್‌ಗಳ ಗುಂಪನ್ನು ನೀಡಿದರೆ, ಎಷ್ಟು ಉಪಯುಕ್ತ ಸಾಮರ್ಥ್ಯ ಲಭ್ಯವಿದೆ?


Performance is somewhat challenging to evaluate.

ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಮೌಲ್ಯಮಾಪನ ಮಾಡುವುದು ಸ್ವಲ್ಪ ಸವಾಲಾಗಿದೆ.


We now consider three important RAID designs.

ನಾವು ಈಗ ಮೂರು ಪ್ರಮುಖ RAID ವಿನ್ಯಾಸಗಳನ್ನು ಪರಿಗಣಿಸುತ್ತೇವೆ.


The first RAID level is actually not a RAID level at all.

ಮೊದಲ RAID ಮಟ್ಟವು ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ RAID ಮಟ್ಟವಲ್ಲ.


This approach is designed to extract the most parallelism.

ಈ ವಿಧಾನವು ಹೆಚ್ಚಿನ ಸಮಾನಾಂತರತೆಯನ್ನು ಹೊರತೆಗೆಯಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


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 ಏನು ಮಾಡುತ್ತದೆ ಎಂಬುದಕ್ಕೆ ಇದು ನಿಖರವಾದ ಉದಾಹರಣೆಯಾಗಿದೆ.


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, removing directories is more dangerous.

ಫೈಲ್ ಅಳಿಸುವುದಕ್ಕೆ ವ್ಯತಿರಿಕ್ತವಾಗಿ, ಡೈರೆಕ್ಟರಿಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು ಹೆಚ್ಚು ಅಪಾಯಕಾರಿ.


The rmdir() has the requirement that the directory be empty.

rmdir() ಡೈರೆಕ್ಟರಿಯು ಖಾಲಿಯಾಗಿರಬೇಕು ಎಂಬ ಅವಶ್ಯಕತೆಯನ್ನು ಹೊಂದಿದೆ.


If you try to delete a non-empty directory, the call to rmdir() will simply 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.

ಲಿಂಕ್() ಸಿಸ್ಟಮ್ ಕರೆ ಎರಡು ವಾದಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.


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 ಎಂಬ ಕಮಾಂಡ್-ಲೈನ್ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


We created a file with the word hello in it.

ನಾವು ಅದರಲ್ಲಿ hello ಎಂಬ ಪದದೊಂದಿಗೆ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ.


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

ಫೈಲ್ ಅಥವಾ ಫೈಲ್2 ಅನ್ನು ತೆರೆಯುವ ಮೂಲಕ ನಾವು ಫೈಲ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು.


The way link works is that it simply creates another name.

ಲಿಂಕ್ ಕೆಲಸ ಮಾಡುವ ವಿಧಾನವೆಂದರೆ ಅದು ಸರಳವಾಗಿ ಇನ್ನೊಂದು ಹೆಸರನ್ನು ರಚಿಸುತ್ತದೆ.


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

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ಫೈಲ್ ಅನ್ನು ತೆಗೆದುಹಾಕಲು, ನಾವು ಅನ್‌ಲಿಂಕ್() ಅನ್ನು ಕರೆಯುತ್ತೇವೆ.


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() ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಫೈಲ್‌ನ ಉಲ್ಲೇಖ ಎಣಿಕೆಯನ್ನು ನೋಡಬಹುದು.


As you can see, for each stripe of data, we have added a single parity block.

ನೀವು ನೋಡುವಂತೆ, ಪ್ರತಿ ಡೇಟಾ ಪಟ್ಟಿಗೆ, ನಾವು ಒಂದೇ ಸಮಾನತೆಯ ಬ್ಲಾಕ್ ಅನ್ನು ಸೇರಿಸಿದ್ದೇವೆ.


For example, parity block P1 has redundant information that it calculated from blocks 4, 5, 6, and 7.

ಉದಾಹರಣೆಗೆ, ಸಮಾನತೆಯ ಬ್ಲಾಕ್ P1 ಬ್ಲಾಕ್‌ಗಳು 4, 5, 6, ಮತ್ತು 7 ರಿಂದ ಲೆಕ್ಕಹಾಕಲಾದ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಹೊಂದಿದೆ.


To compute parity, we need to use a mathematical function that enables us to withstand the loss of any one block from our stripe.

ಸಮಾನತೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು, ನಮ್ಮ ಪಟ್ಟಿಯಿಂದ ಯಾವುದೇ ಒಂದು ಬ್ಲಾಕ್‌ನ ನಷ್ಟವನ್ನು ತಡೆದುಕೊಳ್ಳಲು ನಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುವ ಗಣಿತದ ಕಾರ್ಯವನ್ನು ನಾವು ಬಳಸಬೇಕಾಗಿದೆ.


It turns out the simple function XOR does the trick quite nicely.

ಸರಳ ಕಾರ್ಯ XOR ಸಾಕಷ್ಟು ಉತ್ತಮವಾಗಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ.


For a given set of bits, the XOR of all of those bits returns a 0 if there are an even number of 1’s in the bits, and a 1 if there are an odd number of 1’s.

ನಿರ್ದಿಷ್ಟ ಬಿಟ್‌ಗಳ ಗುಂಪಿಗೆ, ಆ ಎಲ್ಲಾ ಬಿಟ್‌ಗಳ XOR 0 ಅನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ, ಬಿಟ್‌ಗಳಲ್ಲಿ ಸಮ ಸಂಖ್ಯೆಯ 1 ಗಳು ಇದ್ದರೆ ಮತ್ತು ಬೆಸ ಸಂಖ್ಯೆಯ 1 ಗಳು ಇದ್ದರೆ 1.


In the first row (0,0,1,1), there are two 1’s (C2, C3), and thus XOR of all of those values will be 0 (P); similarly, in the second row there is only one 1 (C1), and thus the XOR must be 1 (P).

ಮೊದಲ ಸಾಲಿನಲ್ಲಿ (0,0,1,1), ಎರಡು 1 ಗಳಿವೆ (C2, C3), ಮತ್ತು ಆದ್ದರಿಂದ ಆ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳ XOR 0 ಆಗಿರುತ್ತದೆ (P); ಅದೇ ರೀತಿ, ಎರಡನೇ ಸಾಲಿನಲ್ಲಿ ಕೇವಲ ಒಂದು 1 (C1) ಇದೆ, ಮತ್ತು ಆದ್ದರಿಂದ XOR 1 ಆಗಿರಬೇಕು (P).


You can remember this in a very simple way: that the number of 1’s in any row must be an even (not odd) number; that is the invariant that the RAID must maintain in order for parity to be correct.

ನೀವು ಇದನ್ನು ಬಹಳ ಸರಳ ರೀತಿಯಲ್ಲಿ ನೆನಪಿಟ್ಟುಕೊಳ್ಳಬಹುದು: ಯಾವುದೇ ಸಾಲಿನಲ್ಲಿರುವ 1 ಗಳ ಸಂಖ್ಯೆ ಸಮ (ಬೆಸವಲ್ಲದ) ಸಂಖ್ಯೆ ಆಗಿರಬೇಕು; ಸಮಾನತೆಯನ್ನು ಸರಿಯಾಗಿ ಇರಿಸಿಕೊಳ್ಳಲು RAID ನಿರ್ವಹಿಸಬೇಕಾದ ಸ್ಥಿರಾಂಕ ಅದು.


Imagine the column la- beled C2 is lost.

C2 ಎಂದು ಲೇಬಲ್ ಮಾಡಲಾದ ಕಾಲಮ್ ಕಳೆದುಹೋಗಿದೆ ಎಂದು ಊಹಿಸಿ.


To figure out what values must have been in the column, we simply have to read in all the other values in that row (including the XOR’d parity bit) and reconstruct the right answer.

ಕಾಲಮ್‌ನಲ್ಲಿ ಯಾವ ಮೌಲ್ಯಗಳು ಇರಬೇಕು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನಾವು ಆ ಸಾಲಿನಲ್ಲಿರುವ ಇತರ ಎಲ್ಲಾ ಮೌಲ್ಯಗಳನ್ನು (XOR'd ಸಮಾನತೆಯ ಬಿಟ್ ಸೇರಿದಂತೆ) ಓದಬೇಕು ಮತ್ತು ಸರಿಯಾದ ಉತ್ತರವನ್ನು ಪುನರ್ನಿರ್ಮಿಸಬೇಕು.


Specifically, assume the first row’s value in column C2 is lost (it is a 1); by reading the other values in that row (0 from C0, 0 from C1, 1 from C3, and 0 from the parity column P), we get the values 0, 0, 1, and 0.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ಕಾಲಮ್ C2 ನಲ್ಲಿ ಮೊದಲ ಸಾಲಿನ ಮೌಲ್ಯವು ಕಳೆದುಹೋಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ (ಇದು 1); ಆ ಸಾಲಿನಲ್ಲಿರುವ ಇತರ ಮೌಲ್ಯಗಳನ್ನು ಓದುವ ಮೂಲಕ (C0 ನಿಂದ 0, C1 ನಿಂದ 0, C3 ನಿಂದ 1, ಮತ್ತು ಸಮಾನತೆಯ ಕಾಲಮ್ P ನಿಂದ 0), ನಾವು ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ 0, 0, 1, ಮತ್ತು 0.


Because we know that XOR keeps an even number of 1’s in each row, we know what the missing data must be: a 1.

XOR ಪ್ರತಿ ಸಾಲಿನಲ್ಲಿ ಸಮ ಸಂಖ್ಯೆಯ 1 ಗಳನ್ನು ಇರಿಸುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿರುವುದರಿಂದ, ಕಾಣೆಯಾದ ಡೇಟಾ ಏನಾಗಿರಬೇಕು ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ: 1.


And that is how reconstruction works in a XOR-based parity scheme!

ಮತ್ತು XOR-ಆಧಾರಿತ ಸಮಾನತೆಯ ಯೋಜನೆಯಲ್ಲಿ ಪುನರ್ನಿರ್ಮಾಣವು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ!


Note also how we compute the reconstructed value: we just XOR the data bits and the parity bits together, in the same way that we calculated the parity in the first place.

ಪುನರ್ನಿರ್ಮಿಸಿದ ಮೌಲ್ಯವನ್ನು ನಾವು ಹೇಗೆ ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ: ನಾವು ಡೇಟಾ ಬಿಟ್‌ಗಳು ಮತ್ತು ಸಮಾನತೆಯ ಬಿಟ್‌ಗಳನ್ನು ಒಟ್ಟಿಗೆ XOR ಮಾಡುತ್ತೇವೆ, ನಾವು ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಸಮಾನತೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ ರೀತಿಯಲ್ಲಿಯೇ.


Now you might be wondering: we are talking about XORing all of these bits, and yet above we know that the RAID places 4KB (or larger) blocks on each disk; how do we apply XOR to a bunch of blocks to compute the parity?

ಈಗ ನೀವು ಆಶ್ಚರ್ಯಪಡಬಹುದು: ನಾವು ಈ ಎಲ್ಲಾ ಬಿಟ್‌ಗಳನ್ನು XOR ಮಾಡುವ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತಿದ್ದೇವೆ, ಆದರೂ RAID ಪ್ರತಿ ಡಿಸ್ಕ್‌ನಲ್ಲಿ 4KB (ಅಥವಾ ದೊಡ್ಡ) ಬ್ಲಾಕ್‌ಗಳನ್ನು ಇರಿಸುತ್ತದೆ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ; ಸಮಾನತೆಯನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ನಾವು ಬ್ಲಾಕ್‌ಗಳ ಗುಂಪಿಗೆ XOR ಅನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸುತ್ತೇವೆ?


ಇದು ಸಹ ಸುಲಭ ಎಂದು ತಿರುಗುತ್ತದೆ.


Simply perform a bitwise XOR across each bit of the data blocks; put the result of each bitwise XOR into the corresponding bit slot in the parity block.

ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳ ಪ್ರತಿಯೊಂದು ಬಿಟ್‌ನಾದ್ಯಂತ ಬಿಟ್‌ವೈಸ್ XOR ಅನ್ನು ಸರಳವಾಗಿ ನಿರ್ವಹಿಸಿ; ಪ್ರತಿ ಬಿಟ್‌ವೈಸ್ XOR ನ ಫಲಿತಾಂಶವನ್ನು ಸಮಾನತೆಯ ಬ್ಲಾಕ್‌ನಲ್ಲಿರುವ ಅನುಗುಣವಾದ ಬಿಟ್ ಸ್ಲಾಟ್‌ಗೆ ಹಾಕಿ.


For example, if we had blocks of size 4 bits (yes, this is still quite a bit smaller than a 4KB block, but you get the picture), they might look something like this:

ಉದಾಹರಣೆಗೆ, ನಾವು 4 ಬಿಟ್‌ಗಳ ಗಾತ್ರದ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದರೆ (ಹೌದು, ಇದು ಇನ್ನೂ 4KB ಬ್ಲಾಕ್‌ಗಿಂತ ಚಿಕ್ಕದಾಗಿದೆ, ಆದರೆ ನಿಮಗೆ ಚಿತ್ರ ಸಿಗುತ್ತದೆ), ಅವು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:


As you can see from the figure, the parity is computed for each bit of each block and the result placed in the parity block.

ಚಿತ್ರದಿಂದ ನೀವು ನೋಡುವಂತೆ, ಪ್ರತಿ ಬ್ಲಾಕ್‌ನ ಪ್ರತಿ ಬಿಟ್‌ಗೆ ಸಮಾನತೆಯನ್ನು ಲೆಕ್ಕಹಾಕಲಾಗುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಸಮಾನತೆಯ ಬ್ಲಾಕ್‌ನಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ.


RAID-4 ವಿಶ್ಲೇಷಣೆ


ಈಗ ನಾವು RAID-4 ಅನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ.


The directory 'foo' would have an entry ('foo', '10') that maps the user-readable name to the low-level name.

'foo' ಎಂಬ ಡೈರೆಕ್ಟರಿಯು ('foo', '10') ಎಂಬ ನಮೂದನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಅದು ಬಳಕೆದಾರರಿಗೆ ಅರ್ಥವಾಗುವ ಹೆಸರನ್ನು ಕಡಿಮೆ-ಮಟ್ಟದ ಹೆಸರಿಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.


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

ಒಂದು ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ನಮೂದೂ ಫೈಲ್‌ಗಳು ಅಥವಾ ಇತರ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಸೂಚಿಸುತ್ತದೆ.


By placing directories within 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, and then created a file 'bar.txt' in the directory 'foo', we could refer to the file by its absolute pathname.

ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಮೂಲ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ 'foo' ಎಂಬ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಿದರೆ, ತದನಂತರ 'foo' ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ 'bar.txt' ಎಂಬ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿದರೆ, ನಾವು ಅದರ ಸಂಪೂರ್ಣ ಮಾರ್ಗ ಹೆಸರಿನಿಂದ ಫೈಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಬಹುದು.


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

ಡೈರೆಕ್ಟರಿಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳು ಒಂದೇ ಹೆಸರನ್ನು ಹೊಂದಬಹುದು, ಅವು ಫೈಲ್-ಸಿಸ್ಟಮ್ ಮರದಲ್ಲಿ ವಿಭಿನ್ನ ಸ್ಥಳಗಳಲ್ಲಿ ಇರುವವರೆಗೆ.


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.

ಯಾವುದೇ ಸಂಪನ್ಮೂಲವನ್ನು ಪ್ರವೇಶಿಸಲು ಮೊದಲ ಹೆಜ್ಜೆಯಾಗಿ ಹೆಸರುಗಳು ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಮುಖ್ಯವಾಗಿವೆ, ಅದನ್ನು ಹೆಸರಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.


In UNIX systems, the file system thus provides a unified way to access files on disk, USB stick, CD-ROM, many other devices, and in fact many other things, all located under the single directory tree.

UNIX ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, ಫೈಲ್ ಸಿಸ್ಟಮ್ ಡಿಸ್ಕ್, USB ಸ್ಟಿಕ್, CD-ROM, ಇತರ ಅನೇಕ ಸಾಧನಗಳಲ್ಲಿ ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಇತರ ಅನೇಕ ವಿಷಯಗಳಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಒಂದು ಏಕೀಕೃತ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇವೆಲ್ಲವೂ ಒಂದೇ ಡೈರೆಕ್ಟರಿ ಮರದ ಅಡಿಯಲ್ಲಿವೆ.


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() ಅನ್ನು ಕರೆ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ಅದಕ್ಕೆ O_CREAT ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ರವಾನಿಸುವ ಮೂಲಕ, ಪ್ರೋಗ್ರಾಂ ಹೊಸ ಫೈಲ್ ಅನ್ನು ರಚಿಸಬಹುದು.


The older way of creating a file is to call creat(), as follows:

ಫೈಲ್ ಅನ್ನು ರಚಿಸುವ ಹಳೆಯ ಮಾರ್ಗವೆಂದರೆ creat() ಅನ್ನು ಕರೆಯುವುದು, ಈ ಕೆಳಗಿನಂತೆ:


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 ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.


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

ಐನೋಡ್ ಎನ್ನುವುದು ಫೈಲ್ ಬಗ್ಗೆ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುವ ಡೇಟಾ ರಚನೆಯಾಗಿದೆ.


File systems use inodes to manage files on a disk.

ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಫೈಲ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಐನೋಡ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.


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

ಐನೋಡ್ ಸಂಖ್ಯೆಯನ್ನು ಐನೋಡ್‌ಗಳ ಶ್ರೇಣಿಗೆ ಸೂಚ್ಯಂಕ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ.


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

ಪ್ರತಿಯೊಂದು ಐನೋಡ್ ಫೈಲ್‌ನ ಗಾತ್ರ, ಅನುಮತಿಗಳು ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್ ಸ್ಥಳಗಳಂತಹ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.


The design of the inode is a key part of file system design.

ಐನೋಡ್‌ನ ವಿನ್ಯಾಸವು ಫೈಲ್ ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸದ ಒಂದು ಪ್ರಮುಖ ಭಾಗವಾಗಿದೆ.


Most modern systems have a similar structure for every file.

ಹೆಚ್ಚಿನ ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ಪ್ರತಿ ಫೈಲ್‌ಗೆ ಇದೇ ರೀತಿಯ ರಚನೆಯನ್ನು ಹೊಂದಿವೆ.


The i-number is the low-level name of the file.

ಐ-ಸಂಖ್ಯೆ ಫೈಲ್‌ನ ಕಡಿಮೆ-ಮಟ್ಟದ ಹೆಸರಾಗಿದೆ.


In vsfs, the i-number helps calculate the inode's location on disk.

vsfs ನಲ್ಲಿ, ಐ-ಸಂಖ್ಯೆಯು ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಐನೋಡ್‌ನ ಸ್ಥಳವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


ಐನೋಡ್ ಟೇಬಲ್ ಐನೋಡ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.


The file system calculates the offset into the inode region.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಐನೋಡ್ ಪ್ರದೇಶಕ್ಕೆ ಆಫ್‌ಸೆಟ್ ಅನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.


Disks are not byte addressable, but sector addressable.

ಡಿಸ್ಕ್‌ಗಳು ಬೈಟ್ ವಿಳಾಸযোগ্যವಲ್ಲ, ಆದರೆ ವಲಯ ವಿಳಾಸযোগ্যವಾಗಿವೆ.


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

ಐನೋಡ್ ಫೈಲ್‌ನ ಪ್ರಕಾರ, ಗಾತ್ರ ಮತ್ತು ಅನುಮತಿಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.


Metadata is any information inside the file system that isn't user data.

ಮೆಟಾಡೇಟಾ ಎಂದರೆ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿರುವ ಯಾವುದೇ ಮಾಹಿತಿಯಾಗಿದೆ, ಅದು ಬಳಕೆದಾರರ ಡೇಟಾ ಅಲ್ಲ.


Direct pointers inside the inode point to disk blocks.

ಐನೋಡ್‌ನಲ್ಲಿರುವ ನೇರ ಪಾಯಿಂಟರ್‌ಗಳು ಡಿಸ್ಕ್ ಬ್ಲಾಕ್‌ಗಳಿಗೆ ಸೂಚಿಸುತ್ತವೆ.


Indirect pointers point to blocks containing more pointers.

ಪರೋಕ್ಷ ಪಾಯಿಂಟರ್‌ಗಳು ಹೆಚ್ಚಿನ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಬ್ಲಾಕ್‌ಗಳಿಗೆ ಸೂಚಿಸುತ್ತವೆ.


Multi-level indexing supports larger files.

ಬಹು-ಹಂತದ ಸೂಚ್ಯಂಕವು ದೊಡ್ಡ ಫೈಲ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.


Extent-based approaches use a disk pointer and a length.

ವಿಸ್ತರಣೆ-ಆಧಾರಿತ ವಿಧಾನಗಳು ಡಿಸ್ಕ್ ಪಾಯಿಂಟರ್ ಮತ್ತು ಉದ್ದವನ್ನು ಬಳಸುತ್ತವೆ.


Linked lists can also be used for file allocation.

ಫೈಲ್ ಹಂಚಿಕೆಗಾಗಿ ಲಿಂಕ್ಡ್ ಪಟ್ಟಿಗಳನ್ನು ಸಹ ಬಳಸಬಹುದು.


The FAT file system is based on a linked-based allocation scheme.

FAT ಫೈಲ್ ಸಿಸ್ಟಮ್ ಲಿಂಕ್-ಆಧಾರಿತ ಹಂಚಿಕೆ ಯೋಜನೆಯನ್ನು ಆಧರಿಸಿದೆ.


Directories contain a list of (entry name, inode number) pairs.

ಡೈರೆಕ್ಟರಿಗಳು (ಪ್ರವೇಶ ಹೆಸರು, ಐನೋಡ್ ಸಂಖ್ಯೆ) ಜೋಡಿಗಳ ಪಟ್ಟಿಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ.


The file system uses caching to improve performance.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸುತ್ತದೆ.


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

ಓದುವ ಮತ್ತು ಬರೆಯುವ ಫೈಲ್‌ಗಳು I/O ಕಾರ್ಯಾಚರಣೆಗಳಿಂದಾಗಿ ದುಬಾರಿಯಾಗಬಹುದು.


Caching helps to reduce the number of I/O operations.

ಸಂಗ್ರಹಣೆಯು I/O ಕಾರ್ಯಾಚರಣೆಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.


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

ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳು ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಪುಟಗಳು ಮತ್ತು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪುಟಗಳನ್ನು ಒಂದುಗೂಡಿಸಿದ ಪುಟ ಸಂಗ್ರಹಣೆಗೆ ಸಂಯೋಜಿಸುತ್ತವೆ.


Write buffering can improve performance by batching updates.

ಬರಹ ಬಫರಿಂಗ್ ನವೀಕರಣಗಳನ್ನು ಗುಂಪು ಮಾಡುವ ಮೂಲಕ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಬಹುದು.


Some applications force writes to disk to avoid data loss.

ಡೇಟಾ ನಷ್ಟವನ್ನು ತಪ್ಪಿಸಲು ಕೆಲವು ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯಲು ಒತ್ತಾಯಿಸುತ್ತವೆ.


The file system uses inodes to store metadata about each file.

ಪ್ರತಿಯೊಂದು ಫೈಲ್‌ನ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಐನೋಡ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ.


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

ಡೈರೆಕ್ಟರಿಗಳು ಒಂದು ನಿರ್ದಿಷ್ಟ ರೀತಿಯ ಫೈಲ್ ಆಗಿದ್ದು ಅದು ಹೆಸರು-ಟು-ಐನೋಡ್ ಮ್ಯಾಪಿಂಗ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.


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

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಉಚಿತ ಅಥವಾ ಹಂಚಿಕೆಯಾದ ಐನೋಡ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಿಟ್‌ಮ್ಯಾಪ್‌ಗಳನ್ನು ಬಳಸುತ್ತವೆ.


The Fast File System (FFS) was designed to be disk-aware.

ವೇಗದ ಫೈಲ್ ಸಿಸ್ಟಮ್ (FFS) ಅನ್ನು ಡಿಸ್ಕ್-ಅರಿವುಳ್ಳ ರೀತಿಯಲ್ಲಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


FFS divides the disk into cylinder groups to improve performance.

ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು FFS ಡಿಸ್ಕ್ ಅನ್ನು ಸಿಲಿಂಡರ್ ಗುಂಪುಗಳಾಗಿ ವಿಂಗಡಿಸುತ್ತದೆ.


Each cylinder group contains a copy of the superblock.

ಪ್ರತಿಯೊಂದು ಸಿಲಿಂಡರ್ ಗುಂಪು ಸೂಪರ್‌ಬ್ಲಾಕ್‌ನ ಪ್ರತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.


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

ಐನೋಡ್ ಬಿಟ್‌ಮ್ಯಾಪ್ ಮತ್ತು ಡೇಟಾ ಬಿಟ್‌ಮ್ಯಾಪ್ ಉಚಿತ ಐನೋಡ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ.


FFS places related files and directories within the same cylinder group.

FFS ಸಂಬಂಧಿತ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಒಂದೇ ಸಿಲಿಂಡರ್ ಗುಂಪಿನಲ್ಲಿ ಇರಿಸುತ್ತದೆ.


For large files, FFS allocates blocks across different cylinder groups.

ದೊಡ್ಡ ಫೈಲ್‌ಗಳಿಗಾಗಿ, FFS ವಿಭಿನ್ನ ಸಿಲಿಂಡರ್ ಗುಂಪುಗಳಲ್ಲಿ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಹಂಚಿಕೆ ಮಾಡುತ್ತದೆ.


The goal is to improve file access locality.

ಗುರಿಯು ಫೈಲ್ ಪ್ರವೇಶದ ಸ್ಥಳೀಯತೆಯನ್ನು ಸುಧಾರಿಸುವುದು.


ವ್ಯವಸ್ಥೆಯು ಅನಿರೀಕ್ಷಿತವಾಗಿ ಸ್ಥಗಿತಗೊಂಡಿತು.


The file system's performance was initially poor.

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ಕಾರ್ಯಕ್ಷಮತೆ ಆರಂಭದಲ್ಲಿ ಕಳಪೆಯಾಗಿತ್ತು.


Fragmentation can significantly reduce performance.

ವಿಘಟನೆ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆ ಮಾಡಬಹುದು.


Disk defragmentation tools help to reorganize on-disk data.

ಡಿಸ್ಕ್ ಡಿಫ್ರಾಗ್ಮೆಂಟೇಶನ್ ಪರಿಕರಗಳು ಆನ್-ಡಿಸ್ಕ್ ಡೇಟಾವನ್ನು ಮರುಸಂಘಟಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತವೆ.


The disk transfer rate improves rapidly, but mechanical aspects improve slowly.

ಡಿಸ್ಕ್ ವರ್ಗಾವಣೆ ದರವು ವೇಗವಾಗಿ ಸುಧಾರಿಸುತ್ತದೆ, ಆದರೆ ಯಾಂತ್ರಿಕ ಅಂಶಗಳು ನಿಧಾನವಾಗಿ ಸುಧಾರಿಸುತ್ತವೆ.


File systems must survive power loss and crashes.

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ವಿದ್ಯುತ್ ವೈಫಲ್ಯ ಮತ್ತು ಕ್ರ್ಯಾಶ್‌ಗಳನ್ನು ಬದುಕಬೇಕು.


The system may crash between any two writes.

ಯಾವುದೇ ಎರಡು ಬರವಣಿಗೆಗಳ ನಡುವೆ ಸಿಸ್ಟಮ್ ಕ್ರ್ಯಾಶ್ ಆಗಬಹುದು.


How do we ensure the file system keeps the on-disk image in a reasonable state?

ಆನ್-ಡಿಸ್ಕ್ ಚಿತ್ರವನ್ನು ನಾವು ಹೇಗೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸಮಂಜಸ ಸ್ಥಿತಿಯಲ್ಲಿ ಇರಿಸುತ್ತದೆ?


Fsck is a tool for finding and repairing inconsistencies.

ಅಸಮಂಜಸತೆಗಳನ್ನು ಹುಡುಕಲು ಮತ್ತು ಸರಿಪಡಿಸಲು fsck ಒಂದು ಸಾಧನವಾಗಿದೆ.


Fsck ಹಲವಾರು ಹಂತಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.


Fsck checks if the superblock looks reasonable.

ಸೂಪರ್ಬ್ಲಾಕ್ ಸಮಂಜಸವಾಗಿದೆಯೇ ಎಂದು Fsck ಪರಿಶೀಲಿಸುತ್ತದೆ.


Fsck scans the inodes to build an understanding of allocated blocks.

ಹಂಚಿಕೆಯಾದ ಬ್ಲಾಕ್‌ಗಳ ತಿಳುವಳಿಕೆಯನ್ನು ನಿರ್ಮಿಸಲು Fsck ಐನೋಡ್‌ಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ.


Fsck verifies the link count of each allocated inode.

Fsck ಪ್ರತಿ ಹಂಚಿಕೆಯಾದ ಐನೋಡ್‌ನ ಲಿಂಕ್ ಎಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.


Fsck ನಕಲಿ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.


A pointer is considered bad if it points outside its valid range.

ಪಾಯಿಂಟರ್ ಅದರ ಮಾನ್ಯ ವ್ಯಾಪ್ತಿಯ ಹೊರಗೆ ಸೂಚಿಸಿದರೆ ಕೆಟ್ಟದಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ.


Fsck performs integrity checks on directory contents.

Fsck ಡೈರೆಕ್ಟರಿ ವಿಷಯಗಳ ಮೇಲೆ ಸಮಗ್ರತೆ ಪರಿಶೀಲನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


ತುಂಬಾ ದೊಡ್ಡ ಡಿಸ್ಕ್‌ಗಳಿಗೆ Fsck ತುಂಬಾ ನಿಧಾನವಾಗಿದೆ.


Journaling adds a little bit of overhead to each write.

ಜರ್ನಲಿಂಗ್ ಪ್ರತಿ ಬರವಣಿಗೆಗೆ ಸ್ವಲ್ಪ ಓವರ್‌ಹೆಡ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.


Journaling recovers more quickly from crashes.

ಜರ್ನಲಿಂಗ್ ಕ್ರ್ಯಾಶ್‌ಗಳಿಂದ ಹೆಚ್ಚು ವೇಗವಾಗಿ ಚೇತರಿಸಿಕೊಳ್ಳುತ್ತದೆ.


The workload appends a single data block to an existing file.

ಕೆಲಸದ ಹೊರೆ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಫೈಲ್‌ಗೆ ಒಂದೇ ಡೇಟಾ ಬ್ಲಾಕ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ.


ಐನೋಡ್ ಹೊಸ ಬ್ಲಾಕ್‌ಗೆ ಸೂಚಿಸಬೇಕು.


The file system must perform three separate writes to the disk.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಡಿಸ್ಕ್‌ಗೆ ಮೂರು ಪ್ರತ್ಯೇಕ ಬರವಣಿಗೆಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು.


A crash may interfere with these updates.

ಕ್ರ್ಯಾಶ್ ಈ ನವೀಕರಣಗಳಿಗೆ ಅಡ್ಡಿಪಡಿಸಬಹುದು.


If the inode points to the wrong data, we will read garbage data.

ಐನೋಡ್ ತಪ್ಪಾದ ಡೇಟಾಗೆ ಸೂಚಿಸಿದರೆ, ನಾವು ಕಸದ ಡೇಟಾವನ್ನು ಓದುತ್ತೇವೆ.


The disk may return an error when trying to read a given block.

ಡಿಸ್ಕ್ ನಿರ್ದಿಷ್ಟ ಬ್ಲಾಕ್ ಅನ್ನು ಓದಲು ಪ್ರಯತ್ನಿಸುವಾಗ ದೋಷವನ್ನು ನೀಡಬಹುದು.


Both of these types of faults are somewhat rare.

ಈ ರೀತಿಯ ದೋಷಗಳು ಸ್ವಲ್ಪ ಅಪರೂಪ.


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

ಕೋಷ್ಟಕವು ಕನಿಷ್ಠ ಒಂದು LSE ಅನ್ನು ಪ್ರದರ್ಶಿಸಿದ ಡ್ರೈವ್‌ಗಳ ಶೇಕಡಾವಾರು ಪ್ರಮಾಣವನ್ನು ತೋರಿಸುತ್ತದೆ.


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

ಉತ್ತಮ ಡ್ರೈವ್‌ಗಳನ್ನು ಖರೀದಿಸುವುದರಿಂದ ಎರಡೂ ರೀತಿಯ ಸಮಸ್ಯೆಗಳ ಆವರ್ತನವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.


ನೀವು ಅವುಗಳ ಬಗ್ಗೆ ಎಚ್ಚರಿಕೆಯಿಂದ ಯೋಚಿಸಬೇಕು.


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 chance of corruption varies greatly across different drive models.

ದುರುಪಯೋಗದ ಸಾಧ್ಯತೆಯು ವಿಭಿನ್ನ ಡ್ರೈವ್ ಮಾದರಿಗಳಲ್ಲಿ ಹೆಚ್ಚು ಬದಲಾಗುತ್ತದೆ.


Age affects are different across models.

ವಯಸ್ಸಿನ ಪರಿಣಾಮಗಳು ಮಾದರಿಗಳಲ್ಲಿ ವಿಭಿನ್ನವಾಗಿವೆ.


Workload and disk size have little impact on corruption.

ಕೆಲಸದ ಹೊರೆ ಮತ್ತು ಡಿಸ್ಕ್ ಗಾತ್ರವು ಭ್ರಷ್ಟಾಚಾರದ ಮೇಲೆ ಕಡಿಮೆ ಪರಿಣಾಮ ಬೀರುತ್ತದೆ.


Most disks with corruption only have a few corruptions.

ದುರುಪಯೋಗ ಹೊಂದಿರುವ ಹೆಚ್ಚಿನ ಡಿಸ್ಕ್‌ಗಳು ಕೆಲವೇ ಭ್ರಷ್ಟಾಚಾರವನ್ನು ಹೊಂದಿವೆ.


Corruption is not independent with a disk or across disks in RAID.

RAID ನಲ್ಲಿ ಡಿಸ್ಕ್ ಅಥವಾ ಡಿಸ್ಕ್‌ಗಳಲ್ಲಿ ಭ್ರಷ್ಟಾಚಾರವು ಸ್ವತಂತ್ರವಾಗಿಲ್ಲ.


There exists spatial locality, and some temporal locality.

ಸ್ಥಳೀಯ ಸ್ಥಳೀಯತೆ ಮತ್ತು ಕೆಲವು ತಾತ್ಕಾಲಿಕ ಸ್ಥಳೀಯತೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.


If you really wish to build a reliable storage system, you must include machinery to detect and recovery from both LSEs and block corruption.

ನೀವು ನಿಜವಾಗಿಯೂ ವಿಶ್ವಾಸಾರ್ಹ ಸಂಗ್ರಹಣೆ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸಲು ಬಯಸಿದರೆ, ನೀವು LSE ಗಳು ಮತ್ತು ಬ್ಲಾಕ್ ಭ್ರಷ್ಟಾಚಾರ ಎರಡನ್ನೂ ಪತ್ತೆಹಚ್ಚಲು ಮತ್ತು ಚೇತರಿಸಿಕೊಳ್ಳಲು ಯಂತ್ರೋಪಕರಣಗಳನ್ನು ಸೇರಿಸಬೇಕು.


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, for example, the system should access the alternate copy.

ಉದಾಹರಣೆಗೆ, ಮಿರರ್ಡ್ RAID ನಲ್ಲಿ, ಸಿಸ್ಟಮ್ ಪರ್ಯಾಯ ಪ್ರತಿಯನ್ನು ಪ್ರವೇಶಿಸಬೇಕು.


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

LSE ಗಳ ಹೆಚ್ಚುತ್ತಿರುವ ಪ್ರಚಲಿತತೆಯು ವರ್ಷಗಳಲ್ಲಿ RAID ವಿನ್ಯಾಸಗಳ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರಿದೆ.


The allocated blocks and reading 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.

ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಲ್ಲಿ, ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಐತಿಹಾಸಿಕ ಕಾರಣಗಳಿಗಾಗಿ ರೈಟ್-ಅಹೆಡ್ ಲಾಗಿಂಗ್ ಅನ್ನು ಜರ್ನಲಿಂಗ್ ಎಂದು ಕರೆಯುತ್ತೇವೆ.


The first file system to do this was Cedar.

ಇದನ್ನು ಮಾಡಿದ ಮೊದಲ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸೆಡಾರ್ ಆಗಿತ್ತು.


ಮೂಲ ಕಲ್ಪನೆಯು ಈ ಕೆಳಗಿನಂತಿರುತ್ತದೆ.


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 ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಮೋಡ್‌ನಂತೆ ಲಭ್ಯವಿದೆ, ಅದರ ಆಧಾರದ ಮೇಲೆ ಈ ಚರ್ಚೆಯು ಹೆಚ್ಚಾಗಿ ಆಧಾರಿತವಾಗಿದೆ.


The system uses journaling to reduce recovery time after a crash.

ವ್ಯವಸ್ಥೆಯು ಕ್ರ್ಯಾಶ್ ಆದ ನಂತರ ಚೇತರಿಕೆ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಜರ್ನಲಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


Journaling reduces recovery time from O(size-of-the-disk-volume) to O(size-of-the-log).

ಜರ್ನಲಿಂಗ್ ಚೇತರಿಕೆ ಸಮಯವನ್ನು O(ಡಿಸ್ಕ್-ಗಾತ್ರ) ದಿಂದ O(ಲಾಗ್-ಗಾತ್ರ) ಕ್ಕೆ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.


Many file systems now use journaling to speed up recovery substantially after a crash and restart.

ಕ್ರ್ಯಾಶ್ ಮತ್ತು ಮರುಪ್ರಾರಂಭದ ನಂತರ ಚೇತರಿಕೆಯನ್ನು ಗಣನೀಯವಾಗಿ ವೇಗಗೊಳಿಸಲು ಅನೇಕ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಈಗ ಜರ್ನಲಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.


The older approach of building a file system checker works but is likely too slow to recover on modern systems.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಪರಿಶೀಲಕವನ್ನು ನಿರ್ಮಿಸುವ ಹಳೆಯ ವಿಧಾನವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಆದರೆ ಆಧುನಿಕ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಚೇತರಿಸಿಕೊಳ್ಳಲು ತುಂಬಾ ನಿಧಾನವಾಗಬಹುದು.


Journaling can come in many different forms.

ಜರ್ನಲಿಂಗ್ ಅನೇಕ ವಿಭಿನ್ನ ರೂಪಗಳಲ್ಲಿ ಬರಬಹುದು.


The most commonly used is ordered metadata journaling.

ಅತ್ಯಂತ ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ವಿಧಾನವೆಂದರೆ ಕ್ರಮಬದ್ಧ ಮೆಟಾಡೇಟಾ ಜರ್ನಲಿಂಗ್.


This reduces the amount of traffic to the journal while still preserving reasonable consistency guarantees.

ಇದು ನ್ಯಾಯಯುತವಾದ ಸ್ಥಿರತೆಯ ಖಾತರಿಗಳನ್ನು ಉಳಿಸಿಕೊಂಡು ಜರ್ನಲ್‌ಗೆ ದಟ್ಟಣೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.


It preserves consistency for both file system metadata as well as user data.

ಇದು ಫೈಲ್ ಸಿಸ್ಟಮ್ ಮೆಟಾಡೇಟಾ ಮತ್ತು ಬಳಕೆದಾರರ ಡೇಟಾ ಎರಡಕ್ಕೂ ಸ್ಥಿರತೆಯನ್ನು ಕಾಪಾಡುತ್ತದೆ.


The system first scans for revoke records.

ವ್ಯವಸ್ಥೆಯು ಮೊದಲು ರದ್ದುಗೊಳಿಸುವ ದಾಖಲೆಗಳಿಗಾಗಿ ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತದೆ.


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

ಯಾವುದೇ ಅಂತಹ ರದ್ದುಪಡಿಸಿದ ಡೇಟಾವನ್ನು ಎಂದಿಗೂ ಮರುಪ್ಲೇ ಮಾಡಲಾಗುವುದಿಲ್ಲ, ಹೀಗಾಗಿ ಮೇಲೆ ತಿಳಿಸಿದ ಸಮಸ್ಯೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.


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

ವಹಿವಾಟಿನ ಪ್ರಾರಂಭದ ಬ್ಲಾಕ್ (TxB) ನ ಬರಹಗಳು ಮತ್ತು ವಹಿವಾಟಿನ ವಿಷಯಗಳನ್ನು ತಾರ್ಕಿಕವಾಗಿ ಒಂದೇ ಸಮಯದಲ್ಲಿ ನೀಡಬಹುದು.


The write to the transaction end block (TxE) must not be issued until said previous writes complete.

ಹೇಳಿದ ಹಿಂದಿನ ಬರಹಗಳು ಪೂರ್ಣಗೊಳ್ಳುವವರೆಗೆ ವಹಿವಾಟಿನ ಅಂತ್ಯದ ಬ್ಲಾಕ್ (TxE) ಗೆ ಬರೆಯಬಾರದು.


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.

ಡೇಟಾ ಬರಹವನ್ನು ವಹಿವಾಟಿನ ಪ್ರಾರಂಭ ಮತ್ತು ಜರ್ನಲ್‌ನ ವಿಷಯಗಳಿಗೆ ಬರೆಯುವಂತೆಯೇ ತಾರ್ಕಿಕವಾಗಿ ನೀಡಬಹುದು.


The time of completion marked for each write in the timelines is arbitrary.

ಸಮಯಾವಧಿಯಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಬರಹಕ್ಕಾಗಿ ಗುರುತಿಸಲಾದ ಪೂರ್ಣಗೊಳಿಸುವ ಸಮಯವು ಯಾದೃಚ್ಛಿಕವಾಗಿದೆ.


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

ನಿಜವಾದ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ, ಪೂರ್ಣಗೊಳಿಸುವ ಸಮಯವನ್ನು I/O ಉಪವ್ಯವಸ್ಥೆಯಿಂದ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಬರಹಗಳನ್ನು ಮರುಕ್ರಮಗೊಳಿಸಬಹುದು.


The only guarantees about ordering that we have are those that must be enforced for protocol correctness.

ಕ್ರಮಗೊಳಿಸುವಿಕೆಯ ಬಗ್ಗೆ ನಾವು ಹೊಂದಿರುವ ಏಕೈಕ ಖಾತರಿಗಳು ಪ್ರೋಟೋಕಾಲ್‌ನ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಜಾರಿಗೊಳಿಸಬೇಕಾದವುಗಳಾಗಿವೆ.


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(ಡಿಸ್ಕ್-ಗಾತ್ರ) ದಿಂದ O(ಲಾಗ್-ಗಾತ್ರ) ಕ್ಕೆ ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ಹೀಗಾಗಿ ಕ್ರ್ಯಾಶ್ ಮತ್ತು ಮರುಪ್ರಾರಂಭದ ನಂತರ ಚೇತರಿಕೆಯನ್ನು ಗಣನೀಯವಾಗಿ ವೇಗಗೊಳಿಸುತ್ತದೆ.


For this reason, many modern file systems use journaling.

ಈ ಕಾರಣಕ್ಕಾಗಿ, ಅನೇಕ ಆಧುನಿಕ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳು ಜರ್ನಲಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತವೆ.


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 ಸೆಕೆಂಡುಗಳಿಗೊಮ್ಮೆ), ಮತ್ತು ಆದ್ದರಿಂದ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಯಾವುದೇ ತೊಂದರೆಯಾಗುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.


Thus, the overall structure of the on-disk layout contains a checkpoint region (which points to the latest pieces of the in- ode map); the inode map pieces each contain addresses of the inodes; the inodes point to files (and directories) just like typical UNIXfile systems.

ಆದ್ದರಿಂದ, ಡಿಸ್ಕ್‌ನಲ್ಲಿನ ಒಟ್ಟಾರೆ ರಚನೆಯು ಚೆಕ್‌ಪಾಯಿಂಟ್ ಪ್ರದೇಶವನ್ನು ಒಳಗೊಂಡಿದೆ (ಇದು ಇನೋಡ್ ನಕ್ಷೆಯ ಇತ್ತೀಚಿನ ಭಾಗಗಳಿಗೆ ಸೂಚಿಸುತ್ತದೆ); ಇನೋಡ್ ನಕ್ಷೆಯ ಭಾಗಗಳು ಪ್ರತಿಯೊಂದೂ ಇನೋಡ್‌ಗಳ ವಿಳಾಸಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ; ಇನೋಡ್‌ಗಳು ಫೈಲ್‌ಗಳು (ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳು) ಗೆ ಸೂಚಿಸುತ್ತವೆ, ಇದು ವಿಶಿಷ್ಟ UNIX ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಂತೆಯೇ ಇರುತ್ತವೆ.


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 ನಲ್ಲಿ), ಮತ್ತು ಒಂದೇ imap ತುಣುಕು, ಇನೋಡ್ ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್.


A real file system would of course have a much bigger CR (indeed, it would have two, as we’ll come to understand later), many imap chunks, and of course many more inodes, data blocks, etc.

ನಿಜವಾದ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಖಂಡಿತವಾಗಿಯೂ ದೊಡ್ಡ CR ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ (ವಾಸ್ತವವಾಗಿ, ಇದು ಎರಡನ್ನು ಹೊಂದಿರುತ್ತದೆ, ನಾವು ನಂತರ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ), ಅನೇಕ imap ತುಣುಕುಗಳು ಮತ್ತು ಸಹಜವಾಗಿ ಇನ್ನೂ ಅನೇಕ ಇನೋಡ್‌ಗಳು, ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳು, ಇತ್ಯಾದಿ.


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 readis the checkpoint region.

ನಾವು ಓದಬೇಕಾದ ಮೊದಲ ಡಿಸ್ಕ್ ಡೇಟಾ ರಚನೆಯು ಚೆಕ್‌ಪಾಯಿಂಟ್ ಪ್ರದೇಶವಾಗಿದೆ.


The checkpoint region contains pointers (i.e., disk ad- dresses) to the entire inode map, and thus LFS then reads in the entire in- ode map and caches it in memory.

ಚೆಕ್‌ಪಾಯಿಂಟ್ ಪ್ರದೇಶವು ಸಂಪೂರ್ಣ ಇನೋಡ್ ನಕ್ಷೆಗೆ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು (ಅಂದರೆ, ಡಿಸ್ಕ್ ವಿಳಾಸಗಳು) ಒಳಗೊಂಡಿದೆ, ಮತ್ತು ಹೀಗಾಗಿ LFS ನಂತರ ಸಂಪೂರ್ಣ ಇನೋಡ್ ನಕ್ಷೆಯನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.


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 ನಲ್ಲಿ ಇನೋಡ್-ಸಂಖ್ಯೆಯಿಂದ ಇನೋಡ್-ಡಿಸ್ಕ್-ವಿಳಾಸ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಹುಡುಕುತ್ತದೆ ಮತ್ತು ಇನೋಡ್‌ನ ಇತ್ತೀಚಿನ ಆವೃತ್ತಿಯನ್ನು ಓದುತ್ತದೆ.


To read a block from the file, at this point, LFS proceeds exactly as a typical UNIXfile system, by using direct pointers or indirect pointers or doubly-indirect pointers as need be.

ಈ ಹಂತದಲ್ಲಿ ಫೈಲ್‌ನಿಂದ ಬ್ಲಾಕ್ ಅನ್ನು ಓದಲು, LFS ನೇರ ಪಾಯಿಂಟರ್‌ಗಳು ಅಥವಾ ಪರೋಕ್ಷ ಪಾಯಿಂಟರ್‌ಗಳು ಅಥವಾ ಅಗತ್ಯವಿರುವಂತೆ ದ್ವಿ-ಪರೋಕ್ಷ ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ ವಿಶಿಷ್ಟ UNIX ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಂತೆ ನಿಖರವಾಗಿ ಮುಂದುವರಿಯುತ್ತದೆ.


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/O ಗಳನ್ನು ನಿರ್ವಹಿಸಬೇಕು; ಸಂಪೂರ್ಣ imap ಅನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಮತ್ತು ಹೀಗಾಗಿ LFS ಓದುವ ಸಮಯದಲ್ಲಿ ಮಾಡುವ ಹೆಚ್ಚುವರಿ ಕೆಲಸವೆಂದರೆ imap ನಲ್ಲಿ ಇನೋಡ್‌ನ ವಿಳಾಸವನ್ನು ಹುಡುಕುವುದು.


Thus far, we’ve simplified our discussion a bit by only considering in- odes and data blocks.

ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಇನೋಡ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುವ ಮೂಲಕ ನಮ್ಮ ಚರ್ಚೆಯನ್ನು ಸ್ವಲ್ಪ ಸರಳಗೊಳಿಸಿದ್ದೇವೆ.


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, ನಮ್ಮ ನೆಚ್ಚಿನ ನಕಲಿ ಫೈಲ್ ಹೆಸರುಗಳಲ್ಲಿ ಒಂದು), ಕೆಲವು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಸಹ ಪ್ರವೇಶಿಸಬೇಕು.


ಆದ್ದರಿಂದ LFS ಡೈರೆಕ್ಟರಿ ಡೇಟಾವನ್ನು ಹೇಗೆ ಸಂಗ್ರಹಿಸುತ್ತದೆ?


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

ಅದೃಷ್ಟವಶಾತ್, ಡೈರೆಕ್ಟರಿ ರಚನೆಯು ಮೂಲತಃ ಕ್ಲಾಸಿಕ್ 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 ಹೊಸ ಇನೋಡ್, ಕೆಲವು ಡೇಟಾ, ಹಾಗೆಯೇ ಈ ಫೈಲ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಡೈರೆಕ್ಟರಿ ಡೇಟಾ ಮತ್ತು ಅದರ ಇನೋಡ್ ಎರಡನ್ನೂ ಬರೆಯಬೇಕು.


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:

ಆದ್ದರಿಂದ, ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ filefoo ಅನ್ನು ರಚಿಸುವುದರಿಂದ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಹೊಸ ರಚನೆಗಳು ಉಂಟಾಗುತ್ತವೆ:


ಫೈಲ್ ಸಿಸ್ಟಮ್ ಜಟಿಲವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ.


We found numerous bugs in the file system.

ನಾವು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಹಲವಾರು ದೋಷಗಳನ್ನು ಕಂಡುಕೊಂಡಿದ್ದೇವೆ.


This paper discusses fault-tolerant services.

ಈ ಪ್ರಬಂಧವು ದೋಷ-ಸಹಿಷ್ಣು ಸೇವೆಗಳ ಬಗ್ಗೆ ಚರ್ಚಿಸುತ್ತದೆ.


Memory contents disappear if the machine crashes.

ಯಂತ್ರವು ಸ್ಥಗಿತಗೊಂಡರೆ ಮೆಮೊರಿ ವಿಷಯಗಳು ಕಣ್ಮರೆಯಾಗುತ್ತವೆ.


ಯಾವತ್ತೂ ಬಹಳ ಸಮಯ.


Updating persistent storage is complicated.

ಶಾಶ್ವತ ಸಂಗ್ರಹಣೆಯನ್ನು ನವೀಕರಿಸುವುದು ಜಟಿಲವಾಗಿದೆ.


ನಾನು ಡಿಸ್ಕ್ ವೇಳಾಪಟ್ಟಿಯ ಬಗ್ಗೆಯೂ ಕಲಿತಿದ್ದೇನೆ.


Check out some of the latest on erasure codes.

ಅಳಿಸುವಿಕೆ ಕೋಡ್‌ಗಳ ಕುರಿತು ಇತ್ತೀಚಿನದನ್ನು ಪರಿಶೀಲಿಸಿ.


ಡಿಸ್ಕ್ ಬಗ್ಗೆ ತಿಳಿದಿರುವುದು ತಂಪಾಗಿದೆ.


Flash Translation Layers use log-structuring internally.

ಫ್ಲ್ಯಾಶ್ ಅನುವಾದ ಪದರಗಳು ಆಂತರಿಕವಾಗಿ ಲಾಗ್-ರಚನೆಯನ್ನು ಬಳಸುತ್ತವೆ.


Distributed systems have changed the world.

ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳು ಪ್ರಪಂಚವನ್ನು ಬದಲಾಯಿಸಿವೆ.


ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಕಷ್ಟ.


ನಾನು ಯಾವಾಗಲೂ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳನ್ನು ಬಳಸುತ್ತೇನೆ.


They use replication and retry techniques.

ಅವರು ಪ್ರತಿಕೃತಿ ಮತ್ತು ಮರುಪ್ರಯತ್ನ ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತಾರೆ.


ಸಂವಹನವು ಅಂತರ್ಗತವಾಗಿ ವಿಶ್ವಾಸಾರ್ಹವಲ್ಲ.


Packets sometimes do not reach their destination.

ಪ್ಯಾಕೆಟ್‌ಗಳು ಕೆಲವೊಮ್ಮೆ ತಮ್ಮ ಗಮ್ಯಸ್ಥಾನವನ್ನು ತಲುಪುವುದಿಲ್ಲ.


ಸಿಸ್ಟಮ್ ಕಾರ್ಯಕ್ಷಮತೆ ಸಾಮಾನ್ಯವಾಗಿ ನಿರ್ಣಾಯಕವಾಗಿದೆ.


ನಮಗೆ ವಿಶ್ವಾಸಾರ್ಹ ಸಂವಹನ ಬೇಕು.


ಕಳುಹಿಸುವವರು ಟೈಮರ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತಾರೆ.


Sequence counters can be used to avoid duplicates.

ನಕಲುಗಳನ್ನು ತಪ್ಪಿಸಲು ಅನುಕ್ರಮ ಕೌಂಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.


The server crashed before writing the data to disk.

ಸರ್ವರ್ ಡೇಟಾವನ್ನು ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯುವ ಮೊದಲು ಕ್ರ್ಯಾಶ್ ಆಯಿತು.


Clients handle server failure based on assumptions.

ಕ್ಲೈಂಟ್‌ಗಳು ಊಹೆಗಳ ಆಧಾರದ ಮೇಲೆ ಸರ್ವರ್ ವೈಫಲ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತವೆ.


NFS servers must commit each write to stable storage.

NFS ಸರ್ವರ್‌ಗಳು ಸ್ಥಿರ ಸಂಗ್ರಹಣೆಗೆ ಪ್ರತಿ ಬರವಣಿಗೆಯನ್ನು ಕಮಿಟ್ ಮಾಡಬೇಕು.


The file system design is specifically designed to write to disk quickly.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸವನ್ನು ನಿರ್ದಿಷ್ಟವಾಗಿ ಡಿಸ್ಕ್‌ಗೆ ತ್ವರಿತವಾಗಿ ಬರೆಯಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ.


NFS is centered around the idea of simple and fast recovery.

NFS ಸರಳ ಮತ್ತು ವೇಗದ ಚೇತರಿಕೆಯ ಕಲ್ಪನೆಯನ್ನು ಆಧರಿಸಿದೆ.


Caching can complicate things in a multi-client system.

ಕ್ಯಾಶಿಂಗ್ ಬಹು-ಕ್ಲೈಂಟ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ವಿಷಯಗಳನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸಬಹುದು.


Security in early NFS implementations was remarkably lax.

ಆರಂಭಿಕ NFS ಅನುಷ್ಠಾನಗಳಲ್ಲಿ ಭದ್ರತೆಯು ಗಮನಾರ್ಹವಾಗಿ ಸಡಿಲವಾಗಿತ್ತು.


The original NFS paper is a challenging read.

ಮೂಲ NFS ಪ್ರಬಂಧವು ಒಂದು ಸವಾಲಿನ ಓದು.


AFS was introduced by researchers at Carnegie-Mellon University.

AFS ಅನ್ನು ಕಾರ್ನೆಗಿ-ಮೆಲಾನ್ ವಿಶ್ವವಿದ್ಯಾಲಯದ ಸಂಶೋಧಕರು ಪರಿಚಯಿಸಿದರು.


The main goal was to design a scalable distributed file system.

ಮುಖ್ಯ ಗುರಿ ಏನೆಂದರೆ, ಸ್ಕೇಲೆಬಲ್ ವಿತರಣಾ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವುದು.


In AFS, cache consistency is simple and readily understood.

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 send a Fetch protocol message to the server.

ಕ್ಲೈಂಟ್-ಸೈಡ್ ಕೋಡ್ ಸರ್ವರ್‌ಗೆ ಫೆಚ್ ಪ್ರೋಟೋಕಾಲ್ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತದೆ.


The server was spending much of its CPU time walking down directory paths.

ಸರ್ವರ್ ತನ್ನ CPU ಸಮಯದ ಹೆಚ್ಚಿನ ಭಾಗವನ್ನು ಡೈರೆಕ್ಟರಿ ಮಾರ್ಗಗಳಲ್ಲಿ ನಡೆಯಲು ಕಳೆಯುತ್ತಿತ್ತು.


Measurement is the key to understanding how systems work.

ಸಿಸ್ಟಮ್‌ಗಳು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅಳತೆ ಮುಖ್ಯವಾಗಿದೆ.


The AFS designers were faced with a problem: how to design a scalable file protocol.

AFS ವಿನ್ಯಾಸಕರು ಒಂದು ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದರು: ಸ್ಕೇಲೆಬಲ್ ಫೈಲ್ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಹೇಗೆ ವಿನ್ಯಾಸಗೊಳಿಸುವುದು.


A callback is simply a promise from the server to the client.

ಕಾಲ್ ಬ್ಯಾಕ್ ಎಂದರೆ ಸರ್ವರ್‌ನಿಂದ ಕ್ಲೈಂಟ್‌ಗೆ ಸರಳವಾದ ಭರವಸೆ.


AFSv2 introduced the notion of a file identifier.

AFSv2 ಫೈಲ್ ಗುರುತಿಸುವಿಕೆಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪರಿಚಯಿಸಿತು.


Cache consistency does not solve all problems with file access.

ಕ್ಯಾಶ್ ಸ್ಥಿರತೆಯು ಫೈಲ್ ಪ್ರವೇಶದ ಎಲ್ಲಾ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದಿಲ್ಲ.


The client sends a request to the server.

ಗ್ರಾಹಕ ಸರ್ವರ್‌ಗೆ ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸುತ್ತಾನೆ.


This stateless approach makes more sense as we discuss the protocol.

ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಚರ್ಚಿಸುವಾಗ ಈ ಸ್ಥಿತಿರಹಿತ ವಿಧಾನವು ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣವಾಗಿದೆ.


Imagine the server crashes after the first read completes.

ಮೊದಲ ಓದು ಪೂರ್ಣಗೊಂಡ ನಂತರ ಸರ್ವರ್ ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತದೆ ಎಂದು ಊಹಿಸಿ.


Shared state 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.

ಫೈಲ್ ಅಥವಾ ಡೈರೆಕ್ಟರಿಯನ್ನು ಅನನ್ಯವಾಗಿ ವಿವರಿಸಲು ಫೈಲ್ ಹಿಡಿಕೆಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.


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

ವಾಲ್ಯೂಮ್ ಗುರುತಿಸುವಿಕೆಯು ವಿನಂತಿಯು ಯಾವ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಸರ್ವರ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ.


The inode number tells the server which file within that partition the request is accessing.

ಇನೋಡ್ ಸಂಖ್ಯೆಯು ವಿನಂತಿಯು ಯಾವ ವಿಭಾಗದಲ್ಲಿ ಯಾವ ಫೈಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸುತ್ತಿದೆ ಎಂದು ಸರ್ವರ್‌ಗೆ ತಿಳಿಸುತ್ತದೆ.


The client can issue READ and WRITE protocol messages on a file.

ಗ್ರಾಹಕನು ಫೈಲ್‌ನಲ್ಲಿ READ ಮತ್ತು WRITE ಪ್ರೋಟೋಕಾಲ್ ಸಂದೇಶಗಳನ್ನು ನೀಡಬಹುದು.


The READ protocol message requires the protocol to pass along the file handle.

READ ಪ್ರೋಟೋಕಾಲ್ ಸಂದೇಶವು ಫೈಲ್ ಹಿಡಿಕೆಯನ್ನು ರವಾನಿಸಲು ಪ್ರೋಟೋಕಾಲ್ ಅಗತ್ಯವಿದೆ.


WRITE is handled similarly, except the data is passed from the client to the server.

WRITE ಅನ್ನು ಇದೇ ರೀತಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ, ಡೇಟಾವನ್ನು ಗ್ರಾಹಕರಿಂದ ಸರ್ವರ್‌ಗೆ ರವಾನಿಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ.


The client tracks all relevant state for the file access.

ಗ್ರಾಹಕ ಫೈಲ್ ಪ್ರವೇಶಕ್ಕಾಗಿ ಎಲ್ಲಾ ಸಂಬಂಧಿತ ಸ್ಥಿತಿಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುತ್ತದೆ.


Idempotency is a useful property when building reliable systems.

ವಿಶ್ವಾಸಾರ್ಹ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸುವಾಗ ಐಡೆಂಪೋಟೆನ್ಸಿ ಉಪಯುಕ್ತ ಗುಣಲಕ್ಷಣವಾಗಿದೆ.


ಗ್ರಾಹಕ ಸರಳವಾಗಿ ವಿನಂತಿಯನ್ನು ಮರುಪ್ರಯತ್ನಿಸುತ್ತಾನೆ.


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.

LOOKUP ಮತ್ತು READ ವಿನಂತಿಗಳು ಕ್ಷುಲ್ಲಕವಾಗಿ ಐಡೆಂಪೋಟೆಂಟ್ ಆಗಿವೆ.


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.

NFS ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಫೈಲ್ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ.


Adding caching introduces the cache consistency problem.

ಕ್ಯಾಶಿಂಗ್ ಸೇರಿಸುವುದರಿಂದ ಸಂಗ್ರಹ ಸ್ಥಿರತೆಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ.


The server checks if the cached file is valid.

ಸರ್ವರ್ ಸಂಗ್ರಹಿಸಿದ ಫೈಲ್ ಮಾನ್ಯವಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತದೆ.


Clients should fetch the newer version if the cached copy is invalid.

ಸಂಗ್ರಹಿಸಿದ ಪ್ರತಿಯು ಅಮಾನ್ಯವಾಗಿದ್ದರೆ, ಕ್ಲೈಂಟ್‌ಗಳು ಹೊಸ ಆವೃತ್ತಿಯನ್ನು ಪಡೆಯಬೇಕು.


Server recovery after a crash is more complicated.

ಕ್ರ್ಯಾಶ್ ಆದ ನಂತರ ಸರ್ವರ್ ಚೇತರಿಕೆ ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ.


The server sends a message to clients when it is up and running again.

ಸರ್ವರ್ ಮತ್ತೆ ಕಾರ್ಯನಿರ್ವಹಿಸಲು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಅದು ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತದೆ.


Clients check that the server is alive periodically.

ಕ್ಲೈಂಟ್‌ಗಳು ಸರ್ವರ್ ನಿಯಮಿತವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುತ್ತಾರೆ.


There is a cost to building a more scalable caching model.

ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಕ್ಯಾಶಿಂಗ್ ಮಾದರಿಯನ್ನು ನಿರ್ಮಿಸಲು ವೆಚ್ಚವಿದೆ.


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

AFSv2 ಅನ್ನು ಅಳೆಯಲಾಯಿತು ಮತ್ತು ಮೂಲ ಆವೃತ್ತಿಗಿಂತ ಹೆಚ್ಚು ಸ್ಕೇಲೆಬಲ್ ಎಂದು ಕಂಡುಬಂದಿದೆ.


Each server could support about 50 clients.

ಪ್ರತಿ ಸರ್ವರ್ ಸುಮಾರು 50 ಕ್ಲೈಂಟ್‌ಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ.


Client-side performance often came quite close to local performance.

ಕ್ಲೈಂಟ್-ಸೈಡ್ ಕಾರ್ಯಕ್ಷಮತೆ ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಳೀಯ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಹತ್ತಿರ ಬರುತ್ತದೆ.


File reads usually went to the local disk cache.

ಫೈಲ್ ರೀಡ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಸ್ಥಳೀಯ ಡಿಸ್ಕ್ ಸಂಗ್ರಹಕ್ಕೆ ಹೋಗುತ್ತವೆ.


A client created a new file or wrote to an existing one.

ಒಂದು ಕ್ಲೈಂಟ್ ಹೊಸ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿತು ಅಥವಾ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಒಂದಕ್ಕೆ ಬರೆದಿದೆ.


We examine typical read and write patterns analytically.

ನಾವು ವಿಶಿಷ್ಟವಾದ ಓದುವ ಮತ್ತು ಬರೆಯುವ ಮಾದರಿಗಳನ್ನು ವಿಶ್ಲೇಷಣಾತ್ಮಕವಾಗಿ ಪರೀಕ್ಷಿಸುತ್ತೇವೆ.


ಸಣ್ಣ ಫೈಲ್‌ಗಳು ಕೆಲವು ಬ್ಲಾಕ್‌ಗಳನ್ನು ಹೊಂದಿವೆ.


Large files fit on a local disk but not in client memory.

ದೊಡ್ಡ ಫೈಲ್‌ಗಳು ಸ್ಥಳೀಯ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ ಆದರೆ ಕ್ಲೈಂಟ್ ಮೆಮೊರಿಯಲ್ಲಿ ಅಲ್ಲ.


Access to local memory takes a certain amount of time.

ಸ್ಥಳೀಯ ಮೆಮೊರಿಗೆ ಪ್ರವೇಶಿಸಲು ಒಂದು ನಿರ್ದಿಷ್ಟ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.


Subsequent file accesses will hit in caches.

ನಂತರದ ಫೈಲ್ ಪ್ರವೇಶಗಳು ಸಂಗ್ರಹಗಳಲ್ಲಿ ಹಿಟ್ ಆಗುತ್ತವೆ.


AFS ದೊಡ್ಡ ಸ್ಥಳೀಯ ಡಿಸ್ಕ್ ಸಂಗ್ರಹವನ್ನು ಹೊಂದಿದೆ.


NFS can only cache blocks in client memory.

NFS ಕ್ಲೈಂಟ್ ಮೆಮೊರಿಯಲ್ಲಿ ಮಾತ್ರ ಬ್ಲಾಕ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು.


Sequential writes of new files should perform similarly.

ಹೊಸ ಫೈಲ್‌ಗಳ ಅನುಕ್ರಮ ಬರಹಗಳು ಇದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು.


AFS ಎಲ್ಲಾ ಡೇಟಾವನ್ನು ಸ್ಥಳೀಯ ಡಿಸ್ಕ್‌ಗೆ ಬರೆಯುತ್ತದೆ.


Threads are used to improve the performance of a program.

ಥ್ರೆಡ್‌ಗಳನ್ನು ಪ್ರೋಗ್ರಾಂನ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.


The operating system manages the computer's resources.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕಂಪ್ಯೂಟರ್‌ನ ಸಂಪನ್ಮೂಲಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ.


ಪ್ರವೇಶಕ್ಕಾಗಿ ಟಿಕೆಟ್ ಅಗತ್ಯವಿದೆ.


Time sharing allows multiple users to use a computer simultaneously.

ಸಮಯ ಹಂಚಿಕೆ ಅನೇಕ ಬಳಕೆದಾರರಿಗೆ ಒಂದೇ ಸಮಯದಲ್ಲಿ ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ.


The system uses time slicing to allocate CPU time.

ಸಿಸ್ಟಮ್ ಸಿಪಿಯು ಸಮಯವನ್ನು ನಿಯೋಜಿಸಲು ಸಮಯ ಸ್ಲೈಸಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


The translation lookaside buffer (TLB) speeds up address translation.

ಅನುವಾದ ಲುಕ್ಸೈಡ್ ಬಫರ್ (ಟಿಎಲ್‌ಬಿ) ವಿಳಾಸ ಅನುವಾದವನ್ನು ವೇಗಗೊಳಿಸುತ್ತದೆ.


The operating system provides transparency to the user.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಬಳಕೆದಾರರಿಗೆ ಪಾರದರ್ಶಕತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.


ಟ್ರಾಪ್ ಒಂದು ಸಾಫ್ಟ್‌ವೇರ್ ಅಡಚಣೆಯಾಗಿದೆ.


The system uses a timer interrupt to regain control.

ನಿಯಂತ್ರಣವನ್ನು ಮರಳಿ ಪಡೆಯಲು ಸಿಸ್ಟಮ್ ಟೈಮರ್ ಅಡಚಣೆಯನ್ನು ಬಳಸುತ್ತದೆ.


The system uses a transaction to ensure data consistency.

ಡೇಟಾ ಸ್ಥಿರತೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಿಸ್ಟಮ್ ವಹಿವಾಟು ಬಳಸುತ್ತದೆ.


Virtual memory allows programs to use more memory than is physically available.

ವರ್ಚುವಲ್ ಮೆಮೊರಿ ಪ್ರೋಗ್ರಾಂಗಳು ಭೌತಿಕವಾಗಿ ಲಭ್ಯವಿರುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಮೆಮೊರಿಯನ್ನು ಬಳಸಲು ಅನುಮತಿಸುತ್ತದೆ.


Virtualization allows multiple operating systems to run on a single machine.

ವರ್ಚುವಲೈಸೇಶನ್ ಒಂದೇ ಯಂತ್ರದಲ್ಲಿ ಅನೇಕ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.


The system uses a write-ahead log to ensure data durability.

ಡೇಟಾ ಬಾಳಿಕೆ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಿಸ್ಟಮ್ ರೈಟ್-ಅಹೆಡ್ ಲಾಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


Understanding time-space trade-offs is crucial for system design.

ಸಮಯ-ಸ್ಥಳದ ವ್ಯಾಪಾರ ವಹಿವಾಟುಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸಕ್ಕೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ.


The principle of isolation is fundamental to operating system design.

ಪ್ರತ್ಯೇಕತೆಯ ತತ್ವವು ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ವಿನ್ಯಾಸಕ್ಕೆ ಮೂಲಭೂತವಾಗಿದೆ.


How to build a distributed file system is a complex topic.

ವಿತರಿಸಿದ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಒಂದು ಸಂಕೀರ್ಣ ವಿಷಯವಾಗಿದೆ.


The system must handle disk failures gracefully.

ಸಿಸ್ಟಮ್ ಡಿಸ್ಕ್ ವೈಫಲ್ಯಗಳನ್ನು ಸಲೀಸಾಗಿ ನಿರ್ವಹಿಸಬೇಕು.


The operating system provides an abstraction of the hardware.

ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಹಾರ್ಡ್‌ವೇರ್‌ನ ಒಂದು ಅಮೂರ್ತತೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ.


The system uses caching to improve performance.

ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸಲು ಸಿಸ್ಟಮ್ ಕ್ಯಾಶಿಂಗ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.


ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸಬಹುದಾದಂತೆ ಮಾಡುವುದು ಗುರಿಯಾಗಿದೆ.


The server stores the data on its disks, and clients request data through well-formed protocol messages.

ಸರ್ವರ್ ತನ್ನ ಡಿಸ್ಕ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲೈಂಟ್‌ಗಳು ಉತ್ತಮವಾಗಿ ರೂಪುಗೊಂಡ ಪ್ರೋಟೋಕಾಲ್ ಸಂದೇಶಗಳ ಮೂಲಕ ಡೇಟಾವನ್ನು ವಿನಂತಿಸುತ್ತಾರೆ.


Why do we bother with this arrangement? (i.e., why don’t we just let clients use their local disks?)

ನಾವು ಈ ವ್ಯವಸ್ಥೆಯನ್ನು ಏಕೆ ತೊಂದರೆಗೊಳಿಸಬೇಕು? (ಅಂದರೆ, ಕ್ಲೈಂಟ್‌ಗಳು ತಮ್ಮ ಸ್ಥಳೀಯ ಡಿಸ್ಕ್‌ಗಳನ್ನು ಬಳಸಲು ನಾವು ಏಕೆ ಬಿಡುವುದಿಲ್ಲ?)


Well, primarily this setup allows for easy sharing of data across clients.

ಸರಿ, ಪ್ರಾಥಮಿಕವಾಗಿ ಈ ಸೆಟಪ್ ಕ್ಲೈಂಟ್‌ಗಳಾದ್ಯಂತ ಡೇಟಾವನ್ನು ಸುಲಭವಾಗಿ ಹಂಚಿಕೊಳ್ಳಲು ಅನುಮತಿಸುತ್ತದೆ.


Thus, if you access a file on one machine (Client 0) and then later use another (Client 2), you will have the same view of the file system.

ಆದ್ದರಿಂದ, ನೀವು ಒಂದು ಯಂತ್ರದಲ್ಲಿ (ಕ್ಲೈಂಟ್ 0) ಫೈಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಿದರೆ ಮತ್ತು ನಂತರ ಇನ್ನೊಂದನ್ನು (ಕ್ಲೈಂಟ್ 2) ಬಳಸಿದರೆ, ನೀವು ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ಒಂದೇ ನೋಟವನ್ನು ಹೊಂದಿರುತ್ತೀರಿ.


A secondary benefit is centralized administration; for example, backing up files can be done from the few server machines instead of from the multitude of clients.

ದ್ವಿತೀಯಕ ಪ್ರಯೋಜನವೆಂದರೆ ಕೇಂದ್ರೀಕೃತ ಆಡಳಿತ; ಉದಾಹರಣೆಗೆ, ಫೈಲ್‌ಗಳನ್ನು ಬ್ಯಾಕಪ್ ಮಾಡುವುದನ್ನು ಕೆಲವು ಸರ್ವರ್ ಯಂತ್ರಗಳಿಂದ ಮಾಡಬಹುದು, ಬದಲಿಗೆ ಹೆಚ್ಚಿನ ಸಂಖ್ಯೆಯ ಕ್ಲೈಂಟ್‌ಗಳಿಂದ ಮಾಡಬಹುದು.


Another advantage could be security; having all servers in a locked machine room prevents certain types of problems from arising.

ಇನ್ನೊಂದು ಪ್ರಯೋಜನವೆಂದರೆ ಭದ್ರತೆ; ಲಾಕ್ ಮಾಡಲಾದ ಯಂತ್ರ ಕೋಣೆಯಲ್ಲಿ ಎಲ್ಲಾ ಸರ್ವರ್‌ಗಳನ್ನು ಹೊಂದಿರುವುದು ಕೆಲವು ರೀತಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಉದ್ಭವಿಸುವುದನ್ನು ತಡೆಯುತ್ತದೆ.


A simple client/server distributed file system has more components than the file systems we have studied so far.

ಸರಳ ಕ್ಲೈಂಟ್/ಸರ್ವರ್ ವಿತರಣಾ ಫೈಲ್ ಸಿಸ್ಟಮ್ ನಾವು ಇಲ್ಲಿಯವರೆಗೆ ಅಧ್ಯಯನ ಮಾಡಿದ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗಿಂತ ಹೆಚ್ಚಿನ ಘಟಕಗಳನ್ನು ಹೊಂದಿದೆ.


On the client side, there are client applications which access files and directories through the client-side file system.

ಕ್ಲೈಂಟ್ ಭಾಗದಲ್ಲಿ, ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಮೂಲಕ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಪ್ರವೇಶಿಸುವ ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿವೆ.


A client application issues system calls to the client-side file system (such as open(), read(), write(), close(), mkdir(), etc.) in order to access files which are stored on the server.

ಸರ್ವರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಫೈಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ನೀಡುತ್ತದೆ (ಉದಾಹರಣೆಗೆ open(), read(), write(), close(), mkdir(), ಇತ್ಯಾದಿ).


Thus, to client applications, the file system does not appear to be any different than a local (disk-based) file system, except perhaps for performance.

ಆದ್ದರಿಂದ, ಕ್ಲೈಂಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ, ಫೈಲ್ ಸಿಸ್ಟಮ್ ಸ್ಥಳೀಯ (ಡಿಸ್ಕ್-ಆಧಾರಿತ) ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಿಂದ ಯಾವುದೇ ಭಿನ್ನವಾಗಿ ಕಾಣಿಸುವುದಿಲ್ಲ, ಬಹುಶಃ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಹೊರತುಪಡಿಸಿ.


The role of the client-side file system is to execute the actions needed to service those system calls.

ಆ ಸಿಸ್ಟಮ್ ಕರೆಗಳನ್ನು ಪೂರೈಸಲು ಅಗತ್ಯವಿರುವ ಕ್ರಿಯೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ಪಾತ್ರವಾಗಿದೆ.


For example, if the client issues a read() request, the client-side file system may send a message to the server-side file system (or, more commonly, the file server) to read a particular block.

ಉದಾಹರಣೆಗೆ, ಕ್ಲೈಂಟ್ read() ವಿನಂತಿಯನ್ನು ನೀಡಿದರೆ, ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ನಿರ್ದಿಷ್ಟ ಬ್ಲಾಕ್ ಅನ್ನು ಓದಲು ಸರ್ವರ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ (ಅಥವಾ, ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿ, ಫೈಲ್ ಸರ್ವರ್‌ಗೆ) ಸಂದೇಶವನ್ನು ಕಳುಹಿಸಬಹುದು.


The file server will then read the block from disk (or its own in-memory cache), and send a message back to the client with the requested data.

ನಂತರ ಫೈಲ್ ಸರ್ವರ್ ಡಿಸ್ಕ್‌ನಿಂದ (ಅಥವಾ ಅದರ ಸ್ವಂತ ಇನ್-ಮೆಮೊರಿ ಸಂಗ್ರಹದಿಂದ) ಬ್ಲಾಕ್ ಅನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ವಿನಂತಿಸಿದ ಡೇಟಾದೊಂದಿಗೆ ಕ್ಲೈಂಟ್‌ಗೆ ಸಂದೇಶವನ್ನು ಕಳುಹಿಸುತ್ತದೆ.


Note that a subsequent read() of the same block on the client may be cached in client memory or on the client’s disk even; in the best such case, no network traffic need be generated.

ಕ್ಲೈಂಟ್‌ನಲ್ಲಿ ಅದೇ ಬ್ಲಾಕ್‌ನ ನಂತರದ read() ಅನ್ನು ಕ್ಲೈಂಟ್ ಮೆಮೊರಿಯಲ್ಲಿ ಅಥವಾ ಕ್ಲೈಂಟ್‌ನ ಡಿಸ್ಕ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು; ಉತ್ತಮ ಸಂದರ್ಭದಲ್ಲಿ, ಯಾವುದೇ ನೆಟ್‌ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಉತ್ಪಾದಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.


From this simple overview, you should get a sense that there are two important pieces of software in a client/server distributed file system: the client-side file system and the file server.

ಈ ಸರಳ ಅವಲೋಕನದಿಂದ, ಕ್ಲೈಂಟ್/ಸರ್ವರ್ ವಿತರಣಾ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಎರಡು ಮುಖ್ಯ ಸಾಫ್ಟ್‌ವೇರ್ ತುಣುಕುಗಳಿವೆ ಎಂದು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು: ಕ್ಲೈಂಟ್-ಸೈಡ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ ಮತ್ತು ಫೈಲ್ ಸರ್ವರ್.


Together their behavior determines the behavior of the distributed file system.

ಒಟ್ಟಿಗೆ ಅವರ ನಡವಳಿಕೆಯು ವಿತರಣಾ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನ ನಡವಳಿಕೆಯನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.


One of the earliest and quite successful distributed systems was developed by Sun Microsystems, and is known as the Sun Network File System (or NFS).

ಸನ್ ಮೈಕ್ರೋಸಿಸ್ಟಮ್ಸ್‌ನಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲ್ಪಟ್ಟ ಅತ್ಯಂತ ಆರಂಭಿಕ ಮತ್ತು ಯಶಸ್ವಿ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ, ಇದನ್ನು ಸನ್ ನೆಟ್‌ವರ್ಕ್ ಫೈಲ್ ಸಿಸ್ಟಮ್ (ಅಥವಾ NFS) ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ.


In defining NFS, Sun took an unusual approach: instead of building a proprietary and closed system, Sun instead developed an open protocol which simply specified the exact message formats that clients and servers would use to communicate.

NFS ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವಲ್ಲಿ, ಸನ್ ಅಸಾಮಾನ್ಯ ವಿಧಾನವನ್ನು ತೆಗೆದುಕೊಂಡಿತು: ಸ್ವಾಮ್ಯದ ಮತ್ತು ಮುಚ್ಚಿದ ವ್ಯವಸ್ಥೆಯನ್ನು ನಿರ್ಮಿಸುವ ಬದಲು, ಸನ್ ಬದಲಿಗೆ ಮುಕ್ತ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿತು, ಇದು ಕ್ಲೈಂಟ್‌ಗಳು ಮತ್ತು ಸರ್ವರ್‌ಗಳು ಸಂವಹನ ನಡೆಸಲು ಬಳಸುವ ನಿಖರವಾದ ಸಂದೇಶ ಸ್ವರೂಪಗಳನ್ನು ಸರಳವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿತು.


In NFSv2, the main goal in the design of the protocol was simple and fast server crash recovery.

NFSv2 ನಲ್ಲಿ, ಪ್ರೋಟೋಕಾಲ್‌ನ ವಿನ್ಯಾಸದಲ್ಲಿನ ಮುಖ್ಯ ಗುರಿ ಸರಳ ಮತ್ತು ವೇಗದ ಸರ್ವರ್ ಕ್ರ್ಯಾಶ್ ಚೇತರಿಕೆಯಾಗಿದೆ.


This simple goal is realized in NFSv2 by designing what we refer to as a stateless protocol.

ನಾವು ಸ್ಥಿತಿರಹಿತ ಪ್ರೋಟೋಕಾಲ್ ಎಂದು ಉಲ್ಲೇಖಿಸುವುದನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸುವ ಮೂಲಕ ಈ ಸರಳ ಗುರಿಯನ್ನು NFSv2 ನಲ್ಲಿ ಅರಿತುಕೊಳ್ಳಲಾಗಿದೆ.