Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
mc: move some files related to ELF, DWARF or unwind reading into their own directory
[simgrid.git] / src / mc / sosp / ChunkedData.hpp
1 /* Copyright (c) 2014-2019. The SimGrid Team. All rights reserved.          */
2
3 /* This program is free software; you can redistribute it and/or modify it
4  * under the terms of the license (GNU LGPL) which comes with this package. */
5
6 #ifndef SIMGRID_MC_CHUNKED_DATA_HPP
7 #define SIMGRID_MC_CHUNKED_DATA_HPP
8
9 #include <cstddef>
10 #include <cstdint>
11
12 #include <utility>
13 #include <vector>
14
15 #include "src/mc/mc_forward.hpp"
16 #include "src/mc/sosp/PageStore.hpp"
17
18 namespace simgrid {
19 namespace mc {
20
21 /** A byte-string represented as a sequence of chunks from a PageStore
22  *
23  *  In order to save memory when taking memory snapshots, a given byte-string
24  *  is split in fixed-size chunks. Identical chunks (either from the same
25  *  snapshot or more probably from different snpashots) share the same memory
26  *  storage.
27  *
28  *  Thus a chunked is represented as a sequence of indices of each chunk.
29  */
30 class ChunkedData {
31   /** This is where we store the chunks */
32   PageStore* store_ = nullptr;
33   /** Indices of the chunks in the `PageStore` */
34   std::vector<std::size_t> pagenos_;
35
36 public:
37   ChunkedData() = default;
38   void clear()
39   {
40     for (std::size_t const& pageno : pagenos_)
41       store_->unref_page(pageno);
42     pagenos_.clear();
43   }
44   ~ChunkedData() { clear(); }
45
46   // Copy and move
47   ChunkedData(ChunkedData const& that) : store_(that.store_), pagenos_(that.pagenos_)
48   {
49     for (std::size_t const& pageno : pagenos_)
50       store_->ref_page(pageno);
51   }
52   ChunkedData(ChunkedData&& that) : store_(that.store_), pagenos_(std::move(that.pagenos_))
53   {
54     that.store_ = nullptr;
55     that.pagenos_.clear();
56   }
57   ChunkedData& operator=(ChunkedData const& that)
58   {
59     if (this != &that) {
60       this->clear();
61       store_   = that.store_;
62       pagenos_ = that.pagenos_;
63       for (std::size_t const& pageno : pagenos_)
64         store_->ref_page(pageno);
65     }
66     return *this;
67   }
68   ChunkedData& operator=(ChunkedData&& that)
69   {
70     this->clear();
71     store_      = that.store_;
72     that.store_ = nullptr;
73     pagenos_    = std::move(that.pagenos_);
74     that.pagenos_.clear();
75     return *this;
76   }
77
78   /** How many pages are used */
79   std::size_t page_count() const { return pagenos_.size(); }
80
81   /** Get a chunk index */
82   std::size_t pageno(std::size_t i) const { return pagenos_[i]; }
83
84   /** Get a view of the chunk indices */
85   const std::size_t* pagenos() const { return pagenos_.data(); }
86
87   /** Get a a pointer to a chunk */
88   const void* page(std::size_t i) const { return store_->get_page(pagenos_[i]); }
89
90   ChunkedData(PageStore& store, AddressSpace& as, RemotePtr<void> addr, std::size_t page_count);
91 };
92
93 } // namespace mc
94 } // namespace simgrid
95
96 #endif