Contiguous file allocation program in C

Contiguous file allocation is a technique that is used by operating systems to store and retrieve files on a hard drive. This approach stores each file on the disk in a single continuous block. It suggests that the entire file is kept in a single spot rather than being broken up and scattered over the disk.

In this blog post, we'll go through how to implement a contiguous file allocation method in C. Using the program's syntax, instance, and output that we will provide, and you can better understand the implementation procedure. Before implementing contiguous file allocation, let's first examine its advantages and disadvantages.

Advantages of contiguous file allocation

Greater speed of access:

The complete file is retained in one place, making retrieval faster than if it were spread out across the disk. Contiguous allocation is used to prevent the disk from being excessively fragmented. Fragmentation occurs when files are divided into tiny pieces and preserved in many locations which makes it difficult to find and retrieve the data.

Disadvantages of contiguous file allocation

A file must be stored in a single block of space per contiguous allocation to prevent space wasting. Additional space is lost if the file takes up less space than is available.
One restriction is the amount of contiguous disk space that can be used to store files using contiguous allocation. It may prohibit a file from being placed on the disk, even when there is enough space.

Now that we have discussed the advantages and disadvantages of contiguous file allocation, let's examine its implementation.

Implementation of contiguous file allocation in C:

The first step in putting a contiguous file allocation program into practice is to define the structures that will be used to store information about the files and the disc.

Two categories of structures will be described:

A data structure to record the name, size, and block number of each file.
A disk representation structure that includes a list of free and used blocks as well as the overall number of blocks.

The code for defining these structures is as follows:

struct file {
  char name[50];
  int size;
  int start_block;
};

struct disk {
  int total_blocks;
  int *used_blocks;
  int *free_blocks;
};

The disk must then be initialized by specifying the total number of blocks and designating every block as free. Dynamic memory allocation will be used to allocate memory for the utilized and free block lists.

Here is the code to initialize the disk:

void init_disk(struct disk *d, int total_blocks) {
  d->total_blocks = total_blocks;
  d->used_blocks = (int *)calloc(total_blocks, sizeof(int));
  d->free_blocks = (int *)calloc(total_blocks, sizeof(int));
   for (int i = 0; i<total_blocks; i++) {
    d->free_blocks[i] = 1;
  }
}

Now, we can define the function that allots disk space for a file. This function returns a pointer to the file structure after receiving the file's name and size as inputs.

Here is the code to allocate space for a file:

struct file *allocate_file(struct disk *d, char *name, int size) {
  int start_block = -1;
  int contiguous_blocks = 0;
  for (int i = 0; i< d->total_blocks; i++) {
    if (d->free_blocks[i] == 1) {
      if (start_block == -1) {
start_block = i;
      }
contiguous_blocks++;

if (contiguous_blocks == size) {
break;
}
} else {
start_block = -1;
contiguous_blocks = 0;
}
}
 if (contiguous_blocks != size) {
return NULL;
}
 for (int i = start_block; i<start_block + size; i++) {
d->used_blocks[i] = 1;
d->free_blocks[i] = 0;
}
struct file *f = (struct file *)malloc(sizeof(struct file));
strcpy(f->name, name);
f->size = size;
f->start_block = start_block;

return f;
}

Now, it is possible to define the function to free disk space used by a file. For reference to the file structure, this method releases the blocks that the file had previously occupied.

The following code will release the space that a file is using:

void free_file(struct disk *d, struct file *f) 
{
// mark all the blocks, as free
for (int i = f->start_block; i< f->start_block + f->size; i++) {
d->used_blocks[i] = 0 ;
d->free_blocks[i] = 1 ;
}
 free(f);
}

Now that we have defined all the necessary functions, we can write a main function to test the program. Here is an example main function:

int main() {
// initialize the disk with struct
struct disk d;
init_disk(&d, 10);

// allocate space for a respective file
struct file *f1 = allocate_file(&d, "file1", 3);
if (f1 == NULL) {
printf("Could not allocate space for file1\n");
exit(1);
}

// allocate space for other file
struct file *f2 = allocate_file(&d, "file2", 5);
if (f2 == NULL) {
printf("Could not allocate space for file2\n");
exit(1);
}

// free the 1st file
free_file(&d, f1);

// allocate space for a 3rd file
struct file *f3 = allocate_file(&d, "file3", 4);
if (f3 == NULL) {
printf("Could not allocate space for file3\n");
exit(1);
}

// free the 2nd  file
free_file(&d, f2);

// free the 3rd  file
free_file(&d, f3);

return 0;
}

In this case, we initialize the disk with 10 blocks and allot space for three files. After that, after making room for a third file, we release the remaining files before freeing the first file.

Output:

Here is the output of this program:$ ./contiguous_allocation

As you can see, the program produced no output, proving that everything worked as intended.

Contiguous file allocation can outperform other file allocation strategies in terms of performance, particularly for sequential access patterns. A file can be read or written more quickly than if its blocks were dispersed throughout the disc since they are all stored together in one contiguous area. Applications that conduct numerous sequential I/O operations, such as streaming video or music, may find this to be particularly helpful.

Contiguous file allocation could result in disk fragmentation, which is a possible drawback. It may become challenging to allocate continuous blocks of space for larger files if files are often created and removed since the disk may become fragmented and have small free spaces scattered all over it. The disc head's increased movement time required to access all the dispersed fragments might lead to wasted space and decreased performance.

Techniques like defragmentation can be used to reorganize the files on the disk and group the empty space into bigger blocks to solve this problem. A different file allocation method can better manage frequent file creation and deletion and result in less fragmentation like linked or indexed allocation. It is an alternative strategy.

Contiguous file allocation is subject to fragmentation as well as the potential inadequacy for really big files. Finding adequate contiguous blocks for very large files can be challenging, especially if the disk is already largely occupied with other files. It is because contiguous blocks of space must be discovered to allocate space for a file.

Contiguous file allocation can still be advantageous in some circumstances, such as when working with few files or when the disk is not anticipated to become highly fragmented, despite these drawbacks. You may build and implement file systems for your applications by understanding various file allocation algorithms' implementation specifics and tradeoffs.

It is crucial to carefully weigh the requirements and restrictions of various file allocation methods when building a file system for an application and select the one that best satisfies those requirements. Contiguous file allocation can be useful in your file system design toolkit because it offers a quick and effective approach to allocating space for files on a disk considering.

Conclusion:

This blog post covered the implementation of a contiguous file allocation program in C. We initialized the disk, allotted space for files, and released the space those files had taken up. We also defined the structures for keeping information about files and the disk. To assist you in understanding the implementation procedure, we also provided a sample main function and output. Contiguous file allocation is a practical method that can decrease fragmentation and speed up disk access. Still, it also has drawbacks, including a restriction on file size and difficulty allocating space for huge files. Therefore, weighing the advantages and disadvantages of various file allocation strategies is crucial before selecting one for a given application.

Overall, carefully considering the related data structures and algorithms is necessary to develop a contiguous file allocation program in C. However, if used appropriately, this strategy can offer a quick and effective way to allocate file disc space. After reading the sample code and explanations in this blog article, you thought to have a solid idea of how to create a contiguous file allocation program in C and how it functions in practice.

Next TopicENTRY CONTROL LOOP IN C

← prev next →