process_b.c

 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <time.h>
 
typedef struct {
    uint32_t train_id;
    uint32_t position;
    uint8_t signal_state;
    uint8_t emergency_stop;
    uint16_t speed_limit;
    uint32_t timestamp_ms;
    uint32_t checksum;
    uint32_t sequence_number;
} train_command_t;
 
typedef struct {
    train_command_t cmd_a;
    train_command_t cmd_b;
    train_command_t cmd_a_out;
    train_command_t cmd_b_out;
    volatile uint32_t a_ready;
    volatile uint32_t b_ready;
    volatile uint32_t a_compared;
    volatile uint32_t b_compared;
    volatile uint8_t outputs_match;
    uint32_t mismatch_count;
    uint32_t sequence;
    uint32_t timestamp_ms;
} shared_state_t;
 
__attribute__((aligned(64)))
extern shared_state_t shared_mem;
 
typedef struct {
    uint32_t train_id;
    uint32_t position;
} train_db_entry_t;
 
static train_db_entry_t trains[] = {
    { .train_id = 101, .position = 500 },
    { .train_id = 102, .position = 2500 },
    { .train_id = 103, .position = 7500 },
};
 
#define TRAIN_COUNT (sizeof(trains) / sizeof(trains[0]))
 
static uint32_t crc32(const uint8_t *data, uint32_t len)
{
    uint32_t crc = 0xffffffff;
    for (uint32_t i = 0; i < len; i++) {
        uint8_t byte = data[i];
        crc = (crc >> 8) ^ (uint32_t)(crc ^ byte);
    }
    return crc ^ 0xffffffff;
}
 
static train_command_t compute_command(uint32_t train_id, uint32_t position)
{
    train_command_t cmd = {
        .train_id = train_id,
        .position = position,
        .emergency_stop = 0,
        .timestamp_ms = (uint32_t)(time(NULL) * 1000) & 0xffffffff,
        .sequence_number = 0,
    };
 
    if (position < 1000) {
        cmd.signal_state = 2;
        cmd.speed_limit = 80;
    } else if (position < 5000) {
        cmd.signal_state = 1;
        cmd.speed_limit = 40;
    } else if (position < 9000) {
        cmd.signal_state = 0;
        cmd.speed_limit = 0;
    } else {
        cmd.emergency_stop = 1;
        cmd.signal_state = 0;
        cmd.speed_limit = 0;
    }
 
    uint8_t *cmd_bytes = (uint8_t *)&cmd;
    cmd.checksum = crc32(cmd_bytes, sizeof(cmd) - sizeof(cmd.checksum));
    return cmd;
}
 
static train_command_t safe_state(uint32_t train_id)
{
    train_command_t safe = {
        .train_id = train_id,
        .position = 0,
        .signal_state = 0,
        .emergency_stop = 1,
        .speed_limit = 0,
        .timestamp_ms = 0,
        .checksum = 0,
        .sequence_number = 0,
    };
    return safe;
}
 
static void compare_and_decide(const train_command_t *my_cmd,
                                const train_command_t *other_cmd,
                                train_command_t *output,
                                uint8_t *match_status)
{
    /* IDENTICAL logic to Process A */
    if (my_cmd->train_id == other_cmd->train_id &&
        my_cmd->position == other_cmd->position &&
        my_cmd->signal_state == other_cmd->signal_state &&
        my_cmd->speed_limit == other_cmd->speed_limit) {
 
        *output = *my_cmd;
        *match_status = 1;
 
    } else {
 
        *output = safe_state(my_cmd->train_id);
        *match_status = 0;
    }
}
 
int main(int argc, char *argv[])
{
    (void)argc;
    (void)argv;
 
    uint32_t cycle_count = 0;
    uint32_t sequence = 0;
 
    fprintf(stderr,
            "┌────────────────────────────────────────────────────────┐\n");
    fprintf(stderr,
            "│ Process B - Cross-Comparison (Peer-to-Peer 2oo2)       │\n");
    fprintf(stderr,
            "│ Mirrors Process A, independent comparison              │\n");
    fprintf(stderr,
            "└────────────────────────────────────────────────────────┘\n");
    fprintf(stderr, "\n");
 
    while (1) {
        cycle_count++;
        sequence++;
 
        /* PHASE 1: Compute independently */
        for (uint32_t i = 0; i < TRAIN_COUNT; i++) {
            trains[i].position += (i + 1) * 3;
            if (trains[i].position > 10000) {
                trains[i].position = 10000;
            }
        }
 
        for (uint32_t i = 0; i < TRAIN_COUNT; i++) {
            train_command_t cmd = compute_command(
                trains[i].train_id,
                trains[i].position
            );
            cmd.sequence_number = sequence;
 
            shared_mem.cmd_b = cmd;
            __sync_synchronize();
            shared_mem.b_ready = 1;
 
            if (cycle_count % 10 == 0) {
                fprintf(stderr,
                        "[WEST:B] Cycle %u: Computed train=%u, pos=%u, sig=%u, speed=%u\n",
                        cycle_count, cmd.train_id, cmd.position,
                        cmd.signal_state, cmd.speed_limit);
            }
        }
 
        /* PHASE 2: Wait for A's computation */
        uint32_t timeout_ms = 0;
        while (!shared_mem.a_ready && timeout_ms < 25) {
            usleep(1000);
            timeout_ms++;
        }
 
        if (!shared_mem.a_ready) {
            fprintf(stderr, "[WEST:B] ERROR: Process A timeout\n");
            continue;
        }
 
        /* PHASE 3: Cross-comparison (identical logic to A) */
        train_command_t output;
        uint8_t match_status;
 
        compare_and_decide(
            &shared_mem.cmd_b,
            &shared_mem.cmd_a,
            &output,
            &match_status
        );
 
        shared_mem.cmd_b_out = output;
        __sync_synchronize();
        shared_mem.b_compared = 1;
 
        if (cycle_count % 10 == 0) {
            fprintf(stderr,
                    "[WEST:B] Received A's: train=%u, sig=%u, speed=%u\n",
                    shared_mem.cmd_a.train_id,
                    shared_mem.cmd_a.signal_state,
                    shared_mem.cmd_a.speed_limit);
 
            fprintf(stderr,
                    "[WEST:B] Comparison: %s\n",
                    match_status ? "MATCH ✓" : "MISMATCH ✗");
 
            fprintf(stderr,
                    "[WEST:B] Output: sig=%u, speed=%u\n",
                    output.signal_state, output.speed_limit);
        }
 
        /* PHASE 4: Verify A reached same decision */
        timeout_ms = 0;
        while (!shared_mem.a_compared && timeout_ms < 10) {
            usleep(1000);
            timeout_ms++;
        }
 
        if (shared_mem.a_compared) {
            if (shared_mem.cmd_a_out.signal_state == shared_mem.cmd_b_out.signal_state &&
                shared_mem.cmd_a_out.speed_limit == shared_mem.cmd_b_out.speed_limit) {
 
                shared_mem.outputs_match = 1;
 
            } else {
 
                shared_mem.outputs_match = 0;
                shared_mem.mismatch_count++;
 
                fprintf(stderr,
                        "[WEST:B] ⚠️  ALERT: A's output differs!\n");
                fprintf(stderr,
                        "         A output: sig=%u, speed=%u\n",
                        shared_mem.cmd_a_out.signal_state,
                        shared_mem.cmd_a_out.speed_limit);
                fprintf(stderr,
                        "         B output: sig=%u, speed=%u\n",
                        shared_mem.cmd_b_out.signal_state,
                        shared_mem.cmd_b_out.speed_limit);
            }
        }
 
        /* Reset for next cycle */
        shared_mem.b_ready = 0;
        shared_mem.b_compared = 0;
 
        usleep(25000);
    }
 
    return EXIT_SUCCESS;
}