Merge mermaid diagrams and other cahos

Author: xFrednet

src/lang/interpreter.cc

@@ -501,14 +501,6 @@ namespace verona::interpreter
       rt::core::behavior_ptr behavior_)
     : ui(ui_), behavior(behavior_)
     {
-      // FIXME: Oh no, we need to set the local region before running this but
-      // the interpreter would then need to know about behaviors right?
-      // Maybe not? What if the scheduler sets the behavior before doing this?
-      // That could work, I don't like it but it could
-      //
-      // Looking at this, I believe it would be better to let the interpreter
-      // know about behaviors
-
       // There is a question where the active behavior should be set.
       //
       // Python mixes the runtime and interpreter a bit more. There the runtime
@@ -631,6 +623,21 @@ namespace verona::interpreter
     rt::post_run(initial, ui);
   }
 
+  Scheduler::Scheduler()
+  {
+    auto ui = rt::ui::globalUI();
+    assert(ui->is_mermaid());
+    reinterpret_cast<rt::ui::MermaidUI*>(ui)->scheduler_ready_list =
+      &this->ready;
+  }
+
+  Scheduler::~Scheduler()
+  {
+    auto ui = rt::ui::globalUI();
+    assert(ui->is_mermaid());
+    reinterpret_cast<rt::ui::MermaidUI*>(ui)->scheduler_ready_list = nullptr;
+  }
+
   void Scheduler::add(rt::core::behavior_ptr behavior)
   {
     assert(behavior->status == rt::core::Behavior::Status::New);
@@ -751,10 +758,13 @@ namespace verona::interpreter
       this->next_schedule_msg.reset();
     }
 
+    // FIXME: We should really get wrid of the UI* abstraction. There is no way
+    // that we'll ever change the output at this point and it just makes several
+    // things harder, like this:
     auto ui = rt::ui::globalUI();
     assert(ui->is_mermaid());
     auto mermaid = reinterpret_cast<rt::ui::MermaidUI*>(ui);
-    mermaid->draw_schedule(this->ready, message);
+    mermaid->output(message);
     mermaid->close_file();
   }
 

src/lang/interpreter.h

@@ -14,11 +14,6 @@ namespace rt::objects
   class DynObject;
 } // namespace rt::objects
 
-namespace rt::ui
-{
-  class ScheduleDiagram;
-}
-
 namespace verona::interpreter
 {
   class Interpreter;
@@ -76,6 +71,9 @@ namespace verona::interpreter
     Interpreter* current_int;
 
   public:
+    Scheduler();
+    ~Scheduler();
+
     void add(rt::core::behavior_ptr behavior);
 
     void start(Bytecode* main);

src/rt/behavior.h

@@ -20,7 +20,6 @@ namespace rt::objects
 namespace rt::ui
 {
   class MermaidUI;
-  class ScheduleDiagram;
   class ObjectGraphDiagram;
 }
 
@@ -30,7 +29,6 @@ namespace rt::core
   class Behavior
   {
     friend class rt::ui::MermaidUI;
-    friend class rt::ui::ScheduleDiagram;
     friend class rt::ui::ObjectGraphDiagram;
 
   public:
@@ -66,16 +64,6 @@ namespace rt::core
     static std::shared_ptr<Behavior> get_active_behavior();
 
   private:
-    // This map is a collection of all behaviors that have started running and
-    // therefore also have a local region. This is needed here for the lovely
-    // mermaid output. This uses an ordered map in the hope that the diagram
-    // will keep the same layout every iteration.
-    //
-    // It uses behavior pointers since it's being updated from inside methods
-    // where `this` is a pointer and not a `shared_ptr`. This should be fine
-    // since each behavior should call `complete()` before being freed thereby
-    // also updating this list.
-    static std::map<int, Behavior*> s_running_behaviors;
     static std::shared_ptr<Behavior> s_active_behavior;
 
   private:

src/rt/core/behavior.cc

@@ -14,7 +14,6 @@ namespace rt::objects
 namespace rt::core
 {
   int Behavior::s_behavior_counter = 0;
-  std::map<int, Behavior*> Behavior::s_running_behaviors = {};
   std::shared_ptr<Behavior> Behavior::s_active_behavior = nullptr;
 
   void Behavior::set_active_behavior(std::shared_ptr<Behavior> active)
@@ -79,9 +78,6 @@ namespace rt::core
 
     this->local_region = objects::Region::new_local_region();
 
-    // Add self to running behaviors to have it also drawn as a local region.
-    s_running_behaviors[this->id] = this;
-
     return rt::try_get_bytecode(this->code).value();
   }
 
@@ -108,7 +104,5 @@ namespace rt::core
         cown_deps.erase(cown);
       }
     }
-
-    this->s_running_behaviors.erase(this->id);
   }
 } // namespace rt::core

src/rt/rt.cc

@@ -251,13 +251,8 @@ namespace rt
       std::cout << "Final count: " << objects::DynObject::get_count()
                 << std::endl;
 
-      std::vector<objects::DynObject*> roots;
-      for (auto obj : objects::DynObject::get_objects())
-      {
-        roots.push_back(obj);
-      }
       ui::MermaidUI::highlight_unreachable = true;
-      ui->output(roots, "Memory leak detected!");
+      ui->output("Memory leak detected!");
 
       std::exit(1);
     }

src/rt/ui.h

@@ -41,7 +41,6 @@ namespace rt::core
 namespace rt::ui
 {
   class MermaidDiagram;
-  class ScheduleDiagram;
   class ObjectGraphDiagram;
 
   class MermaidUI : public UI
@@ -50,9 +49,13 @@ namespace rt::ui
     static inline bool pragma_draw_regions_nested = true;
     static inline bool highlight_unreachable = false;
 
+    // This feels really wrong, but is the easiest fix rn. The list should
+    // probably always be passed in to the `output()` call but that would
+    // require more refactorings
+    std::vector<rt::core::behavior_ptr>* scheduler_ready_list;
+
   private:
     friend class ObjectGraphDiagram;
-    friend class ScheduleDiagram;
     friend class MermaidDiagram;
     friend void core::mermaid_builtins(ui::UI* ui);
 
@@ -104,9 +107,6 @@ namespace rt::ui
       std::vector<objects::DynObject*>& roots, std::string message) override;
     void output(std::string message) override;
 
-    void draw_schedule(
-      std::vector<core::behavior_ptr> behaviors, std::string message);
-
     void highlight(
       std::string message,
       std::vector<objects::DynObject*>& highlight) override;