How Computers Work: The CPU and Memory

The following figure shows the parts of a computer:

  • The Central Processing Unit:
    • (CPU),
    • Buses,
    • Ports and controllers,
    • ROM;
  • Main Memory (RAM);
  • Input Devices;
  • Output Devices;
  • Secondary Storage;
    • floppy disks,
    • hard disk,
    • CD-ROM
Figure 0: Inside The Computer

This part of the reading will examine the CPU, Buses, Controllers, and Main Memory. Other sections will examine input devices, output devices, and secondary memory.

The Central Processing Unit (CPU)

Figure 1: The Central Processing Unit

The computer does its primary work in a part of the machine we cannot see, a control center that converts data input to information output. This control center, called the central processing unit (CPU), is a highly complex, extensive set of electronic circuitry that executes stored program instructions. All computers, large and small, must have a central processing unit. As Figure 1 shows, the central processing unit consists of two parts: The control unit and the arithmetic/logic unit. Each part has a specific function.
Before we discuss the control unit and the arithmetic/logic unit in detail, we need to consider data storage and its relationship to the central processing unit. Computers use two types of storage: Primary storage and secondary storage. The CPU interacts closely with primary storage, or main memory, referring to it for both instructions and data. For this reason this part of the reading will discuss memory in the context of the central processing unit. Technically, however, memory is not part of the CPU.

Recall that a computer’s memory holds data only temporarily, at the time the computer is executing a program. Secondary storage holds permanent or semi-permanent data on some external magnetic or optical medium. The diskettes and CD-ROM disks that you have seen with personal computers are secondary storage devices, as are hard disks. Since the physical attributes of secondary storage devices determine the way data is organized on them, we will discuss secondary storage and data organization together in another part of our on-line readings.

Now let us consider the components of the central processing unit.

 

  • The Control Unit
    The control unit of the CPU contains circuitry that uses electrical signals to direct the entire computer system to carry out, or execute, stored program instructions. Like an orchestra leader, the control unit does not execute program instructions; rather, it directs other parts of the system to do so. The control unit must communicate with both the arithmetic/logic unit and memory.

  • The Arithmetic/Logic Unit
    The arithmetic/logic unit (ALU) contains the electronic circuitry that executes all arithmetic and logical operations.

    The arithmetic/logic unit can perform four kinds of arithmetic operations, or mathematical calculations: addition, subtraction, multiplication, and division. As its name implies, the arithmetic/logic unit also performs logical operations. A logical operation is usually a comparison. The unit can compare numbers, letters, or special characters. The computer can then take action based on the result of the comparison. This is a very important capability. It is by comparing that a computer is able to tell, for instance, whether there are unfilled seats on airplanes, whether charge- card customers have exceeded their credit limits, and whether one candidate for Congress has more votes than another.

    Logical operations can test for three conditions:

    • Equal-to condition. In a test for this condition, the arithmetic/logic unit compares two values to determine if they are equal. For example: If the number of tickets sold equals the number of seats in the auditorium, then the concert is declared sold out.
    • Less-than condition. To test for this condition, the computer compares values to determine if one is less than another. For example: If the number of speeding tickets on a driver’s record is less than three, then insurance rates are $425; otherwise, the rates are $500.
    • Greater-than condition. In this type of comparison, the computer determines if one value is greater than another. For example: If the hours a person worked this week are greater than 40, then multiply every extra hour by 1.5 times the usual hourly wage to compute overtime pay.

    A computer can simultaneously test for more than one condition. In fact, a logic unit can usually discern six logical relationships: equal to, less than, greater than, less than or equal to, greater than or equal to, and not equal.

    The symbols that let you define the type of comparison you want the computer to perform are called relational operators. The most common relational operators are the equal sign(=), the less-than symbol(<), and the greater-than symbol(>).

    • Registers: Temporary Storage Areas
      Registers are temporary storage areas for instructions or data. They are not a part of memory; rather they are special additional storage locations that offer the advantage of speed. Registers work under the direction of the control unit to accept, hold, and transfer instructions or data and perform arithmetic or logical comparisons at high speed. The control unit uses a data storage register the way a store owner uses a cash register-as a temporary, convenient place to store what is used in transactions.

      Computers usually assign special roles to certain registers, including these registers:

      • An accumulator, which collects the result of computations.
      • An address register, which keeps track of where a given instruction or piece of data is stored in memory. Each storage location in memory is identified by an address, just as each house on a street has an address.
      • A storage register, which temporarily holds data taken from or about to be sent to memory.
      • A general-purpose register, which is used for several functions.
    • Memory and Storage
      Memory is also known as primary storage, primary memory, main storage, internal storage, main memory, and RAM (Random Access Memory); all these terms are used interchangeably by people in computer circles. Memory is the part of the computer that holds data and instructions for processing. Although closely associated with the central processing unit, memory is separate from it. Memory stores program instructions or data for only as long as the program they pertain to is in operation. Keeping these items in memory when the program is not running is not feasible for three reasons:

      • Most types of memory only store items while the computer is turned on; data is destroyed when the machine is turned off.
      • If more than one program is running at once (often the case on large computers and sometimes on small computers), a single program can not lay exclusive claim to memory.
      • There may not be room in memory to hold the processed data.

      How do data and instructions get from an input device into memory? The control unit sends them. Likewise, when the time is right, the control unit sends these items from memory to the arithmetic/logic unit, where an arithmetic operation or logical operation is performed. After being processed, the information is sent to memory, where it is hold until it is ready to he released to an output unit.

      The chief characteristic of memory is that it allows very fast access to instructions and data, no matter where the items are within it. We will discuss the physical components of memory-memory chips-later in this chapter.
      To see how registers, memory, and second storage all work together, let us use the analogy of making a salad. In our kitchen we have:

      • a refrigerator where we store our vegetables for the salad;
      • a counter where we place all of our veggies before putting them on the cutting board for chopping;
      • a cutting board on the counter where we chop the vegetables;
      • a recipe that details what veggies to chop;
      • the corners of the cutting board are kept free for partially chopped piles of veggies that we intend to chop more or to mix with other partially chopped veggies.
      • a bowl on the counter where we mix and store the salad;
      • space in the refrigerator to put the mixed salad after it is made.

      The process of making the salad is then: bring the veggies from the fridge to the counter top; place some veggies on the chopping board according to the recipe; chop the veggies, possibly storing some partially chopped veggies temporarily on the corners of the cutting board; place all the veggies in the bowl to either put back in the fridge or put directly on the dinner table.The refrigerator is the equivalent of secondary (disk) storage. It can store high volumes of veggies for long periods of time. The counter top is the equivalent of the computer’s motherboard – everything is done on the counter (inside the computer). The cutting board is the ALU – the work gets done there. The recipe is the control unit – it tells you what to do on the cutting board (ALU). Space on the counter top is the equivalent of RAM memory – all veggies must be brought from the fridge and placed on the counter top for fast access. Note that the counter top (RAM) is faster to access than the fridge (disk), but can not hold as much, and can not hold it for long periods of time. The corners of the cutting board where we temporarily store partially chopped veggies are equivalent to the registers. The corners of the cutting board are very fast to access for chopping, but can not hold much. The salad bowl is like a temporary register, it is for storing the salad waiting to take back to the fridge (putting data back on a disk) or for taking to the dinner table (outputting the data to an output device).
      Now for a more technical example. let us look at how a payroll program uses all three types of storage. Suppose the program calculates the salary of an employee. The data representing the hours worked and the data for the rate of pay are ready in their respective registers. Other data related to the salary calculation-overtime hours, bonuses, deductions, and so forth-is waiting nearby in memory. The data for other employees is available in secondary storage. As the CPU finishes calculations about one employee, the data about the next employee is brought from secondary storage into memory and eventually into the registers.

      The following table summarizes the characteristics of the various kinds of data storage in the storage hierarchy.

      Storage Speed Capacity Relative Cost ($) Permanent?
      Registers Fastest Lowest Highest No
      RAM Very Fast Low/Moderate High No
      Floppy Disk Very Slow Low Low Yes
      Hard Disk Moderate Very High Very Low Yes

      Modern computers are designed with this hierarchy due to the characteristics listed in the table. It has been the cheapest way to get the functionality. However, as RAM becomes cheaper, faster, and even permanent, we may see disks disappear as an internal storage device. Removable disks, like Zip disks or CDs (we describe these in detail in the online reading on storage devices) will probably remain in use longer as a means to physically transfer large volumes of data into the computer. However, even this use of disks will probably be supplanted by the Internet as the major (and eventually only) way of transferring data. Floppy disks drives are already disappearing: the new IMac Macintosh from Apple does not come with one. Within the next five years most new computer designs will only include floppy drives as an extra for people with old floppy disks that they must use.For more detail on the computer’s memory hierarchy, see the How Stuff Works pages on computer memory.. This is optional reading.

    • How the CPU Executes Program Instructions
      Let us examine the way the central processing unit, in association with memory, executes a computer program. We will be looking at how just one instruction in the program is executed. In fact, most computers today can execute only one instruction at a time, though they execute it very quickly. Many personal computers can execute instructions in less than one-millionth of a second, whereas those speed demons known as supercomputers can execute instructions in less than one-billionth of a second.

      Figure 2: The Machine Cycle

      Before an instruction can be executed, program instructions and data must be placed into memory from an input device or a secondary storage device (the process is further complicated by the fact that, as we noted earlier, the data will probably make a temporary stop in a register). As Figure 2 shows, once the necessary data and instruction are in memory, the central processing unit performs the following four steps for each instruction:

      1. The control unit fetches (gets) the instruction from memory.
      2. The control unit decodes the instruction (decides what it means) and directs that the necessary data be moved from memory to the arithmetic/logic unit. These first two steps together are called instruction time, or I-time.
      3. The arithmetic/logic unit executes the arithmetic or logical instruction. That is, the ALU is given control and performs the actual operation on the data.
      4. Thc arithmetic/logic unit stores the result of this operation in memory or in a register. Steps 3 and 4 together are called execution time, or E-time.

      The control unit eventually directs memory to release the result to an output device or a secondary storage device. The combination of I-time and E-time is called the machine cycle. Figure 3 shows an instruction going through the machine cycle.

      Each central processing unit has an internal clock that produces pulses at a fixed rate to synchronize all computer operations. A single machine-cycle instruction may be made up of a substantial number of sub-instructions, each of which must take at least one clock cycle. Each type of central processing unit is designed to understand a specific group of instructions called the instruction set. Just as there are many different languages that people understand, so each different type of CPU has an instruction set it understands. Therefore, one CPU-such as the one for a Compaq personal computer-cannot understand the instruction set from another CPU-say, for a Macintosh.

      Figure 3: The Machine Cycle in Action

      It is one thing to have instructions and data somewhere in memory and quite another for the control unit to be able to find them. How does it do this?

      Figure 4: Memory Addresses Like Mailboxes

      The location in memory for each instruction and each piece of data is identified by an address. That is, each location has an address number, like the mailboxes in front of an apartment house. And, like the mailboxes, the address numbers of the locations remain the same, but the contents (instructions and data) of the locations may change. That is, new instructions or new data may be placed in the locations when the old contents no longer need to be stored in memory. Unlike a mailbox, however, a memory location can hold only a fixed amount of data; an address can hold only a fixed number of bytes – often two bytes in a modern computer.

      Figure 4 shows how a program manipulates data in memory. A payroll program, for example, may give instructions to put the rate of pay in location 3 and the number of hours worked in location 6. To compute the employee’s salary, then, instructions tell the computer to multiply the data in location 3 by the data in location 6 and move the result to location 8. The choice of locations is arbitrary – any locations that are not already spoken for can be used. Programmers using programming languages, however, do not have to worry about the actual address numbers, because each data address is referred to by a name. The name is called a symbolic address. In this example, the symbolic address names are Rate, Hours, and Salary.Now that we see conceptually how a computer works, we will look at the hardware components that make up the internals os a modern computer. Click here to continue the required reading.

Reference :

  1. http://homepage.cs.uri.edu/faculty/wolfe/book/Readings/Reading04.htm

 

NTFS vs FAT

NTFS

Short for New Technology File System, NTFS is a proprietary file system developed by Microsoft . It is a file organizational system that stores and accesses information located on Microsoft Windows NT,Windows 2000, Windows XP operating systems. NTFS offers better methods of data protection and file recovery than the previous FAT file system versions.

NTFS

NTFS is the preferred file system for this version of Windows. It has many benefits over the earlier FAT32 file system, including:

  • The capability to recover from some disk-related errors automatically, which FAT32 cannot.

  • Improved support for larger hard disks.

  • Better security because you can use permissions and encryption to restrict access to specific files to approved users.

FAT

Short for File Allocation Table, FAT is a method of keeping track of the contents of a hard drive used by early Microsoft operating systems. The table is a chart of numbers that correspond to cluster addresses on the hard drive. Below is a listing of the different types of FAT that have been used and the operating systems using them.

FAT32

Enhanced File Allocation Table utilizing a 28-bit binary system, first used in Windows 95 OSR2 and Windows 98, that saves disk space by using 4k Cluster. See FAT32 Page for extended information about FAT32.

Today, later versions of Microsoft Windows, such as Windows XP, Vista, and 7 are using NTFS and not FAT.

Reference :

  1. http://www.computerhope.com/jargon/f/fat.htm
  2. http://windows.microsoft.com/en-us/windows-vista/comparing-ntfs-and-fat-file-systems
  3. http://www.howtogeek.com/177529/htg-explains-why-are-removable-drives-still-using-fat32-instead-of-ntfs/

 

Distributed System

A distributed system is a collection of loosely coupled nodes interconnected
by a communication network. From the point of view of a specific node in
a distributed system, the rest of the nodes and their respective resources are
remote, whereas its own resources are local.

There are four major reasons for building distributed systems:

  1. resource sharing,
  2. computation speedup,
  3. reliability, and
  4. communication.

Distributed File System :

Although the World Wide Web is the predominant distributed system in use
today, it is not the only one. Another important and popular use of distributed
computing is the distributed file system, or DFS.

To explain the structure of a DFS, we need to define the terms service,
server, and client in the DFS context. A service is a software entity running on
one or more machines and providing a particular type of function to clients.
A server is the service software running on a single machine. A client is
a process that can invoke a service using a set of operations that form its
client interface. Sometimes a lower-level interface is defined for the actual
cross-machine interaction; it is the intermachine interface.

A DFS is a file system whose clients, servers, and storage devices are
dispersed among the machines of a distributed system. Accordingly, service
activity has to be carried out across the network. Instead of a single centralized
data repository, the system frequently has multiple and independent storage
devices. As you will see, the concrete configuration and implementation of a
DFS may vary from system to system. In some configurations, servers run on
dedicated machines. In others, a machine can be both a server and a client.A DFS
can be implemented as part of a distributed operating system or, alternatively,
by a software layer whose task is to manage the communication between
conventional operating systems and file systems.

The distinctive features of a DFS are the multiplicity and autonomy of
clients and servers in the system. Ideally, though, a DFS should appear to its
clients to be a conventional, centralized file system. That is, the client interface
of a DFS should not distinguish between local and remote files. A transparent
DFS—like the transparent distributed systems mentioned earlier—facilitates
user mobility by bringing a user’s environment (that is, home directory) to
wherever the user logs in.

The most important performance measure of a DFS is the amount of time
needed to satisfy service requests. In conventional systems, this time consists of
disk-access time and a small amount of CPU-processing time. In a DFS, however,
a remote access has the additional overhead associated with the distributed
structure. This overhead includes the time to deliver the request to a server, as
well as the time to get the response across the network back to the client. For
each direction, in addition to the transfer of the information, there is the CPU
overhead of running the communication protocol software. The performance
of a DFS can be viewed as another dimension of the DFS’s transparency. That is,
the performance of an ideal DFS would be comparable to that of a conventional
file system.

 Naming Structures

We need to differentiate two related notions regarding name mappings in a
DFS:
1. Location transparency. The name of a file does not reveal any hint of the
file’s physical storage location.
2. Location independence. The name of a file does not need to be changed
when the file’s physical storage location changes.

Remote File Access

Basic Caching Scheme
The concept of caching is simple. If the data needed to satisfy the access
request are not already cached, then a copy of those data is brought from
the server to the client system. Accesses are performed on the cached copy.
The idea is to retain recently accessed disk blocks in the cache, so that repeated
accesses to the same information can be handled locally, without additional
network traffic. A replacement policy (for example, the least-recently-used
algorithm) keeps the cache size bounded. No direct correspondence exists
between accesses and traffic to the server. Files are still identified with one
master copy residing at the server machine, but copies (or parts) of the file
are scattered in different caches.

Buffer Vs Cache

Buffer :

A buffer, of course, is a memory area that stores data being transferred between two devices or between a device and an application. Buffering is done for three
reasons.One reason is to cope with a speed mismatch between the producer and
consumer of a data stream. Suppose, for example, that a file is being received
via modem for storage on the hard disk. The modem is about a thousand
times slower than the hard disk. So a buffer is created in main memory to
accumulate the bytes received from the modem. When an entire buffer of data
has arrived, the buffer can be written to disk in a single operation. Since the
disk write is not instantaneous and the modem still needs a place to store
additional incoming data, two buffers are used. After the modem fills the first
buffer, the disk write is requested. The modem then starts to fill the second
buffer while the first buffer is written to disk. By the time the modem has filled
the second buffer, the disk write from the first one should have completed,
so the modem can switch back to the first buffer while the disk writes the
second one. This double buffering decouples the producer of data from the
consumer, thus relaxing timing requirements between them.

A second use of buffering is to provide adaptations for devices that
have different data-transfer sizes. Such disparities are especially common in
computer networking, where buffers are used widely for fragmentation and
reassembly of messages. At the sending side, a large message is fragmented into small network packets. The packets are sent over the network, and the
receiving side places them in a reassembly buffer to form an image of the
source data.

A third use of buffering is to support copy semantics for application I/O.
An example will clarify the meaning of “copy semantics.” Suppose that an
application has a buffer of data that it wishes to write to disk. It calls the
write() system call, providing a pointer to the buffer and an integer specifying
the number of bytes to write. After the system call returns, what happens if
the application changes the contents of the buffer? With copy semantics, the
version of the data written to disk is guaranteed to be the version at the
time of the application system call, independent of any subsequent changes
in the application’s buffer. A simple way in which the operating system can
guarantee copy semantics is for the write() system call to copy the application
data into a kernel buffer before returning control to the application. The disk
write is performed from the kernel buffer, so that subsequent changes to the
application buffer have no effect. Copying of data between kernel buffers and
application data space is common in operating systems, despite the overhead
that this operation introduces, because of the clean semantics. The same effect
can be obtained more efficiently by clever use of virtual memory mapping and
copy-on-write page protection.

Caching

A cache is a region of fast memory that holds copies of data. Access to the cached
copy is more efficient than access to the original. For instance, the instructions of the currently running process are stored on disk, cached in physical memory,
and copied again in the CPU’s secondary and primary caches.

The difference between a buffer and a cache is that a buffer may hold the only existing copy of a data item, whereas a cache, by definition, holds a copy on faster storage of
an item that resides elsewhere.

Caching and buffering are distinct functions, but sometimes a region of memory can be used for both purposes. For instance, to preserve copy semantics and to enable efficient scheduling of disk I/O, the operating system uses buffers in main memory to hold disk data. These buffers are also used as a cache, to improve the I/O efficiency for files that are shared by applications or that are being written and reread rapidly. When the kernel receives a file I/O request, the kernel first accesses the buffer cache to see whether that region of the file is already available in main memory. If it is, a physical disk I/O can be avoided or deferred. Also, disk writes are accumulated in the buffer cache for several seconds, so that large transfers are gathered to allow efficient write schedules.

A spool is a buffer that holds output for a device, such as a printer, that cannot
accept interleaved data streams. Although a printer can serve only one job
at a time, several applications may wish to print their output concurrently,
without having their output mixed together. The operating system solves this
problem by intercepting all output to the printer. Each application’s output
is spooled to a separate disk file. When an application finishes printing, the
spooling system queues the corresponding spool file for output to the printer.
The spooling system copies the queued spool files to the printer one at a time. In
some operating systems, spooling is managed by a system daemon process. In
others, it is handled by an in-kernel thread. In either case, the operating system
provides a control interface that enables users and system administrators to
display the queue, remove unwanted jobs before those jobs print, suspend
printing while the printer is serviced, and so on.

File System Concepts

File Concept :

  • The operating system abstracts from the physical properties of its storage devices to define a logical storage unit, the file.
  • Files are mapped by the operating system onto physical devices. These storage devices are usually nonvolatile, so the contents are persistent between system reboots.
  • A file is a named collection of related information that is recorded on
    secondary storage
  • A file has a certain defined structure, which depends on its type. A text file is a sequence of characters organized into lines (and possibly pages). A source file is a sequence of functions, each of which is further organized as declarations followed by executable statements. An executable file is a series of code sections that the loader can bring into memory and execute.
  • A file system can be created on each of these parts of the disk. Any entity containing a file system is generally known as a volume. The volume may be a subset of a device, a whole device, or multiple devices linked together into a RAID set. Each volume can be thought of as a virtual disk.
  • Volumes can also store multiple operating systems, allowing a system to boot and run more than one operating system.
  • Path names can be of two types: absolute and relative. An absolute path
    name begins at the root and follows a path down to the specified file, giving
    the directory names on the path. A relative path name defines a path from the
    current directory.
  • The first implemented file sharing is method involves manually transferring files between machines via programs like ftp. The second major method uses a distributed file system in which remote directories are visible from a local machine. The third method is through WWW.
  • Once the remote file system is mounted, file operation requests are sent on behalf of the user across the network to the server via the DFS protocol.

File Access Mechanisms

File access mechanism refers to the manner in which the records of a file may be accessed. There are several ways to access files

  • Sequential access
  • Direct/Random access
  • Indexed sequential access

Sequential access

A sequential access is that in which the records are accessed in some sequence i.e the information in the file is processed in order, one record after the other. This access method is the most primitive one. Example: Compilers usually access files in this fashion.

Direct/Random access

  • Random access file organization provides, accessing the records directly.
  • Each record has its own address on the file with by the help of which it can be directly accessed for reading or writing.
  • The records need not be in any sequence within the file and they need not be in adjacent locations on the storage medium.

Indexed sequential access

  • This mechanism is built up on base of sequential access.
  • An index is created for each file which contains pointers to various blocks.
  • Index is searched sequentially and its pointer is used to access the file directly.

Space Allocation

Files are allocated disk spaces by operating system. Operating systems deploy following three main ways to allocate disk space to files.

  • Contiguous Allocation
  • Linked Allocation
  • Indexed Allocation

Contiguous Allocation

  • Each file occupy a contiguous address space on disk.
  • Assigned disk address is in linear order.
  • Easy to implement.
  • External fragmentation is a major issue with this type of allocation technique.

Linked Allocation

  • Each file carries a list of links to disk blocks.
  • Directory contains link / pointer to first block of a file.
  • No external fragmentation
  • Effectively used in sequential access file.
  • Inefficient in case of direct access file.

Indexed Allocation

  • Provides solutions to problems of contigous and linked allocation.
  • A index block is created having all pointers to files.
  • Each file has its own index block which stores the addresses of disk space occupied by the file.
  • Directory contains the addresses of index blocks of files.

 Distributed Information Systems

To make client server systems easier to manage, distributed information systems also known as distributed naming services provide unified access to the information needed for remote computing. The domain name system provides host name to network address translations for the entire Internet
Summary from Text Book :
A file is an abstract data type defined and implemented by the operating
system. It is a sequence of logical records. A logical record may be a byte, a line
(of fixed or variable length), or a more complex data item. The operating system
may specifically support various record types or may leave that support to the
application program.
The major task for the operating system is to map the logical file concept
onto physical storage devices such as magnetic disk or tape. Since the physical
record size of the device may not be the same as the logical record size, it may
be necessary to order logical records into physical records. Again, this task may
be supported by the operating system or left for the application program.
Each device in a file system keeps a volume table of contents or a device
directory listing the location of the files on the device. In addition, it is useful
to create directories to allow files to be organized. A single-level directory
in a multiuser system causes naming problems, since each file must have a
unique name. A two-level directory solves this problem by creating a separate
directory for each user’s files. The directory lists the files by name and includes
the file’s location on the disk, length, type, owner, time of creation, time of last
use, and so on.
The natural generalization of a two-level directory is a tree-structured
directory. A tree-structured directory allows a user to create subdirectories
to organize files. Acyclic-graph directory structures enable users to share
subdirectories and files but complicate searching and deletion.Ageneral graph
structure allows complete flexibility in the sharing of files and directories but
sometimes requires garbage collection to recover unused disk space.
Disks are segmented into one or more volumes, each containing a file
system or left “raw.” File systems may be mounted into the system’s naming structures to make them available. The naming scheme varies by operating
system. Once mounted, the files within the volume are available for use. File
systems may be unmounted to disable access or for maintenance.
File sharing depends on the semantics provided by the system. Files may
have multiple readers, multiple writers, or limits on sharing. Distributed file
systems allow client hosts to mount volumes or directories fromservers, as long
as they can access each other across a network. Remote file systems present
challenges in reliability, performance, and security. Distributed information
systems maintain user, host, and access information so that clients and servers
can share state information to manage use and access.
Since files are the main information-storage mechanism in most computer
systems, file protection is needed. Access to files can be controlled separately
for each type of access—read, write, execute, append, delete, list directory,
and so on. File protection can be provided by access lists, passwords, or other
techniques.
To improve I/O efficiency, I/O transfers between memory and disk are
performed in units of blocks. Each block has one or more sectors. Depending on the disk drive, sector size varies from 32 bytes to 4,096 bytes; the usual size
is 512 bytes.
The basic file system needs only to issue generic commands to the
appropriate device driver to read and write physical blocks on the disk. Each
physical block is identified by its numeric disk address (for example, drive 1,
cylinder 73, track 2, sector 10).

File System – OS Concepts

 

Reference :

  1. https://www.scribd.com/doc/76762983/Operating-Systems-Files-Concept-implementing-File-Systems#scribd
  2. https://www.scribd.com/user/18149086/Mukesh