include examples/s4u/exec-waitany/s4u-exec-waitany.tesh
include examples/s4u/io-async/s4u-io-async.cpp
include examples/s4u/io-async/s4u-io-async.tesh
+include examples/s4u/io-disk-raw/s4u-io-disk-raw.cpp
+include examples/s4u/io-disk-raw/s4u-io-disk-raw.tesh
include examples/s4u/io-file-remote/s4u-io-file-remote.cpp
include examples/s4u/io-file-remote/s4u-io-file-remote.tesh
include examples/s4u/io-file-remote/s4u-io-file-remote_d.xml
include examples/platforms/faulty_host.xml
include examples/platforms/g5k.xml
include examples/platforms/griffon.xml
+include examples/platforms/hosts_with_disks.xml
include examples/platforms/meta_cluster.xml
include examples/platforms/multicore_machine.xml
include examples/platforms/onelink.xml
include include/simgrid/s4u/Barrier.hpp
include include/simgrid/s4u/Comm.hpp
include include/simgrid/s4u/ConditionVariable.hpp
+include include/simgrid/s4u/Disk.hpp
include include/simgrid/s4u/Engine.hpp
include include/simgrid/s4u/Exec.hpp
include include/simgrid/s4u/Host.hpp
include src/kernel/lmm/maxmin.hpp
include src/kernel/lmm/maxmin_test.cpp
include src/kernel/resource/Action.cpp
+include src/kernel/resource/DiskImpl.cpp
+include src/kernel/resource/DiskImpl.hpp
include src/kernel/resource/Model.cpp
include src/kernel/resource/Resource.cpp
include src/kernel/resource/profile/DatedValue.cpp
include src/s4u/s4u_Barrier.cpp
include src/s4u/s4u_Comm.cpp
include src/s4u/s4u_ConditionVariable.cpp
+include src/s4u/s4u_Disk.cpp
include src/s4u/s4u_Engine.cpp
include src/s4u/s4u_Exec.cpp
include src/s4u/s4u_Host.cpp
include src/surf/cpu_interface.hpp
include src/surf/cpu_ti.cpp
include src/surf/cpu_ti.hpp
+include src/surf/disk_s19.cpp
+include src/surf/disk_s19.hpp
include src/surf/host_clm03.cpp
include src/surf/host_clm03.hpp
include src/surf/network_cm02.cpp
--- /dev/null
+<?xml version='1.0'?>
+<!DOCTYPE platform SYSTEM "https://simgrid.org/simgrid.dtd">
+<platform version="4.1">
+ <zone id="AS0" routing="Full">
+ <host id="bob" speed="1Gf">
+ <disk id="Disk1" read_bw="100MBps" write_bw="40MBps">
+ <prop id="size" value="500GiB"/>
+ <prop id="mount" value="/scratch"/>
+ <prop id="content" value="storage/content/storage_content.txt"/>
+ </disk>
+ <disk id="Disk2" read_bw="200MBps" write_bw="80MBps"/>
+ </host>
+
+ <host id="alice" speed="1Gf">
+ <disk id="Disk1" read_bw="200MBps" write_bw="80MBps">
+ <prop id="size" value="500GiB"/>
+ <prop id="mount" value="c:"/>
+ <prop id="content" value="storage/content/win_storage_content.txt"/>
+ </disk>
+ </host>
+
+ <link id="link1" bandwidth="125MBps" latency="150us" />
+
+ <route src="bob" dst="alice">
+ <link_ctn id="link1" />
+ </route>
+ </zone>
+</platform>
energy-exec energy-boot energy-link energy-vm
engine-filtering
exec-async exec-basic exec-dvfs exec-ptask exec-remote exec-waitany
- io-async io-file-system io-file-remote io-storage-raw
+ io-async io-file-system io-file-remote io-storage-raw io-disk-raw
platform-failures platform-profile platform-properties
plugin-hostload
replay-comm replay-storage
static void test(sg_size_t size)
{
- simgrid::s4u::Storage* storage = simgrid::s4u::Storage::by_name("Disk1");
- XBT_INFO("Hello! read %llu bytes from Storage %s", size, storage->get_cname());
+ simgrid::s4u::Disk* disk = simgrid::s4u::Host::current()->get_disks().front();
+ XBT_INFO("Hello! read %llu bytes from %s", size, disk->get_cname());
- simgrid::s4u::IoPtr activity = storage->io_init(size, simgrid::s4u::Io::OpType::READ);
+ simgrid::s4u::IoPtr activity = disk->io_init(size, simgrid::s4u::Io::OpType::READ);
activity->start();
activity->wait();
static void test_cancel(sg_size_t size)
{
- simgrid::s4u::Storage* storage = simgrid::s4u::Storage::by_name("Disk2");
- XBT_INFO("Hello! write %llu bytes from Storage %s", size, storage->get_cname());
+ simgrid::s4u::Disk* disk = simgrid::s4u::Host::current()->get_disks().front();
+ XBT_INFO("Hello! write %llu bytes from %s", size, disk->get_cname());
- simgrid::s4u::IoPtr activity = storage->write_async(size);
+ simgrid::s4u::IoPtr activity = disk->write_async(size);
simgrid::s4u::this_actor::sleep_for(0.5);
XBT_INFO("I changed my mind, cancel!");
activity->cancel();
#!/usr/bin/env tesh
-$ ${bindir:=.}/s4u-io-async ${platfdir}/storage/storage.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n"
-> [ 0.000000] (1:test@bob) Hello! read 20000000 bytes from Storage Disk1
-> [ 0.000000] (2:test_cancel@alice) Hello! write 50000000 bytes from Storage Disk2
+$ ${bindir:=.}/s4u-io-async ${platfdir}/hosts_with_disks.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n"
+> [ 0.000000] (1:test@bob) Hello! read 20000000 bytes from Disk1
+> [ 0.000000] (2:test_cancel@alice) Hello! write 50000000 bytes from Disk1
> [ 0.200000] (1:test@bob) Goodbye now!
> [ 0.500000] (2:test_cancel@alice) I changed my mind, cancel!
> [ 0.500000] (2:test_cancel@alice) Goodbye now!
--- /dev/null
+/* Copyright (c) 2017-2019. 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.hpp"
+#include <string>
+#include <unordered_map>
+
+XBT_LOG_NEW_DEFAULT_CATEGORY(disk, "Messages specific for this simulation");
+
+static void host()
+{
+ /* - Display information on the disks mounted by the current host */
+ XBT_INFO("*** Storage info on %s ***", simgrid::s4u::Host::current()->get_cname());
+
+ /* - Retrieve all disks from current host */
+ std::vector<simgrid::s4u::Disk*> const& disk_list = simgrid::s4u::Host::current()->get_disks();
+
+ /* - For each disk mounted on host, display disk name and mount point */
+ for (auto disk : disk_list)
+ XBT_INFO("Disk name: %s", disk->get_cname());
+
+ /* - Write 400,000 bytes on Disk1 */
+ simgrid::s4u::Disk* disk = disk_list.front();
+ sg_size_t write = disk->write(400000);
+ XBT_INFO("Wrote %llu bytes on '%s'", write, disk->get_cname());
+
+ /* - Now read 200,000 bytes */
+ sg_size_t read = disk->read(200000);
+ XBT_INFO("Read %llu bytes on '%s'", read, disk->get_cname());
+
+ /* - Attach some user data to disk1 */
+ XBT_INFO("*** Get/set data for storage element: Disk1 ***");
+
+ std::string* data = static_cast<std::string*>(disk->get_data());
+
+ XBT_INFO("Get storage data: '%s'", data ? data->c_str() : "No user data");
+
+ disk->set_data(new std::string("Some user data"));
+ data = static_cast<std::string*>(disk->get_data());
+ XBT_INFO("Set and get data: '%s'", data->c_str());
+ delete data;
+}
+
+int main(int argc, char** argv)
+{
+ simgrid::s4u::Engine e(&argc, argv);
+ e.load_platform(argv[1]);
+
+ simgrid::s4u::Actor::create("", simgrid::s4u::Host::by_name("bob"), host);
+
+ e.run();
+ XBT_INFO("Simulated time: %g", simgrid::s4u::Engine::get_clock());
+
+ return 0;
+}
--- /dev/null
+#!/usr/bin/env tesh
+
+$ ${bindir}/s4u-io-disk-raw ${platfdir}/hosts_with_disks.xml "--log=root.fmt:[%10.6r]%e(%i:%P@%h)%e%m%n"
+> [ 0.000000] (1:@bob) *** Storage info on bob ***
+> [ 0.000000] (1:@bob) Disk name: Disk1
+> [ 0.000000] (1:@bob) Disk name: Disk2
+> [ 0.010000] (1:@bob) Wrote 400000 bytes on 'Disk1'
+> [ 0.012000] (1:@bob) Read 200000 bytes on 'Disk1'
+> [ 0.012000] (1:@bob) *** Get/set data for storage element: Disk1 ***
+> [ 0.012000] (1:@bob) Get storage data: 'No user data'
+> [ 0.012000] (1:@bob) Set and get data: 'Some user data'
+> [ 0.012000] (0:maestro@) Simulated time: 0.012
const char* filename = file.get_path();
XBT_INFO("Opened file '%s'", filename);
file.dump();
-
- XBT_INFO("Try to read %llu from '%s'", file.size(), filename);
- sg_size_t read = file.read(file.size());
- XBT_INFO("Have read %llu from '%s'. Offset is now at: %llu", read, filename, file.tell());
- XBT_INFO("Seek back to the beginning of the stream...");
- file.seek(0, SEEK_SET);
- XBT_INFO("Offset is now at: %llu", file.tell());
-
- if (argc > 5) {
- simgrid::s4u::File remoteFile(argv[2], nullptr);
- filename = remoteFile.get_path();
- XBT_INFO("Opened file '%s'", filename);
- XBT_INFO("Try to write %llu MiB to '%s'", remoteFile.size() / 1024, filename);
- sg_size_t write = remoteFile.write(remoteFile.size() * 1024);
- XBT_INFO("Have written %llu bytes to '%s'.", write, filename);
-
- if (std::stoi(argv[5]) != 0) {
- XBT_INFO("Move '%s' (of size %llu) from '%s' to '%s'", filename, remoteFile.size(),
- simgrid::s4u::Host::current()->get_cname(), argv[3]);
- remoteFile.remote_move(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
- } else {
- XBT_INFO("Copy '%s' (of size %llu) from '%s' to '%s'", filename, remoteFile.size(),
- simgrid::s4u::Host::current()->get_cname(), argv[3]);
- remoteFile.remote_copy(simgrid::s4u::Host::by_name(argv[3]), argv[4]);
- }
+ XBT_INFO("Try to write %llu MiB to '%s'", file.size() / 1024, filename);
+ sg_size_t write = file.write(file.size() * 1024);
+ XBT_INFO("Have written %llu bytes to '%s'.", write, filename);
+
+ if (std::stoi(argv[4]) != 0) {
+ XBT_INFO("Move '%s' (of size %llu) from '%s' to '%s'", filename, file.size(),
+ simgrid::s4u::Host::current()->get_cname(), argv[2]);
+ file.remote_move(simgrid::s4u::Host::by_name(argv[2]), argv[3]);
+ } else {
+ XBT_INFO("Copy '%s' (of size %llu) from '%s' to '%s'", filename, file.size(),
+ simgrid::s4u::Host::current()->get_cname(), argv[2]);
+ file.remote_copy(simgrid::s4u::Host::by_name(argv[2]), argv[3]);
}
return 0;
e.load_platform(argv[1]);
e.register_function("host", host);
e.load_deployment(argv[2]);
- std::vector<simgrid::s4u::Storage*> allStorages = e.get_all_storages();
+ std::vector<simgrid::s4u::Host*> all_hosts = e.get_all_hosts();
- for (auto const& s : allStorages) {
- XBT_INFO("Init: %llu/%llu MiB used/free on '%s'", sg_storage_get_size_used(s) / INMEGA,
- sg_storage_get_size_free(s) / INMEGA, s->get_cname());
+ for (auto const& h : all_hosts) {
+ for (auto const& d : h->get_disks())
+ XBT_INFO("Init: %llu/%llu MiB used/free on '%s@%s'", sg_disk_get_size_used(d) / INMEGA,
+ sg_disk_get_size_free(d) / INMEGA, d->get_cname(), h->get_cname());
}
e.run();
- for (auto const& s : allStorages) {
- XBT_INFO("End: %llu/%llu MiB used/free on '%s'", sg_storage_get_size_used(s) / INMEGA,
- sg_storage_get_size_free(s) / INMEGA, s->get_cname());
+ for (auto const& h : all_hosts) {
+ for (auto const& d : h->get_disks())
+ XBT_INFO("End: %llu/%llu MiB used/free on '%s@%s'", sg_disk_get_size_used(d) / INMEGA,
+ sg_disk_get_size_free(d) / INMEGA, d->get_cname(), h->get_cname());
}
XBT_INFO("Simulation time %g", simgrid::s4u::Engine::get_clock());
#!/usr/bin/env tesh
-$ ${bindir:=.}/s4u-io-file-remote ${platfdir}/storage/remote_io.xml s4u-io-file-remote_d.xml "--log=root.fmt:[%10.6r]%e(%i@%5h)%e%m%n"
-> [ 0.000000] (0@ ) Init: 12/476824 MiB used/free on 'Disk1'
-> [ 0.000000] (0@ ) Init: 2280/474556 MiB used/free on 'Disk2'
-> [ 0.000000] (1@alice) Opened file 'c:\Windows\setupact.log'
+$ ${bindir:=.}/s4u-io-file-remote ${platfdir}/hosts_with_disks.xml s4u-io-file-remote_d.xml "--log=root.fmt:[%10.6r]%e(%i@%5h)%e%m%n"
+> [ 0.000000] (0@ ) Init: 2280/509719 MiB used/free on 'Disk1@alice'
+> [ 0.000000] (0@ ) Init: 35/511964 MiB used/free on 'Disk1@bob'
+> [ 0.000000] (0@ ) Init: 0/0 MiB used/free on 'Disk2@bob'
+> [ 0.000000] (1@alice) Opened file 'c:\Windows\Professional.xml'
> [ 0.000000] (1@alice) File Descriptor information:
-> Full path: 'c:\Windows\setupact.log'
-> Size: 101663
+> Full path: 'c:\Windows\Professional.xml'
+> Size: 31881
> Mount point: 'c:'
-> Storage Id: 'Disk2'
-> Storage Type: 'SATA-II_HDD'
+> Disk Id: 'Disk1'
+> Host Id: 'alice'
> File Descriptor Id: 0
-> [ 0.000000] (1@alice) Try to read 101663 from 'c:\Windows\setupact.log'
-> [ 0.000000] (2@ bob) Opened file '/scratch/lib/libsimgrid.so.3.6.2'
+> [ 0.000000] (1@alice) Try to write 31 MiB to 'c:\Windows\Professional.xml'
+> [ 0.000000] (2@ bob) Opened file '/scratch/doc/simgrid/examples/platforms/g5k.xml'
> [ 0.000000] (2@ bob) File Descriptor information:
-> Full path: '/scratch/lib/libsimgrid.so.3.6.2'
-> Size: 12710497
+> Full path: '/scratch/doc/simgrid/examples/platforms/g5k.xml'
+> Size: 17028
> Mount point: '/scratch'
-> Storage Id: 'Disk1'
-> Storage Type: 'SATA-II_HDD'
+> Disk Id: 'Disk1'
+> Host Id: 'bob'
> File Descriptor Id: 0
-> [ 0.000000] (2@ bob) Try to read 12710497 from '/scratch/lib/libsimgrid.so.3.6.2'
-> [ 0.000000] (3@ carl) Opened file '/scratch/lib/libsimgrid.so.3.6.2'
-> [ 0.000000] (3@ carl) File Descriptor information:
-> Full path: '/scratch/lib/libsimgrid.so.3.6.2'
-> Size: 12710497
-> Mount point: '/scratch'
-> Storage Id: 'Disk1'
-> Storage Type: 'SATA-II_HDD'
-> File Descriptor Id: 0
-> [ 0.000000] (3@ carl) Try to read 12710497 from '/scratch/lib/libsimgrid.so.3.6.2'
-> [ 0.000000] (4@ dave) Opened file 'c:\Windows\bootstat.dat'
-> [ 0.000000] (4@ dave) File Descriptor information:
-> Full path: 'c:\Windows\bootstat.dat'
-> Size: 67584
-> Mount point: 'c:'
-> Storage Id: 'Disk2'
-> Storage Type: 'SATA-II_HDD'
-> File Descriptor Id: 0
-> [ 0.000000] (4@ dave) Try to read 67584 from 'c:\Windows\bootstat.dat'
-> [ 0.001469] (4@ dave) Have read 67584 from 'c:\Windows\bootstat.dat'. Offset is now at: 67584
-> [ 0.001469] (4@ dave) Seek back to the beginning of the stream...
-> [ 0.001469] (4@ dave) Offset is now at: 0
-> [ 0.001469] (4@ dave) Opened file 'c:\Windows\Professional.xml'
-> [ 0.001469] (4@ dave) Try to write 31 MiB to 'c:\Windows\Professional.xml'
-> [ 0.003741] (1@alice) Have read 101663 from 'c:\Windows\setupact.log'. Offset is now at: 101663
-> [ 0.003741] (1@alice) Seek back to the beginning of the stream...
-> [ 0.003741] (1@alice) Offset is now at: 0
-> [ 0.276315] (3@ carl) Have read 12710497 from '/scratch/lib/libsimgrid.so.3.6.2'. Offset is now at: 12710497
-> [ 0.276315] (3@ carl) Seek back to the beginning of the stream...
-> [ 0.276315] (3@ carl) Offset is now at: 0
-> [ 0.387036] (2@ bob) Have read 12710497 from '/scratch/lib/libsimgrid.so.3.6.2'. Offset is now at: 12710497
-> [ 0.387036] (2@ bob) Seek back to the beginning of the stream...
-> [ 0.387036] (2@ bob) Offset is now at: 0
-> [ 0.387036] (2@ bob) Opened file '/scratch/doc/simgrid/examples/platforms/g5k.xml'
-> [ 0.387036] (2@ bob) Try to write 16 MiB to '/scratch/doc/simgrid/examples/platforms/g5k.xml'
-> [ 0.528211] (4@ dave) Have written 32646144 bytes to 'c:\Windows\Professional.xml'.
-> [ 0.528211] (4@ dave) Move 'c:\Windows\Professional.xml' (of size 32646144) from 'dave' to 'carl'
-> [ 0.819921] (2@ bob) Have written 17436672 bytes to '/scratch/doc/simgrid/examples/platforms/g5k.xml'.
-> [ 0.819921] (2@ bob) Copy '/scratch/doc/simgrid/examples/platforms/g5k.xml' (of size 17436672) from 'bob' to 'alice'
-> [ 1.843969] (0@ ) End: 60/476776 MiB used/free on 'Disk1'
-> [ 1.843969] (0@ ) End: 2297/474539 MiB used/free on 'Disk2'
-> [ 1.843969] (0@ ) Simulation time 1.84397
+> [ 0.000000] (2@ bob) Try to write 16 MiB to '/scratch/doc/simgrid/examples/platforms/g5k.xml'
+> [ 0.408077] (1@alice) Have written 32646144 bytes to 'c:\Windows\Professional.xml'.
+> [ 0.408077] (1@alice) Move 'c:\Windows\Professional.xml' (of size 32646144) from 'alice' to 'bob'
+> [ 0.435917] (2@ bob) Have written 17436672 bytes to '/scratch/doc/simgrid/examples/platforms/g5k.xml'.
+> [ 0.435917] (2@ bob) Copy '/scratch/doc/simgrid/examples/platforms/g5k.xml' (of size 17436672) from 'bob' to 'alice'
+> [ 1.823119] (0@ ) End: 2297/509702 MiB used/free on 'Disk1@alice'
+> [ 1.823119] (0@ ) End: 82/511917 MiB used/free on 'Disk1@bob'
+> [ 1.823119] (0@ ) End: 0/0 MiB used/free on 'Disk2@bob'
+> [ 1.823119] (0@ ) Simulation time 1.82312
<!DOCTYPE platform SYSTEM "https://simgrid.org/simgrid.dtd">
<platform version="4.1">
<actor host="alice" function="host">
- <argument value = "c:\Windows\setupact.log"/>
+ <argument value = "c:\Windows\Professional.xml"/>
+ <argument value = "bob"/>
+ <argument value = "/scratch/mailbox/Professional.xml"/>
+ <argument value = "1"/>
</actor>
<actor host="bob" function="host">
- <argument value = "/scratch/lib/libsimgrid.so.3.6.2"/>
<argument value = "/scratch/doc/simgrid/examples/platforms/g5k.xml"/>
<argument value = "alice"/>
<argument value = "c:\Windows\Platforms\g5k.xml"/>
<argument value = "0"/>
</actor>
- <actor host="carl" function="host">
- <argument value = "/scratch/lib/libsimgrid.so.3.6.2"/>
- </actor>
- <actor host="dave" function="host">
- <argument value = "c:\Windows\bootstat.dat"/>
- <argument value = "c:\Windows\Professional.xml"/>
- <argument value = "carl"/>
- <argument value = "/scratch/mailbox/Professional.xml"/>
- <argument value = "1"/>
- </actor>
</platform>
* under the terms of the license (GNU LGPL) which comes with this package. */
#include <string>
-#include <unordered_map>
+#include <vector>
#include "simgrid/plugins/file_system.h"
#include "simgrid/s4u.hpp"
class MyHost {
public:
- void show_info(std::unordered_map<std::string, simgrid::s4u::Storage*> const& mounts)
+ void show_info(std::vector<simgrid::s4u::Disk*> const& disks)
{
XBT_INFO("Storage info on %s:", simgrid::s4u::Host::current()->get_cname());
- for (auto const& kv : mounts) {
- std::string mountpoint = kv.first;
- simgrid::s4u::Storage* storage = kv.second;
+ for (auto const& d : disks) {
+ const char* mountpoint = d->get_property("mount");
// Retrieve disk's information
- XBT_INFO(" %s (%s) Used: %llu; Free: %llu; Total: %llu.", storage->get_cname(), mountpoint.c_str(),
- sg_storage_get_size_used(storage), sg_storage_get_size_free(storage), sg_storage_get_size(storage));
+ XBT_INFO(" %s (%s) Used: %llu; Free: %llu; Total: %llu.", d->get_cname(), mountpoint, sg_disk_get_size_used(d),
+ sg_disk_get_size_free(d), sg_disk_get_size(d));
}
}
void operator()()
{
- std::unordered_map<std::string, simgrid::s4u::Storage*> const& mounts =
- simgrid::s4u::Host::current()->get_mounted_storages();
+ std::vector<simgrid::s4u::Disk*> const& disks = simgrid::s4u::Host::current()->get_disks();
- show_info(mounts);
+ show_info(disks);
// Open an non-existing file to create it
- std::string filename = "/home/tmp/data.txt";
+ std::string filename = "/scratch/tmp/data.txt";
simgrid::s4u::File* file = new simgrid::s4u::File(filename, nullptr);
sg_size_t write = file->write(200000); // Write 200,000 bytes
- XBT_INFO("Create a %llu bytes file named '%s' on /sd1", write, filename.c_str());
+ XBT_INFO("Create a %llu bytes file named '%s' on /scratch", write, filename.c_str());
// check that sizes have changed
- show_info(mounts);
+ show_info(disks);
// Now retrieve the size of created file and read it completely
const sg_size_t file_size = file->size();
write = file->write(100000); // Write 100,000 bytes
XBT_INFO("Write %llu bytes on %s", write, filename.c_str());
- simgrid::s4u::Storage* storage = simgrid::s4u::Storage::by_name("Disk4");
-
// Now rename file from ./tmp/data.txt to ./tmp/simgrid.readme
- std::string newpath = "/home/tmp/simgrid.readme";
+ std::string newpath = "/scratch/tmp/simgrid.readme";
XBT_INFO("Move '%s' to '%s'", file->get_path(), newpath.c_str());
file->move(newpath);
// Close the file
delete file;
- // Now attach some user data to disk1
- XBT_INFO("Get/set data for storage element: %s", storage->get_cname());
- XBT_INFO(" Uninitialized storage data: '%s'", static_cast<char*>(storage->get_data()));
-
- storage->set_data(new std::string("Some user data"));
- std::string* storage_data = static_cast<std::string*>(storage->get_data());
- XBT_INFO(" Set and get data: '%s'", storage_data->c_str());
-
- delete storage_data;
+ show_info(disks);
// Reopen the file and then unlink it
- file = new simgrid::s4u::File("/home/tmp/simgrid.readme", nullptr);
+ file = new simgrid::s4u::File("/scratch/tmp/simgrid.readme", nullptr);
XBT_INFO("Unlink file: '%s'", file->get_path());
file->unlink();
delete file; // Unlinking the file on "disk" does not free the object
- show_info(mounts);
+ show_info(disks);
}
};
simgrid::s4u::Engine e(&argc, argv);
sg_storage_file_system_init();
e.load_platform(argv[1]);
- simgrid::s4u::Actor::create("host", simgrid::s4u::Host::by_name("denise"), MyHost());
+ simgrid::s4u::Actor::create("host", simgrid::s4u::Host::by_name("bob"), MyHost());
e.run();
return 0;
#!/usr/bin/env tesh
-$ ${bindir:=.}/s4u-io-file-system ${platfdir}/storage/storage.xml
-> [denise:host:(1) 0.000000] [s4u_test/INFO] Storage info on denise:
-> [denise:host:(1) 0.000000] [s4u_test/INFO] Disk2 (c:) Used: 2391537133; Free: 534479374867; Total: 536870912000.
-> [denise:host:(1) 0.000000] [s4u_test/INFO] Disk4 (/home) Used: 13221994; Free: 536857690006; Total: 536870912000.
-> [denise:host:(1) 0.003333] [s4u_test/INFO] Create a 200000 bytes file named '/home/tmp/data.txt' on /sd1
-> [denise:host:(1) 0.003333] [s4u_test/INFO] Storage info on denise:
-> [denise:host:(1) 0.003333] [s4u_test/INFO] Disk2 (c:) Used: 2391537133; Free: 534479374867; Total: 536870912000.
-> [denise:host:(1) 0.003333] [s4u_test/INFO] Disk4 (/home) Used: 13421994; Free: 536857490006; Total: 536870912000.
-> [denise:host:(1) 0.004333] [s4u_test/INFO] Read 200000 bytes on /home/tmp/data.txt
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Write 100000 bytes on /home/tmp/data.txt
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Move '/home/tmp/data.txt' to '/home/tmp/simgrid.readme'
-> [denise:host:(1) 0.006000] [s4u_test/INFO] User data attached to the file: 777
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Get/set data for storage element: Disk4
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Uninitialized storage data: '(null)'
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Set and get data: 'Some user data'
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Unlink file: '/home/tmp/simgrid.readme'
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Storage info on denise:
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Disk2 (c:) Used: 2391537133; Free: 534479374867; Total: 536870912000.
-> [denise:host:(1) 0.006000] [s4u_test/INFO] Disk4 (/home) Used: 13221994; Free: 536857690006; Total: 536870912000.
+$ ${bindir:=.}/s4u-io-file-system ${platfdir}/hosts_with_disks.xml
+> [bob:host:(1) 0.000000] [s4u_test/INFO] Storage info on bob:
+> [bob:host:(1) 0.000000] [s4u_test/INFO] Disk1 (/scratch) Used: 36933331; Free: 536833978669; Total: 536870912000.
+> [bob:host:(1) 0.000000] [s4u_test/INFO] Disk2 ((null)) Used: 0; Free: 0; Total: 0.
+> [bob:host:(1) 0.005000] [s4u_test/INFO] Create a 200000 bytes file named '/scratch/tmp/data.txt' on /scratch
+> [bob:host:(1) 0.005000] [s4u_test/INFO] Storage info on bob:
+> [bob:host:(1) 0.005000] [s4u_test/INFO] Disk1 (/scratch) Used: 37133331; Free: 536833778669; Total: 536870912000.
+> [bob:host:(1) 0.005000] [s4u_test/INFO] Disk2 ((null)) Used: 0; Free: 0; Total: 0.
+> [bob:host:(1) 0.007000] [s4u_test/INFO] Read 200000 bytes on /scratch/tmp/data.txt
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Write 100000 bytes on /scratch/tmp/data.txt
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Move '/scratch/tmp/data.txt' to '/scratch/tmp/simgrid.readme'
+> [bob:host:(1) 0.009500] [s4u_test/INFO] User data attached to the file: 777
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Storage info on bob:
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Disk1 (/scratch) Used: 37233331; Free: 536833678669; Total: 536870912000.
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Disk2 ((null)) Used: 0; Free: 0; Total: 0.
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Unlink file: '/scratch/tmp/simgrid.readme'
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Storage info on bob:
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Disk1 (/scratch) Used: 36933331; Free: 536833978669; Total: 536870912000.
+> [bob:host:(1) 0.009500] [s4u_test/INFO] Disk2 ((null)) Used: 0; Free: 0; Total: 0.
XBT_PUBLIC void intrusive_ptr_release(Semaphore* m);
XBT_PUBLIC void intrusive_ptr_add_ref(Semaphore* m);
+class Disk;
class Storage;
} // namespace s4u
class NetworkModel;
class LinkImpl;
class NetworkAction;
+class DiskImpl;
+class DiskModel;
class StorageImpl;
class StorageType;
class StorageModel;
typedef simgrid::s4u::ConditionVariable s4u_ConditionVariable;
typedef simgrid::s4u::Mutex s4u_Mutex;
typedef simgrid::s4u::Semaphore s4u_Semaphore;
+typedef simgrid::s4u::Disk s4u_Disk;
typedef simgrid::s4u::Storage s4u_Storage;
typedef simgrid::s4u::NetZone s4u_NetZone;
typedef simgrid::s4u::VirtualMachine s4u_VM;
typedef struct s4u_ConditionVariable s4u_ConditionVariable;
typedef struct s4u_Mutex s4u_Mutex;
typedef struct s4u_Semaphore s4u_Semaphore;
+typedef struct s4u_Disk s4u_Disk;
typedef struct s4u_Storage s4u_Storage;
typedef struct s4u_NetZone s4u_NetZone;
typedef struct s4u_VM s4u_VM;
typedef s4u_NetZone* sg_netzone_t;
typedef s4u_Host* sg_host_t;
typedef s4u_Link* sg_link_t;
+typedef s4u_Disk* sg_disk_t;
typedef s4u_Storage* sg_storage_t;
typedef s4u_File* sg_file_t;
typedef s4u_VM* sg_vm_t;
XBT_PUBLIC int sg_file_rcopy(sg_file_t file, sg_host_t host, const char* fullpath);
XBT_PUBLIC int sg_file_rmove(sg_file_t file, sg_host_t host, const char* fullpath);
+XBT_PUBLIC sg_size_t sg_disk_get_size_free(sg_disk_t d);
+XBT_PUBLIC sg_size_t sg_disk_get_size_used(sg_disk_t d);
+XBT_PUBLIC sg_size_t sg_disk_get_size(sg_disk_t d);
+
XBT_PUBLIC sg_size_t sg_storage_get_size_free(sg_storage_t st);
XBT_PUBLIC sg_size_t sg_storage_get_size_used(sg_storage_t st);
XBT_PUBLIC sg_size_t sg_storage_get_size(sg_storage_t st);
void dump();
int desc_id = 0;
- Storage* local_storage_;
+ Disk* local_disk_ = nullptr;
+ Storage* local_storage_ = nullptr;
std::string mount_point_;
private:
void* userdata_ = nullptr;
};
+class XBT_PUBLIC FileSystemDiskExt {
+public:
+ static simgrid::xbt::Extension<Disk, FileSystemDiskExt> EXTENSION_ID;
+ explicit FileSystemDiskExt(Disk* ptr);
+ FileSystemDiskExt(const FileSystemDiskExt&) = delete;
+ FileSystemDiskExt& operator=(const FileSystemDiskExt&) = delete;
+ std::map<std::string, sg_size_t>* parse_content(const std::string& filename);
+ std::map<std::string, sg_size_t>* get_content() { return content_.get(); }
+ sg_size_t get_size() { return size_; }
+ sg_size_t get_used_size() { return used_size_; }
+ void decr_used_size(sg_size_t size) { used_size_ -= size; }
+ void incr_used_size(sg_size_t size) { used_size_ += size; }
+
+private:
+ std::unique_ptr<std::map<std::string, sg_size_t>> content_;
+ sg_size_t used_size_ = 0;
+ sg_size_t size_ = 0;
+};
+
class XBT_PUBLIC FileSystemStorageExt {
public:
static simgrid::xbt::Extension<Storage, FileSystemStorageExt> EXTENSION_ID;
#include <simgrid/s4u/Barrier.hpp>
#include <simgrid/s4u/Comm.hpp>
#include <simgrid/s4u/ConditionVariable.hpp>
+#include <simgrid/s4u/Disk.hpp>
#include <simgrid/s4u/Engine.hpp>
#include <simgrid/s4u/Exec.hpp>
#include <simgrid/s4u/Host.hpp>
--- /dev/null
+/* Copyright (c) 2019. 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. */
+
+#ifndef INCLUDE_SIMGRID_S4U_DISK_HPP_
+#define INCLUDE_SIMGRID_S4U_DISK_HPP_
+
+#include <simgrid/forward.h>
+#include <simgrid/s4u/Io.hpp>
+#include <xbt/Extendable.hpp>
+#include <xbt/base.h>
+#include <xbt/signal.hpp>
+
+#include <map>
+#include <string>
+#include <unordered_map>
+
+namespace simgrid {
+namespace s4u {
+
+/** Disk represent the disk resources associated to a host
+ *
+ * By default, SimGrid does not keep track of the actual data being written but
+ * only computes the time taken by the corresponding data movement.
+ */
+
+class XBT_PUBLIC Disk : public xbt::Extendable<Disk> {
+ friend Engine;
+ friend Io;
+ friend kernel::resource::DiskImpl;
+
+public:
+ explicit Disk(const std::string& name, kernel::resource::DiskImpl* pimpl) : pimpl_(pimpl), name_(name) {}
+
+protected:
+ virtual ~Disk() = default;
+
+public:
+ /** @brief Callback signal fired when a new Storage is created */
+ static xbt::signal<void(Disk&)> on_creation;
+ /** @brief Callback signal fired when a Storage is destroyed */
+ static xbt::signal<void(Disk const&)> on_destruction;
+ /** @brief Callback signal fired when a Storage's state changes */
+ static xbt::signal<void(Disk const&)> on_state_change;
+
+ /** @brief Retrieves the name of that storage as a C++ string */
+ std::string const& get_name() const { return name_; }
+ /** @brief Retrieves the name of that storage as a C string */
+ const char* get_cname() const { return name_.c_str(); }
+
+ const std::unordered_map<std::string, std::string>* get_properties() const;
+ const char* get_property(const std::string& key) const;
+ void set_property(const std::string&, const std::string& value);
+ Host* get_host();
+
+ void set_data(void* data) { userdata_ = data; }
+ void* get_data() { return userdata_; }
+
+ IoPtr io_init(sg_size_t size, s4u::Io::OpType type);
+
+ IoPtr read_async(sg_size_t size);
+ sg_size_t read(sg_size_t size);
+
+ IoPtr write_async(sg_size_t size);
+ sg_size_t write(sg_size_t size);
+ kernel::resource::DiskImpl* get_impl() const { return pimpl_; }
+
+private:
+ kernel::resource::DiskImpl* const pimpl_;
+ std::string name_;
+ void* userdata_ = nullptr;
+};
+
+} // namespace s4u
+} // namespace simgrid
+
+#endif /* INCLUDE_SIMGRID_S4U_DISK_HPP_ */
#ifndef DOXYGEN
friend Host;
friend Link;
+ friend Disk;
friend Storage;
friend kernel::routing::NetPoint;
friend kernel::routing::NetZoneImpl;
void set_pstate(int pstate_index);
int get_pstate() const;
+ std::vector<Disk*> get_disks() const;
+
std::vector<const char*> get_attached_storages() const;
/** Get an associative list [mount point]->[Storage] of all local mount points.
private:
Storage* storage_ = nullptr;
+ Disk* disk_ = nullptr;
sg_size_t size_ = 0;
OpType type_ = OpType::READ;
std::string name_ = "";
std::atomic_int_fast32_t refcount_{0};
explicit Io(sg_storage_t storage, sg_size_t size, OpType type);
+ explicit Io(sg_disk_t disk, sg_size_t size, OpType type);
public:
#ifndef DOXYGEN
friend XBT_PUBLIC void intrusive_ptr_release(simgrid::s4u::Io* i);
friend XBT_PUBLIC void intrusive_ptr_add_ref(simgrid::s4u::Io* i);
+ friend Disk; // Factory of IOs
friend Storage; // Factory of IOs
#endif
#include "simgrid/kernel/routing/NetPoint.hpp"
#include "simgrid/kernel/routing/NetZoneImpl.hpp"
#include "simgrid/s4u/Host.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
#include "src/surf/StorageImpl.hpp"
#include "src/surf/network_interface.hpp"
#include "simgrid/Exception.hpp"
#include "simgrid/kernel/resource/Action.hpp"
#include "simgrid/s4u/Host.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
#include "src/mc/mc_replay.hpp"
#include "src/simix/smx_private.hpp"
#include "src/surf/StorageImpl.hpp"
return *this;
}
+IoImpl& IoImpl::set_disk(resource::DiskImpl* disk)
+{
+ disk_ = disk;
+ return *this;
+}
+
IoImpl& IoImpl::set_storage(resource::StorageImpl* storage)
{
storage_ = storage;
IoImpl* IoImpl::start()
{
state_ = SIMIX_RUNNING;
- surf_action_ = storage_->io_start(size_, type_);
+ if (storage_)
+ surf_action_ = storage_->io_start(size_, type_);
+ else
+ surf_action_ = disk_->io_start(size_, type_);
surf_action_->set_activity(this);
XBT_DEBUG("Create IO synchro %p %s", this, get_cname());
{
performed_ioops_ = surf_action_->get_cost();
if (surf_action_->get_state() == resource::Action::State::FAILED) {
- if (storage_ && not storage_->is_on())
+ if ((storage_ && not storage_->is_on()) || (disk_ && not disk_->is_on()))
state_ = SIMIX_FAILED;
else
state_ = SIMIX_CANCELED;
class XBT_PUBLIC IoImpl : public ActivityImpl_T<IoImpl> {
resource::StorageImpl* storage_ = nullptr;
+ resource::DiskImpl* disk_ = nullptr;
sg_size_t size_ = 0;
s4u::Io::OpType type_ = s4u::Io::OpType::READ;
sg_size_t performed_ioops_ = 0;
IoImpl& set_size(sg_size_t size);
IoImpl& set_type(s4u::Io::OpType type);
IoImpl& set_storage(resource::StorageImpl* storage);
+ IoImpl& set_disk(resource::DiskImpl* disk);
sg_size_t get_performed_ioops() { return performed_ioops_; }
--- /dev/null
+/* Copyright (c) 2019. 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 "DiskImpl.hpp"
+
+#include "simgrid/s4u/Engine.hpp"
+#include "src/kernel/EngineImpl.hpp"
+#include "src/kernel/lmm/maxmin.hpp"
+
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(disk_kernel, surf, "Logging specific to the disk kernel resource");
+
+simgrid::kernel::resource::DiskModel* surf_disk_model = nullptr;
+
+namespace simgrid {
+namespace kernel {
+namespace resource {
+
+/*********
+ * Model *
+ *********/
+
+DiskModel::DiskModel() : Model(Model::UpdateAlgo::FULL)
+{
+ set_maxmin_system(new simgrid::kernel::lmm::System(true /* selective update */));
+}
+
+DiskModel::~DiskModel()
+{
+ surf_disk_model = nullptr;
+}
+
+/************
+ * Resource *
+ ************/
+
+DiskImpl::DiskImpl(kernel::resource::Model* model, const std::string& name, kernel::lmm::System* maxminSystem,
+ double read_bw, double write_bw)
+ : Resource(model, name, maxminSystem->constraint_new(this, std::max(read_bw, write_bw))), piface_(name, this)
+{
+ DiskImpl::turn_on();
+ XBT_DEBUG("Create resource with read_bw '%f' write_bw '%f'", read_bw, write_bw);
+ constraint_read_ = maxminSystem->constraint_new(this, read_bw);
+ constraint_write_ = maxminSystem->constraint_new(this, write_bw);
+}
+
+DiskImpl::~DiskImpl()
+{
+ xbt_assert(currently_destroying_, "Don't delete Disks directly. Call destroy() instead.");
+}
+
+/** @brief Fire the required callbacks and destroy the object
+ *
+ * Don't delete directly a Disk, call d->destroy() instead.
+ */
+void DiskImpl::destroy()
+{
+ if (not currently_destroying_) {
+ currently_destroying_ = true;
+ s4u::Disk::on_destruction(this->piface_);
+ delete this;
+ }
+}
+
+bool DiskImpl::is_used()
+{
+ THROW_UNIMPLEMENTED;
+}
+
+void DiskImpl::apply_event(kernel::profile::Event* /*event*/, double /*value*/)
+{
+ THROW_UNIMPLEMENTED;
+}
+
+void DiskImpl::turn_on()
+{
+ if (not is_on()) {
+ Resource::turn_on();
+ s4u::Disk::on_state_change(this->piface_);
+ }
+}
+void DiskImpl::turn_off()
+{
+ if (is_on()) {
+ Resource::turn_off();
+ s4u::Disk::on_state_change(this->piface_);
+ }
+}
+
+xbt::signal<void(DiskAction const&, kernel::resource::Action::State, kernel::resource::Action::State)>
+ DiskAction::on_state_change;
+
+/**********
+ * Action *
+ **********/
+void DiskAction::set_state(Action::State state)
+{
+ Action::State old = get_state();
+ Action::set_state(state);
+ on_state_change(*this, old, state);
+}
+} // namespace resource
+} // namespace kernel
+} // namespace simgrid
--- /dev/null
+/* Copyright (c) 2019. 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/kernel/resource/Action.hpp"
+#include "simgrid/kernel/resource/Model.hpp"
+#include "simgrid/kernel/resource/Resource.hpp"
+#include "simgrid/s4u/Disk.hpp"
+#include "simgrid/s4u/Io.hpp"
+#include "src/surf/PropertyHolder.hpp"
+#include "src/surf/surf_interface.hpp"
+
+#include <map>
+
+#ifndef DISK_INTERFACE_HPP_
+#define DISK_INTERFACE_HPP_
+
+/*********
+ * Model *
+ *********/
+
+XBT_PUBLIC_DATA simgrid::kernel::resource::DiskModel* surf_disk_model;
+
+namespace simgrid {
+namespace kernel {
+namespace resource {
+/***********
+ * Classes *
+ ***********/
+
+class DiskAction;
+
+/*********
+ * Model *
+ *********/
+class DiskModel : public kernel::resource::Model {
+public:
+ DiskModel();
+ DiskModel(const DiskModel&) = delete;
+ DiskModel& operator=(const DiskModel&) = delete;
+ ~DiskModel();
+
+ virtual DiskImpl* createDisk(const std::string& id, double read_bw, double write_bw) = 0;
+};
+
+/************
+ * Resource *
+ ************/
+class DiskImpl : public Resource, public surf::PropertyHolder {
+ bool currently_destroying_ = false;
+ s4u::Host* host_ = nullptr;
+
+public:
+ DiskImpl(Model* model, const std::string& name, kernel::lmm::System* maxmin_system, double read_bw, double bwrite_bw);
+ DiskImpl(const DiskImpl&) = delete;
+ DiskImpl& operator=(const DiskImpl&) = delete;
+
+ ~DiskImpl() override;
+
+ /** @brief Public interface */
+ s4u::Disk piface_;
+ s4u::Disk* get_iface() { return &piface_; }
+ /** @brief Check if the Storage is used (if an action currently uses its resources) */
+ bool is_used() override;
+
+ void apply_event(profile::Event* event, double value) override;
+
+ void turn_on() override;
+ void turn_off() override;
+
+ s4u::Host* get_host() { return host_; }
+ void set_host(s4u::Host* host) { host_ = host; }
+
+ void destroy(); // Must be called instead of the destructor
+ virtual DiskAction* io_start(sg_size_t size, s4u::Io::OpType type) = 0;
+ virtual DiskAction* read(sg_size_t size) = 0;
+ virtual DiskAction* write(sg_size_t size) = 0;
+
+ lmm::Constraint* constraint_write_; /* Constraint for maximum write bandwidth*/
+ lmm::Constraint* constraint_read_; /* Constraint for maximum write bandwidth*/
+};
+
+/**********
+ * Action *
+ **********/
+
+class DiskAction : public Action {
+public:
+ static xbt::signal<void(DiskAction const&, Action::State, Action::State)> on_state_change;
+
+ DiskAction(Model* model, double cost, bool failed, DiskImpl* disk, s4u::Io::OpType type)
+ : Action(model, cost, failed), type_(type), disk_(disk){};
+
+ /**
+ * @brief diskAction constructor
+ *
+ * @param model The StorageModel associated to this DiskAction
+ * @param cost The cost of this DiskAction in bytes
+ * @param failed [description]
+ * @param var The lmm variable associated to this DiskAction if it is part of a LMM component
+ * @param storage The Storage associated to this DiskAction
+ * @param type [description]
+ */
+ DiskAction(kernel::resource::Model* model, double cost, bool failed, kernel::lmm::Variable* var, DiskImpl* disk,
+ s4u::Io::OpType type)
+ : Action(model, cost, failed, var), type_(type), disk_(disk){};
+
+ void set_state(simgrid::kernel::resource::Action::State state) override;
+
+ s4u::Io::OpType type_;
+ DiskImpl* disk_;
+};
+
+} // namespace resource
+} // namespace kernel
+} // namespace simgrid
+#endif /* DISK_INTERFACE_HPP_ */
#include "simgrid/plugins/file_system.h"
#include "simgrid/s4u/Actor.hpp"
#include "src/surf/HostImpl.hpp"
+#include "src/surf/xml/platf_private.hpp"
#include "xbt/config.hpp"
#include <algorithm>
namespace simgrid {
namespace s4u {
+simgrid::xbt::Extension<Disk, FileSystemDiskExt> FileSystemDiskExt::EXTENSION_ID;
simgrid::xbt::Extension<Storage, FileSystemStorageExt> FileSystemStorageExt::EXTENSION_ID;
simgrid::xbt::Extension<Host, FileDescriptorHostExt> FileDescriptorHostExt::EXTENSION_ID;
File::File(const std::string& fullpath, sg_host_t host, void* userdata) : fullpath_(fullpath), userdata_(userdata)
{
// this cannot fail because we get a xbt_die if the mountpoint does not exist
- Storage* st = nullptr;
- size_t longest_prefix_length = 0;
- XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
-
- for (auto const& mnt : host->get_mounted_storages()) {
- XBT_DEBUG("See '%s'", mnt.first.c_str());
- mount_point_ = fullpath_.substr(0, mnt.first.length());
-
- if (mount_point_ == mnt.first && mnt.first.length() > longest_prefix_length) {
- /* The current mount name is found in the full path and is bigger than the previous*/
- longest_prefix_length = mnt.first.length();
- st = mnt.second;
+ if (not host->get_mounted_storages().empty()) {
+ Storage* st = nullptr;
+ size_t longest_prefix_length = 0;
+ XBT_DEBUG("Search for storage name for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
+
+ for (auto const& mnt : host->get_mounted_storages()) {
+ XBT_DEBUG("See '%s'", mnt.first.c_str());
+ mount_point_ = fullpath_.substr(0, mnt.first.length());
+
+ if (mount_point_ == mnt.first && mnt.first.length() > longest_prefix_length) {
+ /* The current mount name is found in the full path and is bigger than the previous*/
+ longest_prefix_length = mnt.first.length();
+ st = mnt.second;
+ }
}
- }
- if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
- mount_point_ = fullpath_.substr(0, longest_prefix_length);
- path_ = fullpath_.substr(longest_prefix_length, fullpath_.length());
- } else
- xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
+ if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
+ mount_point_ = fullpath_.substr(0, longest_prefix_length);
+ path_ = fullpath_.substr(longest_prefix_length, fullpath_.length());
+ } else
+ xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
- local_storage_ = st;
+ local_storage_ = st;
+ }
+ if (not host->get_disks().empty()) {
+ Disk* d = nullptr;
+ size_t longest_prefix_length = 0;
+ for (auto const& disk : host->get_disks()) {
+ const char* current_mount_str = disk->get_property("mount");
+ if (current_mount_str) {
+ std::string current_mount = std::string(current_mount_str);
+ mount_point_ = fullpath_.substr(0, current_mount.length());
+ if (mount_point_ == current_mount && current_mount.length() > longest_prefix_length) {
+ /* The current mount name is found in the full path and is bigger than the previous*/
+ longest_prefix_length = current_mount.length();
+ d = disk;
+ }
+ if (longest_prefix_length > 0) { /* Mount point found, split fullpath_ into mount_name and path+filename*/
+ mount_point_ = fullpath_.substr(0, longest_prefix_length);
+ path_ = fullpath_.substr(longest_prefix_length, fullpath_.length());
+ } else
+ xbt_die("Can't find mount point for '%s' on '%s'", fullpath_.c_str(), host->get_cname());
+ }
+ }
+ local_disk_ = d;
+ }
// assign a file descriptor id to the newly opened File
FileDescriptorHostExt* ext = host->extension<simgrid::s4u::FileDescriptorHostExt>();
ext->file_descriptor_table->pop_back();
XBT_DEBUG("\tOpen file '%s'", path_.c_str());
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ std::map<std::string, sg_size_t>* content;
+ if (local_storage_)
+ content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+
+ if (local_disk_)
+ content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+
// if file does not exist create an empty file
auto sz = content->find(path_);
if (sz != content->end()) {
void File::dump()
{
- XBT_INFO("File Descriptor information:\n"
- "\t\tFull path: '%s'\n"
- "\t\tSize: %llu\n"
- "\t\tMount point: '%s'\n"
- "\t\tStorage Id: '%s'\n"
- "\t\tStorage Type: '%s'\n"
- "\t\tFile Descriptor Id: %d",
- get_path(), size_, mount_point_.c_str(), local_storage_->get_cname(), local_storage_->get_type(), desc_id);
+ if (local_storage_)
+ XBT_INFO("File Descriptor information:\n"
+ "\t\tFull path: '%s'\n"
+ "\t\tSize: %llu\n"
+ "\t\tMount point: '%s'\n"
+ "\t\tStorage Id: '%s'\n"
+ "\t\tStorage Type: '%s'\n"
+ "\t\tFile Descriptor Id: %d",
+ get_path(), size_, mount_point_.c_str(), local_storage_->get_cname(), local_storage_->get_type(), desc_id);
+ if (local_disk_)
+ XBT_INFO("File Descriptor information:\n"
+ "\t\tFull path: '%s'\n"
+ "\t\tSize: %llu\n"
+ "\t\tMount point: '%s'\n"
+ "\t\tDisk Id: '%s'\n"
+ "\t\tHost Id: '%s'\n"
+ "\t\tFile Descriptor Id: %d",
+ get_path(), size_, mount_point_.c_str(), local_disk_->get_cname(), local_disk_->get_host()->get_cname(),
+ desc_id);
}
sg_size_t File::read(sg_size_t size)
{
if (size_ == 0) /* Nothing to read, return */
return 0;
+ sg_size_t read_size = 0;
+
+ if (local_storage_) {
+ /* Find the host where the file is physically located and read it */
+ Host* host = local_storage_->get_host();
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
+ // if the current position is close to the end of the file, we may not be able to read the requested size
+ read_size = local_storage_->read(std::min(size, size_ - current_position_));
+ current_position_ += read_size;
+
+ if (host->get_name() != Host::current()->get_name() && read_size > 0) {
+ /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
+ XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), read_size);
+ host->send_to(Host::current(), read_size);
+ }
+ }
- /* Find the host where the file is physically located and read it */
- Host* host = local_storage_->get_host();
- XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
- // if the current position is close to the end of the file, we may not be able to read the requested size
- sg_size_t read_size = local_storage_->read(std::min(size, size_ - current_position_));
- current_position_ += read_size;
-
- if (host->get_name() != Host::current()->get_name() && read_size > 0) {
- /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
- XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), read_size);
- host->send_to(Host::current(), read_size);
+ if (local_disk_) {
+ /* Find the host where the file is physically located and read it */
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
+ // if the current position is close to the end of the file, we may not be able to read the requested size
+ read_size = local_disk_->read(std::min(size, size_ - current_position_));
+ current_position_ += read_size;
}
return read_size;
{
if (size == 0) /* Nothing to write, return */
return 0;
+ sg_size_t write_size = 0;
- /* Find the host where the file is physically located (remote or local)*/
- Host* host = local_storage_->get_host();
+ if (local_storage_) {
+ /* Find the host where the file is physically located (remote or local)*/
+ Host* host = local_storage_->get_host();
- if (host->get_name() != Host::current()->get_name()) {
- /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
- XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
- Host::current()->send_to(host, size);
- }
+ if (host->get_name() != Host::current()->get_name()) {
+ /* the file is hosted on a remote host, initiate a communication between src and dest hosts for data transfer */
+ XBT_DEBUG("File is on %s remote host, initiate data transfer of %llu bytes.", host->get_cname(), size);
+ Host::current()->send_to(host, size);
+ }
- XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_storage_->get_cname(), size, size_, sg_storage_get_size_used(local_storage_), sg_storage_get_size(local_storage_));
- // If the storage is full before even starting to write
- if (sg_storage_get_size_used(local_storage_) >= sg_storage_get_size(local_storage_))
- return 0;
- sg_size_t write_size=0;
- if(write_inside==0){
- /* Substract the part of the file that might disappear from the used sized on the storage element */
- local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_ - current_position_);
- write_size = local_storage_->write(size);
- local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
- current_position_ += write_size;
- size_ = current_position_;
- }else {
- write_size = local_storage_->write(size);
- current_position_ += write_size;
- if(current_position_>size_)
+ XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_storage_->get_cname(), size,
+ size_, sg_storage_get_size_used(local_storage_), sg_storage_get_size(local_storage_));
+ // If the storage is full before even starting to write
+ if (sg_storage_get_size_used(local_storage_) >= sg_storage_get_size(local_storage_))
+ return 0;
+ if (write_inside == 0) {
+ /* Substract the part of the file that might disappear from the used sized on the storage element */
+ local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_ - current_position_);
+ write_size = local_storage_->write(size);
+ local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
+ current_position_ += write_size;
size_ = current_position_;
+ } else {
+ write_size = local_storage_->write(size);
+ current_position_ += write_size;
+ if (current_position_ > size_)
+ size_ = current_position_;
+ }
+ std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+
+ content->erase(path_);
+ content->insert({path_, size_});
}
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
- content->erase(path_);
- content->insert({path_, size_});
+ if (local_disk_) {
+ XBT_DEBUG("WRITE %s on disk '%s'. size '%llu/%llu' '%llu:%llu'", get_path(), local_disk_->get_cname(), size, size_,
+ sg_disk_get_size_used(local_disk_), sg_disk_get_size(local_disk_));
+ // If the storage is full before even starting to write
+ if (sg_disk_get_size_used(local_disk_) >= sg_disk_get_size(local_disk_))
+ return 0;
+ if (write_inside == 0) {
+ /* Substract the part of the file that might disappear from the used sized on the storage element */
+ local_disk_->extension<FileSystemDiskExt>()->decr_used_size(size_ - current_position_);
+ write_size = local_disk_->write(size);
+ local_disk_->extension<FileSystemDiskExt>()->incr_used_size(write_size);
+ current_position_ += write_size;
+ size_ = current_position_;
+ } else {
+ write_size = local_disk_->write(size);
+ current_position_ += write_size;
+ if (current_position_ > size_)
+ size_ = current_position_;
+ }
+ std::map<std::string, sg_size_t>* content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+ content->erase(path_);
+ content->insert({path_, size_});
+ }
return write_size;
}
{
/* Check if the new full path is on the same mount point */
if (fullpath.compare(0, mount_point_.length(), mount_point_) == 0) {
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ std::map<std::string, sg_size_t>* content;
+ if (local_storage_)
+ content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ if (local_disk_)
+ content = local_disk_->extension<FileSystemDiskExt>()->get_content();
auto sz = content->find(path_);
if (sz != content->end()) { // src file exists
sg_size_t new_size = sz->second;
int File::unlink()
{
/* Check if the file is on local storage */
- std::map<std::string, sg_size_t>* content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ std::map<std::string, sg_size_t>* content;
+ const char* name = nullptr;
+ if (local_storage_) {
+ content = local_storage_->extension<FileSystemStorageExt>()->get_content();
+ name = local_storage_->get_cname();
+ }
+ if (local_disk_) {
+ content = local_disk_->extension<FileSystemDiskExt>()->get_content();
+ name = local_disk_->get_cname();
+ }
if (content->find(path_) == content->end()) {
- XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), local_storage_->get_cname());
+ XBT_WARN("File %s is not on disk %s. Impossible to unlink", path_.c_str(), name);
return -1;
} else {
- XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), local_storage_->get_cname());
- local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_);
+ XBT_DEBUG("UNLINK %s on disk '%s'", path_.c_str(), name);
+
+ if (local_storage_)
+ local_storage_->extension<FileSystemStorageExt>()->decr_used_size(size_);
+
+ if (local_disk_)
+ local_disk_->extension<FileSystemDiskExt>()->decr_used_size(size_);
// Remove the file from storage
content->erase(fullpath_);
int File::remote_copy(sg_host_t host, const char* fullpath)
{
/* Find the host where the file is physically located and read it */
- Storage* storage_src = local_storage_;
- Host* src_host = storage_src->get_host();
+ Host* src_host;
+ if (local_storage_) {
+ src_host = local_storage_->get_host();
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
+ }
+
+ if (local_disk_) {
+ src_host = local_disk_->get_host();
+ XBT_DEBUG("READ %s on disk '%s'", get_path(), local_disk_->get_cname());
+ }
+
seek(0, SEEK_SET);
- XBT_DEBUG("READ %s on disk '%s'", get_path(), local_storage_->get_cname());
// if the current position is close to the end of the file, we may not be able to read the requested size
- sg_size_t read_size = local_storage_->read(size_);
+ sg_size_t read_size = 0;
+ if (local_storage_)
+ read_size = local_storage_->read(size_);
+ if (local_disk_)
+ read_size = local_disk_->read(size_);
+
current_position_ += read_size;
- /* Find the host that owns the storage where the file has to be copied */
- Storage* storage_dest = nullptr;
- Host* dst_host;
- size_t longest_prefix_length = 0;
-
- for (auto const& elm : host->get_mounted_storages()) {
- std::string mount_point = std::string(fullpath).substr(0, elm.first.size());
- if (mount_point == elm.first && elm.first.length() > longest_prefix_length) {
- /* The current mount name is found in the full path and is bigger than the previous*/
- longest_prefix_length = elm.first.length();
- storage_dest = elm.second;
+ Host* dst_host = host;
+ if (local_storage_) {
+ /* Find the host that owns the storage where the file has to be copied */
+ Storage* storage_dest = nullptr;
+ size_t longest_prefix_length = 0;
+
+ for (auto const& elm : host->get_mounted_storages()) {
+ std::string mount_point = std::string(fullpath).substr(0, elm.first.size());
+ if (mount_point == elm.first && elm.first.length() > longest_prefix_length) {
+ /* The current mount name is found in the full path and is bigger than the previous*/
+ longest_prefix_length = elm.first.length();
+ storage_dest = elm.second;
+ }
+ }
+
+ if (storage_dest != nullptr) {
+ /* Mount point found, retrieve the host the storage is attached to */
+ dst_host = storage_dest->get_host();
+ } else {
+ XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
+ return -1;
}
}
- if (storage_dest != nullptr) {
- /* Mount point found, retrieve the host the storage is attached to */
- dst_host = storage_dest->get_host();
- } else {
- XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
- return -1;
+ if (local_disk_) {
+ size_t longest_prefix_length = 0;
+ Disk* dst_disk = nullptr;
+
+ for (auto const& disk : host->get_disks()) {
+ const char* current_mount_str = disk->get_property("mount");
+ if (current_mount_str) {
+ std::string current_mount = std::string(current_mount_str);
+ std::string mount_point = std::string(fullpath).substr(0, current_mount.length());
+ if (mount_point == current_mount && current_mount.length() > longest_prefix_length) {
+ /* The current mount name is found in the full path and is bigger than the previous*/
+ longest_prefix_length = current_mount.length();
+ dst_disk = disk;
+ }
+ }
+ }
+
+ if (dst_disk == nullptr) {
+ XBT_WARN("Can't find mount point for '%s' on destination host '%s'", fullpath, host->get_cname());
+ return -1;
+ }
}
XBT_DEBUG("Initiate data transfer of %llu bytes between %s and %s.", read_size, src_host->get_cname(),
- storage_dest->get_host()->get_cname());
+ dst_host->get_cname());
src_host->send_to(dst_host, read_size);
/* Create file on remote host, write it and close it */
File* fd = new File(fullpath, dst_host, nullptr);
- sg_size_t write_size = fd->local_storage_->write(read_size);
- fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
- (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
+ if (local_storage_) {
+ sg_size_t write_size = fd->local_storage_->write(read_size);
+ fd->local_storage_->extension<FileSystemStorageExt>()->incr_used_size(write_size);
+ (*(fd->local_storage_->extension<FileSystemStorageExt>()->get_content()))[path_] = size_;
+ }
+ if (local_disk_)
+ fd->write(read_size);
delete fd;
return 0;
}
return res;
}
+FileSystemDiskExt::FileSystemDiskExt(simgrid::s4u::Disk* ptr)
+{
+ const char* size_str = ptr->get_property("size");
+ const char* content_str = ptr->get_property("content");
+ size_ = size_str ? surf_parse_get_size(size_str, "disk size", ptr->get_name()) : 0;
+ if (content_str)
+ content_.reset(parse_content(content_str));
+}
+
FileSystemStorageExt::FileSystemStorageExt(simgrid::s4u::Storage* ptr)
{
content_.reset(parse_content(ptr->get_impl()->content_name_));
size_ = ptr->get_impl()->size_;
}
+std::map<std::string, sg_size_t>* FileSystemDiskExt::parse_content(const std::string& filename)
+{
+ if (filename.empty())
+ return nullptr;
+
+ std::map<std::string, sg_size_t>* parse_content = new std::map<std::string, sg_size_t>();
+
+ std::ifstream* fs = surf_ifsopen(filename);
+
+ std::string line;
+ std::vector<std::string> tokens;
+ do {
+ std::getline(*fs, line);
+ boost::trim(line);
+ if (line.length() > 0) {
+ boost::split(tokens, line, boost::is_any_of(" \t"), boost::token_compress_on);
+ xbt_assert(tokens.size() == 2, "Parse error in %s: %s", filename.c_str(), line.c_str());
+ sg_size_t size = std::stoull(tokens.at(1));
+
+ used_size_ += size;
+ parse_content->insert({tokens.front(), size});
+ }
+ } while (not fs->eof());
+ delete fs;
+ return parse_content;
+}
+
std::map<std::string, sg_size_t>* FileSystemStorageExt::parse_content(const std::string& filename)
{
if (filename.empty())
}
}
-using simgrid::s4u::FileSystemStorageExt;
using simgrid::s4u::FileDescriptorHostExt;
+using simgrid::s4u::FileSystemDiskExt;
+using simgrid::s4u::FileSystemStorageExt;
+static void on_disk_creation(simgrid::s4u::Disk& d)
+{
+ d.extension_set(new FileSystemDiskExt(&d));
+}
static void on_storage_creation(simgrid::s4u::Storage& st)
{
st.extension_set(new FileSystemStorageExt(&st));
simgrid::s4u::Storage::on_creation.connect(&on_storage_creation);
}
+ if (not FileSystemDiskExt::EXTENSION_ID.valid()) {
+ FileSystemDiskExt::EXTENSION_ID = simgrid::s4u::Disk::extension_create<FileSystemDiskExt>();
+ simgrid::s4u::Disk::on_creation.connect(&on_disk_creation);
+ }
+
if (not FileDescriptorHostExt::EXTENSION_ID.valid()) {
FileDescriptorHostExt::EXTENSION_ID = simgrid::s4u::Host::extension_create<FileDescriptorHostExt>();
simgrid::s4u::Host::on_creation.connect(&on_host_creation);
return file->remote_move(host, fullpath);
}
+sg_size_t sg_disk_get_size_free(sg_disk_t d)
+{
+ return d->extension<FileSystemDiskExt>()->get_size() - d->extension<FileSystemDiskExt>()->get_used_size();
+}
+
+sg_size_t sg_disk_get_size_used(sg_disk_t d)
+{
+ return d->extension<FileSystemDiskExt>()->get_used_size();
+}
+
+sg_size_t sg_disk_get_size(sg_disk_t d)
+{
+ return d->extension<FileSystemDiskExt>()->get_size();
+}
+
sg_size_t sg_storage_get_size_free(sg_storage_t st)
{
return st->extension<FileSystemStorageExt>()->get_size() - st->extension<FileSystemStorageExt>()->get_used_size();
--- /dev/null
+/* Copyright (c) 2019. 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/Engine.hpp"
+#include "simgrid/s4u/Host.hpp"
+#include "simgrid/s4u/Io.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
+
+namespace simgrid {
+namespace xbt {
+template class Extendable<s4u::Disk>;
+} // namespace xbt
+
+namespace s4u {
+
+xbt::signal<void(Disk&)> Disk::on_creation;
+xbt::signal<void(Disk const&)> Disk::on_destruction;
+xbt::signal<void(Disk const&)> Disk::on_state_change;
+
+Host* Disk::get_host()
+{
+ return pimpl_->get_host();
+}
+
+const std::unordered_map<std::string, std::string>* Disk::get_properties() const
+{
+ return pimpl_->get_properties();
+}
+
+const char* Disk::get_property(const std::string& key) const
+{
+ return this->pimpl_->get_property(key);
+}
+
+void Disk::set_property(const std::string& key, const std::string& value)
+{
+ kernel::actor::simcall([this, &key, &value] { this->pimpl_->set_property(key, value); });
+}
+
+IoPtr Disk::io_init(sg_size_t size, Io::OpType type)
+{
+ return IoPtr(new Io(this, size, type));
+}
+
+IoPtr Disk::read_async(sg_size_t size)
+{
+ return IoPtr(io_init(size, Io::OpType::READ))->start();
+}
+
+sg_size_t Disk::read(sg_size_t size)
+{
+ return IoPtr(io_init(size, Io::OpType::READ))->start()->wait()->get_performed_ioops();
+}
+
+IoPtr Disk::write_async(sg_size_t size)
+{
+
+ return IoPtr(io_init(size, Io::OpType::WRITE)->start());
+}
+
+sg_size_t Disk::write(sg_size_t size)
+{
+ return IoPtr(io_init(size, Io::OpType::WRITE))->start()->wait()->get_performed_ioops();
+}
+
+} // namespace s4u
+} // namespace simgrid
#include "mc/mc.h"
#include "simgrid/kernel/routing/NetPoint.hpp"
#include "simgrid/kernel/routing/NetZoneImpl.hpp"
+#include "simgrid/s4u/Disk.hpp"
#include "simgrid/s4u/Engine.hpp"
#include "simgrid/s4u/Host.hpp"
#include "simgrid/s4u/Mailbox.hpp"
return this->pimpl_cpu->get_pstate();
}
+std::vector<Disk*> Host::get_disks() const
+{
+ return kernel::actor::simcall([this] { return this->pimpl_->get_disks(); });
+}
+
/**
* @ingroup simix_storage_management
* @brief Returns the list of storages attached to a host.
/* 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 "src/kernel/activity/IoImpl.hpp"
namespace simgrid {
namespace s4u {
+Io::Io(sg_disk_t disk, sg_size_t size, OpType type) : disk_(disk), size_(size), type_(type)
+{
+ Activity::set_remaining(size_);
+ pimpl_ = kernel::activity::IoImplPtr(new kernel::activity::IoImpl());
+}
+
Io::Io(sg_storage_t storage, sg_size_t size, OpType type) : storage_(storage), size_(size), type_(type)
{
Activity::set_remaining(size_);
Io* Io::start()
{
kernel::actor::simcall([this] {
- (*boost::static_pointer_cast<kernel::activity::IoImpl>(pimpl_))
- .set_name(name_)
- .set_storage(storage_->get_impl())
- .set_size(size_)
- .set_type(type_)
- .start();
+ if (storage_) {
+ (*boost::static_pointer_cast<kernel::activity::IoImpl>(pimpl_))
+ .set_name(name_)
+ .set_storage(storage_->get_impl())
+ .set_size(size_)
+ .set_type(type_)
+ .start();
+ } else {
+ (*boost::static_pointer_cast<kernel::activity::IoImpl>(pimpl_))
+ .set_name(name_)
+ .set_disk(disk_->get_impl())
+ .set_size(size_)
+ .set_type(type_)
+ .start();
+ }
});
state_ = State::STARTED;
return this;
find_model_description(surf_optimization_mode_description, value);
}
+static void _sg_cfg_cb__disk_model(const std::string& value)
+{
+ xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
+
+ if (value == "help") {
+ model_help("disk", surf_disk_model_description);
+ exit(0);
+ }
+
+ find_model_description(surf_disk_model_description, value);
+}
+
/* callback of the cpu/model variable */
-static void _sg_cfg_cb__storage_mode(const std::string& value)
+static void _sg_cfg_cb__storage_model(const std::string& value)
{
xbt_assert(_sg_cfg_init_status < 2, "Cannot change the model after the initialization");
declare_model_flag("cpu/model", "Cas01", &_sg_cfg_cb__cpu_model, surf_cpu_model_description, "model",
"The model to use for the CPU");
- declare_model_flag("storage/model", "default", &_sg_cfg_cb__storage_mode, surf_storage_model_description, "model",
+ declare_model_flag("disk/model", "default", &_sg_cfg_cb__disk_model, surf_disk_model_description, "model",
+ "The model to use for the disk");
+
+ declare_model_flag("storage/model", "default", &_sg_cfg_cb__storage_model, surf_storage_model_description, "model",
"The model to use for the storage");
declare_model_flag("network/model", "LV08", &_sg_cfg_cb__network_model, surf_network_model_description, "model",
for (auto const& arg : actors_at_boot_)
delete arg;
actors_at_boot_.clear();
+
+ for (auto const& d : disks_)
+ d->destroy();
}
/** Re-starts all the actors that are marked as restartable.
{
return process_list_.size();
}
+
+std::vector<s4u::Disk*> HostImpl::get_disks()
+{
+ std::vector<s4u::Disk*> disks;
+ for (auto const& d : disks_)
+ disks.push_back(&d->piface_);
+ return disks;
+}
+
std::vector<const char*> HostImpl::get_attached_storages()
{
std::vector<const char*> storages;
#define SURF_HOST_INTERFACE_HPP_
#include "src/kernel/actor/ActorImpl.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
#include "src/surf/PropertyHolder.hpp"
#include "src/surf/StorageImpl.hpp"
#include "src/surf/cpu_interface.hpp"
explicit HostImpl(s4u::Host* host);
virtual ~HostImpl();
+ std::vector<s4u::Disk*> get_disks();
/** @brief Get the vector of storages (by names) attached to the Host */
virtual std::vector<const char*> get_attached_storages();
std::map<std::string, kernel::resource::StorageImpl*> storage_;
+ std::vector<kernel::resource::DiskImpl*> disks_;
+
s4u::Host* piface_ = nullptr;
void turn_on();
--- /dev/null
+/* Copyright (c) 2013-2019. 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 "disk_s19.hpp"
+#include "simgrid/kernel/routing/NetPoint.hpp"
+#include "simgrid/s4u/Engine.hpp"
+#include "simgrid/s4u/Host.hpp"
+#include "src/kernel/lmm/maxmin.hpp"
+#include "src/surf/xml/platf.hpp"
+#include "surf/surf.hpp"
+
+XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(disk_kernel);
+
+/*********
+ * Model *
+ *********/
+
+void surf_disk_model_init_default()
+{
+ surf_disk_model = new simgrid::kernel::resource::DiskS19Model();
+}
+
+namespace simgrid {
+namespace kernel {
+namespace resource {
+
+DiskS19Model::DiskS19Model()
+{
+ all_existing_models.push_back(this);
+}
+
+DiskImpl* DiskS19Model::createDisk(const std::string& id, double read_bw, double write_bw)
+{
+ XBT_DEBUG("SURF disk create resource\n\t\tid '%s'\n\t\tread_bw '%f'\n", id.c_str(), read_bw);
+
+ return new DiskS19(this, id, get_maxmin_system(), read_bw, write_bw);
+}
+
+double DiskS19Model::next_occuring_event(double now)
+{
+ return DiskModel::next_occuring_event_full(now);
+}
+
+void DiskS19Model::update_actions_state(double /*now*/, double delta)
+{
+ for (auto it = std::begin(*get_started_action_set()); it != std::end(*get_started_action_set());) {
+ auto& action = *it;
+ ++it; // increment iterator here since the following calls to action.finish() may invalidate it
+ action.update_remains(lrint(action.get_variable()->get_value() * delta));
+ action.update_max_duration(delta);
+
+ if (((action.get_remains_no_update() <= 0) && (action.get_variable()->get_penalty() > 0)) ||
+ ((action.get_max_duration() != NO_MAX_DURATION) && (action.get_max_duration() <= 0))) {
+ action.finish(Action::State::FINISHED);
+ }
+ }
+}
+
+/************
+ * Resource *
+ ************/
+
+DiskS19::DiskS19(DiskModel* model, const std::string& name, lmm::System* maxminSystem, double read_bw, double write_bw)
+ : DiskImpl(model, name, maxminSystem, read_bw, write_bw)
+{
+ XBT_DEBUG("Create resource with read_bw '%f' write_bw '%f'", read_bw, write_bw);
+}
+
+DiskAction* DiskS19::io_start(sg_size_t size, s4u::Io::OpType type)
+{
+ return new DiskS19Action(get_model(), size, not is_on(), this, type);
+}
+
+DiskAction* DiskS19::read(sg_size_t size)
+{
+ return new DiskS19Action(get_model(), size, not is_on(), this, s4u::Io::OpType::READ);
+}
+
+DiskAction* DiskS19::write(sg_size_t size)
+{
+ return new DiskS19Action(get_model(), size, not is_on(), this, s4u::Io::OpType::WRITE);
+}
+
+/**********
+ * Action *
+ **********/
+
+DiskS19Action::DiskS19Action(Model* model, double cost, bool failed, DiskImpl* disk, s4u::Io::OpType type)
+ : DiskAction(model, cost, failed, model->get_maxmin_system()->variable_new(this, 1.0, -1.0, 3), disk, type)
+{
+ XBT_IN("(%s,%g", disk->get_cname(), cost);
+
+ // Must be less than the max bandwidth for all actions
+ model->get_maxmin_system()->expand(disk->get_constraint(), get_variable(), 1.0);
+ switch (type) {
+ case s4u::Io::OpType::READ:
+ model->get_maxmin_system()->expand(disk->constraint_read_, get_variable(), 1.0);
+ break;
+ case s4u::Io::OpType::WRITE:
+ model->get_maxmin_system()->expand(disk->constraint_write_, get_variable(), 1.0);
+ break;
+ default:
+ THROW_UNIMPLEMENTED;
+ }
+ XBT_OUT();
+}
+
+void DiskS19Action::cancel()
+{
+ set_state(Action::State::FAILED);
+}
+
+void DiskS19Action::suspend()
+{
+ XBT_IN("(%p)", this);
+ if (is_running()) {
+ get_model()->get_maxmin_system()->update_variable_penalty(get_variable(), 0.0);
+ set_suspend_state(Action::SuspendStates::SUSPENDED);
+ }
+ XBT_OUT();
+}
+
+void DiskS19Action::resume()
+{
+ THROW_UNIMPLEMENTED;
+}
+
+void DiskS19Action::set_max_duration(double /*duration*/)
+{
+ THROW_UNIMPLEMENTED;
+}
+
+void DiskS19Action::set_sharing_penalty(double)
+{
+ THROW_UNIMPLEMENTED;
+}
+void DiskS19Action::update_remains_lazy(double /*now*/)
+{
+ THROW_IMPOSSIBLE;
+}
+} // namespace resource
+} // namespace kernel
+} // namespace simgrid
--- /dev/null
+/* Copyright (c) 2013-2019. 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 <xbt/base.h>
+
+#include "src/kernel/resource/DiskImpl.hpp"
+
+#ifndef DISK_S19_HPP_
+#define DISK_S19_HPP_
+
+namespace simgrid {
+namespace kernel {
+namespace resource {
+
+/***********
+ * Classes *
+ ***********/
+
+class XBT_PRIVATE DiskS19Model;
+class XBT_PRIVATE DiskS19;
+class XBT_PRIVATE DiskS19Action;
+
+/*********
+ * Model *
+ *********/
+
+class DiskS19Model : public DiskModel {
+public:
+ DiskS19Model();
+ DiskImpl* createDisk(const std::string& id, double read_bw, double write_bw) override;
+ double next_occuring_event(double now) override;
+ void update_actions_state(double now, double delta) override;
+};
+
+/************
+ * Resource *
+ ************/
+
+class DiskS19 : public DiskImpl {
+public:
+ DiskS19(DiskModel* model, const std::string& name, kernel::lmm::System* maxminSystem, double read_bw,
+ double write_bw);
+ virtual ~DiskS19() = default;
+ DiskAction* io_start(sg_size_t size, s4u::Io::OpType type) override;
+ DiskAction* read(sg_size_t size) override;
+ DiskAction* write(sg_size_t size) override;
+};
+
+/**********
+ * Action *
+ **********/
+
+class DiskS19Action : public DiskAction {
+public:
+ DiskS19Action(Model* model, double cost, bool failed, DiskImpl* disk, s4u::Io::OpType type);
+ void suspend() override;
+ void cancel() override;
+ void resume() override;
+ void set_max_duration(double duration) override;
+ void set_sharing_penalty(double sharing_penalty) override;
+ void update_remains_lazy(double now) override;
+};
+
+} // namespace resource
+} // namespace kernel
+} // namespace simgrid
+#endif /* DISK_S19_HPP_ */
double min_by_net =
surf_network_model->next_occuring_event_is_idempotent() ? surf_network_model->next_occuring_event(now) : -1;
double min_by_sto = surf_storage_model->next_occuring_event(now);
+ double min_by_dsk = surf_disk_model->next_occuring_event(now);
- XBT_DEBUG("model %p, %s min_by_cpu %f, %s min_by_net %f, %s min_by_sto %f",
- this, typeid(surf_cpu_model_pm).name(), min_by_cpu,
- typeid(surf_network_model).name(), min_by_net,
- typeid(surf_storage_model).name(), min_by_sto);
+ XBT_DEBUG("model %p, %s min_by_cpu %f, %s min_by_net %f, %s min_by_sto %f, %s min_by_dsk %f", this,
+ typeid(surf_cpu_model_pm).name(), min_by_cpu, typeid(surf_network_model).name(), min_by_net,
+ typeid(surf_storage_model).name(), min_by_sto, typeid(surf_disk_model).name(), min_by_dsk);
double res = min_by_cpu;
if (res < 0 || (min_by_net >= 0.0 && min_by_net < res))
res = min_by_net;
if (res < 0 || (min_by_sto >= 0.0 && min_by_sto < res))
res = min_by_sto;
+ if (res < 0 || (min_by_dsk >= 0.0 && min_by_dsk < res))
+ res = min_by_dsk;
return res;
}
#include "src/include/simgrid/sg_config.hpp"
#include "src/include/surf/surf.hpp"
#include "src/kernel/EngineImpl.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
#include "src/kernel/resource/profile/Profile.hpp"
#include "src/simix/smx_private.hpp"
#include "src/surf/HostImpl.hpp"
host->pimpl_->storage_ = mount_list;
mount_list.clear();
+ host->pimpl_->disks_ = std::move(args->disks);
+ for (auto d : host->pimpl_->disks_)
+ d->set_host(host);
+
/* Change from the defaults */
if (args->state_trace)
host->pimpl_cpu->set_state_profile(args->state_trace);
delete cabinet->radicals;
}
+simgrid::kernel::resource::DiskImpl* sg_platf_new_disk(simgrid::kernel::routing::DiskCreationArgs* disk)
+{
+ simgrid::kernel::resource::DiskImpl* d = surf_disk_model->createDisk(disk->id, disk->read_bw, disk->write_bw);
+ if (disk->properties) {
+ d->set_properties(*disk->properties);
+ delete disk->properties;
+ }
+ simgrid::s4u::Disk::on_creation(*d->get_iface());
+ return d;
+}
+
void sg_platf_new_storage(simgrid::kernel::routing::StorageCreationArgs* storage)
{
xbt_assert(std::find(known_storages.begin(), known_storages.end(), storage->id) == known_storages.end(),
std::string host_model_name = simgrid::config::get_value<std::string>("host/model");
std::string network_model_name = simgrid::config::get_value<std::string>("network/model");
std::string cpu_model_name = simgrid::config::get_value<std::string>("cpu/model");
+ std::string disk_model_name = simgrid::config::get_value<std::string>("disk/model");
std::string storage_model_name = simgrid::config::get_value<std::string>("storage/model");
/* The compound host model is needed when using non-default net/cpu models */
XBT_DEBUG("Call vm_model_init");
surf_vm_model_init_HL13();
+ XBT_DEBUG("Call disk_model_init");
+ int disk_id = find_model_description(surf_disk_model_description, disk_model_name);
+ surf_disk_model_description[disk_id].model_init_preparse();
+
XBT_DEBUG("Call storage_model_init");
int storage_id = find_model_description(surf_storage_model_description, storage_model_name);
surf_storage_model_description[storage_id].model_init_preparse();
#include "simgrid/s4u/Engine.hpp"
#include "src/include/surf/surf.hpp"
#include "src/instr/instr_private.hpp"
+#include "src/kernel/resource/DiskImpl.hpp"
#include "src/kernel/resource/profile/FutureEvtSet.hpp"
#include "src/plugins/vm/VirtualMachineImpl.hpp"
for (auto const& model : all_existing_models) {
if (model != surf_host_model && model != surf_vm_model && model != surf_network_model &&
- model != surf_storage_model) {
+ model != surf_storage_model && model != surf_disk_model) {
double next_event_model = model->next_occuring_event(NOW);
if ((time_delta < 0.0 || next_event_model < time_delta) && next_event_model >= 0.0)
time_delta = next_event_model;
{"Full", "Full update of remaining and variables. Slow but may be useful when debugging.", nullptr},
};
+const std::vector<surf_model_description_t> surf_disk_model_description = {
+ {"default", "Simplistic disk model.", &surf_disk_model_init_default},
+};
+
const std::vector<surf_model_description_t> surf_storage_model_description = {
{"default", "Simplistic storage model.", &surf_storage_model_init_default},
};
*/
XBT_PUBLIC void surf_storage_model_init_default();
+XBT_PUBLIC void surf_disk_model_init_default();
+
/* --------------------
* Model Descriptions
* -------------------- */
XBT_PUBLIC_DATA const std::vector<surf_model_description_t> surf_cpu_model_description;
/** @brief The list of all network models (pick one with --cfg=network/model) */
XBT_PUBLIC_DATA const std::vector<surf_model_description_t> surf_network_model_description;
+/** @brief The list of all disk models (pick one with --cfg=disk/model) */
+XBT_PUBLIC_DATA const std::vector<surf_model_description_t> surf_disk_model_description;
/** @brief The list of all storage models (pick one with --cfg=storage/model) */
XBT_PUBLIC_DATA const std::vector<surf_model_description_t> surf_storage_model_description;
/** @brief The list of all host models (pick one with --cfg=host/model:) */
profile::Profile* state_trace = nullptr;
std::string coord = "";
std::unordered_map<std::string, std::string>* properties = nullptr;
+ std::vector<simgrid::kernel::resource::DiskImpl*> disks;
};
class HostLinkCreationArgs {
sg_size_t size;
};
+class DiskCreationArgs {
+public:
+ std::string id;
+ std::unordered_map<std::string, std::string>* properties;
+ double read_bw;
+ double write_bw;
+};
+
class MountCreationArgs {
public:
std::string storageId;
XBT_PUBLIC void sg_platf_new_trace(simgrid::kernel::routing::ProfileCreationArgs* trace);
+XBT_PUBLIC simgrid::kernel::resource::DiskImpl*
+sg_platf_new_disk(simgrid::kernel::routing::DiskCreationArgs* disk); // Add a disk to the current host
+
XBT_PUBLIC void sg_platf_new_storage(simgrid::kernel::routing::StorageCreationArgs* storage); // Add a storage to the current Zone
XBT_PUBLIC void sg_platf_new_storage_type(simgrid::kernel::routing::StorageTypeCreationArgs* storage_type);
XBT_PUBLIC void sg_platf_new_mount(simgrid::kernel::routing::MountCreationArgs* mount);
static std::string surf_parsed_filename; // Currently parsed file (for the error messages)
std::vector<simgrid::kernel::resource::LinkImpl*>
- parsed_link_list; /* temporary store of current list link of a route */
-
+ parsed_link_list; /* temporary store of current link list of a route */
+std::vector<simgrid::kernel::resource::DiskImpl*> parsed_disk_list; /* temporary store of current disk list of a host */
/*
* Helping functions
*/
: nullptr;
host.pstate = surf_parse_get_int(A_surfxml_host_pstate);
host.coord = A_surfxml_host_coordinates;
+ host.disks.swap(parsed_disk_list);
sg_platf_new_host(&host);
}
void STag_surfxml_disk() {
- THROW_UNIMPLEMENTED;
+ ZONE_TAG = 0;
+ xbt_assert(current_property_set == nullptr,
+ "Someone forgot to reset the property set to nullptr in its closing tag (or XML malformed)");
}
+
void ETag_surfxml_disk() {
+ simgrid::kernel::routing::DiskCreationArgs disk;
+ disk.properties = current_property_set;
+ current_property_set = nullptr;
+
+ disk.id = A_surfxml_disk_id;
+ disk.read_bw = surf_parse_get_bandwidth(A_surfxml_disk_read___bw, "read_bw of disk ", disk.id);
+ disk.write_bw = surf_parse_get_bandwidth(A_surfxml_disk_write___bw, "write_bw of disk ", disk.id);
+
+ parsed_disk_list.push_back(sg_platf_new_disk(&disk));
}
void STag_surfxml_host___link(){
src/surf/xml/simgrid_dtd.c
src/surf/xml/surfxml_sax_cb.cpp
+ src/surf/disk_s19.hpp
src/surf/StorageImpl.hpp
src/surf/storage_n11.hpp
src/surf/surf_interface.hpp
src/kernel/resource/Action.cpp
src/kernel/resource/Model.cpp
src/kernel/resource/Resource.cpp
+ src/kernel/resource/DiskImpl.cpp
+ src/kernel/resource/DiskImpl.hpp
src/kernel/resource/profile/DatedValue.cpp
src/kernel/resource/profile/DatedValue.hpp
src/surf/cpu_cas01.cpp
src/surf/cpu_interface.cpp
src/surf/cpu_ti.cpp
+ src/surf/disk_s19.cpp
src/surf/network_cm02.cpp
src/surf/network_constant.cpp
src/surf/network_interface.cpp
src/s4u/s4u_Barrier.cpp
src/s4u/s4u_ConditionVariable.cpp
src/s4u/s4u_Comm.cpp
+ src/s4u/s4u_Disk.cpp
src/s4u/s4u_Engine.cpp
src/s4u/s4u_Exec.cpp
src/s4u/s4u_Host.cpp
include/simgrid/s4u/Barrier.hpp
include/simgrid/s4u/Comm.hpp
include/simgrid/s4u/ConditionVariable.hpp
+ include/simgrid/s4u/Disk.hpp
include/simgrid/s4u/Engine.hpp
include/simgrid/s4u/Exec.hpp
include/simgrid/s4u/Host.hpp
examples/platforms/faulty_host.xml
examples/platforms/g5k.xml
examples/platforms/griffon.xml
+ examples/platforms/hosts_with_disks.xml
examples/platforms/meta_cluster.xml
examples/platforms/multicore_machine.xml
examples/platforms/onelink.xml