Programming lesson
Mastering C Process Management and Custom Heap Allocation: A Step-by-Step Guide for CS 444/544
Learn to build a Makefile, use fork(), exec() variants, and implement your own malloc with brk()/sbrk() for CS 444/544. Includes trend-inspired examples from modern AI apps and gaming.
Introduction: Why Process Management and Heap Allocation Matter in 2026
In the world of systems programming, understanding process creation and memory management is as fundamental as knowing how to use a smartphone. With the rise of AI applications, real-time gaming engines, and high-frequency trading platforms, efficient memory allocation and process control have never been more critical. This tutorial is designed to help you ace the CS 444/544 programming projects 1–5, focusing on building a robust Makefile, mastering fork() and exec() functions, and implementing your own heap manager (beavalloc). By the end, you'll have the skills to tackle similar challenges in any low-level programming environment.
Project 1: The Makefile – Your Project's Backbone
A well-structured Makefile ensures your code compiles consistently. For this assignment, you need a single Makefile that builds all C programs in one directory. The commands make clean and make all must work flawlessly. Here's a template to get you started:
CC = gcc
CFLAGS = -Wall -Wextra -g
all: fork_demo fork_file fork_hello exec_ls beavalloc
fork_demo: fork_demo.c
$(CC) $(CFLAGS) -o fork_demo fork_demo.c
fork_file: fork_file.c
$(CC) $(CFLAGS) -o fork_file fork_file.c
fork_hello: fork_hello.c
$(CC) $(CFLAGS) -o fork_hello fork_hello.c
exec_ls: exec_ls.c
$(CC) $(CFLAGS) -o exec_ls exec_ls.c
beavalloc: beavalloc.c main.c
$(CC) $(CFLAGS) -o beavalloc beavalloc.c main.c
clean:
rm -f fork_demo fork_file fork_hello exec_ls beavalloc
Notice the use of -Wall -Wextra flags. These help catch potential bugs early. Always test with make clean && make all before submitting.
Project 2: Fork and Variable Behavior
When you call fork(), the child process gets a copy of the parent's memory. Let's see what happens with a variable xx. The parent initializes xx = 100 before fork. After fork, both processes have their own xx. Changing xx in one process does not affect the other. Here's a code snippet:
#include <stdio.h>
#include <unistd.h>
int main() {
int xx = 100;
pid_t pid = fork();
if (pid == 0) { // child
xx = 777;
printf("Child: xx = %d\n", xx);
} else { // parent
xx = 999;
printf("Parent: xx = %d\n", xx);
}
return 0;
}
Output will show the child prints 777 and parent prints 999. The variable xx in each process is independent. This concept is similar to how a multiplayer game server spawns separate player instances – each player's score is independent.
Project 3: File Sharing After Fork
When both parent and child write to the same file, their writes can interleave. The file descriptor is shared, but the kernel ensures each write() is atomic for small writes. However, using fprintf() may cause interleaving. Here's an example:
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
FILE *fp = fopen("JUNK.txt", "w");
fprintf(fp, "before fork\n");
pid_t pid = fork();
if (pid == 0) {
for (int i = 0; i < 10; i++)
fprintf(fp, "child\n");
} else {
for (int i = 0; i < 10; i++)
fprintf(fp, "parent\n");
wait(NULL);
}
fclose(fp);
return 0;
}
Because both processes run concurrently, the output may have mixed lines. This is like two AI agents writing to a shared log – without synchronization, the order is unpredictable.
Project 4: Ensuring Child Prints First Without wait()
To guarantee child prints before parent without using wait() or busy loops, you can use a pipe or signal. A simple trick: use a pipe to synchronize. The child writes to the pipe after printing, and the parent reads from the pipe before printing. Here's how:
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
int pipefd[2];
pipe(pipefd);
pid_t pid = fork();
if (pid == 0) {
printf("hello\n");
write(pipefd[1], "x", 1); // signal parent
close(pipefd[1]);
} else {
char c;
read(pipefd[0], &c, 1); // wait for child
printf("goodbye\n");
close(pipefd[0]);
}
return 0;
}
The parent blocks on read() until the child writes. This is similar to how a mobile app waits for a server response before updating the UI.
Project 5: Using exec() Variants
The exec() family replaces the current process image with a new program. You need to call ls -l -F -h using execl(), execlp(), execv(), and execvp(). The parent must wait for the child. Here's an example:
#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
pid_t pid = fork();
if (pid == 0) {
// execl: path, arg0, arg1, ..., NULL
execl("/bin/ls", "ls", "-l", "-F", "-h", NULL);
// execlp: searches PATH
// execlp("ls", "ls", "-l", "-F", "-h", NULL);
// execv: array of args
// char *args[] = {"ls", "-l", "-F", "-h", NULL};
// execv("/bin/ls", args);
// execvp: searches PATH
// execvp("ls", args);
perror("exec failed");
return 1;
} else {
wait(NULL);
printf("Child finished\n");
}
return 0;
}
The differences: execl and execv require full path; execlp and execvp use the PATH environment variable. This is like launching a game from Steam – you can either specify the exact executable path or rely on the system to find it.
Heap Management: Building Your Own beavalloc
Now for the most challenging part: implementing your own malloc using brk()/sbrk(). You'll write beavalloc(), beavfree(), beavcalloc(), and beavrealloc(). The key is to manage a free list using a first-fit algorithm. Here's a simplified structure:
typedef struct block {
size_t size;
int free;
struct block *next;
struct block *prev;
} block_t;
#define BLOCK_SIZE sizeof(block_t)
#define HEAP_SIZE 1024
block_t *free_list = NULL;
void *beavalloc(size_t size) {
if (size == 0) return NULL;
// Align size to 8 bytes
size = (size + 7) & ~7;
block_t *curr = free_list;
// First-fit search
while (curr != NULL) {
if (curr->free && curr->size >= size) {
// Split if large enough
if (curr->size > size + BLOCK_SIZE + 8) {
block_t *new_block = (block_t *)((char *)curr + BLOCK_SIZE + size);
new_block->size = curr->size - size - BLOCK_SIZE;
new_block->free = 1;
new_block->next = curr->next;
new_block->prev = curr;
if (curr->next) curr->next->prev = new_block;
curr->next = new_block;
curr->size = size;
}
curr->free = 0;
return (void *)(curr + 1);
}
curr = curr->next;
}
// No suitable block, request more heap
void *new_heap = sbrk(HEAP_SIZE);
if (new_heap == (void *)-1) {
errno = ENOMEM;
return NULL;
}
block_t *new_block = (block_t *)new_heap;
new_block->size = HEAP_SIZE - BLOCK_SIZE;
new_block->free = 1;
new_block->next = free_list;
new_block->prev = NULL;
if (free_list) free_list->prev = new_block;
free_list = new_block;
// Now try again recursively
return beavalloc(size);
}
void beavfree(void *ptr) {
if (ptr == NULL) return;
block_t *block = (block_t *)ptr - 1;
block->free = 1;
// Coalesce with next block if free
if (block->next && block->next->free) {
block->size += BLOCK_SIZE + block->next->size;
block->next = block->next->next;
if (block->next) block->next->prev = block;
}
// Coalesce with previous block if free
if (block->prev && block->prev->free) {
block->prev->size += BLOCK_SIZE + block->size;
block->prev->next = block->next;
if (block->next) block->next->prev = block->prev;
}
}
This implementation uses a doubly linked list. When beavalloc is called, it scans for a free block that fits. If the block is much larger, it splits. If no block fits, it requests more memory via sbrk(1024). The beavfree function marks the block free and coalesces adjacent free blocks to reduce fragmentation.
Remember to implement beavcalloc by calling beavalloc and zeroing memory, and beavrealloc by allocating a new block, copying data, and freeing the old one.
Testing Your beavalloc
Use the provided main.c with tests. Run them individually to debug. A common pitfall is not aligning memory correctly or not handling edge cases like size 0. Also, ensure your Makefile includes the correct flags.
Connecting to Real-World Trends
In 2026, custom memory allocators are used in game engines like Unreal Engine 5 to manage assets efficiently, and in AI frameworks like TensorFlow to reduce allocation overhead. Understanding fork() is crucial for server applications that spawn worker processes, similar to how a streaming service handles multiple user requests. These skills are timeless and highly valued in systems programming roles at companies like Apple, Google, and Microsoft.
Conclusion
By completing these projects, you've gained hands-on experience with process management and heap allocation. You now know how to write a Makefile, use fork() and exec(), and implement a custom allocator. These are foundational skills for any serious C programmer. Keep practicing, and don't hesitate to ask questions – the journey is as important as the destination.