simplify the way Jbods are defined

diff --git a/examples/cpp/plugin-jbod/s4u-plugin-jbod.cpp b/examples/cpp/plugin-jbod/s4u-plugin-jbod.cpp
index 5f6b4ab..a3cb9e8 100644 (file)
--- a/examples/cpp/plugin-jbod/s4u-plugin-jbod.cpp
+++ b/examples/cpp/plugin-jbod/s4u-plugin-jbod.cpp
@@ -41,23 +41,23 @@ int main(int argc, char** argv)
 
   auto* jbod_raid0 =
     simgrid::plugin::Jbod::create_jbod(zone, "jbod_raid0", 1e9, 4, simgrid::plugin::Jbod::RAID::RAID0, 1e7, 5e6);
-  zone->add_route(host, jbod_raid0, {link});
+  zone->add_route(host, jbod_raid0->get_controller(), {link});
 
   auto* jbod_raid1 =
     simgrid::plugin::Jbod::create_jbod(zone, "jbod_raid1", 1e9, 4, simgrid::plugin::Jbod::RAID::RAID1, 1e7, 5e6);
-  zone->add_route(host, jbod_raid1, {link});
+  zone->add_route(host, jbod_raid1->get_controller(), {link});
 
   auto* jbod_raid4 =
     simgrid::plugin::Jbod::create_jbod(zone, "jbod_raid4", 1e9, 4, simgrid::plugin::Jbod::RAID::RAID4, 1e7, 5e6);
-  zone->add_route(host, jbod_raid4, {link});
+  zone->add_route(host, jbod_raid4->get_controller(), {link});
 
   auto* jbod_raid5 =
     simgrid::plugin::Jbod::create_jbod(zone, "jbod_raid5", 1e9, 4, simgrid::plugin::Jbod::RAID::RAID5, 1e7, 5e6);
-  zone->add_route(host, jbod_raid5, {link});
+  zone->add_route(host, jbod_raid5->get_controller(), {link});
 
   auto* jbod_raid6 =
     simgrid::plugin::Jbod::create_jbod(zone, "jbod_raid6", 1e9, 4, simgrid::plugin::Jbod::RAID::RAID6, 1e7, 5e6);
-  zone->add_route(host, jbod_raid6, {link});
+  zone->add_route(host, jbod_raid6->get_controller(), {link});
 
   zone->seal();
 

diff --git a/include/simgrid/plugins/jbod.hpp b/include/simgrid/plugins/jbod.hpp
index 5c84e91..4ee799f 100644 (file)
--- a/include/simgrid/plugins/jbod.hpp
+++ b/include/simgrid/plugins/jbod.hpp
@@ -16,9 +16,10 @@ using JbodIoPtr = boost::intrusive_ptr<JbodIo>;
 XBT_PUBLIC void intrusive_ptr_release(const JbodIo* io);
 XBT_PUBLIC void intrusive_ptr_add_ref(const JbodIo* io);
 
-class Jbod : public s4u::Host {
+class Jbod {
 public:
   enum class RAID {RAID0 = 0, RAID1 = 1, RAID4 = 4 , RAID5 = 5, RAID6 = 6};
+  s4u::Host* get_controller() const { return controller_; }
   int get_parity_disk_idx() { return parity_disk_idx_; }
   void update_parity_disk_idx() { parity_disk_idx_ = (parity_disk_idx_- 1) % num_disks_; }
 
@@ -34,12 +35,14 @@ public:
                            RAID raid_level, double read_bandwidth, double write_bandwidth);
 
 protected:
+  void set_controller(s4u::Host* host) { controller_ = host; }
   void set_num_disks(unsigned int num_disks) { num_disks_ = num_disks; }
   void set_parity_disk_idx(unsigned int index) { parity_disk_idx_ = index; }
   void set_read_disk_idx(int index) { read_disk_idx_ = index; }
   void set_raid_level(RAID raid_level) { raid_level_ = raid_level; }
 
 private:
+  s4u::Host* controller_;
   unsigned int num_disks_;
   RAID raid_level_;
   unsigned int parity_disk_idx_;

diff --git a/src/plugins/jbod.cpp b/src/plugins/jbod.cpp
index bd42728..b6f87c2 100644 (file)
--- a/src/plugins/jbod.cpp
+++ b/src/plugins/jbod.cpp
@@ -21,45 +21,46 @@ Jbod* Jbod::create_jbod(s4u::NetZone* zone, const std::string& name, double spee
              "RAID%d requires at least 3 disks", (int) raid_level);
   xbt_assert(not (raid_level == RAID::RAID6 && num_disks < 4), "RAID6 requires at least 4 disks");
 
-  auto* jbod = static_cast<Jbod*>(zone->create_host(name, speed));
+  auto* jbod = new Jbod();
+  jbod->set_controller(zone->create_host(name, speed));
   jbod->set_num_disks(num_disks);
   jbod->set_parity_disk_idx(num_disks -1 );
   jbod->set_read_disk_idx(-1);
   jbod->set_raid_level(raid_level);
   for (unsigned int i = 0; i < num_disks; i++)
-    jbod->create_disk(name + "_disk_" + std::to_string(i), read_bandwidth, write_bandwidth);
+    jbod->get_controller()->create_disk(name + "_disk_" + std::to_string(i), read_bandwidth, write_bandwidth);
 
   return jbod;
 }
 
 JbodIoPtr Jbod::read_async(sg_size_t size)
 {
-  auto comm = s4u::Comm::sendto_init()->set_source(const_cast<Jbod*>(this))->set_payload_size(size);
+  auto comm = s4u::Comm::sendto_init()->set_source(this->controller_)->set_payload_size(size);
   std::vector<s4u::IoPtr> pending_ios;
   sg_size_t read_size = 0;
   std::vector<s4u::Disk*> targets;
   switch(raid_level_) {
     case RAID::RAID0:
       read_size = size / num_disks_;
-      targets = get_disks();
+      targets = controller_->get_disks();
       break;
     case RAID::RAID1:
       read_size = size;
-      targets.push_back(get_disks().at(get_next_read_disk_idx()));
+      targets.push_back(controller_->get_disks().at(get_next_read_disk_idx()));
       break;
     case RAID::RAID4:
       read_size = size / (num_disks_ - 1);
-      targets = get_disks();
+      targets = controller_->get_disks();
       targets.pop_back();
       break;
     case RAID::RAID5:
       read_size = size / (num_disks_ - 1);
-      targets = get_disks();
+      targets = controller_->get_disks();
       targets.erase(targets.begin() + (get_parity_disk_idx() + 1 % num_disks_));
       break;
     case RAID::RAID6:
       read_size = size / (num_disks_ - 2);
-      targets = get_disks();
+      targets = controller_->get_disks();
       if ( (get_parity_disk_idx() + 2 % num_disks_) == 0 ) {
         targets.pop_back();
         targets.erase(targets.begin());
@@ -91,7 +92,7 @@ sg_size_t Jbod::read(sg_size_t size)
 
 JbodIoPtr Jbod::write_async(sg_size_t size)
 {
-  auto comm = s4u::Comm::sendto_init(s4u::Host::current(), const_cast<Jbod*>(this));
+  auto comm = s4u::Comm::sendto_init(s4u::Host::current(), this->get_controller());
   std::vector<s4u::IoPtr> pending_ios;
   sg_size_t write_size = 0;
   switch(raid_level_) {
@@ -116,7 +117,7 @@ JbodIoPtr Jbod::write_async(sg_size_t size)
     default:
       xbt_die("Unsupported RAID level. Supported level are: 0, 1, 4, 5, and 6");
   }
-  for (const auto* disk : get_disks()) {
+  for (const auto* disk : get_controller()->get_disks()) {
     auto io = s4u::IoPtr(disk->io_init(write_size, s4u::Io::OpType::WRITE));
     io->set_name(disk->get_name());
     pending_ios.push_back(io);
@@ -148,7 +149,7 @@ void JbodIo::wait()
     transfer_->wait();
     XBT_DEBUG("Data received on JBOD");
     if (parity_block_comp_) {
-      parity_block_comp_->set_host(const_cast<Jbod*>(jbod_))->wait();
+      parity_block_comp_->set_host(jbod_->get_controller())->wait();
       XBT_DEBUG("Parity block computed");
     }
     XBT_DEBUG("Start writing");