X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/4340c977641036e7aa8ae5dcb69ccb3cac1df3c5..a92d7b716f51a53dea7f59db8524d4add713b910:/src/mc/PageStore.hpp diff --git a/src/mc/PageStore.hpp b/src/mc/PageStore.hpp index f1d84d3396..80332eaebc 100644 --- a/src/mc/PageStore.hpp +++ b/src/mc/PageStore.hpp @@ -7,30 +7,26 @@ #ifndef SIMGRID_MC_PAGESTORE_HPP #define SIMGRID_MC_PAGESTORE_HPP -#include - +#include #include -#include -#include -#include -#include +#include +#include -#include +#include "xbt/base.h" -#include "mc_mmu.h" -#include "mc_forward.h" +#include "src/mc/mc_mmu.h" +#include "src/mc/mc_forward.hpp" namespace simgrid { namespace mc { /** @brief Storage for snapshot memory pages * - * The first (lower) layer of the per-page snapshot mechanism is a page - * store: it's responsibility is to store immutable shareable - * reference-counted memory pages independently of the snapshoting - * logic. Snapshot management and representation, soft-dirty tracking is - * handled to an higher layer. READMORE + * The first (lower) layer of the per-page snapshot mechanism is a page store: + * its responsibility is to store immutable sharable reference-counted memory + * pages independently of the snapshotting logic. Snapshot management and + * representation is handled to an higher layer. READMORE * * Data structure: * @@ -78,65 +74,50 @@ namespace mc { */ class PageStore { public: // Types -#ifdef MC_PAGE_STORE_MD4 - typedef boost::array hash_type; -#else - typedef uint64_t hash_type; -#endif + typedef std::uint64_t hash_type; private: // Types -#ifdef MC_PAGE_STORE_MD4 - // We are using a secure hash to identify a page. - // We assume there will not be any collision: we need to map a hash - // to a single page index. - typedef boost::unordered_map pages_map_type; -#else // We are using a cheap hash to index a page. // We should expect collision and we need to associate multiple page indices // to the same hash. - typedef boost::unordered_set page_set_type; - typedef boost::unordered_map pages_map_type; -#endif + typedef std::unordered_set page_set_type; + typedef std::unordered_map pages_map_type; private: // Fields: - /** First page - * - * mc_page_store_get_page expects that this is the first field. - * */ + /** First page */ void* memory_; /** Number of available pages in virtual memory */ - size_t capacity_; + std::size_t capacity_; /** Top of the used pages (index of the next available page) */ - size_t top_index_; + std::size_t top_index_; /** Page reference count */ - std::vector page_counts_; + std::vector page_counts_; /** Index of available pages before the top */ - std::vector free_pages_; + std::vector free_pages_; /** Index from page hash to page index */ pages_map_type hash_index_; private: // Methods - void resize(size_t size); - size_t alloc_page(); - void remove_page(size_t pageno); + void resize(std::size_t size); + std::size_t alloc_page(); + void remove_page(std::size_t pageno); public: // Constructors PageStore(PageStore const&) = delete; PageStore& operator=(PageStore const&) = delete; - explicit PageStore(size_t size); + explicit PageStore(std::size_t size); ~PageStore(); public: // Methods /** @brief Decrement the reference count for a given page * - * Decrement the reference count of this page. Used when a snapshot is - * destroyed. + * Decrement the reference count of this page. Used when a snapshot is destroyed. * * If the reference count reaches zero, the page is recycled: * it is added to the `free_pages_` list and removed from the `hash_index_`. * * */ - void unref_page(size_t pageno); + void unref_page(std::size_t pageno); /** @brief Increment the refcount for a given page * @@ -151,60 +132,59 @@ public: // Methods void ref_page(size_t pageno); /** @brief Store a page in the page store */ - size_t store_page(void* page); + std::size_t store_page(void* page); /** @brief Get a page from its page number * - * @param Number of the memory page in the store + * @param pageno Number of the memory page in the store * @return Start of the page */ - const void* get_page(size_t pageno) const; + const void* get_page(std::size_t pageno) const; public: // Debug/test methods /** @brief Get the number of references for a page */ - size_t get_ref(size_t pageno); + std::size_t get_ref(std::size_t pageno); /** @brief Get the number of used pages */ - size_t size(); + std::size_t size(); /** @brief Get the capacity of the page store * * The capacity is expanded by a system call (mremap). * */ - size_t capacity(); + std::size_t capacity(); }; -inline __attribute__((always_inline)) -void PageStore::unref_page(size_t pageno) { - if ((--this->page_counts_[pageno]) == 0) { +XBT_ALWAYS_INLINE void PageStore::unref_page(std::size_t pageno) +{ + if ((--this->page_counts_[pageno]) == 0) this->remove_page(pageno); - } } -inline __attribute__((always_inline)) -void PageStore::ref_page(size_t pageno) { +XBT_ALWAYS_INLINE void PageStore::ref_page(size_t pageno) +{ ++this->page_counts_[pageno]; } -inline __attribute__((always_inline)) -const void* PageStore::get_page(size_t pageno) const { - return mc_page_from_number(this->memory_, pageno); +XBT_ALWAYS_INLINE const void* PageStore::get_page(std::size_t pageno) const +{ + return (void*) simgrid::mc::mmu::join(pageno, (std::uintptr_t) this->memory_); } -inline __attribute__((always_inline)) -size_t PageStore::get_ref(size_t pageno) { +XBT_ALWAYS_INLINE std::size_t PageStore::get_ref(std::size_t pageno) +{ return this->page_counts_[pageno]; } -inline __attribute__((always_inline)) -size_t PageStore::size() { +XBT_ALWAYS_INLINE std::size_t PageStore::size() +{ return this->top_index_ - this->free_pages_.size(); } -inline __attribute__((always_inline)) -size_t PageStore::capacity() { +XBT_ALWAYS_INLINE std::size_t PageStore::capacity() +{ return this->capacity_; }