#include <type_traits>
#include "src/mc/mc_forward.hpp"
-#include "src/mc/remote_ptr.hpp"
+#include "src/mc/RemotePtr.hpp"
namespace simgrid {
namespace mc {
* @param options
*/
virtual const void* read_bytes(void* buffer, std::size_t size,
- remote_ptr<void> address, int process_index = ProcessIndexAny,
+ RemotePtr<void> address, int process_index = ProcessIndexAny,
ReadOptions options = ReadOptions::none()) const = 0;
/** Read a given data structure from the address space */
template<class T> inline
- void read(T *buffer, remote_ptr<T> ptr, int process_index = ProcessIndexAny)
+ void read(T *buffer, RemotePtr<T> ptr, int process_index = ProcessIndexAny)
{
this->read_bytes(buffer, sizeof(T), ptr, process_index);
}
/** Read a given data structure from the address space */
template<class T> inline
- T read(remote_ptr<T> ptr, int process_index = ProcessIndexMissing)
+ T read(RemotePtr<T> ptr, int process_index = ProcessIndexMissing)
{
static_assert(std::is_trivial<T>::value, "Cannot read a non-trivial type");
T res;
* @return Snapshot page numbers of this new snapshot
*/
ChunkedData::ChunkedData(PageStore& store, AddressSpace& as,
- remote_ptr<void> addr, std::size_t page_count,
+ RemotePtr<void> addr, std::size_t page_count,
const std::size_t* ref_page_numbers, const std::uint64_t* pagemap)
{
store_ = &store;
continue;
}
- remote_ptr<void> page = remote(addr.address() + (i << xbt_pagebits));
+ RemotePtr<void> page = remote(addr.address() + (i << xbt_pagebits));
xbt_assert(mc_page_offset((void*)page.address())==0,
"Not at the beginning of a page");
}
ChunkedData(PageStore& store, AddressSpace& as,
- remote_ptr<void> addr, std::size_t page_count,
+ RemotePtr<void> addr, std::size_t page_count,
const std::size_t* ref_page_numbers, const std::uint64_t* pagemap);
};
_mc_property_automaton = xbt_automaton_new();
simgrid::mc::Process* process = &this->process();
- simgrid::mc::remote_ptr<int> address
+ simgrid::mc::RemotePtr<int> address
= simgrid::mc::remote((int*) message.data);
simgrid::xbt::add_proposition(_mc_property_automaton,
message.name,
XBT_DEBUG("Get debug information done !");
}
-std::shared_ptr<simgrid::mc::ObjectInformation> Process::find_object_info(remote_ptr<void> addr) const
+std::shared_ptr<simgrid::mc::ObjectInformation> Process::find_object_info(RemotePtr<void> addr) const
{
for (auto const& object_info : this->object_infos) {
if (addr.address() >= (std::uint64_t)object_info->start
return nullptr;
}
-std::shared_ptr<ObjectInformation> Process::find_object_info_exec(remote_ptr<void> addr) const
+std::shared_ptr<ObjectInformation> Process::find_object_info_exec(RemotePtr<void> addr) const
{
for (std::shared_ptr<ObjectInformation> const& info : this->object_infos) {
if (addr.address() >= (std::uint64_t) info->start_exec
return nullptr;
}
-std::shared_ptr<ObjectInformation> Process::find_object_info_rw(remote_ptr<void> addr) const
+std::shared_ptr<ObjectInformation> Process::find_object_info_rw(RemotePtr<void> addr) const
{
for (std::shared_ptr<ObjectInformation> const& info : this->object_infos) {
if (addr.address() >= (std::uint64_t)info->start_rw
return nullptr;
}
-simgrid::mc::Frame* Process::find_function(remote_ptr<void> ip) const
+simgrid::mc::Frame* Process::find_function(RemotePtr<void> ip) const
{
std::shared_ptr<simgrid::mc::ObjectInformation> info = this->find_object_info_exec(ip);
return info ? info->find_function((void*) ip.address()) : nullptr;
this->read_bytes(target, size, remote(var->address));
}
-char* Process::read_string(remote_ptr<void> address) const
+char* Process::read_string(RemotePtr<void> address) const
{
if (!address)
return nullptr;
}
const void *Process::read_bytes(void* buffer, std::size_t size,
- remote_ptr<void> address, int process_index,
+ RemotePtr<void> address, int process_index,
ReadOptions options) const
{
if (process_index != simgrid::mc::ProcessIndexDisabled) {
* @param remote target process memory address (target)
* @param len data size
*/
-void Process::write_bytes(const void* buffer, size_t len, remote_ptr<void> address)
+void Process::write_bytes(const void* buffer, size_t len, RemotePtr<void> address)
{
if (pwrite_whole(this->memory_file, buffer, len, address.address()) < 0)
xbt_die("Write to process %lli failed", (long long) this->pid_);
}
-void Process::clear_bytes(remote_ptr<void> address, size_t len)
+void Process::clear_bytes(RemotePtr<void> address, size_t len)
{
pthread_once(&zero_buffer_flag, MC_zero_buffer_init);
while (len) {
// Read memory:
const void* read_bytes(void* buffer, std::size_t size,
- remote_ptr<void> address, int process_index = ProcessIndexAny,
+ RemotePtr<void> address, int process_index = ProcessIndexAny,
ReadOptions options = ReadOptions::none()) const override;
void read_variable(const char* name, void* target, size_t size) const;
template<class T>
read_variable(name, &res, sizeof(T));
return res;
}
- char* read_string(remote_ptr<void> address) const;
+ char* read_string(RemotePtr<void> address) const;
// Write memory:
- void write_bytes(const void* buffer, size_t len, remote_ptr<void> address);
- void clear_bytes(remote_ptr<void> address, size_t len);
+ void write_bytes(const void* buffer, size_t len, RemotePtr<void> address);
+ void clear_bytes(RemotePtr<void> address, size_t len);
// Debug information:
- std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info(remote_ptr<void> addr) const;
- std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info_exec(remote_ptr<void> addr) const;
- std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info_rw(remote_ptr<void> addr) const;
- simgrid::mc::Frame* find_function(remote_ptr<void> ip) const;
+ std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info(RemotePtr<void> addr) const;
+ std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info_exec(RemotePtr<void> addr) const;
+ std::shared_ptr<simgrid::mc::ObjectInformation> find_object_info_rw(RemotePtr<void> addr) const;
+ simgrid::mc::Frame* find_function(RemotePtr<void> ip) const;
simgrid::mc::Variable* find_variable(const char* name) const;
// Heap access:
pid_t pid() const { return pid_; }
- bool in_maestro_stack(remote_ptr<void> p) const
+ bool in_maestro_stack(RemotePtr<void> p) const
{
return p >= this->maestro_stack_start_ && p < this->maestro_stack_end_;
}
int socket_ = -1;
bool running_ = false;
std::vector<simgrid::xbt::VmMap> memory_map_;
- remote_ptr<void> maestro_stack_start_, maestro_stack_end_;
+ RemotePtr<void> maestro_stack_start_, maestro_stack_end_;
int memory_file = -1;
std::vector<IgnoredRegion> ignored_regions_;
int clear_refs_fd_ = -1;
#include <xbt/base.h>
-#include "src/mc/remote_ptr.hpp"
+#include "src/mc/RemotePtr.hpp"
#include "src/mc/PageStore.hpp"
#include "src/mc/AddressSpace.hpp"
#include "src/mc/ChunkedData.hpp"
// Other getters
- remote_ptr<void> start() const { return remote(start_addr_); }
- remote_ptr<void> end() const { return remote((char*)start_addr_ + size_); }
- remote_ptr<void> permanent_address() const { return remote(permanent_addr_); }
+ RemotePtr<void> start() const { return remote(start_addr_); }
+ RemotePtr<void> end() const { return remote((char*)start_addr_ + size_); }
+ RemotePtr<void> permanent_address() const { return remote(permanent_addr_); }
std::size_t size() const { return size_; }
StorageType storage_type() const { return storage_type_; }
RegionType region_type() const { return region_type_; }
- bool contain(remote_ptr<void> p) const
+ bool contain(RemotePtr<void> p) const
{
return p >= start() && p < end();
}
* model-checker.
*
* We do not actually store the target address space because we can
- * always detect it in context. This way `remote_ptr` is as efficient
+ * always detect it in context. This way `RemotePtr` is as efficient
* as a `uint64_t`.
*/
-template<class T> class remote_ptr {
+template<class T> class RemotePtr {
std::uint64_t address_;
public:
- remote_ptr() : address_(0) {}
- remote_ptr(std::uint64_t address) : address_(address) {}
- remote_ptr(T* address) : address_((std::uintptr_t)address) {}
+ RemotePtr() : address_(0) {}
+ RemotePtr(std::uint64_t address) : address_(address) {}
+ RemotePtr(T* address) : address_((std::uintptr_t)address) {}
std::uint64_t address() const { return address_; }
operator bool() const
{
return !address_;
}
- operator remote_ptr<void>() const
+ operator RemotePtr<void>() const
{
- return remote_ptr<void>(address_);
+ return RemotePtr<void>(address_);
}
- remote_ptr<T> operator+(std::uint64_t n) const
+ RemotePtr<T> operator+(std::uint64_t n) const
{
- return remote_ptr<T>(address_ + n * sizeof(T));
+ return RemotePtr<T>(address_ + n * sizeof(T));
}
- remote_ptr<T> operator-(std::uint64_t n) const
+ RemotePtr<T> operator-(std::uint64_t n) const
{
- return remote_ptr<T>(address_ - n * sizeof(T));
+ return RemotePtr<T>(address_ - n * sizeof(T));
}
- remote_ptr<T>& operator+=(std::uint64_t n)
+ RemotePtr<T>& operator+=(std::uint64_t n)
{
address_ += n * sizeof(T);
return *this;
}
- remote_ptr<T>& operator-=(std::uint64_t n)
+ RemotePtr<T>& operator-=(std::uint64_t n)
{
address_ -= n * sizeof(T);
return *this;
};
template<class X, class Y>
-bool operator<(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator<(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() < y.address();
}
template<class X, class Y>
-bool operator>(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator>(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() > y.address();
}
template<class X, class Y>
-bool operator>=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator>=(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() >= y.address();
}
template<class X, class Y>
-bool operator<=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator<=(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() <= y.address();
}
template<class X, class Y>
-bool operator==(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator==(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() == y.address();
}
template<class X, class Y>
-bool operator!=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
+bool operator!=(RemotePtr<X> const& x, RemotePtr<Y> const& y)
{
return x.address() != y.address();
}
template<class T> inline
-remote_ptr<T> remote(T *p)
+RemotePtr<T> remote(T *p)
{
- return remote_ptr<T>(p);
+ return RemotePtr<T>(p);
}
template<class T=void> inline
-remote_ptr<T> remote(uint64_t p)
+RemotePtr<T> remote(uint64_t p)
{
- return remote_ptr<T>(p);
+ return RemotePtr<T>(p);
}
}
}
const void* Snapshot::read_bytes(void* buffer, std::size_t size,
- remote_ptr<void> address, int process_index,
+ RemotePtr<void> address, int process_index,
ReadOptions options) const
{
mc_mem_region_t region = mc_get_snapshot_region((void*)address.address(), this, process_index);
Snapshot(Process* process);
~Snapshot();
const void* read_bytes(void* buffer, std::size_t size,
- remote_ptr<void> address, int process_index = ProcessIndexAny,
+ RemotePtr<void> address, int process_index = ProcessIndexAny,
ReadOptions options = ReadOptions::none()) const override;
public: // To be private
int num_state;
#include <cstddef>
-#include "src/mc/remote_ptr.hpp"
+#include "src/mc/RemotePtr.hpp"
#include "src/mc/AddressSpace.hpp"
#include "src/mc/mc_xbt.hpp"
namespace mc {
void read_element(AddressSpace const& as,
- void* local, remote_ptr<s_xbt_dynar_t> addr, std::size_t i, std::size_t len)
+ void* local, RemotePtr<s_xbt_dynar_t> addr, std::size_t i, std::size_t len)
{
s_xbt_dynar_t d;
as.read_bytes(&d, sizeof(d), addr);
as.read_bytes(local, len, remote(xbt_dynar_get_ptr(&d, i)));
}
-std::size_t read_length(AddressSpace const& as, remote_ptr<s_xbt_dynar_t> addr)
+std::size_t read_length(AddressSpace const& as, RemotePtr<s_xbt_dynar_t> addr)
{
if (!addr)
return 0;
#include <xbt/dynar.h>
-#include "src/mc/remote_ptr.hpp"
+#include "src/mc/RemotePtr.hpp"
#include "src/mc/AddressSpace.hpp"
namespace simgrid {
namespace mc {
XBT_PRIVATE void read_element(AddressSpace const& as,
- void* local, remote_ptr<s_xbt_dynar_t> addr, std::size_t i, std::size_t len);
+ void* local, RemotePtr<s_xbt_dynar_t> addr, std::size_t i, std::size_t len);
XBT_PRIVATE std::size_t read_length(
- AddressSpace const& as, remote_ptr<s_xbt_dynar_t> addr);
+ AddressSpace const& as, RemotePtr<s_xbt_dynar_t> addr);
}
}
)
set(MC_SRC
- src/mc/remote_ptr.hpp
+ src/mc/RemotePtr.hpp
src/mc/AddressSpace.hpp
src/mc/AddressSpace.cpp
src/mc/Frame.hpp