Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
159642fd6a19fb2ece0cd56714fa86c5795e6129
[simgrid.git] / src / mc / AddressSpace.hpp
1 /* Copyright (c) 2008-2015. The SimGrid Team.
2  * All rights reserved.                                                     */
3
4 /* This program is free software; you can redistribute it and/or modify it
5  * under the terms of the license (GNU LGPL) which comes with this package. */
6
7 #ifndef SIMGRID_MC_ADDRESS_SPACE_H
8 #define SIMGRID_MC_ADDRESS_SPACE_H
9
10 #include <cstddef>
11 #include <cstdint>
12 #include <type_traits>
13
14 #include <xbt/misc.h>
15
16 #include "src/mc/mc_forward.hpp"
17
18 namespace simgrid {
19 namespace mc {
20
21 /** Pointer to a remote address-space (process, snapshot)
22  *
23  *  With this we can clearly identify the expected type of an address in the
24  *  remote process while avoiding to use native local pointers.
25  *
26  *  Some operators (+/-) assume use the size of the underlying element. This
27  *  only works if the target applications is using the same target: it won't
28  *  work for example, when inspecting a 32 bit application from a 64 bit
29  *  model-checker.
30  */
31 template<class T> class remote_ptr {
32   std::uint64_t address_;
33 public:
34   remote_ptr() : address_(0) {}
35   remote_ptr(std::uint64_t address) : address_(address) {}
36   remote_ptr(T* address) : address_((std::uintptr_t)address) {}
37   std::uint64_t address() const { return address_; }
38
39   operator bool() const
40   {
41     return address_;
42   }
43   bool operator!() const
44   {
45     return !address_;
46   }
47   operator remote_ptr<void>() const
48   {
49     return remote_ptr<void>(address_);
50   }
51   remote_ptr<T> operator+(std::uint64_t n) const
52   {
53     return remote_ptr<T>(address_ + n * sizeof(T));
54   }
55   remote_ptr<T> operator-(std::uint64_t n) const
56   {
57     return remote_ptr<T>(address_ - n * sizeof(T));
58   }
59   remote_ptr<T>& operator+=(std::uint64_t n)
60   {
61     address_ += n * sizeof(T);
62     return *this;
63   }
64   remote_ptr<T>& operator-=(std::uint64_t n)
65   {
66     address_ -= n * sizeof(T);
67     return *this;
68   }
69 };
70
71 template<class X, class Y>
72 bool operator<(remote_ptr<X> const& x, remote_ptr<Y> const& y)
73 {
74   return x.address() < y.address();
75 }
76
77 template<class X, class Y>
78 bool operator>(remote_ptr<X> const& x, remote_ptr<Y> const& y)
79 {
80   return x.address() > y.address();
81 }
82
83 template<class X, class Y>
84 bool operator>=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
85 {
86   return x.address() >= y.address();
87 }
88
89 template<class X, class Y>
90 bool operator<=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
91 {
92   return x.address() <= y.address();
93 }
94
95 template<class X, class Y>
96 bool operator==(remote_ptr<X> const& x, remote_ptr<Y> const& y)
97 {
98   return x.address() == y.address();
99 }
100
101 template<class X, class Y>
102 bool operator!=(remote_ptr<X> const& x, remote_ptr<Y> const& y)
103 {
104   return x.address() != y.address();
105 }
106
107 template<class T> inline
108 remote_ptr<T> remote(T *p)
109 {
110   return remote_ptr<T>(p);
111 }
112
113 template<class T=void> inline
114 remote_ptr<T> remote(uint64_t p)
115 {
116   return remote_ptr<T>(p);
117 }
118
119 /** Process index used when no process is available
120  *
121  *  The expected behaviour is that if a process index is needed it will fail.
122  * */
123 const int ProcessIndexMissing = -1;
124
125 /** Process index used when we don't care about the process index
126  * */
127 const int ProcessIndexDisabled = -2;
128
129 /** Constant used when any process will do.
130  *
131  *  This is is index of the first process.
132  */
133 const int ProcessIndexAny = 0;
134
135 /** Options for read operations
136  *
137  *  This is a set of flags managed with bitwise operators. Only the
138  *  meaningful operations are defined: addition, conversions to/from
139  *  integers are not allowed.
140  */
141 class ReadOptions {
142   std::uint32_t value_;
143   constexpr explicit ReadOptions(std::uint32_t value) : value_(value) {}
144 public:
145   constexpr ReadOptions() : value_(0) {}
146
147   constexpr operator bool() const { return value_ != 0; }
148   constexpr operator!() const { return value_ == 0; }
149
150   constexpr ReadOptions operator|(ReadOptions const& that) const
151   {
152     return ReadOptions(value_ | that.value_);
153   }
154   constexpr ReadOptions operator&(ReadOptions const& that) const
155   {
156     return ReadOptions(value_ & that.value_);
157   }
158   constexpr ReadOptions operator^(ReadOptions const& that) const
159   {
160     return ReadOptions(value_ ^ that.value_);
161   }
162   constexpr ReadOptions operator~() const
163   {
164     return ReadOptions(~value_);
165   }
166
167   ReadOptions& operator|=(ReadOptions const& that)
168   {
169     value_ |= that.value_;
170     return *this;
171   }
172   ReadOptions& operator&=(ReadOptions const& that)
173   {
174     value_ &= that.value_;
175     return *this;
176   }
177   ReadOptions& operator^=(ReadOptions const& that)
178   {
179     value_ &= that.value_;
180     return *this;
181   }
182
183   /** Copy the data to the given buffer */
184   static constexpr ReadOptions none() { return ReadOptions(0); }
185
186   /** Allows to return a pointer to another buffer where the data is
187    *  available instead of copying the data into the buffer
188    */
189   static constexpr ReadOptions lazy() { return ReadOptions(1); }
190 };
191
192 /** A given state of a given process (abstract base class)
193  *
194  *  Currently, this might either be:
195  *
196  *  * the current state of an existing process;
197  *
198  *  * a snapshot.
199  */
200 class AddressSpace {
201 private:
202   Process* process_;
203 public:
204   AddressSpace(Process* process) : process_(process) {}
205   virtual ~AddressSpace();
206
207   simgrid::mc::Process* process() const { return process_; }
208
209   /** Read data from the address space
210    *
211    *  @param buffer        target buffer for the data
212    *  @param size          number of bytes
213    *  @param address       remote source address of the data
214    *  @param process_index which process (used for SMPI privatization)
215    *  @param options
216    */
217   virtual const void* read_bytes(void* buffer, std::size_t size,
218     remote_ptr<void> address, int process_index = ProcessIndexAny,
219     ReadOptions options = ReadOptions::none()) const = 0;
220
221   /** Read a given data structure from the address space */
222   template<class T> inline
223   void read(T *buffer, remote_ptr<T> ptr, int process_index = ProcessIndexAny)
224   {
225     this->read_bytes(buffer, sizeof(T), ptr, process_index);
226   }
227
228   /** Read a given data structure from the address space */
229   template<class T> inline
230   T read(remote_ptr<T> ptr, int process_index = ProcessIndexMissing)
231   {
232     static_assert(std::is_trivial<T>::value, "Cannot read a non-trivial type");
233     T res;
234     return *(T*)this->read_bytes(&res, sizeof(T), ptr, process_index);
235   }
236 };
237
238 }
239 }
240
241 #endif