ranger - mirror of ranger - a simple, vim-like file manager

path: root/doc/pydoc/ranger.ext.accumulator.html

diff options

Diffstat (limited to 'doc/pydoc/ranger.ext.accumulator.html')

0 files changed, 0 insertions, 0 deletions

ik.com> 2015-04-23 20:42:17 -0700 committer Kartik K. Agaram <vc@akkartik.com> 2015-04-23 20:42:17 -0700 1153 - start of scheduler implementation' href='/akkartik/mu/commit/cpp/038scheduler?h=hlt&id=c475ccc380c7a17d088ae6fa17060d39c59ec5d1'>c475ccc3 ^

6ca059ef ^

b3899909 ^

ccba6718 ^

317c0a34 ^

ccba6718 ^

6ca059ef ^

89807038 ^

c76b49e7 ^

89807038 ^

6ca059ef ^

89807038 ^

b24eb476 ^

ec99eb7a ^

afbe301d ^

6573fe1f ^

2c7e84c2 ^

6573fe1f ^

d8509b41 ^

cea49fde ^

05d17773 ^

89807038 ^

d9a7e6ab ^

89807038 ^

c442a5ad ^

b3899909 ^

45ca3bb7 ^

7e7493b4 ^

89807038 ^

45ca3bb7 ^

89807038 ^

50bff0c5 ^

89807038 ^

89807038 ^

6c96a437 ^

6abdff27 ^

89807038 ^

89807038 ^

ac0e9db5 ^

b24eb476 ^

05d17773 ^

89807038 ^

05d17773 ^

89807038 ^

6ca059ef ^

31401373 ^

77017b6d ^

31401373 ^

77017b6d ^

6c96a437 ^

31401373 ^

795f5244 ^

31401373 ^

cea49fde ^

ae5f0b6f ^

8f0a9149 ^

6c96a437 ^

8f0a9149 ^

364b8f88 ^

78c50205 ^

7e8d0ba8 ^

8f0a9149 ^

cea49fde ^

8f0a9149 ^

cea49fde ^

5152d4ea ^

6d17ef49 ^

5152d4ea ^

5497090a ^

6d17ef49 ^

b24eb476 ^

6d17ef49 ^

b24eb476 ^

ec99eb7a ^

6d17ef49 ^

7fd01071 ^

6d17ef49 ^

45ca3bb7 ^

b24eb476 ^

45ca3bb7 ^

6ca059ef ^

5eddbc16 ^

6ca059ef ^

795f5244 ^

166e3c0d ^

5eddbc16 ^

166e3c0d ^

1b76245c ^

5db2faeb ^

7afe09fb ^

9dcbec39 ^

5db2faeb ^

166e3c0d ^

7f73795c ^

45ca3bb7 ^

5e14ce10 ^

3e3383e7 ^

cdf28227 ^

3473c63a ^

016599f1 ^

78a12c9d ^

1fa53058 ^

6d17ef49 ^

0487a30e ^

827898fc ^

6ca059ef ^

afbe301d ^

4a943d4e ^

5e14ce10 ^

a542b5a9 ^

4a943d4e ^

a542b5a9 ^

ccc5eb73 ^

78a12c9d ^

4a943d4e ^

82ceda30 ^

75a00270 ^

4a943d4e ^

75a00270 ^

1a33d221 ^

5f98a10c ^

75a00270 ^

45ca3bb7 ^

00b808d9 ^

4a943d4e ^

00b808d9 ^

45ca3bb7 ^

6c96a437 ^

45ca3bb7 ^

19695cc7 ^

00b808d9 ^

00b808d9 ^

45ca3bb7 ^

b24eb476 ^

6c96a437 ^

45ca3bb7 ^

82ceda30 ^

4a943d4e ^

82ceda30 ^

795f5244 ^

166e3c0d ^

82ceda30 ^

166e3c0d ^

2b250717 ^

e4630643 ^

7afe09fb ^

9dcbec39 ^

e4630643 ^

166e3c0d ^

b24eb476 ^

6c96a437 ^

05d17773 ^

82ceda30 ^

cfb142b9 ^

827898fc ^

82ceda30 ^

9d670bb5 ^

45ca3bb7 ^

9d670bb5 ^

134dad7c ^

795f5244 ^

166e3c0d ^

134dad7c ^

166e3c0d ^

2b250717 ^

e4630643 ^

7afe09fb ^

9dcbec39 ^

e4630643 ^

166e3c0d ^

b24eb476 ^

6c96a437 ^

134dad7c ^

a6cdf15c ^

795f5244 ^

166e3c0d ^

a6cdf15c ^

6c96a437 ^

00b808d9 ^

a6cdf15c ^

88e99894 ^

4a943d4e ^

88e99894 ^

c442a5ad ^

88e99894 ^

6abdff27 ^

2ada05dc ^

6abdff27 ^

6abdff27 ^

2ada05dc ^

6abdff27 ^

6abdff27 ^

6c96a437 ^

6abdff27 ^

88e99894 ^

b24eb476 ^

88e99894 ^

795f5244 ^

166e3c0d ^

88e99894 ^

166e3c0d ^

2b250717 ^

88e99894 ^

7afe09fb ^

9dcbec39 ^

88e99894 ^

7afe09fb ^

9dcbec39 ^

88e99894 ^

166e3c0d ^

b24eb476 ^

6c96a437 ^

88e99894 ^

94fed202 ^

d8c6265d ^

ccba6718 ^

d8c6265d ^

ccba6718 ^

d8c6265d ^

2b250717 ^

d8c6265d ^

6c96a437 ^

d8c6265d ^

ccba6718 ^

d8c6265d ^

27d90d80 ^

4a943d4e ^

9c184f02 ^

4a943d4e ^

1
2

24
25

41
42

60
61

64
65

75
76

81
82

83
84
85

88
89

106
107

108
109
110

125
126
127

142
143

153
154
155

158
159
160

162
163
164

173
174

177
178

195
196

261
262

344
345

370
371
372

392
393

396
397

398
399
400

409
410

440
441

444
445

450
451

453
454

455
456
457

460
461

463
464

466
467

473
474

477
478

494
495

501
502

505
506
507

508
509
510

554
555
556

577
578

581
582

585
586

604
605
606

685
686
687

//: Run a second routine concurrently using 'start-running', without any
//: guarantees on how the operations in each are interleaved with each other.

void test_scheduler() {
  run(
      "def f1 [\n"
      "  start-running f2\n"
         // wait for f2 to run
      "  {\n"
      "    jump-unless 1:num, -1\n"
      "  }\n"
      "]\n"
      "def f2 [\n"
      "  1:num <- copy 1\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "schedule: f1\n"
      "schedule: f2\n"
  );
}

//: first, add a deadline to run(routine)
:(before "End Globals")
int Scheduling_interval = 500;
:(before "End routine Fields")
int instructions_run_this_scheduling_slice;
:(before "End routine Constructor")
instructions_run_this_scheduling_slice = 0;
:(after "Running One Instruction")
 ++Current_routine->instructions_run_this_scheduling_slice;
:(replace{} "bool should_continue_running(const routine* current_routine)")
bool should_continue_running(const routine* current_routine) {
  assert(current_routine == Current_routine);  // argument passed in just to make caller readable above
  return Current_routine->state == RUNNING
      && Current_routine->instructions_run_this_scheduling_slice < Scheduling_interval;
}
:(after "stop_running_current_routine:")
// Reset instructions_run_this_scheduling_slice
Current_routine->instructions_run_this_scheduling_slice = 0;

//: now the rest of the scheduler is clean

:(before "struct routine")
enum routine_state {
  RUNNING,
  COMPLETED,
  // End routine States
};
:(before "End routine Fields")
enum routine_state state;
:(before "End routine Constructor")
state = RUNNING;

:(before "End Globals")
vector<routine*> Routines;
int Current_routine_index = 0;
:(before "End Reset")
Scheduling_interval = 500;
for (int i = 0;  i < SIZE(Routines);  ++i)
  delete Routines.at(i);
Routines.clear();
Current_routine = NULL;
:(replace{} "void run(const recipe_ordinal r)")
void run(const recipe_ordinal r) {
  run(new routine(r));
}

:(code)
void run(routine* rr) {
  Routines.push_back(rr);
  Current_routine_index = 0, Current_routine = Routines.at(0);
  while (!all_routines_done()) {
    skip_to_next_routine();
    assert(Current_routine);
    assert(Current_routine->state == RUNNING);
    trace(100, "schedule") << current_routine_label() << end();
    run_current_routine();
    // Scheduler State Transitions
    if (Current_routine->completed())
      Current_routine->state = COMPLETED;
    // End Scheduler State Transitions

    // Scheduler Cleanup
    // End Scheduler Cleanup
  }
  // End Run Routine
}

bool all_routines_done() {
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->state == RUNNING)
      return false;
  }
  return true;
}

// skip Current_routine_index past non-RUNNING routines
void skip_to_next_routine() {
  assert(!Routines.empty());
  assert(Current_routine_index < SIZE(Routines));
  for (int i = (Current_routine_index+1)%SIZE(Routines);  i != Current_routine_index;  i = (i+1)%SIZE(Routines)) {
    if (Routines.at(i)->state == RUNNING) {
      Current_routine_index = i;
      Current_routine = Routines.at(i);
      return;
    }
  }
}

string current_routine_label() {
  return routine_label(Current_routine);
}

string routine_label(routine* r) {
  ostringstream result;
  const call_stack& calls = r->calls;
  for (call_stack::const_iterator p = calls.begin();  p != calls.end();  ++p) {
    if (p != calls.begin()) result << '/';
    result << get(Recipe, p->running_recipe).name;
  }
  return result.str();
}

//: special case for the very first routine
:(replace{} "void run_main(int argc, char* argv[])")
void run_main(int argc, char* argv[]) {
  recipe_ordinal r = get(Recipe_ordinal, "main");
  assert(r);
  routine* main_routine = new routine(r);
  // pass in commandline args as ingredients to main
  // todo: test this
  Current_routine = main_routine;
  for (int i = 1;  i < argc;  ++i) {
    vector<double> arg;
    arg.push_back(/*alloc id*/0);
    arg.push_back(new_mu_text(argv[i]));
    assert(get(Memory, arg.back()) == 0);
    current_call().ingredient_atoms.push_back(arg);
  }
  run(main_routine);
}

//:: To schedule new routines to run, call 'start-running'.

//: 'start-running' will return a unique id for the routine that was created.
//: routine id is a number, but don't do any arithmetic on it
:(before "End routine Fields")
int id;
:(before "End Globals")
int Next_routine_id = 1;
:(before "End Reset")
Next_routine_id = 1;
:(before "End routine Constructor")
id = Next_routine_id;
++Next_routine_id;

//: routines save the routine that spawned them
:(before "End routine Fields")
// todo: really should be routine_id, but that's less efficient.
int parent_index;  // only < 0 if there's no parent_index
:(before "End routine Constructor")
parent_index = -1;

:(before "End Primitive Recipe Declarations")
START_RUNNING,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "start-running", START_RUNNING);
:(before "End Primitive Recipe Checks")
case START_RUNNING: {
  if (inst.ingredients.empty()) {
    raise << maybe(get(Recipe, r).name) << "'start-running' requires at least one ingredient: the recipe to start running\n" << end();
    break;
  }
  if (!is_mu_recipe(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'start-running' should be a recipe, but got '" << to_string(inst.ingredients.at(0)) << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case START_RUNNING: {
  routine* new_routine = new routine(ingredients.at(0).at(0));
  new_routine->parent_index = Current_routine_index;
  // populate ingredients
  for (int i = /*skip callee*/1;  i < SIZE(current_instruction().ingredients);  ++i) {
    new_routine->calls.front().ingredient_atoms.push_back(ingredients.at(i));
    reagent/*copy*/ ingredient = current_instruction().ingredients.at(i);
    new_routine->calls.front().ingredients.push_back(ingredient);
    // End Populate start-running Ingredient
  }
  Routines.push_back(new_routine);
  products.resize(1);
  products.at(0).push_back(new_routine->id);
  break;
}

:(code)
void test_scheduler_runs_single_routine() {
  Scheduling_interval = 1;
  run(
      "def f1 [\n"
      "  1:num <- copy 0\n"
      "  2:num <- copy 0\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "schedule: f1\n"
      "run: {1: \"number\"} <- copy {0: \"literal\"}\n"
      "schedule: f1\n"
      "run: {2: \"number\"} <- copy {0: \"literal\"}\n"
  );
}

void test_scheduler_interleaves_routines() {
  Scheduling_interval = 1;
  run(
      "def f1 [\n"
      "  start-running f2\n"
      "  1:num <- copy 0\n"
      "  2:num <- copy 0\n"
      "]\n"
      "def f2 [\n"
      "  3:num <- copy 0\n"
      "  4:num <- copy 0\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "schedule: f1\n"
      "run: start-running {f2: \"recipe-literal\"}\n"
      "schedule: f2\n"
      "run: {3: \"number\"} <- copy {0: \"literal\"}\n"
      "schedule: f1\n"
      "run: {1: \"number\"} <- copy {0: \"literal\"}\n"
      "schedule: f2\n"
      "run: {4: \"number\"} <- copy {0: \"literal\"}\n"
      "schedule: f1\n"
      "run: {2: \"number\"} <- copy {0: \"literal\"}\n"
  );
}

void test_start_running_takes_ingredients() {
  run(
      "def f1 [\n"
      "  start-running f2, 3\n"
         // wait for f2 to run
      "  {\n"
      "    jump-unless 1:num, -1\n"
      "  }\n"
      "]\n"
      "def f2 [\n"
      "  1:num <- next-ingredient\n"
      "  2:num <- add 1:num, 1\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 4 in location 2\n"
  );
}

//: type-checking for 'start-running'

void test_start_running_checks_types() {
  Hide_errors = true;
  run(
      "def f1 [\n"
      "  start-running f2, 3\n"
      "]\n"
      "def f2 n:&:num [\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "error: f1: ingredient 0 has the wrong type at 'start-running f2, 3'\n"
  );
}

// 'start-running' only uses the ingredients of the callee, not its products
:(before "End is_indirect_call_with_ingredients Special-cases")
if (r == START_RUNNING) return true;

//: back to testing 'start-running'

:(code)
void test_start_running_returns_routine_id() {
  run(
      "def f1 [\n"
      "  1:num <- start-running f2\n"
      "]\n"
      "def f2 [\n"
      "  12:num <- copy 44\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 2 in location 1\n"
  );
}

//: this scenario requires some careful setup
void test_scheduler_skips_completed_routines() {
  recipe_ordinal f1 = load(
      "recipe f1 [\n"
      "  1:num <- copy 0\n"
      "]\n").front();
  recipe_ordinal f2 = load(
      "recipe f2 [\n"
      "  2:num <- copy 0\n"
      "]\n").front();
  Routines.push_back(new routine(f1));  // f1 meant to run
  Routines.push_back(new routine(f2));
  Routines.back()->state = COMPLETED;  // f2 not meant to run
  run(
      "def f3 [\n"
      "  3:num <- copy 0\n"
      "]\n"
  );
  // f1 and f3 can run in any order
  CHECK_TRACE_CONTENTS(
      "schedule: f1\n"
      "mem: storing 0 in location 1\n"
  );
  CHECK_TRACE_DOESNT_CONTAIN("schedule: f2");
  CHECK_TRACE_DOESNT_CONTAIN("mem: storing 0 in location 2");
  CHECK_TRACE_CONTENTS(
      "schedule: f3\n"
      "mem: storing 0 in location 3\n"
  );
}

void test_scheduler_starts_at_middle_of_routines() {
  Routines.push_back(new routine(COPY));
  Routines.back()->state = COMPLETED;
  run(
      "def f1 [\n"
      "  1:num <- copy 0\n"
      "  2:num <- copy 0\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "schedule: f1\n"
  );
  CHECK_TRACE_DOESNT_CONTAIN("run: idle");
}

//:: Errors in a routine cause it to terminate.

void test_scheduler_terminates_routines_after_errors() {
  Hide_errors = true;
  Scheduling_interval = 2;
  run(
      "def f1 [\n"
      "  start-running f2\n"
      "  1:num <- copy 0\n"
      "  2:num <- copy 0\n"
      "]\n"
      "def f2 [\n"
         // divide by 0 twice
      "  3:num <- divide-with-remainder 4, 0\n"
      "  4:num <- divide-with-remainder 4, 0\n"
      "]\n"
  );
  // f2 should stop after first divide by 0
  CHECK_TRACE_CONTENTS(
      "error: f2: divide by zero in '3:num <- divide-with-remainder 4, 0'\n"
  );
  CHECK_TRACE_DOESNT_CONTAIN("error: f2: divide by zero in '4:num <- divide-with-remainder 4, 0'");
}

:(after "operator<<(ostream& os, end /*unused*/)")
  if (Trace_stream && Trace_stream->curr_label == "error" && Current_routine) {
    Current_routine->state = COMPLETED;
  }

//:: Routines are marked completed when their parent completes.

:(code)
void test_scheduler_kills_orphans() {
  run(
      "def main [\n"
      "  start-running f1\n"
         // f1 never actually runs because its parent completes without
         // waiting for it
      "]\n"
      "def f1 [\n"
      "  1:num <- copy 0\n"
      "]\n"
  );
  CHECK_TRACE_DOESNT_CONTAIN("schedule: f1");
}

:(before "End Scheduler Cleanup")
for (int i = 0;  i < SIZE(Routines);  ++i) {
  if (Routines.at(i)->state == COMPLETED) continue;
  if (Routines.at(i)->parent_index < 0) continue;  // root thread
  // structured concurrency: http://250bpm.com/blog:71
  if (has_completed_parent(i)) {
    Routines.at(i)->state = COMPLETED;
  }
}

:(code)
bool has_completed_parent(int routine_index) {
  for (int j = routine_index;  j >= 0;  j = Routines.at(j)->parent_index) {
    if (Routines.at(j)->state == COMPLETED)
      return true;
  }
  return false;
}

//:: 'routine-state' can tell if a given routine id is running

void test_routine_state_test() {
  Scheduling_interval = 2;
  run(
      "def f1 [\n"
      "  1:num/child-id <- start-running f2\n"
      "  12:num <- copy 0\n"  // race condition since we don't care about location 12
         // thanks to Scheduling_interval, f2's one instruction runs in
         // between here and completes
      "  2:num/state <- routine-state 1:num/child-id\n"
      "]\n"
      "def f2 [\n"
      "  12:num <- copy 0\n"
         // trying to run a second instruction marks routine as completed
      "]\n"
  );
  // routine f2 should be in state COMPLETED
  CHECK_TRACE_CONTENTS(
      "mem: storing 1 in location 2\n"
  );
}

:(before "End Primitive Recipe Declarations")
ROUTINE_STATE,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "routine-state", ROUTINE_STATE);
:(before "End Primitive Recipe Checks")
case ROUTINE_STATE: {
  if (SIZE(inst.ingredients) != 1) {
    raise << maybe(get(Recipe, r).name) << "'routine-state' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
    break;
  }
  if (!is_mu_number(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'routine-state' should be a routine id generated by 'start-running', but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case ROUTINE_STATE: {
  int id = ingredients.at(0).at(0);
  int result = -1;
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->id == id) {
      result = Routines.at(i)->state;
      break;
    }
  }
  products.resize(1);
  products.at(0).push_back(result);
  break;
}

//:: miscellaneous helpers

:(before "End Primitive Recipe Declarations")
STOP,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "stop", STOP);
:(before "End Primitive Recipe Checks")
case STOP: {
  if (SIZE(inst.ingredients) != 1) {
    raise << maybe(get(Recipe, r).name) << "'stop' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
    break;
  }
  if (!is_mu_number(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'stop' should be a routine id generated by 'start-running', but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case STOP: {
  int id = ingredients.at(0).at(0);
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->id == id) {
      Routines.at(i)->state = COMPLETED;
      break;
    }
  }
  break;
}

:(before "End Primitive Recipe Declarations")
_DUMP_ROUTINES,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "$dump-routines", _DUMP_ROUTINES);
:(before "End Primitive Recipe Checks")
case _DUMP_ROUTINES: {
  break;
}
:(before "End Primitive Recipe Implementations")
case _DUMP_ROUTINES: {
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    cerr << i << ": " << Routines.at(i)->id << ' ' << Routines.at(i)->state << ' ' << Routines.at(i)->parent_index << '\n';
  }
  break;
}

//: support for stopping routines after some number of cycles

:(code)
void test_routine_discontinues_past_limit() {
  Scheduling_interval = 2;
  run(
      "def f1 [\n"
      "  1:num/child-id <- start-running f2\n"
      "  limit-time 1:num/child-id, 10\n"
         // padding loop just to make sure f2 has time to complete
      "  2:num <- copy 20\n"
      "  2:num <- subtract 2:num, 1\n"
      "  jump-if 2:num, -2:offset\n"
      "]\n"
      "def f2 [\n"
      "  jump -1:offset\n"  // run forever
      "  $print [should never get here], 10/newline\n"
      "]\n"
  );
  // f2 terminates
  CHECK_TRACE_CONTENTS(
      "schedule: discontinuing routine 2\n"
  );
}

:(before "End routine States")
DISCONTINUED,
:(before "End Scheduler State Transitions")
if (Current_routine->limit >= 0) {
  if (Current_routine->limit <= Scheduling_interval) {
    trace(100, "schedule") << "discontinuing routine " << Current_routine->id << end();
    Current_routine->state = DISCONTINUED;
    Current_routine->limit = 0;
  }
  else {
    Current_routine->limit -= Scheduling_interval;
  }
}

:(before "End Test Teardown")
if (Passed && any_routines_with_error())
  raise << "some routines died with errors\n" << end();
:(before "End Mu Test Teardown")
if (Passed && any_routines_with_error())
  raise << Current_scenario->name << ": some routines died with errors\n" << end();

:(code)
bool any_routines_with_error() {
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->state == DISCONTINUED)
      return true;
  }
  return false;
}

:(before "End routine Fields")
int limit;
:(before "End routine Constructor")
limit = -1;  /* no limit */

:(before "End Primitive Recipe Declarations")
LIMIT_TIME,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "limit-time", LIMIT_TIME);
:(before "End Primitive Recipe Checks")
case LIMIT_TIME: {
  if (SIZE(inst.ingredients) != 2) {
    raise << maybe(get(Recipe, r).name) << "'limit-time' requires exactly two ingredient, but got '" << to_original_string(inst) << "'\n" << end();
    break;
  }
  if (!is_mu_number(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'limit-time' should be a routine id generated by 'start-running', but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    break;
  }
  if (!is_mu_number(inst.ingredients.at(1))) {
    raise << maybe(get(Recipe, r).name) << "second ingredient of 'limit-time' should be a number (of instructions to run for), but got '" << inst.ingredients.at(1).original_string << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case LIMIT_TIME: {
  int id = ingredients.at(0).at(0);
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->id == id) {
      Routines.at(i)->limit = ingredients.at(1).at(0);
      break;
    }
  }
  break;
}

:(before "End routine Fields")
int instructions_run;
:(before "End routine Constructor")
instructions_run = 0;
:(before "Reset instructions_run_this_scheduling_slice")
Current_routine->instructions_run += Current_routine->instructions_run_this_scheduling_slice;
:(before "End Primitive Recipe Declarations")
NUMBER_OF_INSTRUCTIONS,
:(before "End Primitive Recipe Numbers")
put(Recipe_ordinal, "number-of-instructions", NUMBER_OF_INSTRUCTIONS);
:(before "End Primitive Recipe Checks")
case NUMBER_OF_INSTRUCTIONS: {
  if (SIZE(inst.ingredients) != 1) {
    raise << maybe(get(Recipe, r).name) << "'number-of-instructions' requires exactly one ingredient, but got '" << to_original_string(inst) << "'\n" << end();
    break;
  }
  if (!is_mu_number(inst.ingredients.at(0))) {
    raise << maybe(get(Recipe, r).name) << "first ingredient of 'number-of-instructions' should be a routine id generated by 'start-running', but got '" << inst.ingredients.at(0).original_string << "'\n" << end();
    break;
  }
  break;
}
:(before "End Primitive Recipe Implementations")
case NUMBER_OF_INSTRUCTIONS: {
  int id = ingredients.at(0).at(0);
  int result = -1;
  for (int i = 0;  i < SIZE(Routines);  ++i) {
    if (Routines.at(i)->id == id) {
      result = Routines.at(i)->instructions_run;
      break;
    }
  }
  products.resize(1);
  products.at(0).push_back(result);
  break;
}

:(code)
void test_number_of_instructions() {
  run(
      "def f1 [\n"
      "  10:num/child-id <- start-running f2\n"
      "  {\n"
      "    loop-unless 20:num\n"
      "  }\n"
      "  11:num <- number-of-instructions 10:num\n"
      "]\n"
      "def f2 [\n"
         // 2 instructions worth of work
      "  1:num <- copy 34\n"
      "  20:num <- copy 1\n"
      "]\n"
  );
  // f2 runs an extra instruction for the implicit 'return' added by the
  // fill_in_return_ingredients transform
  CHECK_TRACE_CONTENTS(
      "mem: storing 3 in location 11\n"
  );
}

void test_number_of_instructions_across_multiple_scheduling_intervals() {
  Scheduling_interval = 1;
  run(
      "def f1 [\n"
      "  10:num/child-id <- start-running f2\n"
      "  {\n"
      "    loop-unless 20:num\n"
      "  }\n"
      "  11:num <- number-of-instructions 10:num\n"
      "]\n"
      "def f2 [\n"
         // 4 instructions worth of work
      "  1:num <- copy 34\n"
      "  2:num <- copy 1\n"
      "  2:num <- copy 3\n"
      "  20:num <- copy 1\n"
      "]\n"
  );
  // f2 runs an extra instruction for the implicit 'return' added by the
  // fill_in_return_ingredients transform
  CHECK_TRACE_CONTENTS(
      "mem: storing 5 in location 11\n"
  );
}

//:: make sure that each routine gets a different alloc to start

void test_new_concurrent() {
  run(
      "def f1 [\n"
      "  start-running f2\n"
      "  1:&:num/raw <- new number:type\n"
         // wait for f2 to complete
      "  {\n"
      "    loop-unless 4:num/raw\n"
      "  }\n"
      "]\n"
      "def f2 [\n"
      "  2:&:num/raw <- new number:type\n"
         // hack: assumes scheduler implementation
      "  3:bool/raw <- equal 1:&:num/raw, 2:&:num/raw\n"
         // signal f2 complete
      "  4:num/raw <- copy 1\n"
      "]\n"
  );
  CHECK_TRACE_CONTENTS(
      "mem: storing 0 in location 3\n"
  );
}


context:
space:
mode: