Refactor large integer multiplication program

Author: XuhuaHuang

OperatingSystem/large_integer_multiplication.c

@@ -4,7 +4,7 @@
  * @brief Demonstrates large integer multiplication via recursive decomposition,
  * delegating sub-multiplications to a child process over a pair of pipes.
  *
- * Usage: ./large_mul <a> <b>   (both values must be in [1000, 9999])
+ * Usage: ./large_mul <a> <b> (both values must be in [1000, 9999])
  *
  * @version 0.1
  * @date 2026-02-20
@@ -20,58 +20,26 @@
 #include <unistd.h>
 
 /**
- * @brief Signed 64-bit integer for intermediate values
+ * @brief Signed 64-bit integer used for all intermediate and final values.
  */
 typedef long long ll_t;
 
-/* A simple two-element message sent across either pipe. */
-typedef struct {
-  ll_t x;
-  ll_t y;
-} pair_t;
-
-/**
- * @brief Write a pair_t struct atomically to a file descriptor.
- *
- * @param fd The file descriptor to write to.
- * @param p The pair_t struct to write.
- * @return int 0 on success, -1 on failure
- */
-static int write_pair(int fd, pair_t p) {
-  // `write` may not write all bytes in one call, but for small structs it is atomic on pipes.
-  // it returns the number of bytes actually written, which may be less than sizeof(pair_t) if an error occurs.
-  ssize_t n = write(fd, &p, sizeof(pair_t));
-  if (n != (ssize_t)sizeof(pair_t)) {
-    perror("write_pair: write");
-    return -1;
-  }
-  return 0;
+static inline void print_calc(const char* label) {
+  printf("\n");
+  printf("#################\n");
+  printf("# Calculating %s #\n", label);
+  printf("#################\n");
+  return;
 }
 
 /**
- * @brief Read a pair_t struct atomically from a file descriptor.
+ * @brief Write a single ll_t value atomically to a file descriptor.
  *
- * @param fd The file descriptor to read from.
- * @param p The pair_t struct to store the read values.
- * @return int 0 on success, -1 on failure
+ * @param fd  Destination file descriptor.
+ * @param v   Value to transmit.
+ * @return int 0 on success, -1 on failure.
  */
-static int read_pair(int fd, pair_t* p) {
-  ssize_t n = read(fd, p, sizeof(pair_t));
-  if (n != (ssize_t)sizeof(pair_t)) {
-    perror("read_pair: read");
-    return -1;
-  }
-  return 0;
-}
-
-/**
- * @brief Write a signed 64-bit integer atomically to a file descriptor.
- *
- * @param fd The file descriptor to write to.
- * @param v The value to write.
- * @return int 0 on success, -1 on failure
- */
-static int write_ll(int fd, ll_t v) {
+static inline int write_ll(int fd, ll_t v) {
   ssize_t n = write(fd, &v, sizeof(ll_t));
   if (n != (ssize_t)sizeof(ll_t)) {
     perror("write_ll: write");
@@ -81,13 +49,13 @@ static int write_ll(int fd, ll_t v) {
 }
 
 /**
- * @brief Read a signed 64-bit integer atomically from a file descriptor.
+ * @brief Read a single ll_t value atomically from a file descriptor.
  *
- * @param fd The file descriptor to read from.
- * @param v The point to store the read value in.
- * @return int 0 on success, -1 on failure
+ * @param fd  Source file descriptor.
+ * @param v   Pointer to store the received value.
+ * @return int 0 on success, -1 on failure.
  */
-static int read_ll(int fd, ll_t* v) {
+static inline int read_ll(int fd, ll_t* v) {
   ssize_t n = read(fd, v, sizeof(ll_t));
   if (n != (ssize_t)sizeof(ll_t)) {
     perror("read_ll: read");
@@ -97,28 +65,45 @@ static int read_ll(int fd, ll_t* v) {
 }
 
 /**
- * @brief The child waits for four pair_t messages, multiplies each pair, and
- * returns the ll_t result back to the parent.  After the fourth result it
- * closes its pipe ends and exits cleanly.
+ * @brief Child event loop: receives two operands individually, multiplies
+ * them, and returns the product.  Repeats for @p rounds iterations before
+ * closing its pipe ends and exiting cleanly.
  *
- * @param pipe_in read-end of the parent to child pipe
- * @param pipe_out write-end of the child to parent pipe
+ * @param pipe_in   Read-end of the parent-to-child pipe.
+ * @param pipe_out  Write-end of the child-to-parent pipe.
+ * @param rounds    Number of multiplication jobs to process.
  */
-static void run_child(int pipe_in, int pipe_out) {
-  for (int i = 0; i < 4; ++i) {
-    pair_t operands;
-    if (read_pair(pipe_in, &operands) != 0) {
-      fprintf(stderr, "child: failed to read operands (round %d)\n", i + 1);
+static void run_child(int pipe_in, int pipe_out, int rounds) {
+  pid_t curr_pid   = getpid();
+  pid_t parent_pid = getppid();
+
+  for (int i = 0; i < rounds; ++i) {
+    ll_t x = 0, y = 0;
+
+    if (read_ll(pipe_in, &x) != 0) {
+      fprintf(
+        stderr, "Child (PID %d, PPID %d): failed to read first operand (round %d)\n", curr_pid, parent_pid, i + 1
+      );
       exit(EXIT_FAILURE);
     }
+    printf("Child (PID %d, PPID %d): Received %lld from parent\n", curr_pid, parent_pid, x);
+    fflush(stdout);
 
-    ll_t product = operands.x * operands.y;
+    if (read_ll(pipe_in, &y) != 0) {
+      fprintf(
+        stderr, "Child (PID %d, PPID %d): failed to read second operand (round %d)\n", curr_pid, parent_pid, i + 1
+      );
+      exit(EXIT_FAILURE);
+    }
+    printf("Child (PID %d, PPID %d): Received %lld from parent\n", curr_pid, parent_pid, y);
+    fflush(stdout);
 
-    printf("[child]  round %d: %lld * %lld = %lld\n", i + 1, operands.x, operands.y, product);
+    ll_t product = x * y;
+    printf("Child (PID %d, PPID %d): Sending %lld to parent\n", curr_pid, parent_pid, product);
     fflush(stdout);
 
     if (write_ll(pipe_out, product) != 0) {
-      fprintf(stderr, "child: failed to write result (round %d)\n", i + 1);
+      fprintf(stderr, "Child (PID %d PPID %d): failed to write result (round %d)\n", curr_pid, parent_pid, i + 1);
       exit(EXIT_FAILURE);
     }
   }
@@ -128,23 +113,48 @@ static void run_child(int pipe_in, int pipe_out) {
   exit(EXIT_SUCCESS);
 }
 
-static ll_t send_and_receive(int pipe_out, int pipe_in, ll_t x, ll_t y) {
-  pair_t job = {x, y};
-  if (write_pair(pipe_out, job) != 0) {
-    fprintf(stderr, "parent: failed to send job (%lld, %lld)\n", x, y);
+/**
+ * @brief Send two operands to the child individually and await the product.
+ *
+ * Each operand is transmitted as a distinct ll_t write so the child can
+ * log its receipt of each value independently, matching the expected output
+ * protocol.
+ *
+ * @param p_write    Write-end of the parent-to-child pipe.
+ * @param p_read     Read-end of the child-to-parent pipe.
+ * @param x          First operand.
+ * @param y          Second operand.
+ * @param parent_pid PID of the parent process, for logging.
+ * @return ll_t      The product returned by the child.
+ */
+static ll_t send_and_receive(int p_write, int p_read, ll_t x, ll_t y, pid_t parent_pid) {
+  printf("Parent (PID %d): Sending %lld to child\n", parent_pid, x);
+  fflush(stdout);
+  if (write_ll(p_write, x) != 0) {
+    fprintf(stderr, "Parent (PID %d): failed to send %lld\n", parent_pid, x);
+    exit(EXIT_FAILURE);
+  }
+
+  printf("Parent (PID %d): Sending %lld to child\n", parent_pid, y);
+  fflush(stdout);
+  if (write_ll(p_write, y) != 0) {
+    fprintf(stderr, "Parent (PID %d): failed to send %lld\n", parent_pid, y);
     exit(EXIT_FAILURE);
   }
 
   ll_t result = 0;
-  if (read_ll(pipe_in, &result) != 0) {
-    fprintf(stderr, "parent: failed to read result for (%lld, %lld)\n", x, y);
+  if (read_ll(p_read, &result) != 0) {
+    fprintf(stderr, "Parent (PID %d): failed to read result for (%lld, %lld)\n", parent_pid, x, y);
     exit(EXIT_FAILURE);
   }
+  printf("Parent (PID %d): Received %lld from child\n", parent_pid, result);
+  fflush(stdout);
+
   return result;
 }
 
 int main(int argc, char* argv[]) {
-  /* --- Argument validation ------------------------------------------ */
+  /* Argument validation */
   if (argc != 3) {
     fprintf(stderr, "Usage: %s <a> <b>\n", argv[0]);
     fprintf(stderr, "  Both arguments must be integers in the range [1000, 9999].\n");
@@ -164,17 +174,16 @@ int main(int argc, char* argv[]) {
     return EXIT_FAILURE;
   }
 
-  /* --- Decompose a and b -------------------------------------------- */
-  ll_t a1 = a / 100; /* high two digits of a */
-  ll_t a2 = a % 100; /* low  two digits of a */
-  ll_t b1 = b / 100; /* high two digits of b */
-  ll_t b2 = b % 100; /* low  two digits of b */
-
-  printf("[parent] a=%lld  =>  a1=%lld, a2=%lld\n", a, a1, a2);
-  printf("[parent] b=%lld  =>  b1=%lld, b2=%lld\n", b, b1, b2);
+  printf("Your integers are %lld %lld\n", a, b);
   fflush(stdout);
 
-  /* --- Establish pipes ----------------------------------------------- */
+  /* Decompose a and b */
+  ll_t a1 = a / 100; // first two digits of a, integer division truncates
+  ll_t a2 = a % 100; // last two digits of a
+  ll_t b1 = b / 100; // firsttwo digits of b
+  ll_t b2 = b % 100; // last two digits of b
+
+  /* Establish pipes */
   int parent_to_child[2]; /* parent writes, child reads  */
   int child_to_parent[2]; /* child  writes, parent reads */
 
@@ -183,49 +192,60 @@ int main(int argc, char* argv[]) {
     return EXIT_FAILURE;
   }
 
-  /* --- Fork ---------------------------------------------------------- */
+  /* Fork */
   pid_t pid = fork();
   if (pid < 0) {
     perror("fork");
     return EXIT_FAILURE;
   }
 
+  /* Most importanat part of the program */
+  // Identify the child process and run the child event loop
   if (pid == 0) {
-    /* ---- Child ---- */
+    /* Child */
+    // Close unused pipe ends in the child thread for hygiene and to avoid accidental misuse.
     close(parent_to_child[1]); /* child does not write to this pipe  */
     close(child_to_parent[0]); /* child does not read  from this pipe */
 
-    run_child(parent_to_child[0], child_to_parent[1]);
+    run_child(parent_to_child[0], child_to_parent[1], /* rounds = */ 4);
     /* run_child never returns */
   }
 
-  /* ---- Parent ---- */
+  /* Parent */
+  pid_t parent_pid = getpid();
+
   close(parent_to_child[0]); /* parent does not read from this pipe  */
   close(child_to_parent[1]); /* parent does not write to this pipe   */
 
   int p_write = parent_to_child[1];
   int p_read  = child_to_parent[0];
 
-  /* Round 1: A = a1 * b1  =>  X = A * 10^4 */
-  ll_t A = send_and_receive(p_write, p_read, a1, b1);
+  printf("Parent (PID %d): created child (PID %d)\n", parent_pid, pid);
+  fflush(stdout);
+
+  /* Round 1: X = (a1 * b1) * 10^4 */
+  print_calc("X");
+  fflush(stdout);
+
+  ll_t A = send_and_receive(p_write, p_read, a1, b1, parent_pid);
   ll_t X = A * 10000LL;
-  printf("[parent] A = a1*b1 = %lld  =>  X = A*10^4 = %lld\n", A, X);
 
-  /* Round 2: B = a2 * b1 */
-  ll_t B = send_and_receive(p_write, p_read, a2, b1);
-  printf("[parent] B = a2*b1 = %lld\n", B);
+  /* Round 2 & 3: Y = (a1*b2 + a2*b1) * 10^2 */
+  print_calc("Y");
+  fflush(stdout);
 
-  /* Round 3: C = a1 * b2  =>  Y = (B + C) * 10^2 */
-  ll_t C = send_and_receive(p_write, p_read, a1, b2);
+  ll_t B = send_and_receive(p_write, p_read, a1, b2, parent_pid);
+  ll_t C = send_and_receive(p_write, p_read, a2, b1, parent_pid);
   ll_t Y = (B + C) * 100LL;
-  printf("[parent] C = a1*b2 = %lld  =>  Y = (B+C)*10^2 = %lld\n", C, Y);
 
-  /* Round 4: D = a2 * b2  =>  Z = D * 10^0 */
-  ll_t D = send_and_receive(p_write, p_read, a2, b2);
+  /* Round 4: Z = a2 * b2 */
+  print_calc("Z");
+  fflush(stdout);
+
+  ll_t D = send_and_receive(p_write, p_read, a2, b2, parent_pid);
   ll_t Z = D;
-  printf("[parent] D = a2*b2 = %lld  =>  Z = D = %lld\n", D, Z);
 
-  /* --- Close pipe ends and reap child -------------------------------- */
+  /* Close pipe ends and reap child */
   close(p_write);
   close(p_read);
 
@@ -235,11 +255,10 @@ int main(int argc, char* argv[]) {
     fprintf(stderr, "Warning: child process did not exit cleanly.\n");
   }
 
-  /* --- Final computation -------------------------------------------- */
+  /* Final result */
   ll_t result = X + Y + Z;
 
-  printf("\n[parent] X + Y + Z = %lld + %lld + %lld = %lld\n", X, Y, Z, result);
-  printf("[parent] Verification: %lld * %lld = %lld\n", a, b, a * b);
+  printf("\n%lld * %lld == %lld + %lld + %lld == %lld\n", a, b, X, Y, Z, result);
 
   return EXIT_SUCCESS;
 }