~ /phase-1
Phase I · Process-based parallelism

Split the matrix, fork the work.

Phase I sets up the Linux environment and runs the first experiments with process-based parallelism. The provided C program divides matrix multiplication among child processes. We vary only the matrix size and the number of processes, and time every run.

C · GCC 11.4fork() / wait()Ubuntu 24.04 ARM646 configurations × 3 runs
See the results Read the report

The phase in four steps#

Build the environment#

Create an Ubuntu 24.04 ARM64 virtual machine in UTM with 4 cores and 4 GB of RAM, then install the build tools. VM & Linux setup →

Compile and verify#

Compile matrix_fork.c with gcc -Wall, run it, and confirm it prints an execution time with no warnings or crashes. Build & run →

Run controlled experiments#

Test N = 1200, 1800 and 2400 with PROCS = 1 and 4, three runs each, on an otherwise idle VM. Experiment plan →

Analyze and report#

Compute averages, speedup, efficiency and overhead, and explain the trends. Results →

Objectives#

Environment setup#

Configure a Linux VM so that experiments are reproducible and controlled.

Clean compilation#

Compile and run the provided C program without warnings or runtime errors.

Understand processes#

Analyze how fork() and wait() produce process-based parallel execution.

Measure performance#

Time the program under different values of N and PROCS.

Collect data#

Record structured performance data for analysis and reporting.

Report#

Explain the setup, results and scaling behaviour in a written analysis.

Scope of work#

Observation, not optimization

The provided source code is used without structural changes. Only two parameters change: the matrix size N and the number of processes PROCS. The goal is to analyze the program's behaviour, not to rewrite or optimize the algorithm.

Outcome#

Phase I produced:

  • a reliable, documented experimental environment,
  • baseline performance data for process-based parallelism,
  • a structured evaluation method that Phase II builds on.

The central finding is that four processes never beat one at these matrix sizes. Process overhead outweighed the parallel work. Phase II asks the same question again, this time with Java threads.