Codexion

Codexion is a pthread-based concurrency simulation built for the 42 curriculum. Each coder thread repeats this cycle:

1. wait for scheduler turn
2. acquire two dongles
3. compile
4. debug
5. refactor

If a coder does not compile again before its burnout timeout, the monitor marks it as burned out and stops the whole simulation.

Build

cd coders
make

Useful targets:

make clean
make fclean
make re

Run

./codexion <coders> <burnout_ms> <compile_ms> <debug_ms> <refactor_ms> <required_compilations> <dongle_cooldown_ms> <scheduler>

Rules enforced by the parser:

• exactly 8 arguments after the executable name
• all numeric values must be positive integers
• scheduler must be fifo or edf

Arguments

Argument	Meaning
coders	number of coder threads
burnout_ms	max time allowed since last successful compile
compile_ms	duration of compile phase
debug_ms	duration of debug phase
refactor_ms	duration of refactor phase
required_compilations	compile count required per coder before success
dongle_cooldown_ms	cooldown applied to both dongles after release
scheduler	fifo or edf

Examples

# FIFO run
./codexion 5 800 120 80 80 3 20 fifo

# EDF run
./codexion 5 800 120 80 80 3 20 edf

# Single coder edge case: only one dongle is reachable, so burnout is expected
./codexion 1 300 120 80 80 2 20 fifo

Synchronization Model

• Dongles are mutexes arranged in a ring (one left dongle per coder, right dongle points to a neighbor).
• To reduce deadlock risk, odd and even coders lock in opposite order.
• Print output is serialized with a dedicated mutex.
• Global stop state is protected by a mutex.
• Per-coder compile time and compile count are mutex-protected.

Scheduler Modes

• fifo:
  • coders receive monotonically increasing tickets
  • only the now_serving ticket may proceed
  • condition-variable broadcast wakes waiters when a turn finishes
• edf:
  • coders enqueue with deadline = last_compiled_time + burnout_ms
  • min-heap picks earliest deadline first
  • each coder has its own condition variable, broadcast on dongle release

Burnout and Completion

• Monitor thread checks coders in a loop every 1 ms.
• Burnout condition is:
  • current_time - last_compiled_time > burnout_ms
• On burnout, output includes burned out, then stop_all is set.
• If all coders reach required_compilations, simulation stops cleanly.
• After a successful completion, the program prints:

All <number_of_coders> number of coders compiled <required_compilations> times!

Notes

• Timekeeping uses gettimeofday-based millisecond values.
• Sleep is implemented as a short-loop usleep(500) for finer timing control.