From 65361948ca7975553757a0e0df4ac7352413044c Mon Sep 17 00:00:00 2001 From: "Kartik K. Agaram" Date: Thu, 14 May 2015 16:04:45 -0700 Subject: 1376 - update github docs --- html/039wait.cc.html | 106 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 74 insertions(+), 32 deletions(-) (limited to 'html/039wait.cc.html') diff --git a/html/039wait.cc.html b/html/039wait.cc.html index feb7e536..687cd207 100644 --- a/html/039wait.cc.html +++ b/html/039wait.cc.html @@ -2,7 +2,7 @@ -Mu - 039wait.cc +~/Desktop/s/mu/039wait.cc @@ -14,11 +14,12 @@ pre { white-space: pre-wrap; font-family: monospace; color: #d0d0d0; background- body { font-family: monospace; color: #d0d0d0; background-color: #000000; } * { font-size: 1em; } .cSpecial { color: #008000; } +.Identifier { color: #008080; } .Constant { color: #008080; } .Comment { color: #8080ff; } .Delimiter { color: #c000c0; } .Special { color: #ff6060; } -.Identifier { color: #008080; } +.CommentedCode { color: #6c6c6c; } .traceContains { color: #008000; } --> @@ -38,14 +39,14 @@ body { font-family: monospace; color: #d0d0d0; background-color: #000000; } :(scenario wait_for_location) recipe f1 [ - 1:integer <- copy 0:literal + 1:number <- copy 0:literal start-running f2:recipe - wait-for-location 1:integer + wait-for-location 1:number # now wait for f2 to run and modify location 1 before using its value - 2:integer <- copy 1:integer + 2:number <- copy 1:number ] recipe f2 [ - 1:integer <- copy 34:literal + 1:number <- copy 34:literal ] # if we got the synchronization wrong we'd be storing 0 in location 2 +mem: storing 34 in location 2 @@ -57,9 +58,9 @@ WAITING, :(before "End routine Fields") // only if state == WAITING index_t waiting_on_location; -int old_value_of_wating_location; +int old_value_of_waiting_location; :(before "End routine Constructor") -waiting_on_location = old_value_of_wating_location = 0; +waiting_on_location = old_value_of_waiting_location = 0; //: primitive recipe to put routines in that state @@ -69,11 +70,12 @@ WAIT_FOR_LOCATION, Recipe_number["wait-for-location"] = WAIT_FOR_LOCATION; :(before "End Primitive Recipe Implementations") case WAIT_FOR_LOCATION: { - reagent loc = canonize(current_instruction().ingredients[0]); + reagent loc = canonize(current_instruction().ingredients.at(0)); Current_routine->state = WAITING; Current_routine->waiting_on_location = loc.value; - Current_routine->old_value_of_wating_location = Memory[loc.value]; + Current_routine->old_value_of_waiting_location = Memory[loc.value]; trace("run") << "waiting for location " << loc.value << " to change from " << Memory[loc.value]; +//? trace("schedule") << Current_routine->id << ": waiting for location " << loc.value << " to change from " << Memory[loc.value]; //? 2 break; } @@ -81,28 +83,38 @@ case WAIT_FOR_LOCATION: { :(before "End Scheduler State Transitions") for (index_t i = 0; i < Routines.size(); ++i) { - if (Routines[i]->state != WAITING) continue; - if (Memory[Routines[i]->waiting_on_location] && - Memory[Routines[i]->waiting_on_location] != Routines[i]->old_value_of_wating_location) { +//? trace("schedule") << "wake up loop 1: routine " << Routines.at(i)->id << " has state " << Routines.at(i)->state; //? 1 + if (Routines.at(i)->state != WAITING) continue; +//? trace("schedule") << "waiting on location: " << Routines.at(i)->waiting_on_location; //? 1 +//? if (Routines.at(i)->waiting_on_location) //? 2 +//? trace("schedule") << "checking routine " << Routines.at(i)->id << " waiting on location " //? 2 +//? << Routines.at(i)->waiting_on_location << ": " << Memory[Routines.at(i)->waiting_on_location] << " vs " << Routines.at(i)->old_value_of_waiting_location; //? 2 + if (Routines.at(i)->waiting_on_location && + Memory[Routines.at(i)->waiting_on_location] != Routines.at(i)->old_value_of_waiting_location) { trace("schedule") << "waking up routine\n"; - Routines[i]->state = RUNNING; - Routines[i]->waiting_on_location = Routines[i]->old_value_of_wating_location = 0; + Routines.at(i)->state = RUNNING; + Routines.at(i)->waiting_on_location = Routines.at(i)->old_value_of_waiting_location = 0; } } -//: also allow waiting on a routine +//: also allow waiting on a routine to stop running :(scenario wait_for_routine) recipe f1 [ - 1:integer <- copy 0:literal - 2:integer/routine <- start-running f2:recipe - wait-for-routine 2:integer/routine + 1:number <- copy 0:literal + 12:number/routine <- start-running f2:recipe + wait-for-routine 12:number/routine # now wait for f2 to run and modify location 1 before using its value - 3:integer <- copy 1:integer + 3:number <- copy 1:number ] recipe f2 [ - 1:integer <- copy 34:literal + 1:number <- copy 34:literal ] ++schedule: f1 ++run: waiting for routine 2 ++schedule: f2 ++schedule: waking up routine 1 ++schedule: f1 # if we got the synchronization wrong we'd be storing 0 in location 3 +mem: storing 34 in location 3 @@ -118,28 +130,58 @@ WAIT_FOR_ROUTINE, Recipe_number["wait-for-routine"] = WAIT_FOR_ROUTINE; :(before "End Primitive Recipe Implementations") case WAIT_FOR_ROUTINE: { - reagent loc = canonize(current_instruction().ingredients[0]); Current_routine->state = WAITING; - Current_routine->waiting_on_routine = loc.value; - trace("run") << "waiting for routine " << loc.value; + assert(ingredients.at(0).size() == 1); // scalar + Current_routine->waiting_on_routine = ingredients.at(0).at(0); + trace("run") << "waiting for routine " << ingredients.at(0).at(0); break; } :(before "End Scheduler State Transitions") +// Wake up any routines waiting for other routines to go to sleep. +// Important: this must come after the scheduler loop above giving routines +// waiting for locations to change a chance to wake up. for (index_t i = 0; i < Routines.size(); ++i) { - if (Routines[i]->state != WAITING) continue; - if (!Routines[i]->waiting_on_routine) continue; - index_t id = Routines[i]->waiting_on_routine; - assert(id != i); + if (Routines.at(i)->state != WAITING) continue; + if (!Routines.at(i)->waiting_on_routine) continue; + index_t id = Routines.at(i)->waiting_on_routine; + assert(id != Routines.at(i)->id); for (index_t j = 0; j < Routines.size(); ++j) { - if (Routines[j]->id == id && Routines[j]->state != WAITING) { - trace("schedule") << "waking up routine\n"; - Routines[i]->state = RUNNING; - Routines[i]->waiting_on_routine = 0; + if (Routines.at(j)->id == id && Routines.at(j)->state != RUNNING) { + trace("schedule") << "waking up routine " << Routines.at(i)->id; + Routines.at(i)->state = RUNNING; + Routines.at(i)->waiting_on_routine = 0; } } } +:(before "End Primitive Recipe Declarations") +SWITCH, +:(before "End Primitive Recipe Numbers") +Recipe_number["switch"] = SWITCH; +:(before "End Primitive Recipe Implementations") +case SWITCH: { + index_t id = some_other_running_routine(); + if (id) { + assert(id != Current_routine->id); +//? cerr << "waiting on " << id << " from " << Current_routine->id << '\n'; //? 1 + Current_routine->state = WAITING; + Current_routine->waiting_on_routine = id; + } + break; +} + +:(code) +index_t some_other_running_routine() { + for (index_t i = 0; i < Routines.size(); ++i) { + if (i == Current_routine_index) continue; + assert(Routines.at(i) != Current_routine); + assert(Routines.at(i)->id != Current_routine->id); + if (Routines.at(i)->state == RUNNING) + return Routines.at(i)->id; + } + return 0; +} -- cgit 1.4.1-2-gfad0