examples/smpi/mc/smpi_send_deterministic
simgrid.jar_finalized
simgrid_full.jar
-src/mc_page_store_unit.cpp
+src/PageStore_unit.cpp
src/bindings/java/MANIFEST.MF
NATIVE/
VERSION
src/include/mc/datatypes.h
src/include/mc/mc.h
src/mc/mc_mmu.h
- src/mc/mc_page_store.h
+ src/mc/PageStore.hpp
src/mc/mc_record.h
src/include/simgrid/platf_interface.h
src/include/simgrid/sg_config.h
src/mc/mc_checkpoint.cpp
src/mc/mc_snapshot.h
src/mc/mc_snapshot.cpp
- src/mc/mc_page_store.h
- src/mc/mc_page_store.cpp
+ src/mc/PageStore.hpp
+ src/mc/PageStore.cpp
src/mc/mc_page_snapshot.cpp
src/mc/mc_comm_pattern.h
src/mc/mc_comm_pattern.cpp
if(HAVE_MC)
set(TEST_CFILES ${TEST_CFILES}
- src/mc/mc_page_store.cpp
+ src/mc/PageStore.cpp
src/mc/mc_snapshot.cpp
)
set(TEST_UNITS ${TEST_UNITS}
- ${CMAKE_CURRENT_BINARY_DIR}/src/mc_page_store_unit.cpp
+ ${CMAKE_CURRENT_BINARY_DIR}/src/PageStore_unit.cpp
${CMAKE_CURRENT_BINARY_DIR}/src/mc_snapshot_unit.cpp
)
endif()
#include <cassert>
#include "ModelChecker.hpp"
-#include "mc_page_store.h"
+#include "PageStore.hpp"
::simgrid::mc::ModelChecker* mc_model_checker = NULL;
namespace mc {
ModelChecker::ModelChecker(pid_t pid, int socket)
+ : page_store_(500)
{
- this->page_store_ = mc_pages_store_new();
- this->fd_clear_refs_ = -1;
this->hostnames_ = xbt_dict_new();
MC_process_init(&this->process(), pid, socket);
}
ModelChecker::~ModelChecker()
{
- mc_pages_store_delete(this->page_store_);
- if(this->record_)
- xbt_dynar_free(&this->record_);
MC_process_clear(&this->process_);
xbt_dict_free(&this->hostnames_);
}
#include "mc_forward.h"
#include "mc_process.h"
-#include "mc_page_store.h"
+#include "PageStore.hpp"
#include "mc_protocol.h"
namespace simgrid {
*/
class ModelChecker {
// This is the parent snapshot of the current state:
- mc_pages_store_t page_store_;
- int fd_clear_refs_;
- xbt_dynar_t record_;
+ s_mc_pages_store_t page_store_;
s_mc_process_t process_;
/** String pool for host names */
// TODO, use std::unordered_set with heterogeneous comparison lookup (C++14)
{
return process_;
}
- s_mc_pages_store_t& page_store()
+ PageStore& page_store()
{
- return *page_store_;
+ return page_store_;
}
const char* get_host_name(const char* name);
};
#include <xbt.h>
-#include "mc_page_store.h"
+#include "PageStore.hpp"
#ifdef MC_PAGE_STORE_MD4
#include <nettle/md4.h>
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_page_snapshot, mc,
"Logging specific to mc_page_snapshot");
-// ***** Utility:
+namespace simgrid {
+namespace mc {
/** @brief Compte a hash for the given memory page
*
* @return hash off the page
*/
static inline __attribute__ ((always_inline))
-s_mc_pages_store::hash_type mc_hash_page(const void* data)
+PageStore::hash_type mc_hash_page(const void* data)
{
#ifdef MC_PAGE_STORE_MD4
boost::array<uint64_t,2> result;
// ***** snapshot_page_manager
-s_mc_pages_store::s_mc_pages_store(size_t size) :
+PageStore::PageStore(size_t size) :
memory_(NULL), capacity_(0), top_index_(0)
{
// Using mmap in order to be able to expand the region
this->page_counts_.resize(size);
}
-s_mc_pages_store::~s_mc_pages_store()
+PageStore::~PageStore()
{
::munmap(this->memory_, this->capacity_ << xbt_pagebits);
}
-void s_mc_pages_store::resize(size_t size)
+void PageStore::resize(size_t size)
{
size_t old_bytesize = this->capacity_ << xbt_pagebits;
size_t new_bytesize = size << xbt_pagebits;
*
* @return index of the free page
*/
-size_t s_mc_pages_store::alloc_page()
+size_t PageStore::alloc_page()
{
if (this->free_pages_.empty()) {
}
}
-void s_mc_pages_store::remove_page(size_t pageno)
+void PageStore::remove_page(size_t pageno)
{
this->free_pages_.push_back(pageno);
const void* page = this->get_page(pageno);
}
/** Store a page in memory */
-size_t s_mc_pages_store::store_page(void* page)
+size_t PageStore::store_page(void* page)
{
xbt_assert(top_index_ <= this->capacity_, "top_index is not consistent");
return pageno;
}
-// ***** Main C API
-
-extern "C" {
-
-mc_pages_store_t mc_pages_store_new()
-{
- return new s_mc_pages_store_t(500);
}
-
-void mc_pages_store_delete(mc_pages_store_t store)
-{
- delete store;
-}
-
}
#ifdef SIMGRID_TEST
#include <memory>
-#include "mc/mc_page_store.h"
+#include "mc/PageStore.hpp"
static int value = 0;
{
xbt_test_add("Init");
size_t pagesize = (size_t) getpagesize();
- std::unique_ptr<s_mc_pages_store_t> store = std::unique_ptr<s_mc_pages_store_t>(new s_mc_pages_store(500));
+ std::unique_ptr<simgrid::mc::PageStore> store
+ = std::unique_ptr<simgrid::mc::PageStore>(new simgrid::mc::PageStore(500));
void* data = getpage();
xbt_test_assert(store->size()==0, "Bad size");
#ifndef MC_PAGE_STORE_H
#define MC_PAGE_STORE_H
-struct s_mc_pages_store;
-
-#ifdef __cplusplus
+namespace simgrid {
+namespace mc {
/** @brief Storage for snapshot memory pages
*
* we must be able to store multiple indices for the same hash.
*
*/
-struct s_mc_pages_store {
+class PageStore {
public: // Types
#ifdef MC_PAGE_STORE_MD4
typedef boost::array<uint64_t,2> hash_type;
void remove_page(size_t pageno);
public: // Constructors
- explicit s_mc_pages_store(size_t size);
- ~s_mc_pages_store();
+ PageStore(PageStore const&) = delete;
+ PageStore& operator=(PageStore const&) = delete;
+ explicit PageStore(size_t size);
+ ~PageStore();
public: // Methods
};
inline __attribute__((always_inline))
-void s_mc_pages_store::unref_page(size_t pageno) {
+void PageStore::unref_page(size_t pageno) {
if ((--this->page_counts_[pageno]) == 0) {
this->remove_page(pageno);
}
}
inline __attribute__((always_inline))
-void s_mc_pages_store::ref_page(size_t pageno) {
+void PageStore::ref_page(size_t pageno) {
++this->page_counts_[pageno];
}
inline __attribute__((always_inline))
-const void* s_mc_pages_store::get_page(size_t pageno) const {
+const void* PageStore::get_page(size_t pageno) const {
return mc_page_from_number(this->memory_, pageno);
}
inline __attribute__((always_inline))
-size_t s_mc_pages_store::get_ref(size_t pageno) {
+size_t PageStore::get_ref(size_t pageno) {
return this->page_counts_[pageno];
}
inline __attribute__((always_inline))
-size_t s_mc_pages_store::size() {
+size_t PageStore::size() {
return this->top_index_ - this->free_pages_.size();
}
inline __attribute__((always_inline))
-size_t s_mc_pages_store::capacity() {
+size_t PageStore::capacity() {
return this->capacity_;
}
-#endif
-
-SG_BEGIN_DECL()
-
-mc_pages_store_t mc_pages_store_new(void);
-void mc_pages_store_delete(mc_pages_store_t store);
-
-/**
- */
-static inline __attribute__((always_inline))
-const void* mc_page_store_get_page(mc_pages_store_t page_store, size_t pageno)
-{
- // This is page_store->memory_:
- void* memory = *(void**)page_store;
- return mc_page_from_number(memory, pageno);
}
-
-SG_END_DECL()
+}
#endif
namespace simgrid {
namespace mc {
+ class PageStore;
class ModelChecker;
}
}
typedef ::simgrid::mc::ModelChecker s_mc_model_checker_t;
+typedef ::simgrid::mc::PageStore s_mc_pages_store_t;
#else
typedef struct _s_mc_model_checker s_mc_model_checker_t;
+typedef struct _s_mc_pages_store s_mc_pages_store_t;
#endif
typedef struct s_memory_map s_memory_map_t, *memory_map_t;
typedef struct s_dw_variable s_dw_variable_t, *dw_variable_t;
typedef struct s_dw_frame s_dw_frame_t, *dw_frame_t;
-typedef struct s_mc_pages_store s_mc_pages_store_t, *mc_pages_store_t;
+typedef s_mc_pages_store_t *mc_pages_store_t;
typedef struct s_mc_snapshot s_mc_snapshot_t, *mc_snapshot_t;
typedef struct s_mc_process s_mc_process_t, * mc_process_t;
typedef s_mc_model_checker_t *mc_model_checker_t;
#include <unistd.h> // pread, pwrite
-#include "mc_page_store.h"
+#include "PageStore.hpp"
#include "mc_mmu.h"
#include "mc_private.h"
#include "mc_snapshot.h"
#include "mc_snapshot.h"
#include "mc_private.h"
#include "mc_mmu.h"
-#include "mc_page_store.h"
+#include "PageStore.hpp"
extern "C" {
#include "mc_forward.h"
#include "ModelChecker.hpp"
-#include "mc_page_store.h"
+#include "PageStore.hpp"
#include "mc_mmalloc.h"
#include "mc_address_space.h"
#include "mc_unw.h"
{
size_t pageno = mc_page_number(region->start_addr, (void*) addr);
size_t snapshot_pageno = region->chunked.page_numbers[pageno];
- const void* snapshot_page = mc_page_store_get_page(
- &mc_model_checker->page_store(), snapshot_pageno);
+ const void* snapshot_page =
+ mc_model_checker->page_store().get_page(snapshot_pageno);
return (char*) snapshot_page + mc_page_offset((void*) addr);
}