X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/78ad8111935dd39520e2cbae135e042817d78583..f754aabeea56ded8bc234a5ffc7dda03428d6b88:/src/mc/AddressSpace.hpp diff --git a/src/mc/AddressSpace.hpp b/src/mc/AddressSpace.hpp index 8ac72ea462..18969aaa0a 100644 --- a/src/mc/AddressSpace.hpp +++ b/src/mc/AddressSpace.hpp @@ -1,29 +1,20 @@ -/* Copyright (c) 2008-2014. The SimGrid Team. +/* Copyright (c) 2008-2015. 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 MC_ADDRESS_SPACE_H -#define MC_ADDRESS_SPACE_H +#ifndef SIMGRID_MC_ADDRESS_SPACE_H +#define SIMGRID_MC_ADDRESS_SPACE_H +#include +#include #include +#include #include -#include - -#include - -#include "mc_forward.h" - -// Compatibility stuff, will be removed: -#define MC_ADDRESS_SPACE_READ_FLAGS_NONE ::simgrid::mc::AddressSpace::Normal -#define MC_ADDRESS_SPACE_READ_FLAGS_LAZY ::simgrid::mc::AddressSpace::Lazy - -// Compatibility stuff, will be removed: -#define MC_PROCESS_INDEX_MISSING ::simgrid::mc::ProcessIndexMissing -#define MC_PROCESS_INDEX_DISABLED ::simgrid::mc::ProcessIndexDisabled -#define MC_PROCESS_INDEX_ANY ::simgrid::mc::ProcessIndexAny +#include "src/mc/mc_forward.hpp" +#include "src/mc/RemotePtr.hpp" namespace simgrid { namespace mc { @@ -44,25 +35,154 @@ const int ProcessIndexDisabled = -2; */ const int ProcessIndexAny = 0; +/** Options for read operations + * + * This is a set of flags managed with bitwise operators. Only the + * meaningful operations are defined: addition, conversions to/from + * integers are not allowed. + */ +class ReadOptions { + std::uint32_t value_; + constexpr explicit ReadOptions(std::uint32_t value) : value_(value) {} +public: + constexpr ReadOptions() : value_(0) {} + + constexpr operator bool() const { return value_ != 0; } + constexpr bool operator!() const { return value_ == 0; } + + constexpr ReadOptions operator|(ReadOptions const& that) const + { + return ReadOptions(value_ | that.value_); + } + constexpr ReadOptions operator&(ReadOptions const& that) const + { + return ReadOptions(value_ & that.value_); + } + constexpr ReadOptions operator^(ReadOptions const& that) const + { + return ReadOptions(value_ ^ that.value_); + } + constexpr ReadOptions operator~() const + { + return ReadOptions(~value_); + } + + ReadOptions& operator|=(ReadOptions const& that) + { + value_ |= that.value_; + return *this; + } + ReadOptions& operator&=(ReadOptions const& that) + { + value_ &= that.value_; + return *this; + } + ReadOptions& operator^=(ReadOptions const& that) + { + value_ &= that.value_; + return *this; + } + + /** Copy the data to the given buffer */ + static constexpr ReadOptions none() { return ReadOptions(0); } + + /** Allows to return a pointer to another buffer where the data is + * available instead of copying the data into the buffer + */ + static constexpr ReadOptions lazy() { return ReadOptions(1); } +}; + +/** A value from another process + * + * This represents a value from another process: + * + * * constructor/destructor are disabled; + * + * * raw memory copy (std::memcpy) is used to copy Remote; + * + * * raw memory comparison is used to compare them; + * + * * when T is a trivial type, Remote is convertible to a T. + * + * We currently only handle the case where the type has the same layout + * in the current process and in the target process: we don't handle + * cross-architecture (such as 32-bit/64-bit access). + */ +template +class Remote { +private: + // If we use a union, it won't work with abstract types: + char buffer[sizeof(T)]; +public: + // HACK, some code currently cast this to T* which is **not** legal. + void* data() { return buffer; } + const void* data() const { return buffer; } + constexpr std::size_t size() const { return sizeof(T); } + operator T() const { + static_assert(std::is_trivial::value, "Cannot convert non trivial type"); + T res; + std::memcpy(&res, buffer, sizeof(T)); + return res; + } + Remote() {} + Remote(T const& x) + { + std::memcpy(&x, buffer, sizeof(T)); + } + Remote& operator=(T const& x) + { + std::memcpy(&x, buffer, sizeof(T)); + } +}; + +/** A given state of a given process (abstract base class) + * + * Currently, this might either be: + * + * * the current state of an existing process; + * + * * a snapshot. + */ class AddressSpace { +private: + Process* process_; public: - enum ReadMode { - Normal, - /** Allows the `read_bytes` to return a pointer to another buffer - * where the data ins available instead of copying the data into the buffer - */ - Lazy - }; + AddressSpace(Process* process) : process_(process) {} virtual ~AddressSpace(); + + simgrid::mc::Process* process() const { return process_; } + + /** Read data from the address space + * + * @param buffer target buffer for the data + * @param size number of bytes + * @param address remote source address of the data + * @param process_index which process (used for SMPI privatization) + * @param options + */ virtual const void* read_bytes(void* buffer, std::size_t size, - std::uint64_t address, int process_index = ProcessIndexAny, - ReadMode mode = Normal) = 0; - template - T read(uint64_t address, int process_index = ProcessIndexMissing) + RemotePtr address, int process_index = ProcessIndexAny, + ReadOptions options = ReadOptions::none()) const = 0; + + /** Read a given data structure from the address space */ + template inline + void read(T *buffer, RemotePtr ptr, int process_index = ProcessIndexAny) { - static_assert(std::is_trivial::value, "Cannot read a non-trivial type"); - T res; - this->read_bytes(&res, sizeof(T), address, process_index); + this->read_bytes(buffer, sizeof(T), ptr, process_index); + } + + template inline + void read(Remote& buffer, RemotePtr ptr, int process_index = ProcessIndexAny) + { + this->read_bytes(buffer.data(), sizeof(T), ptr, process_index); + } + + /** Read a given data structure from the address space */ + template inline + Remote read(RemotePtr ptr, int process_index = ProcessIndexMissing) + { + Remote res; + this->read_bytes(&res, sizeof(T), ptr, process_index); return res; } }; @@ -70,15 +190,4 @@ public: } } -// Deprecated compatibility wrapper: -static inline -const void* MC_address_space_read( - mc_address_space_t address_space, simgrid::mc::AddressSpace::ReadMode mode, - void* target, const void* addr, size_t size, - int process_index) -{ - return address_space->read_bytes(target, size, (std::uint64_t) addr, - process_index, mode); -} - #endif