X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/242530a43236d91a6522c6f3768776aca9f04508..ea74f5d95928a521a588737e81f1de94eef25d19:/src/s4u/s4u_Io.cpp diff --git a/src/s4u/s4u_Io.cpp b/src/s4u/s4u_Io.cpp index 73149eb614..bf092d9130 100644 --- a/src/s4u/s4u_Io.cpp +++ b/src/s4u/s4u_Io.cpp @@ -1,105 +1,126 @@ -/* Copyright (c) 2018-2020. The SimGrid Team. All rights reserved. */ +/* Copyright (c) 2018-2022. The SimGrid Team. All rights reserved. */ /* This program is free software; you can redistribute it and/or modify it * under the terms of the license (GNU LGPL) which comes with this package. */ -#include "simgrid/s4u/Disk.hpp" -#include "simgrid/s4u/Io.hpp" -#include "simgrid/s4u/Storage.hpp" +#include +#include +#include + #include "src/kernel/activity/IoImpl.hpp" -#include "xbt/log.h" +#include "src/kernel/actor/ActorImpl.hpp" +#include "src/kernel/actor/SimcallObserver.hpp" namespace simgrid { namespace s4u { +xbt::signal Io::on_start; -Io::Io(sg_disk_t disk, sg_size_t size, OpType type) : disk_(disk), size_(size), type_(type) +Io::Io(kernel::activity::IoImplPtr pimpl) { - Activity::set_remaining(size_); - pimpl_ = kernel::activity::IoImplPtr(new kernel::activity::IoImpl()); + pimpl_ = pimpl; } -Io::Io(sg_storage_t storage, sg_size_t size, OpType type) : storage_(storage), size_(size), type_(type) +IoPtr Io::init() { - Activity::set_remaining(size_); - pimpl_ = kernel::activity::IoImplPtr(new kernel::activity::IoImpl()); + auto pimpl = kernel::activity::IoImplPtr(new kernel::activity::IoImpl()); + return IoPtr(static_cast(pimpl->get_iface())); } Io* Io::start() { - kernel::actor::simcall([this] { - if (storage_) { - (*boost::static_pointer_cast(pimpl_)) - .set_name(get_name()) - .set_storage(storage_->get_impl()) - .set_size(size_) - .set_type(type_) - .start(); - } else { - (*boost::static_pointer_cast(pimpl_)) - .set_name(get_name()) - .set_disk(disk_->get_impl()) - .set_size(size_) - .set_type(type_) - .start(); - } - }); + kernel::actor::simcall( + [this] { (*boost::static_pointer_cast(pimpl_)).set_name(get_name()).start(); }); + + if (suspended_) + pimpl_->suspend(); + state_ = State::STARTED; + on_start(*this); return this; } -Io* Io::cancel() +ssize_t Io::wait_any_for(const std::vector& ios, double timeout) { - simgrid::kernel::actor::simcall([this] { boost::static_pointer_cast(pimpl_)->cancel(); }); - state_ = State::CANCELED; - return this; + std::vector rios(ios.size()); + std::transform(begin(ios), end(ios), begin(rios), + [](const IoPtr& io) { return static_cast(io->pimpl_.get()); }); + + kernel::actor::ActorImpl* issuer = kernel::actor::ActorImpl::self(); + kernel::actor::IoWaitanySimcall observer{issuer, rios, timeout}; + ssize_t changed_pos = kernel::actor::simcall_blocking( + [&observer] { + kernel::activity::IoImpl::wait_any_for(observer.get_issuer(), observer.get_ios(), observer.get_timeout()); + }, + &observer); + if (changed_pos != -1) + ios.at(changed_pos)->complete(State::FINISHED); + return changed_pos; } -Io* Io::wait() +IoPtr Io::set_disk(const_sg_disk_t disk) { - return this->wait_for(-1); + xbt_assert(state_ == State::INITED || state_ == State::STARTING, "Cannot set disk once the Io is started"); + + kernel::actor::simcall( + [this, disk] { boost::static_pointer_cast(pimpl_)->set_disk(disk->get_impl()); }); + + // Setting the disk may allow to start the activity, let's try + if (state_ == State::STARTING) + vetoable_start(); + + return this; } -Io* Io::wait_for(double timeout) +IoPtr Io::set_priority(double priority) { - if (state_ == State::INITED) - vetoable_start(); - simcall_io_wait(pimpl_, timeout); - state_ = State::FINISHED; - this->release_dependencies(); + xbt_assert(state_ == State::INITED || state_ == State::STARTING, + "Cannot change the priority of an io after its start"); + kernel::actor::simcall([this, priority] { + boost::static_pointer_cast(pimpl_)->set_sharing_penalty(1. / priority); + }); return this; } -bool Io::test() +IoPtr Io::set_size(sg_size_t size) { - xbt_assert(state_ == State::INITED || state_ == State::STARTED || state_ == State::STARTING || - state_ == State::FINISHED); - - if (state_ == State::FINISHED) - return true; - - if (state_ == State::INITED || state_ == State::STARTING) - this->vetoable_start(); + xbt_assert(state_ == State::INITED || state_ == State::STARTING, "Cannot set size once the Io is started"); + kernel::actor::simcall( + [this, size] { boost::static_pointer_cast(pimpl_)->set_size(size); }); + Activity::set_remaining(size); + return this; +} - if (simcall_io_test(pimpl_)) { - state_ = State::FINISHED; - this->release_dependencies(); - return true; - } +IoPtr Io::set_op_type(OpType type) +{ + xbt_assert(state_ == State::INITED || state_ == State::STARTING, "Cannot set size once the Io is started"); + kernel::actor::simcall( + [this, type] { boost::static_pointer_cast(pimpl_)->set_type(type); }); + return this; +} - return false; +IoPtr Io::update_priority(double priority) +{ + kernel::actor::simcall([this, priority] { + boost::static_pointer_cast(pimpl_)->update_sharing_penalty(1. / priority); + }); + return this; } /** @brief Returns the amount of flops that remain to be done */ -double Io::get_remaining() +double Io::get_remaining() const { return kernel::actor::simcall( [this]() { return boost::static_pointer_cast(pimpl_)->get_remaining(); }); } -sg_size_t Io::get_performed_ioops() +sg_size_t Io::get_performed_ioops() const { - return kernel::actor::simcall( - [this]() { return boost::static_pointer_cast(pimpl_)->get_performed_ioops(); }); + return boost::static_pointer_cast(pimpl_)->get_performed_ioops(); +} + +bool Io::is_assigned() const +{ + return boost::static_pointer_cast(pimpl_)->get_disk() != nullptr; } } // namespace s4u