Instructions

Instruction type definitions for thread execution

Instructions

The Instructions object defines all instruction types supported by the simulator. Each instruction type represents an atomic operation that a thread can perform.

Instruction Types

All instruction types are exported as string constants:

instructions.js

export const Instructions = {
  ACQUIRE: "acquire",
  WITHDRAW: "withdraw",
  DEPOSIT: "deposit",
  RELEASE: "release",
  WAIT_SEM: "wait_sem",
  PRINT: "print",
  SIGNAL_SEM: "signal_sem",
  WAIT_FOOD: "wait_food",
  EAT_FOOD: "eat_food",
  COOK_DISH: "cook_dish",
  SIGNAL_FOOD: "signal_food",
  ENTER_READ: "enter_read",
  READ_BOOK: "read_book",
  EXIT_READ: "exit_read",
  ENTER_WRITE: "enter_write",
  UPDATE_CATALOG: "update_catalog",
  EXIT_WRITE: "exit_write",
  RUN_STAGE: "run_stage",
  BARRIER_WAIT: "barrier_wait",
  BUILD_STAGE: "build_stage",
  JOIN_THREAD: "join_thread",
  AWAIT_ALL: "await_all",
  COMPLETE_HOUSE: "complete_house",
  PETERSON_LOCK: "peterson_lock",
  USE_STATION: "use_station",
  PETERSON_UNLOCK: "peterson_unlock",
  END: "end"
};

Instruction Categories

Mutex Instructions

ACQUIRE - Attempt to acquire mutex

Tries to lock the mutex. Blocks if already locked.

{ type: Instructions.ACQUIRE }

Blocking: Yes (if mutex is locked)

RELEASE - Release mutex

Unlocks the mutex and transfers ownership to next waiting thread.

{ type: Instructions.RELEASE }

Blocking: No

Bank Account Instructions

WITHDRAW - Withdraw money

Removes money from shared account balance.

{ type: Instructions.WITHDRAW, amount: 100 }

amount · number · required

Amount to withdraw (capped at available balance)

Blocking: No

DEPOSIT - Deposit money

Adds money to shared account balance.

{ type: Instructions.DEPOSIT, amount: 50 }

amount · number · required

Amount to deposit

Blocking: No

Semaphore Instructions

WAIT_SEM - Wait on semaphore

Attempts to acquire a token and printer. Blocks if none available.

{ type: Instructions.WAIT_SEM }

Blocking: Yes (if count is 0)

PRINT - Print pages

Simulates printing work on assigned printer.

{ type: Instructions.PRINT, pages: 10 }

pages · number · required

Number of pages to print

Blocking: No

SIGNAL_SEM - Signal semaphore

Releases printer and token. May transfer to waiting thread.

{ type: Instructions.SIGNAL_SEM }

Blocking: No

Condition Variable Instructions

WAIT_FOOD - Wait for food

Customer waits for available dish. Blocks if none ready.

{ type: Instructions.WAIT_FOOD }

Blocking: Yes (if no dishes available)

EAT_FOOD - Eat food

Consumes reserved dish.

{ type: Instructions.EAT_FOOD }

Blocking: No

COOK_DISH - Cook dish

Chef prepares one dish.

{ type: Instructions.COOK_DISH }

Blocking: No

SIGNAL_FOOD - Signal food ready

Chef notifies one waiting customer.

{ type: Instructions.SIGNAL_FOOD }

Blocking: No

Monitor Instructions

ENTER_READ - Enter as reader

Request read access to library catalog. Multiple readers allowed.

{ type: Instructions.ENTER_READ }

Blocking: Yes (if writer is active)

READ_BOOK - Read from catalog

Simulates reading operation.

{ type: Instructions.READ_BOOK }

Blocking: No

EXIT_READ - Exit as reader

Release read access.

{ type: Instructions.EXIT_READ }

Blocking: No

ENTER_WRITE - Enter as writer

Request exclusive write access.

{ type: Instructions.ENTER_WRITE }

Blocking: Yes (if any readers or writer active)

UPDATE_CATALOG - Update catalog

Modifies catalog (increments version).

{ type: Instructions.UPDATE_CATALOG }

Blocking: No

EXIT_WRITE - Exit as writer

Release write access.

{ type: Instructions.EXIT_WRITE }

Blocking: No

Barrier Instructions

RUN_STAGE - Run race stage

Advance through race segment.

{ type: Instructions.RUN_STAGE }

Blocking: No

BARRIER_WAIT - Wait at barrier

Wait at checkpoint until all racers arrive.

{ type: Instructions.BARRIER_WAIT }

Blocking: Yes (until all participants arrive)

Join/Await Instructions

BUILD_STAGE - Build construction stage

Complete one stage of house construction.

{ type: Instructions.BUILD_STAGE, stageName: "Foundation", duration: 3 }

stageName · string · required

Name of construction stage

duration · number · required

Number of ticks to complete

Blocking: No

JOIN_THREAD - Join on single thread

Wait for specific thread to finish.

{ type: Instructions.JOIN_THREAD, targetName: "Worker-1" }

targetName · string · required

Name of thread to wait for

Blocking: Yes (until target finishes)

AWAIT_ALL - Await multiple threads

Wait for all specified threads to finish.

{ type: Instructions.AWAIT_ALL, targets: ["Worker-1", "Worker-2"] }

targets · Array<string> · required

Array of thread names to wait for

Blocking: Yes (until all targets finish)

COMPLETE_HOUSE - Complete house

Final delivery marker.

{ type: Instructions.COMPLETE_HOUSE }

Blocking: No

Peterson’s Algorithm Instructions

PETERSON_LOCK - Lock with Peterson

Acquire station using Peterson’s algorithm.

{ type: Instructions.PETERSON_LOCK, robotId: 0 }

robotId · number · required

Robot identifier (0 or 1)

Blocking: Yes (busy-wait until lock acquired)

USE_STATION - Use robot station

Perform work at shared station.

{ type: Instructions.USE_STATION }

Blocking: No

PETERSON_UNLOCK - Unlock with Peterson

Release station using Peterson’s algorithm.

{ type: Instructions.PETERSON_UNLOCK, robotId: 0 }

robotId · number · required

Robot identifier (0 or 1)

Blocking: No

Control Flow Instructions

END - End thread execution

Explicitly mark thread as finished.

{ type: Instructions.END }

Blocking: No (terminates thread)

Usage in Scenarios

Bank Account (Mutex)

const client = new Thread("Client-1", [
  { type: Instructions.ACQUIRE },
  { type: Instructions.WITHDRAW, amount: 100 },
  { type: Instructions.RELEASE }
]);

Printer Control (Semaphore)

const job = new Thread("Job-1", [
  { type: Instructions.WAIT_SEM },
  { type: Instructions.PRINT, pages: 10 },
  { type: Instructions.SIGNAL_SEM }
]);

Restaurant (Condition Variable)

const customer = new Thread("Customer-1", [
  { type: Instructions.WAIT_FOOD },
  { type: Instructions.EAT_FOOD }
]);

const chef = new Thread("Chef", [
  { type: Instructions.COOK_DISH },
  { type: Instructions.SIGNAL_FOOD }
]);

Related Documentation

• Engine - Instruction execution logic
• Thread - Thread model with program counter
• Scenarios - How instructions are used in scenarios