STONE RIDGE, N.Y. 12484

INSTRUCTOR: Karl Wick         SEMESTER: Spring 1999

A short side trip to Memory and Formatting

Part One - A generic memory map

Note: The above table applies to the DOS operating system. Windows simply uses one large continuous block of memory with the beginning holding the BIOS and the rest divided by the system as neccessary.

At power up, the micro-processor always looks at memory location zero, where it should find the BIOS ROM and its first instructions.

The size of the ROM can vary, and may be overlapped with RAM in many machines.

Before we go on, here are some definitions:

Part Two - Disk Formatting defined and explained.

Formatting is the process of preparing a floppy disk to store data. There are various types of format in use, but th emost common is the 3-1/2" disk capable of holding 1.44 megabytes of information.

Some disks come pre-formatted for a particular operating system (they are not interchangable), and others come unformatted. Pre-formatted disks are mass formatted at the factory and occasionally contain errors or bad places.

We format a disk for the following reasons;

• To make a new blank disk ready for use
• To make sure that the factory made no mistakes on a pre-formatted disk
• To make a disk more compatable with a drive who's hardware may be slightly out of alignment.
• To completely erase a used disk
• To use a disk from one type of machine with another machine. IE an apple disk in a PC.

Here is a table of the data capacities of some common disks.

Format.com is an External file which usually resides in the \DOS\ sub-directory. Because it is an external command it must be loaded from disk each time that it is invoked. If it is not present on a disk then an error will be generated.

Here is a visual illustration of what takes place when we format a disk. Although we show only one side of the disk, both sides are divided in similar fashion.

Disk storage space = (# of tracks per side) * (# of sectors per track) * (# of sides) * (512 bytes).

Note: The 512 bytes per sector is typical and may vary with some systems.

Example: (80 Tracks per side) * (18 sectors per track) * (2 sides) * (512 bytes per sector)  =

1,474,560 bytes. Why is this not 1.44  as in megabytes?  A very good question. Actually a megabyte is often thought of as being 1000 kilobytes (a moot point by the way), but a kilobyte is 1024 bytes instead of 1000,  so ...  1,474,560 / 1024 = 1440 kilobytes or about 1.44 megabytes.

Some sectors may be defective,

so DOS will mark them as unusable and display a message telling how many bytes of data storage space will be unusable.

Insert a disk into the drive and type Format A: <enter>

After the format is complete you will be asked for a"Volume Label". You can either give the disk a name here or simply type <enter> to use none.

Then you will see several lines of information telling you the results of the format operation and asking if you want to format another. If you say yes, then the format routine (which is still in memory at this time) begins again. If not, then those memory loactions become available for use by other programs.

More about how data is stored on the disk

In addition to dividing the disk surface into tracks and sectors, the Format command does several other things.

1. It creates a directory area on the disk to store the names and locations of files when they are stored on the disk.
2. It decides the number of file names which can be stored in this directory.
3. It decides how much space a file may take occupy on the disk.
4. It allows you to create a bootable "System Disk" if you so desire.

A boot disk contains three special files, two of these files are 'hidden' (do not appear in directory listings) so that the casual user cannot inadvertantly delete of modify them.

These files are: IO.SYS, MSDOS.SYS, and Command.com, with the first two being the hidden files.

DOS looks for these files locations at the beginning of the directory area. (the first sector of the first track, after the MBR.) If they are not there then the disk cannot boot the system.

The best way to make sure that these entries are at the beginning of the directory is to load these files is to load them onto the disk right after formatting and before any other information is stored on the disk.

The format process is identical to the regular version, with the exception that the three critical files are loaded onto the disk automatically as soon as format is complete.

It will even give the message "Loading system files".

The root directory of a "standard" 3-1/2" floppy will occupy 14 sectors. You might recall that a sector on these disks holds 512 bytes of information, so the entire root directory can hold 14 * 512 bytes or 7168 bytes (or about 0.5% of the available space on the disk.) Since each entry holds only 32 bytes of information this is enough for 244 file and sub-directory names.

Occasionally, if a disk has many very small files (244 to be exact) and you try to create another you will see the message "File creation error". This means that the root directory is full and cannot hold any more names. You will need to:

• Remove files,
• Consolidate files, or
• Use another disk

The size of the root directory cannot be changed after formatting.

Now let us further complicate matters

File Allocation Units

DOS (And other operating systems) add another level of complication to the whole storage process. When storing a file, the space reserved for that file is not usually the same as the actual size of the file in bytes or even in sectors.

Space is set aside for a file in fixed amounts called Allocation Units. An allocation unit may contain one sector or more than sector depending on the OS and the size of the disk. The number of allocation units set aside to store a particular file is the minimum amount of disk space reserved for that file.

For example, after formatting a floppy disk, the OS may give a message saying that it created 2847 allocation units on the disk with 512 bytes per allocation unit. This may be the same size as one sector or an integer multiple of sectors.

Let us assume that an allocation unit on a particular disk is 512 bytes (the same size as one sector), and we have five files named "SMALL", "LARGE", "LARGER", "TINY", and "EXACT".

1. The file SMALL is 495 bytes long
2. The file LARGE is 800 bytes long
3. The file LARGER is 1025 bytes long
4. The file EXACT is 512 bytes long
5. The file TINY is 1 byte long (a single character).

The space that DOS will reserve for each file is the smallest integer number of allocation units which has a total space at least as large as the file.

Notice that more space is actully reserved to store a file than the file really needs. This results in a certain amount of wasted space on the disk. With some files like SMALL, the wasted space is almost insignificant, with others like LARGE it becomes relative substantial (about 20% of the total allocated space)

Notice that the files LARGE and TINY both have 511 wasted bytes in their allocations. With LARGE this is about 1/3 of the total but with TINY it is almost all of the total.

Rule of thumb: On average there will be larger ratio of wasted space to used space if you are storing small files than if you are storing large files.

So, it is more efficient to store large files ... but eventually a file becomes too large to fit onto the disk so you need a larger disk.

Larger disks use more bytes per allocation unit.

The following table lists some of the allocation unit sizes created by DOS when it formats a hard disk:

The moral of the story is: Every disk has a lot of wasted space!

So, why does an OS store data in this way? Why not store it in the actual amount of bytes used or at least the amount of sectors?

Well, basically it would make the FAT huge.

The FAT tells DOS which clusters of the disk are:

• In use
• Available
• Defective

To keep track of a 1 gigabyte disk with 512 KByte sectors by sector would require 2000 entries in the FAT and each entry would probably be 16 bytes long, using 32kB just for the FAT. Two copies of the FAT would require twice as much space.

It would take an inordinate amount of time to search through all of this data to find a particular file, thus decreasing the throughput of the entire system.

Again, a tradeoff has been made, some wasted disk space give us acceptable speed.

Disk Fragmentation

(chapter 42 in book)

When a file is first stored on an empty disk DOS tries to store it in sequential locations. This makes reading it back into the computer a lot easier and faster. (Just find the starting point and keep reading).

When a file is deleted, the actual data is NOT removed from the disk. The FAT is simply updated to show the allocation units occupied by that file as available. The data remains until another file is written to those locations.

When the size of a file is larger than the longest continuous set of allocation units left on the disk, it cannot be stored in sequential locations. Instead, parts of the file may be stored in several places on the disk. The FAT must keep track of the allocation units used and the order in which to access them. It also takes longer because other sectors must pass under the disk head while rotating to the needed one.

Here is a representation of a blank formatted disk.

Here is the same disk with one file stored on it.

Here is the same disk with two files stored on it.

This is a disk which holds many files, all in sequential order.

The white areas are empty of data.

If we need to add a small file (less than 2 allocation units in length), everything is OK.

If we needed to add a file over 4 allocation units in length, it would not fit on the disk. If we need to add a file 3 or 4 allocation units in length, it would have to be stored in non-sequential locations. The file would be Fragmented.

This Disk Contains a Fragmented File (in red).

In order to read this file we need to jump around to three different parts of the disk.

Below is a disk with the same files after defragmentation.

The files on this disk are much faster to read as they require less overhead during access.

Defragmentation

Defragmentation is the process of consolidating the files on a disk into sequential allocation units
AND consolidating the free allocations units too.

Use the CHKDSK command to test a dist for fragmentation. You must add a drive or directory specification after the command. CHKDSK *.* will check all directories.

If CHKDSK finds more than a few fragented files, they can be consolidated using the DEFRAG command.

In the next chapter we will take a closer look at DOS and many of its commands.

In case you don't see two buttons above, click here to go to chapter 5.