diff --git a/ARP_CSFR/.gitignore b/ARP_CSFR/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..63470a9bd645cf6cfe743cd90cda02c294020627 --- /dev/null +++ b/ARP_CSFR/.gitignore @@ -0,0 +1,39 @@ +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +# Build directories +compiler-plugin/plugin_build/ +runtime/build-all/ + +# Temporary files +*.swp +*log.txt + +# Doxygen output +runtime/html/ diff --git a/AUTHORS b/ARP_CSFR/AUTHORS similarity index 100% rename from AUTHORS rename to ARP_CSFR/AUTHORS diff --git a/COPYING b/ARP_CSFR/COPYING similarity index 100% rename from COPYING rename to ARP_CSFR/COPYING diff --git a/ARP_CSFR/README.md b/ARP_CSFR/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d6c672d571ec9e6c69ed3f7a2533b34fa8e0b6a9 --- /dev/null +++ b/ARP_CSFR/README.md @@ -0,0 +1,151 @@ +# Atlas: Programming for Persistent Memory +[![Build Status](https://travis-ci.org/HewlettPackard/Atlas.svg?branch=master)](https://travis-ci.org/HewlettPackard/Atlas) + +Data in persistent memory survives certain tolerated events such as +process termination, OS reboots/crashes, and power +failures. Persistent memory is assumed to be directly accessible with +CPU loads and stores. This kind of programming is relevant on new +servers with NVDIMMs as well as future machines with +non-volatile memory such as memristors or 3D XPoint. Atlas provides +high level APIs that allow the programmer to persist data in a +fault-tolerant manner and reuse it later on. Any program which has +reusable data that can be exploited to achieve a faster restart or a +restart from an intermediate program point is a candidate for this +paradigm. + +A persistent memory allocator is provided for identifying data that +should be preserved regardless of machine shutdowns or failures. By +conforming to certain programming idioms and APIs, programmers can +automatically obtain failure-resilience of persistent data. The +programming model with implementation details can be found in the +[OOPSLA 2014 paper on Atlas](http://dl.acm.org/citation.cfm?id=2660224). + +The current implementation supports +POSIX threads but the implementation for C/C++11 threads should be similar. +Linux tmpfs is currently used to simulate persistent +memory. Hence, persistent data in this implementation survives process +crashes but not OS shutdowns/panics and power failures. However, the +APIs and the implementation are ready for all of the above +failures. The intention is to allow programmers to write code in a +programming style that is ready for upcoming persistent memory based +systems. + +This software is currently experimental, see `COPYING` for license +terms. Contributions and feedback are very welcome. + +## What is Included? + +APIs are provided for creation and management of persistent +regions which are implemented on top of memory mapped files. Support +for a persistent memory allocator is provided. In essence, a +programmer is able to identify data structures that must be maintained +in a persistent manner. The goal of Atlas is to ensure that persistent +data are updated in a consistent manner regardless of failures. + +The current implementation has two primary components: a +compiler-plugin and a runtime library. The programmer writes +multithreaded code, possibly using locks for synchronization, and puts +data in persistent regions as required. This code is passed through +the plugin at compile-time that results in calls to the runtime +library at appropriate program points. When this program is run, +automatic failure-atomicity (all-or-nothing) of updates to persistent +data structures is provided. If a failure occurs, recovery must be +initiated to ensure that persistent data structures are consistent. + +## Persistent Region APIs + +A preview is provided here. See `runtime/include/atlas_alloc.h` for the +actual interfaces. + +A programmer needs to create one or more named persistent regions, +entities that hold everything persistent. The interface +**_NVM_FindOrCreateRegion_** or a variant can be used for this purpose. If a +region with the provided name exists, a handle to the region is +returned. Otherwise a region is created and its handle is +returned. Interfaces to close or delete a region are available. + +To populate a persistent region, memory must be dynamically allocated +from that persistent region using **_nvm_alloc_** (or a variant) that has a +malloc-style interface. The region identifier must be provided so as +to identify the persistent region intended. An **_nvm_free_** is provided +for deallocation purposes. + +Management of persistent regions and the contained data together +identify the persistent objects used by a program. Care must be taken +to ensure that all valid data within a persistent region is reachable +from the persistent root of the region. Use the interface +**_NVM_SetRegionRoot_** for this purpose. + +## Consistency APIs + +See `runtime/include/atlas_api.h` for the actual interfaces. + +Persistent data must be kept consistent regardless of failures. The +programmer needs to call **_NVM_Initialize_** and **_NVM_Finalize_** +to start and stop Atlas support. Additionally, Atlas needs to know +code sections where program invariants are modified. If the program is +multithreaded and written using locks for synchronization, Atlas +automatically infers boundaries of regions where it must preserve +failure-atomicity (all-or-nothing) of updates to persistent +memory. Optionally, the programmer can demarcate sections of code with +calls to **_nvm_begin_durable_** and **_nvm_end_durable_** to identify +a durable or failure-atomic section of code. Note that no isolation +among threads is provided by a durable section. In contrast, if +persistent data is modified within a critical section, the critical +section provides both isolation among threads and durability to +persistent memory. + +## Restart Code + +A program might want to reuse data within a persistent region. For +this purpose, after finding a region handle, use the interface +**_NVM_GetRegionRoot_** to access the reachable data. Instead of +starting from scratch, this data can be reused to essentially restart +from where the region was left off the last time around. + +That's all, as far as Atlas APIs are concerned. Compared to a +transient program, the idea is to write persistent memory programs +with as few changes as possible. + +## Organization + +- The APIs for this model are in `runtime/include`. [API doc here](http://hewlettpackard.github.io/Atlas/runtime/doc/atlas__api_8h.html). +- Instructions on how to build the compiler-plugin are in +`compiler-plugin/README.md`. +- Instructions on how to build the runtime are in `runtime/README.md`. +- For example programs using Atlas, see `runtime/tests`. +- The Atlas library sources are in `runtime/src`. + +## Dependencies + +* Currently, we support only x86-64 CPUs +* We assume Linux OS. Linux tmpfs must be supported. Testing has been + done on RedHat and Ubuntu. +* We assume modern C/C++ compilers in the build environment that must + support C/C++11. +* The default compiler used in the build is clang. Testing has been + done with version 3.6.0 or later. The instrumentation support is + currently available only with clang/LLVM. The runtime should build + with any compiler supporting C/C++11 though clang is preferred for + uniformity purposes. +* cmake version 3.1 or later +* boost library +* bash 4.0 + +For Ubuntu 16.04, these dependencies can be installed with: + + sudo apt-get install llvm clang cmake libboost-graph-dev + +* ruby (for certain test scripts), see **Installing Ruby** at [gorails](https://gorails.com/setup/ubuntu/16.04) for instructions. + +## Discuss +Questions, feedback, comments are welcome on our public [mailing list](https://groups.google.com/forum/#!forum/atlas-discuss). Subscribe by using the Google Groups web interface or by sending an email with subject “subscribe” to atlas-discuss+subscribe [AT] googlegroups.com. + + +## Reference + +Dhruva R. Chakrabarti, Hans-J. Boehm, and Kumud Bhandari. 2014. +[Atlas: leveraging locks for non-volatile memory consistency](http://dl.acm.org/citation.cfm?id=2660224). +In _Proceedings of the 2014 ACM International Conference on Object Oriented +Programming Systems Languages & Applications_ (OOPSLA '14). ACM, New +York, NY, USA, 433-452. diff --git a/compiler-plugin/README.md b/ARP_CSFR/compiler-plugin/README.md similarity index 100% rename from compiler-plugin/README.md rename to ARP_CSFR/compiler-plugin/README.md diff --git a/compiler-plugin/build_plugin b/ARP_CSFR/compiler-plugin/build_plugin similarity index 100% rename from compiler-plugin/build_plugin rename to ARP_CSFR/compiler-plugin/build_plugin diff --git a/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp b/ARP_CSFR/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp similarity index 100% rename from compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp rename to ARP_CSFR/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp diff --git a/compiler-plugin/test/README.md b/ARP_CSFR/compiler-plugin/test/README.md similarity index 100% rename from compiler-plugin/test/README.md rename to ARP_CSFR/compiler-plugin/test/README.md diff --git a/compiler-plugin/test/long_double.c b/ARP_CSFR/compiler-plugin/test/long_double.c similarity index 100% rename from compiler-plugin/test/long_double.c rename to ARP_CSFR/compiler-plugin/test/long_double.c diff --git a/compiler-plugin/test/store_int.c b/ARP_CSFR/compiler-plugin/test/store_int.c similarity index 100% rename from compiler-plugin/test/store_int.c rename to ARP_CSFR/compiler-plugin/test/store_int.c diff --git a/compiler-plugin/test/strops.c b/ARP_CSFR/compiler-plugin/test/strops.c similarity index 100% rename from compiler-plugin/test/strops.c rename to ARP_CSFR/compiler-plugin/test/strops.c diff --git a/compiler-plugin/test/test_instr b/ARP_CSFR/compiler-plugin/test/test_instr similarity index 100% rename from compiler-plugin/test/test_instr rename to ARP_CSFR/compiler-plugin/test/test_instr diff --git a/compiler-plugin/test/test_refs/long_double.ref b/ARP_CSFR/compiler-plugin/test/test_refs/long_double.ref similarity index 100% rename from compiler-plugin/test/test_refs/long_double.ref rename to ARP_CSFR/compiler-plugin/test/test_refs/long_double.ref diff --git a/compiler-plugin/test/test_refs/store_int.ref b/ARP_CSFR/compiler-plugin/test/test_refs/store_int.ref similarity index 100% rename from compiler-plugin/test/test_refs/store_int.ref rename to ARP_CSFR/compiler-plugin/test/test_refs/store_int.ref diff --git a/compiler-plugin/test/test_refs/strops.ref b/ARP_CSFR/compiler-plugin/test/test_refs/strops.ref similarity index 100% rename from compiler-plugin/test/test_refs/strops.ref rename to ARP_CSFR/compiler-plugin/test/test_refs/strops.ref diff --git a/ARP_CSFR/runtime/CMakeLists.txt b/ARP_CSFR/runtime/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..478ffadfbd0f09998392135ef124ee847b8cd1f8 --- /dev/null +++ b/ARP_CSFR/runtime/CMakeLists.txt @@ -0,0 +1,278 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# Top level CMakeLists for Atlas project + +cmake_minimum_required (VERSION 3.1.0) + +project (Atlas) +set (Atlas_VERSION_MAJOR 1) +set (Atlas_VERSION_MINOR 0) + +if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE) + message(FATAL_ERROR "In-source builds are not allowed. +Please create a directory and run cmake from there, passing the path +to this source directory as the last argument. +This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. +Please delete them.") +endif () + +#need pthreads to build tests and tools - find an equivalent pthread compatible library on host +set (THREADS_PREFER_PTHREAD_FLAG ON) +find_package (Threads REQUIRED) +link_libraries (Threads::Threads) + +#helper function used to build up relative file paths to files to be copied to build dir +function (prepend_paths FILES TARGET_PATH) + set (LISTVAR "") + foreach (t ${ARGN}) + list (APPEND LISTVAR "${TARGET_PATH}/${t}") + endforeach (t) + set (${FILES} "${LISTVAR}" PARENT_SCOPE) +endfunction (prepend_paths) + +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} README.md) + +set (ATLAS_INTERNAL_INCLUDES "src/internal_includes") +set (ATLAS_INCLUDE_DIR "include") +set (ATLAS_INCLUDE_FILES atlas_alloc.h atlas_api.h atlas_alloc_cpp.hpp) +prepend_paths (ATLAS_INCLUDE_FILES ${ATLAS_INCLUDE_DIR} ${ATLAS_INCLUDE_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_INCLUDE_FILES}) + +set (ATLAS_TESTS_DIR "tests") +set (ATLAS_TESTS_FILES run_quick_test) +prepend_paths (ATLAS_TESTS_FILES ${ATLAS_TESTS_DIR} ${ATLAS_TESTS_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_TESTS_FILES}) + +set (ATLAS_TESTS_DATA_STRUCT_IN_DIR "${ATLAS_TESTS_DIR}/data_structures_inputs") +set (ATLAS_TESTS_DATA_STRUCT_IN_FILES timing.txt cow_array_list_nvm.ref cow_array_list.ref queue_nvm.ref queue.ref + sll_ll.ref sll_nvm.ref sll.ref alarm_clock.ref alarm_clock_nvm.ref cow_array_list.in + cow_array_list_nvm.in queue_nvm.in queue.in sll.in sll_ll.in sll_nvm.in alarm_clock.in + alarm_clock_nvm.in stores.ref stores_nvm.ref stores.in stores_nvm.in) +prepend_paths (ATLAS_TESTS_DATA_STRUCT_IN_FILES ${ATLAS_TESTS_DATA_STRUCT_IN_DIR} ${ATLAS_TESTS_DATA_STRUCT_IN_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_TESTS_DATA_STRUCT_IN_FILES}) + +set (ATLAS_CONSISTENCY_DIR "${ATLAS_TESTS_DIR}/consistency") +set (ATLAS_CONSISTENCY_TESTS test_consistency) +prepend_paths (ATLAS_CONSISTENCY_TESTS ${ATLAS_CONSISTENCY_DIR} ${ATLAS_CONSISTENCY_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_CONSISTENCY_TESTS}) + +set (ATLAS_REGION_DIR "${ATLAS_TESTS_DIR}/region") +set (ATLAS_REGION_TESTS test_region) +prepend_paths (ATLAS_REGION_TESTS ${ATLAS_REGION_DIR} ${ATLAS_REGION_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_REGION_TESTS}) + +set (ATLAS_PMALLOC_DIR "${ATLAS_TESTS_DIR}/pmalloc") +set (ATLAS_PMALLOC_TESTS test_pmalloc) +prepend_paths (ATLAS_PMALLOC_TESTS ${ATLAS_PMALLOC_DIR} ${ATLAS_PMALLOC_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_PMALLOC_TESTS}) + +#default to debug build if no build type specified +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + message ("No build type specified, defaulting to debug") + set (CMAKE_BUILD_TYPE "Debug" CACHE STRING "Defaulted to debug build, none specified" FORCE) +endif () + +#use clang for everything +set (CMAKE_C_COMPILER "clang") +set (CMAKE_CXX_COMPILER "clang++") + +#set flags for using instrumentation + +set (INSTR $ENV{PLUGIN}) +if (INSTR) + message ("Found environment variable PLUGIN set to ${INSTR}") +elseif (EXISTS "${CMAKE_SOURCE_DIR}/../compiler-plugin/plugin_build/NvmInstrumenter.so") + set (INSTR "${CMAKE_SOURCE_DIR}/../compiler-plugin/plugin_build/NvmInstrumenter.so") + message ("Found a compiler plugin build in ${INSTR}") +else () + message (FATAL_ERROR "Cannot find NvmInstrumenter.so, is it built in Atlas/compiler-plugin/plugin_build? If built outside of Atlas/compiler-plugin/plugin_build set environment variable PLUGIN to it's location.") +endif () +set (NVM_INSTR_FLAGS "-Xclang -load -Xclang ${INSTR}") + +#debug settings +set (CMAKE_C_FLAGS_DEBUG "-g3 -DDEBUG") +set (CMAKE_CXX_FLAGS_DEBUG "-g3 -DDEBUG") + +#Defines required for building Atlas +set (ATLAS_SPECIFIC_FLAGS "-DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE") + +#Cmake defines used to specify different targets for Atlas - must pass to cmake as -DVAR_NAME=true +if (ALL_PERSISTENT) + message ("Configuring for all persistent") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALL_PERSISTENT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALL_PERSISTENT") +endif () +if (NVM_STATS) + message ("Configuring for nvm stats") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNVM_STATS") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNVM_STATS") +endif () +if (FLC) + message ("Configuring for critical section level cache flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_FLUSH_LOCAL_COMMIT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FLUSH_LOCAL_COMMIT") +endif () +if (FGC) + message ("Configuring for global consistent point cache flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_FLUSH_GLOBAL_COMMIT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FLUSH_GLOBAL_COMMIT") +endif () +if (USE_TABLE_FLUSH) + message ("Configuring for table based flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_TABLE_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_TABLE_FLUSH") +endif () +if (DISABLE_FLUSH) + message ("Configuring disabling all cache line flushes") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDISABLE_FLUSHES") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DDISABLE_FLUSHES") +endif () +if (DISABLE_HELPER) + message ("Configuring disabling helper") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_HELPER") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_HELPER") +endif () +if (DISABLE_ALLOC_LOGGING) + message ("Configuring disabling alloc logging") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_ALLOC_LOGGING") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_ALLOC_LOGGING") +endif () +if (DISABLE_LOG_FLUSH) + message ("Configuring disabling log flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_LOG_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_LOG_FLUSH") +endif () +if (DISABLE_DATA_FLUSH) + message ("Configuring disabling data flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_DATA_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_DATA_FLUSH") +endif () +if (PROFILE_HT) + message ("Configuring profile helper thread") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_PROFILE_HT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_PROFILE_HT") +endif () +if (USE_MOVNT) + message ("Configuring use movnt") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MOVNT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_MOVNT") +endif () +if (NO_SFENCE) + message ("Configuring for movnt use with no sfence") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NO_SFENCE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NO_SFENCE") +endif () +if (LOG_FLUSH_OPT) + message ("Configuring to log flush optimization") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_FLUSH_OPT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_FLUSH_OPT") +endif () +if (LOG_WITH_NVM_ALLOC) + message ("Configuring to log with nvm alloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_WITH_NVM_ALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_WITH_NVM_ALLOC") +endif () +if (LOG_WITH_MALLOC) + message ("Configuring to log with malloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_WITH_MALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_WITH_MALLOC") +endif () +if (USE_MALLOC) + message ("Configuring to use malloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_MALLOC") +endif () +if (OPT_UNIQ_LOC) + message ("Configuring to opt uniq loc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_OPT_UNIQ_LOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_OPT_UNIQ_LOC") +endif () +if (ALWAYS_LOG) + message ("Configuring to always log") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALWAYS_LOG") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALWAYS_LOG") +endif () +if (ALWAYS_MAP) + message ("Configuring to always map") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALWAYS_MAP") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALWAYS_MAP") +endif () +if (TRACE) + message ("Configuring to use trace") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVM_TRACE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVM_TRACE") +endif () +if (FORCE_FAIL) + message ("Configuring to perform process crash testing") + set (APP_FLAGS "-D_FORCE_FAIL") +endif () +if (FAIL_ATLAS) + message ("Configuring atlas to fail internally") + set (ATLAS_SPECIFIC_FLAGS "${ATLAS_SPECIFIC_FLAGS} -D_FORCE_FAIL -rdynamic") +endif () +if (VERBOSE_TRACE) + message ("Configuring for verbose trace") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVM_VERBOSE_TRACE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVM_VERBOSE_TRACE") +endif () +if (SRRF) + message ("Configuring for strong restart race freedom") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SRRF") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_SRRF") +endif () +if (NVDIMM_PROLIANT) + message ("Configuring for ProLiant NVDIMM") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVDIMM_PROLIANT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVDIMM_PROLIANT") +endif () +if (NO_NEST) + message ("Configuring for no nesting of critical sections") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NO_NEST") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NO_NEST") +endif () +if (CONSISTENCY_FAIL) + message ("Setting consistency tests to fail") + set (CONSISTENCY_FAIL_FLAG "-DCONSISTENCY_FAIL") +endif () + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED ON) +set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline ${ATLAS_SPECIFIC_FLAGS}") +set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -Wall -Wextra -pedantic -Winline ${ATLAS_SPECIFIC_FLAGS}") + +#copy necessary files from the src dir to the build dir +foreach (t ${ATLAS_COPY_FILES}) + configure_file (${CMAKE_SOURCE_DIR}/${t} ${PROJECT_BINARY_DIR}/${t} COPYONLY) +endforeach (t) + +include_directories (${CMAKE_SOURCE_DIR}/${ATLAS_INTERNAL_INCLUDES} ${CMAKE_SOURCE_DIR}/${ATLAS_INCLUDE_DIR}) + +set (LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) + +#variable to build only data structures in tests +if (NOT DATA_STRUCTS_ONLY) + message ("Defaulting to build all tests") + add_subdirectory (tests) +else () + message ("Building only data structures") + add_subdirectory (tests/data_structures) +endif () + +add_subdirectory (src) +add_library (atlas $ $ $ $ $ $) #defaults to static build + +#install () diff --git a/runtime/src/README.md b/ARP_CSFR/runtime/README.md similarity index 100% rename from runtime/src/README.md rename to ARP_CSFR/runtime/README.md diff --git a/ARP_CSFR/runtime/include/atlas_alloc.h b/ARP_CSFR/runtime/include/atlas_alloc.h new file mode 100644 index 0000000000000000000000000000000000000000..46ea81ce1472858602d0034800af5eee4bad9be0 --- /dev/null +++ b/ARP_CSFR/runtime/include/atlas_alloc.h @@ -0,0 +1,194 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_H +#define ATLAS_ALLOC_H + +#include +#include +#include + +// +// Persistent region API +// These are interfaces for creating and managing persistent regions, +// entities that contain persistent data. Once a persistent region is +// created, objects can be allocated out of the region, e.g. by using +// nvm_alloc. Any data not in a persistent region is considered +// transient. +// +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// @brief Create a named persistent region. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region created +/// +/// This interface does not check for an existing entry with +/// the same name. If a region with the same name already exists, the +/// behavior of the program is undefined. +/// +uint32_t NVM_CreateRegion(const char *name, int flags); + +/// +/// @brief Create a persistent region with the provided name. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @param is_created Indicator whether the region got created as a +/// result of the call +/// @return Id of the region found or created +/// +/// If the region already exists, the existing id of the region is returned. +/// Otherwise a region is created and its newly assigned id returned. +/// +uint32_t NVM_FindOrCreateRegion(const char *name, int flags, int *is_created); + +/// +/// @brief Find the id of a region when it is known to exist already +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region found +/// +/// This interface should be used over NVM_FindOrCreateRegion for +/// efficiency reasons if the region is known to exist. If a region +/// with the provided name does not exist, an assertion failure will +/// occur. +/// +uint32_t NVM_FindRegion(const char *name, int flags); + +/// +/// @brief Delete the region with the provided name. +/// @param name Name of the persistent region +/// +/// Use this interface to completely destroy a region. If the region +/// does not exist, an assertion failure will occur. +/// +void NVM_DeleteRegion(const char *name); + +/// +/// @brief Close a persistent region +/// @param rid Region id +/// +/// After closing, it won't be available to the calling process +/// without calling NVM_FindOrCreateRegion. The region will stay in +/// NVM even after calling this interface. This interface allows +/// closing a region with normal bookkeeping. +/// +void NVM_CloseRegion(uint32_t rid); + +/// +/// @brief Get the root pointer of the persistent region +/// @param rid Region id +/// @return Root pointer of the region +/// +/// The region must have been created already. Currently, only one +/// root is implemented for a given region. The idea is that anything +/// within a region that is not reachable from the root after program +/// termination is assumed to be garbage and can be recycled. During +/// execution, anything within a region that is not reachable from the +/// root or from other _roots_ (in the GC sense) is assumed to be +/// garbage as well. +/// +void *NVM_GetRegionRoot(uint32_t rid); + +/// +/// @brief Set the root pointer of an existing persistent region +/// @param rid Region id +/// @param root The new root of the region +/// +void NVM_SetRegionRoot(uint32_t rid, void *root); + +/// +/// @brief Determines if a memory location is within a region +/// @param ptr Queried address +/// @param sz Size of the location in bytes +/// @return 1 if within the region, otherwise 0 +/// +int NVM_IsInRegion(void *ptr, size_t sz); + +/// +/// @brief Determines if the addresses are on different cache lines +/// +/// @param p1 First address +/// @param p2 Second address +/// @return Indicates whether the addresses are on different cache +/// lines +/// +/// The objects under consideration must not cross cache lines, +/// otherwise this interface is inadequate. +/// +int isOnDifferentCacheLine(void *p1, void *p2); + +/// +/// @brief Determines if a memory location is aligned to a cache line +/// +/// @param p Address of memory location under consideration +/// @return Indicates whether the memory location is cache line +/// aligned +/// +int isCacheLineAligned(void *p); + +/// +/// @brief Malloc style interface for allocation from a persistent +/// region +/// +/// @param sz Size of location to be allocated +/// @param rid Id of persistent region for allocation +/// @return Address of memory location allocated +/// +void *nvm_alloc(size_t sz, uint32_t rid); + +/// +/// @brief Calloc style interface for allocation from a persistent +/// region +/// +/// @param nmemb Number of elements in the array to be allocated +/// @param sz Size of each element +/// @param rid Id of persistent region for allocation +/// @return Pointer to allocated memory +/// +void *nvm_calloc(size_t nmemb, size_t sz, uint32_t rid); + +/// +/// @brief Realloc style interface for allocation from a persistent +/// region +/// +/// @param ptr Address of memory block provided +/// @param sz New size of allocation +/// @param rid Id of persistent region for allocation +/// @return Pointer to re-allocated memory +/// +void *nvm_realloc(void *ptr, size_t sz, uint32_t rid); + +/// +/// @brief Deallocation interface for persistent data +/// +/// @param ptr Address of memory location to be freed. +/// +/// Though the usual use case would be for the location to be in +/// persistent memory, this interface will also work for transient +/// data. The implementation is required to transparently handle +/// this case as well. +/// +void nvm_free(void *ptr); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ARP_CSFR/runtime/include/atlas_alloc_cpp.hpp b/ARP_CSFR/runtime/include/atlas_alloc_cpp.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9f201bb76c36d36ff9bc9c51c9f370e1e09324fb --- /dev/null +++ b/ARP_CSFR/runtime/include/atlas_alloc_cpp.hpp @@ -0,0 +1,120 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_CPP_H +#define ATLAS_ALLOC_CPP_H + +// Forward declarations +namespace Atlas +{ + class PRegion; +} + +/// +/// @brief Get a handle to a persistent region +/// @param rid Region identifier +/// @return Pointer to the corresponding persistent region +/// +/// Currently, this interface is to be used by a client only for the +/// placement new operations +/// +Atlas::PRegion *NVM_GetRegion(uint32_t rid); + +/// +/// @brief Object allocation for C++ +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the C++ placement new operator. The +/// corresponding delete operation is NVM_Destroy. +/// +void* operator new(size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Array form allocation for C++, type must have explicit +/// destructor +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the array form C++ placement new +/// operator. The type of the array elements must have an explicit +/// destructor. The corresponding delete operation is +/// NVM_Destroy_Array. +/// +void* operator new[](size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Object destruction for C++ +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an object that was +/// created from a persistent region using the single-object new +/// operator. The implementation calls the destructor followed by +/// actual deallocation. This interface can also be called for +/// destroying an object that was created using the default +/// single-object new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default single-object delete operator. This interface must not be +/// called for deallocating an object created in any other way, e.g. a +/// placement new operator where the placement address is not within a +/// persistent region. +/// +template static inline void NVM_Destroy(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete ptr; + return; + } + ptr->~T(); + void nvm_delete(void*); + nvm_delete(ptr); +} + +/// +/// @brief Array form destruction for C++, type must have explicit +/// destructor +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an array of objects +/// that was created from a persistent region using the array-form new +/// operator. The implementation calls the destructors for all objects +/// of the array followed by actual deallocation. Note that the type +/// of the array elements must have an explicit destructor for this +/// interface to work correctly. This interface can also be called for +/// destroying an array of objects that was created using the default +/// array-form new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default array-form delete operator. This interface must not be +/// called for deallocating an object created in any other way. +/// +template static inline void NVM_Destroy_Array(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete [] ptr; + return; + } + char *delete_ptr = reinterpret_cast(ptr) - sizeof(size_t); + size_t count = *reinterpret_cast(delete_ptr); + for (int i=count-1; i>=0; --i) (ptr+i)->~T(); + void nvm_delete(void*); + nvm_delete(delete_ptr); +} + +#endif diff --git a/ARP_CSFR/runtime/include/atlas_api.h b/ARP_CSFR/runtime/include/atlas_api.h new file mode 100644 index 0000000000000000000000000000000000000000..e2076651a227bf3838ceb39a1db070d0b1e2f53e --- /dev/null +++ b/ARP_CSFR/runtime/include/atlas_api.h @@ -0,0 +1,179 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_API_H +#define ATLAS_API_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// +// Here are the APIs for initializing/finalizing Atlas. Each of the +// following 2 interfaces must be called only once. + +/// +/// Initialize Atlas internal data structures. This should be +/// called before persistent memory access. +/// +void NVM_Initialize(); + +/// +/// Finalize Atlas internal data structures. This should be called +/// before normal program exit. If not called, the implementation +/// will assume that program exit was abnormal and will require +/// invocation of recovery before restart. +/// +void NVM_Finalize(); + + +void NVM_UsrDone(); + + +// +// No special interfaces are required for lock-based critical +// sections if compiler support is available. Use the +// compiler-plugin to take advantage of automatic instrumentation +// of critical sections. +// + +/// +/// The following 2 interfaces demarcate a failure-atomic section +/// of code, i.e. code where persistent locations are updated and +/// all-or-nothing behavior of those updates is required. Note that +/// no isolation among threads is provided by these 2 interfaces. +/// +void nvm_begin_durable(); +void nvm_end_durable(); + +// +// The following interfaces are for low-level programming of +// persistent memory, where the high-level consistency support +// afforded by Atlas is not used. Instead, persistence is explicitly +// managed by the following interfaces. +// + +/// +/// Is the following address with associated size within an open +/// persistent region? +/// +int NVM_IsInOpenPR(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses +/// +void nvm_psync(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses without a trailing barrier +/// +void nvm_psync_acq(void *addr, size_t sz /* in bytes */); + +// This may be invoked by a user program to print out Atlas statistics +#ifdef NVM_STATS + void NVM_PrintStats(); +#endif + +#ifdef __cplusplus +} +#endif + +// End of Atlas APIs + +#ifdef NVM_STATS +extern __thread uint64_t num_flushes; +#endif + +// Useful macros +#define NVM_BEGIN_DURABLE() nvm_begin_durable() +#define NVM_END_DURABLE() nvm_end_durable() + +#define NVM_CLFLUSH(p) nvm_clflush((char*)(void*)(p)) + +#ifndef DISABLE_FLUSHES +#define NVM_FLUSH(p) \ + { full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } + +#define NVM_FLUSH_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } \ + } + +#define NVM_FLUSH_ACQ(p) \ + { full_fence(); \ + NVM_CLFLUSH(p); \ + } + +#define NVM_FLUSH_ACQ_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH(p); \ + } \ + } + +#define NVM_PSYNC(p1,s) nvm_psync(p1,s) + +#define NVM_PSYNC_COND(p1,s) \ + { if (NVM_IsInOpenPR(p1, s)) nvm_psync(p1,s); } + +#define NVM_PSYNC_ACQ(p1,s) \ + { \ + nvm_psync_acq(p1,s); \ + } \ + +#define NVM_PSYNC_ACQ_COND(p1,s) \ + { \ + if (NVM_IsInOpenPR(p1, s)) nvm_psync_acq(p1, s); \ + } \ + +#else +#define NVM_FLUSH(p) +#define NVM_FLUSH_COND(p) +#define NVM_FLUSH_ACQ(p) +#define NVM_FLUSH_ACQ_COND(p) +#define NVM_PSYNC(p1,s) +#define NVM_PSYNC_COND(p1,s) +#define NVM_PSYNC_ACQ(p1,s) +#define NVM_PSYNC_ACQ_COND(p1,s) +#endif + +static __inline void nvm_clflush(const void *p) +{ +#ifndef DISABLE_FLUSHES +#ifdef NVM_STATS + ++num_flushes; +#endif + __asm__ __volatile__ ( + "clflush %0 \n" : "+m" (*(char*)(p)) + ); +#endif +} + +// Used in conjunction with clflush. +static __inline void full_fence() { + __asm__ __volatile__ ("mfence" ::: "memory"); + } + +#endif diff --git a/runtime/scripts b/ARP_CSFR/runtime/scripts similarity index 100% rename from runtime/scripts rename to ARP_CSFR/runtime/scripts diff --git a/runtime/src/CMakeCache.txt b/ARP_CSFR/runtime/src/CMakeCache.txt similarity index 100% rename from runtime/src/CMakeCache.txt rename to ARP_CSFR/runtime/src/CMakeCache.txt diff --git a/runtime/src/CMakeFiles/3.5.1/CMakeCCompiler.cmake b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeCCompiler.cmake similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CMakeCCompiler.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeCCompiler.cmake diff --git a/runtime/src/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake diff --git a/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin diff --git a/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin diff --git a/runtime/src/CMakeFiles/3.5.1/CMakeSystem.cmake b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeSystem.cmake similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CMakeSystem.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CMakeSystem.cmake diff --git a/runtime/src/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c diff --git a/runtime/src/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp b/ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp similarity index 100% rename from runtime/src/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp rename to ARP_CSFR/runtime/src/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp diff --git a/runtime/src/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/CMakeFiles/CMakeError.log b/ARP_CSFR/runtime/src/CMakeFiles/CMakeError.log similarity index 100% rename from runtime/src/CMakeFiles/CMakeError.log rename to ARP_CSFR/runtime/src/CMakeFiles/CMakeError.log diff --git a/runtime/src/CMakeFiles/CMakeOutput.log b/ARP_CSFR/runtime/src/CMakeFiles/CMakeOutput.log similarity index 100% rename from runtime/src/CMakeFiles/CMakeOutput.log rename to ARP_CSFR/runtime/src/CMakeFiles/CMakeOutput.log diff --git a/ARP_CSFR/runtime/src/CMakeFiles/Makefile.cmake b/ARP_CSFR/runtime/src/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000000000000000000000000000000000000..60797a92dfe70cbcffc0ba14ecdd1f8f8ded20a3 --- /dev/null +++ b/ARP_CSFR/runtime/src/CMakeFiles/Makefile.cmake @@ -0,0 +1,258 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "../CMakeLists.txt" + "../README.md" + "../include/atlas_alloc.h" + "../include/atlas_alloc_cpp.hpp" + "../include/atlas_api.h" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "CMakeFiles/3.5.1/CMakeSystem.cmake" + "CMakeFiles/feature_tests.c" + "CMakeFiles/feature_tests.cxx" + "CMakeLists.txt" + "cache_flush/CMakeLists.txt" + "consistency/CMakeLists.txt" + "logger/CMakeLists.txt" + "pmalloc/CMakeLists.txt" + "pregion_mgr/CMakeLists.txt" + "recover/CMakeLists.txt" + "util/CMakeLists.txt" + "../tests/CMakeLists.txt" + "../tests/consistency/CMakeLists.txt" + "../tests/consistency/test_consistency" + "../tests/data_structures/CMakeLists.txt" + "../tests/data_structures/CQ/CMakeLists.txt" + "../tests/data_structures/RB/CMakeLists.txt" + "../tests/data_structures/TATP/CMakeLists.txt" + "../tests/data_structures/TPCC/CMakeLists.txt" + "../tests/data_structures_inputs/alarm_clock.in" + "../tests/data_structures_inputs/alarm_clock.ref" + "../tests/data_structures_inputs/alarm_clock_nvm.in" + "../tests/data_structures_inputs/alarm_clock_nvm.ref" + "../tests/data_structures_inputs/cow_array_list.in" + "../tests/data_structures_inputs/cow_array_list.ref" + "../tests/data_structures_inputs/cow_array_list_nvm.in" + "../tests/data_structures_inputs/cow_array_list_nvm.ref" + "../tests/data_structures_inputs/queue.in" + "../tests/data_structures_inputs/queue.ref" + "../tests/data_structures_inputs/queue_nvm.in" + "../tests/data_structures_inputs/queue_nvm.ref" + "../tests/data_structures_inputs/sll.in" + "../tests/data_structures_inputs/sll.ref" + "../tests/data_structures_inputs/sll_ll.in" + "../tests/data_structures_inputs/sll_ll.ref" + "../tests/data_structures_inputs/sll_nvm.in" + "../tests/data_structures_inputs/sll_nvm.ref" + "../tests/data_structures_inputs/stores.in" + "../tests/data_structures_inputs/stores.ref" + "../tests/data_structures_inputs/stores_nvm.in" + "../tests/data_structures_inputs/stores_nvm.ref" + "../tests/data_structures_inputs/timing.txt" + "../tests/pmalloc/CMakeLists.txt" + "../tests/pmalloc/test_pmalloc" + "../tests/region/CMakeLists.txt" + "../tests/region/test_region" + "../tests/run_quick_test" + "/usr/share/cmake-3.5/Modules/CMakeCCompiler.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeCCompilerABI.c" + "/usr/share/cmake-3.5/Modules/CMakeCInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCXXCompiler.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeCXXCompilerABI.cpp" + "/usr/share/cmake-3.5/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCompilerIdDetection.cmake" + "/usr/share/cmake-3.5/Modules/CMakeConfigurableFile.in" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCXXCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompileFeatures.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompilerABI.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompilerId.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineSystem.cmake" + "/usr/share/cmake-3.5/Modules/CMakeFindBinUtils.cmake" + "/usr/share/cmake-3.5/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake-3.5/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeParseArguments.cmake" + "/usr/share/cmake-3.5/Modules/CMakeParseImplicitLinkInfo.cmake" + "/usr/share/cmake-3.5/Modules/CMakeSystem.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCXXCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCompilerCommon.cmake" + "/usr/share/cmake-3.5/Modules/CMakeUnixFindMake.cmake" + "/usr/share/cmake-3.5/Modules/CheckForPthreads.c" + "/usr/share/cmake-3.5/Modules/CheckIncludeFile.c.in" + "/usr/share/cmake-3.5/Modules/CheckIncludeFile.cmake" + "/usr/share/cmake-3.5/Modules/CheckLibraryExists.cmake" + "/usr/share/cmake-3.5/Modules/CheckSymbolExists.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/ADSP-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Borland-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Clang-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Compaq-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Cray-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GHS-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-C-FeatureTests.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-C.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-CXX-FeatureTests.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/HP-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IAR-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Intel-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/MIPSpro-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/MSVC-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/PGI-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/PathScale-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SCO-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SDCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SunPro-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/TI-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Watcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/XL-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/zOS-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/FindPackageHandleStandardArgs.cmake" + "/usr/share/cmake-3.5/Modules/FindPackageMessage.cmake" + "/usr/share/cmake-3.5/Modules/FindThreads.cmake" + "/usr/share/cmake-3.5/Modules/Internal/FeatureTesting.cmake" + "/usr/share/cmake-3.5/Modules/MultiArchCross.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU-C.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux.cmake" + "/usr/share/cmake-3.5/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/3.5.1/CMakeSystem.cmake" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "README.md" + "include/atlas_alloc.h" + "include/atlas_api.h" + "include/atlas_alloc_cpp.hpp" + "tests/run_quick_test" + "tests/data_structures_inputs/timing.txt" + "tests/data_structures_inputs/cow_array_list_nvm.ref" + "tests/data_structures_inputs/cow_array_list.ref" + "tests/data_structures_inputs/queue_nvm.ref" + "tests/data_structures_inputs/queue.ref" + "tests/data_structures_inputs/sll_ll.ref" + "tests/data_structures_inputs/sll_nvm.ref" + "tests/data_structures_inputs/sll.ref" + "tests/data_structures_inputs/alarm_clock.ref" + "tests/data_structures_inputs/alarm_clock_nvm.ref" + "tests/data_structures_inputs/cow_array_list.in" + "tests/data_structures_inputs/cow_array_list_nvm.in" + "tests/data_structures_inputs/queue_nvm.in" + "tests/data_structures_inputs/queue.in" + "tests/data_structures_inputs/sll.in" + "tests/data_structures_inputs/sll_ll.in" + "tests/data_structures_inputs/sll_nvm.in" + "tests/data_structures_inputs/alarm_clock.in" + "tests/data_structures_inputs/alarm_clock_nvm.in" + "tests/data_structures_inputs/stores.ref" + "tests/data_structures_inputs/stores_nvm.ref" + "tests/data_structures_inputs/stores.in" + "tests/data_structures_inputs/stores_nvm.in" + "tests/consistency/test_consistency" + "tests/region/test_region" + "tests/pmalloc/test_pmalloc" + "CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/region/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/data_structures/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/data_structures/TATP/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/data_structures/RB/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/data_structures/TPCC/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/data_structures/CQ/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/consistency/CMakeFiles/CMakeDirectoryInformation.cmake" + "tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/cache_flush/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/consistency/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/logger/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/util/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/pregion_mgr/CMakeFiles/CMakeDirectoryInformation.cmake" + "src/recover/CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/atlas.dir/DependInfo.cmake" + "tests/region/CMakeFiles/focdelete.dir/DependInfo.cmake" + "tests/region/CMakeFiles/focclose.dir/DependInfo.cmake" + "tests/region/CMakeFiles/createclose.dir/DependInfo.cmake" + "tests/region/CMakeFiles/createclosedelete.dir/DependInfo.cmake" + "tests/region/CMakeFiles/createclosefocclose.dir/DependInfo.cmake" + "tests/region/CMakeFiles/finddelete.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/alarm_clock.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/stores.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sll_mt.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sll.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/queue.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/cow_array_list.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sll_mt_ll.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sll_ll.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/queue_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/stores_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/pc_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sll_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/sps_nvm.dir/DependInfo.cmake" + "tests/data_structures/CMakeFiles/linked_list_nvm.dir/DependInfo.cmake" + "tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/DependInfo.cmake" + "tests/data_structures/RB/CMakeFiles/rb_nvm.dir/DependInfo.cmake" + "tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/DependInfo.cmake" + "tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/DependInfo.cmake" + "tests/consistency/CMakeFiles/malloc_free_test.dir/DependInfo.cmake" + "tests/pmalloc/CMakeFiles/new_delete.dir/DependInfo.cmake" + "src/cache_flush/CMakeFiles/Cache_flush.dir/DependInfo.cmake" + "src/consistency/CMakeFiles/Consistency.dir/DependInfo.cmake" + "src/logger/CMakeFiles/Logger.dir/DependInfo.cmake" + "src/util/CMakeFiles/Util.dir/DependInfo.cmake" + "src/pmalloc/CMakeFiles/Pmalloc.dir/DependInfo.cmake" + "src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/DependInfo.cmake" + "src/recover/CMakeFiles/clean_mem.dir/DependInfo.cmake" + "src/recover/CMakeFiles/recover.dir/DependInfo.cmake" + "src/recover/CMakeFiles/del_log.dir/DependInfo.cmake" + "src/recover/CMakeFiles/del_rgn.dir/DependInfo.cmake" + ) diff --git a/ARP_CSFR/runtime/src/CMakeFiles/Makefile2 b/ARP_CSFR/runtime/src/CMakeFiles/Makefile2 new file mode 100644 index 0000000000000000000000000000000000000000..20c7c64c74d4a34e11ef2fdba90090d3688356d7 --- /dev/null +++ b/ARP_CSFR/runtime/src/CMakeFiles/Makefile2 @@ -0,0 +1,1909 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +# The main recursive all target +all: + +.PHONY : all + +# The main recursive preinstall target +preinstall: + +.PHONY : preinstall + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +#============================================================================= +# Target rules for target CMakeFiles/atlas.dir + +# All Build rule for target. +CMakeFiles/atlas.dir/all: src/cache_flush/CMakeFiles/Cache_flush.dir/all +CMakeFiles/atlas.dir/all: src/consistency/CMakeFiles/Consistency.dir/all +CMakeFiles/atlas.dir/all: src/logger/CMakeFiles/Logger.dir/all +CMakeFiles/atlas.dir/all: src/util/CMakeFiles/Util.dir/all +CMakeFiles/atlas.dir/all: src/pmalloc/CMakeFiles/Pmalloc.dir/all +CMakeFiles/atlas.dir/all: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all + $(MAKE) -f CMakeFiles/atlas.dir/build.make CMakeFiles/atlas.dir/depend + $(MAKE) -f CMakeFiles/atlas.dir/build.make CMakeFiles/atlas.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=26 "Built target atlas" +.PHONY : CMakeFiles/atlas.dir/all + +# Include target in all. +all: CMakeFiles/atlas.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +CMakeFiles/atlas.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 22 + $(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/atlas.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : CMakeFiles/atlas.dir/rule + +# Convenience name for target. +atlas: CMakeFiles/atlas.dir/rule + +.PHONY : atlas + +# clean rule for target. +CMakeFiles/atlas.dir/clean: + $(MAKE) -f CMakeFiles/atlas.dir/build.make CMakeFiles/atlas.dir/clean +.PHONY : CMakeFiles/atlas.dir/clean + +# clean rule for target. +clean: CMakeFiles/atlas.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests + +# Convenience name for "all" pass in the directory. +tests/all: tests/region/all +tests/all: tests/data_structures/all +tests/all: tests/consistency/all +tests/all: tests/pmalloc/all + +.PHONY : tests/all + +# Convenience name for "clean" pass in the directory. +tests/clean: tests/region/clean +tests/clean: tests/data_structures/clean +tests/clean: tests/consistency/clean +tests/clean: tests/pmalloc/clean + +.PHONY : tests/clean + +# Convenience name for "preinstall" pass in the directory. +tests/preinstall: tests/region/preinstall +tests/preinstall: tests/data_structures/preinstall +tests/preinstall: tests/consistency/preinstall +tests/preinstall: tests/pmalloc/preinstall + +.PHONY : tests/preinstall + +#============================================================================= +# Directory level rules for directory tests/region + +# Convenience name for "all" pass in the directory. +tests/region/all: tests/region/CMakeFiles/focdelete.dir/all +tests/region/all: tests/region/CMakeFiles/focclose.dir/all +tests/region/all: tests/region/CMakeFiles/createclose.dir/all +tests/region/all: tests/region/CMakeFiles/createclosedelete.dir/all +tests/region/all: tests/region/CMakeFiles/createclosefocclose.dir/all +tests/region/all: tests/region/CMakeFiles/finddelete.dir/all + +.PHONY : tests/region/all + +# Convenience name for "clean" pass in the directory. +tests/region/clean: tests/region/CMakeFiles/focdelete.dir/clean +tests/region/clean: tests/region/CMakeFiles/focclose.dir/clean +tests/region/clean: tests/region/CMakeFiles/createclose.dir/clean +tests/region/clean: tests/region/CMakeFiles/createclosedelete.dir/clean +tests/region/clean: tests/region/CMakeFiles/createclosefocclose.dir/clean +tests/region/clean: tests/region/CMakeFiles/finddelete.dir/clean + +.PHONY : tests/region/clean + +# Convenience name for "preinstall" pass in the directory. +tests/region/preinstall: + +.PHONY : tests/region/preinstall + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/focdelete.dir + +# All Build rule for target. +tests/region/CMakeFiles/focdelete.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/focdelete.dir/build.make tests/region/CMakeFiles/focdelete.dir/depend + $(MAKE) -f tests/region/CMakeFiles/focdelete.dir/build.make tests/region/CMakeFiles/focdelete.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=50,51 "Built target focdelete" +.PHONY : tests/region/CMakeFiles/focdelete.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/focdelete.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/focdelete.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/focdelete.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/focdelete.dir/rule + +# Convenience name for target. +focdelete: tests/region/CMakeFiles/focdelete.dir/rule + +.PHONY : focdelete + +# clean rule for target. +tests/region/CMakeFiles/focdelete.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/focdelete.dir/build.make tests/region/CMakeFiles/focdelete.dir/clean +.PHONY : tests/region/CMakeFiles/focdelete.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/focdelete.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/focclose.dir + +# All Build rule for target. +tests/region/CMakeFiles/focclose.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/focclose.dir/build.make tests/region/CMakeFiles/focclose.dir/depend + $(MAKE) -f tests/region/CMakeFiles/focclose.dir/build.make tests/region/CMakeFiles/focclose.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=48,49 "Built target focclose" +.PHONY : tests/region/CMakeFiles/focclose.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/focclose.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/focclose.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/focclose.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/focclose.dir/rule + +# Convenience name for target. +focclose: tests/region/CMakeFiles/focclose.dir/rule + +.PHONY : focclose + +# clean rule for target. +tests/region/CMakeFiles/focclose.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/focclose.dir/build.make tests/region/CMakeFiles/focclose.dir/clean +.PHONY : tests/region/CMakeFiles/focclose.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/focclose.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/createclose.dir + +# All Build rule for target. +tests/region/CMakeFiles/createclose.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/createclose.dir/build.make tests/region/CMakeFiles/createclose.dir/depend + $(MAKE) -f tests/region/CMakeFiles/createclose.dir/build.make tests/region/CMakeFiles/createclose.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=36,37 "Built target createclose" +.PHONY : tests/region/CMakeFiles/createclose.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/createclose.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/createclose.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/createclose.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/createclose.dir/rule + +# Convenience name for target. +createclose: tests/region/CMakeFiles/createclose.dir/rule + +.PHONY : createclose + +# clean rule for target. +tests/region/CMakeFiles/createclose.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/createclose.dir/build.make tests/region/CMakeFiles/createclose.dir/clean +.PHONY : tests/region/CMakeFiles/createclose.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/createclose.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/createclosedelete.dir + +# All Build rule for target. +tests/region/CMakeFiles/createclosedelete.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/createclosedelete.dir/build.make tests/region/CMakeFiles/createclosedelete.dir/depend + $(MAKE) -f tests/region/CMakeFiles/createclosedelete.dir/build.make tests/region/CMakeFiles/createclosedelete.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=38,39 "Built target createclosedelete" +.PHONY : tests/region/CMakeFiles/createclosedelete.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/createclosedelete.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/createclosedelete.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/createclosedelete.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/createclosedelete.dir/rule + +# Convenience name for target. +createclosedelete: tests/region/CMakeFiles/createclosedelete.dir/rule + +.PHONY : createclosedelete + +# clean rule for target. +tests/region/CMakeFiles/createclosedelete.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/createclosedelete.dir/build.make tests/region/CMakeFiles/createclosedelete.dir/clean +.PHONY : tests/region/CMakeFiles/createclosedelete.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/createclosedelete.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/createclosefocclose.dir + +# All Build rule for target. +tests/region/CMakeFiles/createclosefocclose.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/createclosefocclose.dir/build.make tests/region/CMakeFiles/createclosefocclose.dir/depend + $(MAKE) -f tests/region/CMakeFiles/createclosefocclose.dir/build.make tests/region/CMakeFiles/createclosefocclose.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=40,41 "Built target createclosefocclose" +.PHONY : tests/region/CMakeFiles/createclosefocclose.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/createclosefocclose.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/createclosefocclose.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/createclosefocclose.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/createclosefocclose.dir/rule + +# Convenience name for target. +createclosefocclose: tests/region/CMakeFiles/createclosefocclose.dir/rule + +.PHONY : createclosefocclose + +# clean rule for target. +tests/region/CMakeFiles/createclosefocclose.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/createclosefocclose.dir/build.make tests/region/CMakeFiles/createclosefocclose.dir/clean +.PHONY : tests/region/CMakeFiles/createclosefocclose.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/createclosefocclose.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/region/CMakeFiles/finddelete.dir + +# All Build rule for target. +tests/region/CMakeFiles/finddelete.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/region/CMakeFiles/finddelete.dir/build.make tests/region/CMakeFiles/finddelete.dir/depend + $(MAKE) -f tests/region/CMakeFiles/finddelete.dir/build.make tests/region/CMakeFiles/finddelete.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=46,47 "Built target finddelete" +.PHONY : tests/region/CMakeFiles/finddelete.dir/all + +# Include target in all. +all: tests/region/CMakeFiles/finddelete.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/region/CMakeFiles/finddelete.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/region/CMakeFiles/finddelete.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/region/CMakeFiles/finddelete.dir/rule + +# Convenience name for target. +finddelete: tests/region/CMakeFiles/finddelete.dir/rule + +.PHONY : finddelete + +# clean rule for target. +tests/region/CMakeFiles/finddelete.dir/clean: + $(MAKE) -f tests/region/CMakeFiles/finddelete.dir/build.make tests/region/CMakeFiles/finddelete.dir/clean +.PHONY : tests/region/CMakeFiles/finddelete.dir/clean + +# clean rule for target. +clean: tests/region/CMakeFiles/finddelete.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/data_structures + +# Convenience name for "all" pass in the directory. +tests/data_structures/all: tests/data_structures/CMakeFiles/alarm_clock.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/stores.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sll_mt.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sll.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/queue.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/cow_array_list.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sll_mt_ll.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sll_ll.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/queue_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/stores_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/pc_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sll_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/sps_nvm.dir/all +tests/data_structures/all: tests/data_structures/CMakeFiles/linked_list_nvm.dir/all +tests/data_structures/all: tests/data_structures/TATP/all +tests/data_structures/all: tests/data_structures/RB/all +tests/data_structures/all: tests/data_structures/TPCC/all +tests/data_structures/all: tests/data_structures/CQ/all + +.PHONY : tests/data_structures/all + +# Convenience name for "clean" pass in the directory. +tests/data_structures/clean: tests/data_structures/CMakeFiles/alarm_clock.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/stores.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sll_mt.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sll.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/queue.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/cow_array_list.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sll_ll.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/queue_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/stores_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/pc_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sll_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/sps_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean +tests/data_structures/clean: tests/data_structures/TATP/clean +tests/data_structures/clean: tests/data_structures/RB/clean +tests/data_structures/clean: tests/data_structures/TPCC/clean +tests/data_structures/clean: tests/data_structures/CQ/clean + +.PHONY : tests/data_structures/clean + +# Convenience name for "preinstall" pass in the directory. +tests/data_structures/preinstall: tests/data_structures/TATP/preinstall +tests/data_structures/preinstall: tests/data_structures/RB/preinstall +tests/data_structures/preinstall: tests/data_structures/TPCC/preinstall +tests/data_structures/preinstall: tests/data_structures/CQ/preinstall + +.PHONY : tests/data_structures/preinstall + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/alarm_clock.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/alarm_clock.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock.dir/build.make tests/data_structures/CMakeFiles/alarm_clock.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock.dir/build.make tests/data_structures/CMakeFiles/alarm_clock.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=22,23 "Built target alarm_clock" +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/alarm_clock.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/alarm_clock.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/alarm_clock.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/rule + +# Convenience name for target. +alarm_clock: tests/data_structures/CMakeFiles/alarm_clock.dir/rule + +.PHONY : alarm_clock + +# clean rule for target. +tests/data_structures/CMakeFiles/alarm_clock.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock.dir/build.make tests/data_structures/CMakeFiles/alarm_clock.dir/clean +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/alarm_clock.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/stores.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/stores.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/stores.dir/build.make tests/data_structures/CMakeFiles/stores.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/stores.dir/build.make tests/data_structures/CMakeFiles/stores.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=81,82 "Built target stores" +.PHONY : tests/data_structures/CMakeFiles/stores.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/stores.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/stores.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/stores.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/stores.dir/rule + +# Convenience name for target. +stores: tests/data_structures/CMakeFiles/stores.dir/rule + +.PHONY : stores + +# clean rule for target. +tests/data_structures/CMakeFiles/stores.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/stores.dir/build.make tests/data_structures/CMakeFiles/stores.dir/clean +.PHONY : tests/data_structures/CMakeFiles/stores.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/stores.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sll_mt.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sll_mt.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt.dir/build.make tests/data_structures/CMakeFiles/sll_mt.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt.dir/build.make tests/data_structures/CMakeFiles/sll_mt.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=73,74 "Built target sll_mt" +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sll_mt.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sll_mt.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sll_mt.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/rule + +# Convenience name for target. +sll_mt: tests/data_structures/CMakeFiles/sll_mt.dir/rule + +.PHONY : sll_mt + +# clean rule for target. +tests/data_structures/CMakeFiles/sll_mt.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt.dir/build.make tests/data_structures/CMakeFiles/sll_mt.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sll_mt.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sll.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sll.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/sll.dir/build.make tests/data_structures/CMakeFiles/sll.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sll.dir/build.make tests/data_structures/CMakeFiles/sll.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=69,70 "Built target sll" +.PHONY : tests/data_structures/CMakeFiles/sll.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sll.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sll.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sll.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sll.dir/rule + +# Convenience name for target. +sll: tests/data_structures/CMakeFiles/sll.dir/rule + +.PHONY : sll + +# clean rule for target. +tests/data_structures/CMakeFiles/sll.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sll.dir/build.make tests/data_structures/CMakeFiles/sll.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sll.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sll.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/queue.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/queue.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/queue.dir/build.make tests/data_structures/CMakeFiles/queue.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/queue.dir/build.make tests/data_structures/CMakeFiles/queue.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=60,61 "Built target queue" +.PHONY : tests/data_structures/CMakeFiles/queue.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/queue.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/queue.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/queue.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/queue.dir/rule + +# Convenience name for target. +queue: tests/data_structures/CMakeFiles/queue.dir/rule + +.PHONY : queue + +# clean rule for target. +tests/data_structures/CMakeFiles/queue.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/queue.dir/build.make tests/data_structures/CMakeFiles/queue.dir/clean +.PHONY : tests/data_structures/CMakeFiles/queue.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/queue.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/cow_array_list.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/cow_array_list.dir/all: + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list.dir/build.make tests/data_structures/CMakeFiles/cow_array_list.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list.dir/build.make tests/data_structures/CMakeFiles/cow_array_list.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=29,30 "Built target cow_array_list" +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/cow_array_list.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/cow_array_list.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/cow_array_list.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/rule + +# Convenience name for target. +cow_array_list: tests/data_structures/CMakeFiles/cow_array_list.dir/rule + +.PHONY : cow_array_list + +# clean rule for target. +tests/data_structures/CMakeFiles/cow_array_list.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list.dir/build.make tests/data_structures/CMakeFiles/cow_array_list.dir/clean +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/cow_array_list.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sll_mt_ll.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sll_mt_ll.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make tests/data_structures/CMakeFiles/sll_mt_ll.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=75,76 "Built target sll_mt_ll" +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sll_mt_ll.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sll_mt_ll.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sll_mt_ll.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/rule + +# Convenience name for target. +sll_mt_ll: tests/data_structures/CMakeFiles/sll_mt_ll.dir/rule + +.PHONY : sll_mt_ll + +# clean rule for target. +tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sll_ll.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sll_ll.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/sll_ll.dir/build.make tests/data_structures/CMakeFiles/sll_ll.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sll_ll.dir/build.make tests/data_structures/CMakeFiles/sll_ll.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=71,72 "Built target sll_ll" +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sll_ll.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sll_ll.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sll_ll.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/rule + +# Convenience name for target. +sll_ll: tests/data_structures/CMakeFiles/sll_ll.dir/rule + +.PHONY : sll_ll + +# clean rule for target. +tests/data_structures/CMakeFiles/sll_ll.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sll_ll.dir/build.make tests/data_structures/CMakeFiles/sll_ll.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sll_ll.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/queue_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/queue_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/queue_nvm.dir/build.make tests/data_structures/CMakeFiles/queue_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/queue_nvm.dir/build.make tests/data_structures/CMakeFiles/queue_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=62,63 "Built target queue_nvm" +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/queue_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/queue_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/queue_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/rule + +# Convenience name for target. +queue_nvm: tests/data_structures/CMakeFiles/queue_nvm.dir/rule + +.PHONY : queue_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/queue_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/queue_nvm.dir/build.make tests/data_structures/CMakeFiles/queue_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/queue_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/stores_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/stores_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/stores_nvm.dir/build.make tests/data_structures/CMakeFiles/stores_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/stores_nvm.dir/build.make tests/data_structures/CMakeFiles/stores_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=83,84 "Built target stores_nvm" +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/stores_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/stores_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/stores_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/rule + +# Convenience name for target. +stores_nvm: tests/data_structures/CMakeFiles/stores_nvm.dir/rule + +.PHONY : stores_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/stores_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/stores_nvm.dir/build.make tests/data_structures/CMakeFiles/stores_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/stores_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/alarm_clock_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=24,25 "Built target alarm_clock_nvm" +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/rule + +# Convenience name for target. +alarm_clock_nvm: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/rule + +.PHONY : alarm_clock_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/cow_array_list_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=31,32 "Built target cow_array_list_nvm" +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/rule + +# Convenience name for target. +cow_array_list_nvm: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/rule + +.PHONY : cow_array_list_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/pc_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/pc_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/pc_nvm.dir/build.make tests/data_structures/CMakeFiles/pc_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/pc_nvm.dir/build.make tests/data_structures/CMakeFiles/pc_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=58,59 "Built target pc_nvm" +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/pc_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/pc_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/pc_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/rule + +# Convenience name for target. +pc_nvm: tests/data_structures/CMakeFiles/pc_nvm.dir/rule + +.PHONY : pc_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/pc_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/pc_nvm.dir/build.make tests/data_structures/CMakeFiles/pc_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/pc_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sll_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sll_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/sll_nvm.dir/build.make tests/data_structures/CMakeFiles/sll_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sll_nvm.dir/build.make tests/data_structures/CMakeFiles/sll_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=77,78 "Built target sll_nvm" +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sll_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sll_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sll_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/rule + +# Convenience name for target. +sll_nvm: tests/data_structures/CMakeFiles/sll_nvm.dir/rule + +.PHONY : sll_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/sll_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sll_nvm.dir/build.make tests/data_structures/CMakeFiles/sll_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sll_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/sps_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/sps_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/sps_nvm.dir/build.make tests/data_structures/CMakeFiles/sps_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/sps_nvm.dir/build.make tests/data_structures/CMakeFiles/sps_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=79,80 "Built target sps_nvm" +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/sps_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/sps_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/sps_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/rule + +# Convenience name for target. +sps_nvm: tests/data_structures/CMakeFiles/sps_nvm.dir/rule + +.PHONY : sps_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/sps_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/sps_nvm.dir/build.make tests/data_structures/CMakeFiles/sps_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/sps_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target tests/data_structures/CMakeFiles/linked_list_nvm.dir + +# All Build rule for target. +tests/data_structures/CMakeFiles/linked_list_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend + $(MAKE) -f tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make tests/data_structures/CMakeFiles/linked_list_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=52,53 "Built target linked_list_nvm" +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CMakeFiles/linked_list_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CMakeFiles/linked_list_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CMakeFiles/linked_list_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/rule + +# Convenience name for target. +linked_list_nvm: tests/data_structures/CMakeFiles/linked_list_nvm.dir/rule + +.PHONY : linked_list_nvm + +# clean rule for target. +tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/data_structures/TATP + +# Convenience name for "all" pass in the directory. +tests/data_structures/TATP/all: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/all + +.PHONY : tests/data_structures/TATP/all + +# Convenience name for "clean" pass in the directory. +tests/data_structures/TATP/clean: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean + +.PHONY : tests/data_structures/TATP/clean + +# Convenience name for "preinstall" pass in the directory. +tests/data_structures/TATP/preinstall: + +.PHONY : tests/data_structures/TATP/preinstall + +#============================================================================= +# Target rules for target tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir + +# All Build rule for target. +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend + $(MAKE) -f tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=85,86,87 "Built target tatp_nvm" +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/all + +# Include target in all. +all: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 25 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/rule + +# Convenience name for target. +tatp_nvm: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/rule + +.PHONY : tatp_nvm + +# clean rule for target. +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean: + $(MAKE) -f tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/data_structures/RB + +# Convenience name for "all" pass in the directory. +tests/data_structures/RB/all: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/all + +.PHONY : tests/data_structures/RB/all + +# Convenience name for "clean" pass in the directory. +tests/data_structures/RB/clean: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean + +.PHONY : tests/data_structures/RB/clean + +# Convenience name for "preinstall" pass in the directory. +tests/data_structures/RB/preinstall: + +.PHONY : tests/data_structures/RB/preinstall + +#============================================================================= +# Target rules for target tests/data_structures/RB/CMakeFiles/rb_nvm.dir + +# All Build rule for target. +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend + $(MAKE) -f tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=64,65,66 "Built target rb_nvm" +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/all + +# Include target in all. +all: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 25 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/RB/CMakeFiles/rb_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rule + +# Convenience name for target. +rb_nvm: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rule + +.PHONY : rb_nvm + +# clean rule for target. +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean: + $(MAKE) -f tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/data_structures/TPCC + +# Convenience name for "all" pass in the directory. +tests/data_structures/TPCC/all: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/all + +.PHONY : tests/data_structures/TPCC/all + +# Convenience name for "clean" pass in the directory. +tests/data_structures/TPCC/clean: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean + +.PHONY : tests/data_structures/TPCC/clean + +# Convenience name for "preinstall" pass in the directory. +tests/data_structures/TPCC/preinstall: + +.PHONY : tests/data_structures/TPCC/preinstall + +#============================================================================= +# Target rules for target tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir + +# All Build rule for target. +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend + $(MAKE) -f tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=88,89,90 "Built target tpcc_nvm" +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/all + +# Include target in all. +all: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 25 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/rule + +# Convenience name for target. +tpcc_nvm: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/rule + +.PHONY : tpcc_nvm + +# clean rule for target. +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean: + $(MAKE) -f tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/data_structures/CQ + +# Convenience name for "all" pass in the directory. +tests/data_structures/CQ/all: tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/all + +.PHONY : tests/data_structures/CQ/all + +# Convenience name for "clean" pass in the directory. +tests/data_structures/CQ/clean: tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/clean + +.PHONY : tests/data_structures/CQ/clean + +# Convenience name for "preinstall" pass in the directory. +tests/data_structures/CQ/preinstall: + +.PHONY : tests/data_structures/CQ/preinstall + +#============================================================================= +# Target rules for target tests/data_structures/CQ/CMakeFiles/cq_nvm.dir + +# All Build rule for target. +tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/depend + $(MAKE) -f tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=33,34,35 "Built target cq_nvm" +.PHONY : tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/all + +# Include target in all. +all: tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 25 + $(MAKE) -f CMakeFiles/Makefile2 tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/rule + +# Convenience name for target. +cq_nvm: tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/rule + +.PHONY : cq_nvm + +# clean rule for target. +tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/clean: + $(MAKE) -f tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/clean +.PHONY : tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/clean + +# clean rule for target. +clean: tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/consistency + +# Convenience name for "all" pass in the directory. +tests/consistency/all: tests/consistency/CMakeFiles/malloc_free_test.dir/all + +.PHONY : tests/consistency/all + +# Convenience name for "clean" pass in the directory. +tests/consistency/clean: tests/consistency/CMakeFiles/malloc_free_test.dir/clean + +.PHONY : tests/consistency/clean + +# Convenience name for "preinstall" pass in the directory. +tests/consistency/preinstall: + +.PHONY : tests/consistency/preinstall + +#============================================================================= +# Target rules for target tests/consistency/CMakeFiles/malloc_free_test.dir + +# All Build rule for target. +tests/consistency/CMakeFiles/malloc_free_test.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/consistency/CMakeFiles/malloc_free_test.dir/build.make tests/consistency/CMakeFiles/malloc_free_test.dir/depend + $(MAKE) -f tests/consistency/CMakeFiles/malloc_free_test.dir/build.make tests/consistency/CMakeFiles/malloc_free_test.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=54,55 "Built target malloc_free_test" +.PHONY : tests/consistency/CMakeFiles/malloc_free_test.dir/all + +# Include target in all. +all: tests/consistency/CMakeFiles/malloc_free_test.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/consistency/CMakeFiles/malloc_free_test.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/consistency/CMakeFiles/malloc_free_test.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/consistency/CMakeFiles/malloc_free_test.dir/rule + +# Convenience name for target. +malloc_free_test: tests/consistency/CMakeFiles/malloc_free_test.dir/rule + +.PHONY : malloc_free_test + +# clean rule for target. +tests/consistency/CMakeFiles/malloc_free_test.dir/clean: + $(MAKE) -f tests/consistency/CMakeFiles/malloc_free_test.dir/build.make tests/consistency/CMakeFiles/malloc_free_test.dir/clean +.PHONY : tests/consistency/CMakeFiles/malloc_free_test.dir/clean + +# clean rule for target. +clean: tests/consistency/CMakeFiles/malloc_free_test.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory tests/pmalloc + +# Convenience name for "all" pass in the directory. +tests/pmalloc/all: tests/pmalloc/CMakeFiles/new_delete.dir/all + +.PHONY : tests/pmalloc/all + +# Convenience name for "clean" pass in the directory. +tests/pmalloc/clean: tests/pmalloc/CMakeFiles/new_delete.dir/clean + +.PHONY : tests/pmalloc/clean + +# Convenience name for "preinstall" pass in the directory. +tests/pmalloc/preinstall: + +.PHONY : tests/pmalloc/preinstall + +#============================================================================= +# Target rules for target tests/pmalloc/CMakeFiles/new_delete.dir + +# All Build rule for target. +tests/pmalloc/CMakeFiles/new_delete.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f tests/pmalloc/CMakeFiles/new_delete.dir/build.make tests/pmalloc/CMakeFiles/new_delete.dir/depend + $(MAKE) -f tests/pmalloc/CMakeFiles/new_delete.dir/build.make tests/pmalloc/CMakeFiles/new_delete.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=56,57 "Built target new_delete" +.PHONY : tests/pmalloc/CMakeFiles/new_delete.dir/all + +# Include target in all. +all: tests/pmalloc/CMakeFiles/new_delete.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +tests/pmalloc/CMakeFiles/new_delete.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 tests/pmalloc/CMakeFiles/new_delete.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : tests/pmalloc/CMakeFiles/new_delete.dir/rule + +# Convenience name for target. +new_delete: tests/pmalloc/CMakeFiles/new_delete.dir/rule + +.PHONY : new_delete + +# clean rule for target. +tests/pmalloc/CMakeFiles/new_delete.dir/clean: + $(MAKE) -f tests/pmalloc/CMakeFiles/new_delete.dir/build.make tests/pmalloc/CMakeFiles/new_delete.dir/clean +.PHONY : tests/pmalloc/CMakeFiles/new_delete.dir/clean + +# clean rule for target. +clean: tests/pmalloc/CMakeFiles/new_delete.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src + +# Convenience name for "all" pass in the directory. +src/all: src/cache_flush/all +src/all: src/consistency/all +src/all: src/logger/all +src/all: src/util/all +src/all: src/pmalloc/all +src/all: src/pregion_mgr/all +src/all: src/recover/all + +.PHONY : src/all + +# Convenience name for "clean" pass in the directory. +src/clean: src/cache_flush/clean +src/clean: src/consistency/clean +src/clean: src/logger/clean +src/clean: src/util/clean +src/clean: src/pmalloc/clean +src/clean: src/pregion_mgr/clean +src/clean: src/recover/clean + +.PHONY : src/clean + +# Convenience name for "preinstall" pass in the directory. +src/preinstall: src/cache_flush/preinstall +src/preinstall: src/consistency/preinstall +src/preinstall: src/logger/preinstall +src/preinstall: src/util/preinstall +src/preinstall: src/pmalloc/preinstall +src/preinstall: src/pregion_mgr/preinstall +src/preinstall: src/recover/preinstall + +.PHONY : src/preinstall + +#============================================================================= +# Directory level rules for directory src/cache_flush + +# Convenience name for "all" pass in the directory. +src/cache_flush/all: src/cache_flush/CMakeFiles/Cache_flush.dir/all + +.PHONY : src/cache_flush/all + +# Convenience name for "clean" pass in the directory. +src/cache_flush/clean: src/cache_flush/CMakeFiles/Cache_flush.dir/clean + +.PHONY : src/cache_flush/clean + +# Convenience name for "preinstall" pass in the directory. +src/cache_flush/preinstall: + +.PHONY : src/cache_flush/preinstall + +#============================================================================= +# Target rules for target src/cache_flush/CMakeFiles/Cache_flush.dir + +# All Build rule for target. +src/cache_flush/CMakeFiles/Cache_flush.dir/all: + $(MAKE) -f src/cache_flush/CMakeFiles/Cache_flush.dir/build.make src/cache_flush/CMakeFiles/Cache_flush.dir/depend + $(MAKE) -f src/cache_flush/CMakeFiles/Cache_flush.dir/build.make src/cache_flush/CMakeFiles/Cache_flush.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=1,2,3 "Built target Cache_flush" +.PHONY : src/cache_flush/CMakeFiles/Cache_flush.dir/all + +# Include target in all. +all: src/cache_flush/CMakeFiles/Cache_flush.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/cache_flush/CMakeFiles/Cache_flush.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 3 + $(MAKE) -f CMakeFiles/Makefile2 src/cache_flush/CMakeFiles/Cache_flush.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/cache_flush/CMakeFiles/Cache_flush.dir/rule + +# Convenience name for target. +Cache_flush: src/cache_flush/CMakeFiles/Cache_flush.dir/rule + +.PHONY : Cache_flush + +# clean rule for target. +src/cache_flush/CMakeFiles/Cache_flush.dir/clean: + $(MAKE) -f src/cache_flush/CMakeFiles/Cache_flush.dir/build.make src/cache_flush/CMakeFiles/Cache_flush.dir/clean +.PHONY : src/cache_flush/CMakeFiles/Cache_flush.dir/clean + +# clean rule for target. +clean: src/cache_flush/CMakeFiles/Cache_flush.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/consistency + +# Convenience name for "all" pass in the directory. +src/consistency/all: src/consistency/CMakeFiles/Consistency.dir/all + +.PHONY : src/consistency/all + +# Convenience name for "clean" pass in the directory. +src/consistency/clean: src/consistency/CMakeFiles/Consistency.dir/clean + +.PHONY : src/consistency/clean + +# Convenience name for "preinstall" pass in the directory. +src/consistency/preinstall: + +.PHONY : src/consistency/preinstall + +#============================================================================= +# Target rules for target src/consistency/CMakeFiles/Consistency.dir + +# All Build rule for target. +src/consistency/CMakeFiles/Consistency.dir/all: + $(MAKE) -f src/consistency/CMakeFiles/Consistency.dir/build.make src/consistency/CMakeFiles/Consistency.dir/depend + $(MAKE) -f src/consistency/CMakeFiles/Consistency.dir/build.make src/consistency/CMakeFiles/Consistency.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=4,5,6,7,8 "Built target Consistency" +.PHONY : src/consistency/CMakeFiles/Consistency.dir/all + +# Include target in all. +all: src/consistency/CMakeFiles/Consistency.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/consistency/CMakeFiles/Consistency.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 5 + $(MAKE) -f CMakeFiles/Makefile2 src/consistency/CMakeFiles/Consistency.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/consistency/CMakeFiles/Consistency.dir/rule + +# Convenience name for target. +Consistency: src/consistency/CMakeFiles/Consistency.dir/rule + +.PHONY : Consistency + +# clean rule for target. +src/consistency/CMakeFiles/Consistency.dir/clean: + $(MAKE) -f src/consistency/CMakeFiles/Consistency.dir/build.make src/consistency/CMakeFiles/Consistency.dir/clean +.PHONY : src/consistency/CMakeFiles/Consistency.dir/clean + +# clean rule for target. +clean: src/consistency/CMakeFiles/Consistency.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/logger + +# Convenience name for "all" pass in the directory. +src/logger/all: src/logger/CMakeFiles/Logger.dir/all + +.PHONY : src/logger/all + +# Convenience name for "clean" pass in the directory. +src/logger/clean: src/logger/CMakeFiles/Logger.dir/clean + +.PHONY : src/logger/clean + +# Convenience name for "preinstall" pass in the directory. +src/logger/preinstall: + +.PHONY : src/logger/preinstall + +#============================================================================= +# Target rules for target src/logger/CMakeFiles/Logger.dir + +# All Build rule for target. +src/logger/CMakeFiles/Logger.dir/all: + $(MAKE) -f src/logger/CMakeFiles/Logger.dir/build.make src/logger/CMakeFiles/Logger.dir/depend + $(MAKE) -f src/logger/CMakeFiles/Logger.dir/build.make src/logger/CMakeFiles/Logger.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=9,10,11,12,13,14,15 "Built target Logger" +.PHONY : src/logger/CMakeFiles/Logger.dir/all + +# Include target in all. +all: src/logger/CMakeFiles/Logger.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/logger/CMakeFiles/Logger.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 7 + $(MAKE) -f CMakeFiles/Makefile2 src/logger/CMakeFiles/Logger.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/logger/CMakeFiles/Logger.dir/rule + +# Convenience name for target. +Logger: src/logger/CMakeFiles/Logger.dir/rule + +.PHONY : Logger + +# clean rule for target. +src/logger/CMakeFiles/Logger.dir/clean: + $(MAKE) -f src/logger/CMakeFiles/Logger.dir/build.make src/logger/CMakeFiles/Logger.dir/clean +.PHONY : src/logger/CMakeFiles/Logger.dir/clean + +# clean rule for target. +clean: src/logger/CMakeFiles/Logger.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/util + +# Convenience name for "all" pass in the directory. +src/util/all: src/util/CMakeFiles/Util.dir/all + +.PHONY : src/util/all + +# Convenience name for "clean" pass in the directory. +src/util/clean: src/util/CMakeFiles/Util.dir/clean + +.PHONY : src/util/clean + +# Convenience name for "preinstall" pass in the directory. +src/util/preinstall: + +.PHONY : src/util/preinstall + +#============================================================================= +# Target rules for target src/util/CMakeFiles/Util.dir + +# All Build rule for target. +src/util/CMakeFiles/Util.dir/all: + $(MAKE) -f src/util/CMakeFiles/Util.dir/build.make src/util/CMakeFiles/Util.dir/depend + $(MAKE) -f src/util/CMakeFiles/Util.dir/build.make src/util/CMakeFiles/Util.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=20,21 "Built target Util" +.PHONY : src/util/CMakeFiles/Util.dir/all + +# Include target in all. +all: src/util/CMakeFiles/Util.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/util/CMakeFiles/Util.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 src/util/CMakeFiles/Util.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/util/CMakeFiles/Util.dir/rule + +# Convenience name for target. +Util: src/util/CMakeFiles/Util.dir/rule + +.PHONY : Util + +# clean rule for target. +src/util/CMakeFiles/Util.dir/clean: + $(MAKE) -f src/util/CMakeFiles/Util.dir/build.make src/util/CMakeFiles/Util.dir/clean +.PHONY : src/util/CMakeFiles/Util.dir/clean + +# clean rule for target. +clean: src/util/CMakeFiles/Util.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/pmalloc + +# Convenience name for "all" pass in the directory. +src/pmalloc/all: src/pmalloc/CMakeFiles/Pmalloc.dir/all + +.PHONY : src/pmalloc/all + +# Convenience name for "clean" pass in the directory. +src/pmalloc/clean: src/pmalloc/CMakeFiles/Pmalloc.dir/clean + +.PHONY : src/pmalloc/clean + +# Convenience name for "preinstall" pass in the directory. +src/pmalloc/preinstall: + +.PHONY : src/pmalloc/preinstall + +#============================================================================= +# Target rules for target src/pmalloc/CMakeFiles/Pmalloc.dir + +# All Build rule for target. +src/pmalloc/CMakeFiles/Pmalloc.dir/all: + $(MAKE) -f src/pmalloc/CMakeFiles/Pmalloc.dir/build.make src/pmalloc/CMakeFiles/Pmalloc.dir/depend + $(MAKE) -f src/pmalloc/CMakeFiles/Pmalloc.dir/build.make src/pmalloc/CMakeFiles/Pmalloc.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=16,17 "Built target Pmalloc" +.PHONY : src/pmalloc/CMakeFiles/Pmalloc.dir/all + +# Include target in all. +all: src/pmalloc/CMakeFiles/Pmalloc.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/pmalloc/CMakeFiles/Pmalloc.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 src/pmalloc/CMakeFiles/Pmalloc.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/pmalloc/CMakeFiles/Pmalloc.dir/rule + +# Convenience name for target. +Pmalloc: src/pmalloc/CMakeFiles/Pmalloc.dir/rule + +.PHONY : Pmalloc + +# clean rule for target. +src/pmalloc/CMakeFiles/Pmalloc.dir/clean: + $(MAKE) -f src/pmalloc/CMakeFiles/Pmalloc.dir/build.make src/pmalloc/CMakeFiles/Pmalloc.dir/clean +.PHONY : src/pmalloc/CMakeFiles/Pmalloc.dir/clean + +# clean rule for target. +clean: src/pmalloc/CMakeFiles/Pmalloc.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/pregion_mgr + +# Convenience name for "all" pass in the directory. +src/pregion_mgr/all: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all + +.PHONY : src/pregion_mgr/all + +# Convenience name for "clean" pass in the directory. +src/pregion_mgr/clean: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/clean + +.PHONY : src/pregion_mgr/clean + +# Convenience name for "preinstall" pass in the directory. +src/pregion_mgr/preinstall: + +.PHONY : src/pregion_mgr/preinstall + +#============================================================================= +# Target rules for target src/pregion_mgr/CMakeFiles/Pregion_mgr.dir + +# All Build rule for target. +src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all: + $(MAKE) -f src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/depend + $(MAKE) -f src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=18,19 "Built target Pregion_mgr" +.PHONY : src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all + +# Include target in all. +all: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 2 + $(MAKE) -f CMakeFiles/Makefile2 src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/rule + +# Convenience name for target. +Pregion_mgr: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/rule + +.PHONY : Pregion_mgr + +# clean rule for target. +src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/clean: + $(MAKE) -f src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/clean +.PHONY : src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/clean + +# clean rule for target. +clean: src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory src/recover + +# Convenience name for "all" pass in the directory. +src/recover/all: src/recover/CMakeFiles/clean_mem.dir/all +src/recover/all: src/recover/CMakeFiles/recover.dir/all +src/recover/all: src/recover/CMakeFiles/del_log.dir/all +src/recover/all: src/recover/CMakeFiles/del_rgn.dir/all + +.PHONY : src/recover/all + +# Convenience name for "clean" pass in the directory. +src/recover/clean: src/recover/CMakeFiles/clean_mem.dir/clean +src/recover/clean: src/recover/CMakeFiles/recover.dir/clean +src/recover/clean: src/recover/CMakeFiles/del_log.dir/clean +src/recover/clean: src/recover/CMakeFiles/del_rgn.dir/clean + +.PHONY : src/recover/clean + +# Convenience name for "preinstall" pass in the directory. +src/recover/preinstall: + +.PHONY : src/recover/preinstall + +#============================================================================= +# Target rules for target src/recover/CMakeFiles/clean_mem.dir + +# All Build rule for target. +src/recover/CMakeFiles/clean_mem.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f src/recover/CMakeFiles/clean_mem.dir/build.make src/recover/CMakeFiles/clean_mem.dir/depend + $(MAKE) -f src/recover/CMakeFiles/clean_mem.dir/build.make src/recover/CMakeFiles/clean_mem.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=27,28 "Built target clean_mem" +.PHONY : src/recover/CMakeFiles/clean_mem.dir/all + +# Include target in all. +all: src/recover/CMakeFiles/clean_mem.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/recover/CMakeFiles/clean_mem.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 src/recover/CMakeFiles/clean_mem.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/recover/CMakeFiles/clean_mem.dir/rule + +# Convenience name for target. +clean_mem: src/recover/CMakeFiles/clean_mem.dir/rule + +.PHONY : clean_mem + +# clean rule for target. +src/recover/CMakeFiles/clean_mem.dir/clean: + $(MAKE) -f src/recover/CMakeFiles/clean_mem.dir/build.make src/recover/CMakeFiles/clean_mem.dir/clean +.PHONY : src/recover/CMakeFiles/clean_mem.dir/clean + +# clean rule for target. +clean: src/recover/CMakeFiles/clean_mem.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target src/recover/CMakeFiles/recover.dir + +# All Build rule for target. +src/recover/CMakeFiles/recover.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f src/recover/CMakeFiles/recover.dir/build.make src/recover/CMakeFiles/recover.dir/depend + $(MAKE) -f src/recover/CMakeFiles/recover.dir/build.make src/recover/CMakeFiles/recover.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=67,68 "Built target recover" +.PHONY : src/recover/CMakeFiles/recover.dir/all + +# Include target in all. +all: src/recover/CMakeFiles/recover.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/recover/CMakeFiles/recover.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 src/recover/CMakeFiles/recover.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/recover/CMakeFiles/recover.dir/rule + +# Convenience name for target. +recover: src/recover/CMakeFiles/recover.dir/rule + +.PHONY : recover + +# clean rule for target. +src/recover/CMakeFiles/recover.dir/clean: + $(MAKE) -f src/recover/CMakeFiles/recover.dir/build.make src/recover/CMakeFiles/recover.dir/clean +.PHONY : src/recover/CMakeFiles/recover.dir/clean + +# clean rule for target. +clean: src/recover/CMakeFiles/recover.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target src/recover/CMakeFiles/del_log.dir + +# All Build rule for target. +src/recover/CMakeFiles/del_log.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f src/recover/CMakeFiles/del_log.dir/build.make src/recover/CMakeFiles/del_log.dir/depend + $(MAKE) -f src/recover/CMakeFiles/del_log.dir/build.make src/recover/CMakeFiles/del_log.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=42,43 "Built target del_log" +.PHONY : src/recover/CMakeFiles/del_log.dir/all + +# Include target in all. +all: src/recover/CMakeFiles/del_log.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/recover/CMakeFiles/del_log.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 src/recover/CMakeFiles/del_log.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/recover/CMakeFiles/del_log.dir/rule + +# Convenience name for target. +del_log: src/recover/CMakeFiles/del_log.dir/rule + +.PHONY : del_log + +# clean rule for target. +src/recover/CMakeFiles/del_log.dir/clean: + $(MAKE) -f src/recover/CMakeFiles/del_log.dir/build.make src/recover/CMakeFiles/del_log.dir/clean +.PHONY : src/recover/CMakeFiles/del_log.dir/clean + +# clean rule for target. +clean: src/recover/CMakeFiles/del_log.dir/clean + +.PHONY : clean + +#============================================================================= +# Target rules for target src/recover/CMakeFiles/del_rgn.dir + +# All Build rule for target. +src/recover/CMakeFiles/del_rgn.dir/all: CMakeFiles/atlas.dir/all + $(MAKE) -f src/recover/CMakeFiles/del_rgn.dir/build.make src/recover/CMakeFiles/del_rgn.dir/depend + $(MAKE) -f src/recover/CMakeFiles/del_rgn.dir/build.make src/recover/CMakeFiles/del_rgn.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=44,45 "Built target del_rgn" +.PHONY : src/recover/CMakeFiles/del_rgn.dir/all + +# Include target in all. +all: src/recover/CMakeFiles/del_rgn.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +src/recover/CMakeFiles/del_rgn.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 24 + $(MAKE) -f CMakeFiles/Makefile2 src/recover/CMakeFiles/del_rgn.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles 0 +.PHONY : src/recover/CMakeFiles/del_rgn.dir/rule + +# Convenience name for target. +del_rgn: src/recover/CMakeFiles/del_rgn.dir/rule + +.PHONY : del_rgn + +# clean rule for target. +src/recover/CMakeFiles/del_rgn.dir/clean: + $(MAKE) -f src/recover/CMakeFiles/del_rgn.dir/build.make src/recover/CMakeFiles/del_rgn.dir/clean +.PHONY : src/recover/CMakeFiles/del_rgn.dir/clean + +# clean rule for target. +clean: src/recover/CMakeFiles/del_rgn.dir/clean + +.PHONY : clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/runtime/src/CMakeFiles/TargetDirectories.txt b/ARP_CSFR/runtime/src/CMakeFiles/TargetDirectories.txt similarity index 100% rename from runtime/src/CMakeFiles/TargetDirectories.txt rename to ARP_CSFR/runtime/src/CMakeFiles/TargetDirectories.txt diff --git a/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake diff --git a/runtime/src/CMakeFiles/atlas.dir/build.make b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/build.make similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/build.make rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/build.make diff --git a/runtime/src/CMakeFiles/atlas.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/cmake_clean.cmake diff --git a/runtime/src/CMakeFiles/atlas.dir/cmake_clean_target.cmake b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/cmake_clean_target.cmake similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/cmake_clean_target.cmake rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/cmake_clean_target.cmake diff --git a/runtime/src/CMakeFiles/atlas.dir/depend.make b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/depend.make similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/depend.make rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/depend.make diff --git a/runtime/src/CMakeFiles/atlas.dir/flags.make b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/flags.make similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/flags.make rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/flags.make diff --git a/runtime/src/CMakeFiles/atlas.dir/link.txt b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/link.txt similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/link.txt rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/link.txt diff --git a/runtime/src/CMakeFiles/atlas.dir/progress.make b/ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/progress.make similarity index 100% rename from runtime/src/CMakeFiles/atlas.dir/progress.make rename to ARP_CSFR/runtime/src/CMakeFiles/atlas.dir/progress.make diff --git a/runtime/src/CMakeFiles/cmake.check_cache b/ARP_CSFR/runtime/src/CMakeFiles/cmake.check_cache similarity index 100% rename from runtime/src/CMakeFiles/cmake.check_cache rename to ARP_CSFR/runtime/src/CMakeFiles/cmake.check_cache diff --git a/runtime/src/CMakeFiles/feature_tests.bin b/ARP_CSFR/runtime/src/CMakeFiles/feature_tests.bin similarity index 100% rename from runtime/src/CMakeFiles/feature_tests.bin rename to ARP_CSFR/runtime/src/CMakeFiles/feature_tests.bin diff --git a/runtime/src/CMakeFiles/feature_tests.c b/ARP_CSFR/runtime/src/CMakeFiles/feature_tests.c similarity index 100% rename from runtime/src/CMakeFiles/feature_tests.c rename to ARP_CSFR/runtime/src/CMakeFiles/feature_tests.c diff --git a/runtime/src/CMakeFiles/feature_tests.cxx b/ARP_CSFR/runtime/src/CMakeFiles/feature_tests.cxx similarity index 100% rename from runtime/src/CMakeFiles/feature_tests.cxx rename to ARP_CSFR/runtime/src/CMakeFiles/feature_tests.cxx diff --git a/ARP_CSFR/runtime/src/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..d61f00d8cad3920809f4d992ac3031b3f32e7f10 --- /dev/null +++ b/ARP_CSFR/runtime/src/CMakeFiles/progress.marks @@ -0,0 +1 @@ +90 diff --git a/ARP_CSFR/runtime/src/CMakeLists.txt b/ARP_CSFR/runtime/src/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..1c208db77b73a19b0c053d515a2b79c3db95834f --- /dev/null +++ b/ARP_CSFR/runtime/src/CMakeLists.txt @@ -0,0 +1,23 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# src CMakeLists.txt + +add_subdirectory (cache_flush) +add_subdirectory (consistency) +add_subdirectory (logger) +add_subdirectory (util) +add_subdirectory (pmalloc) +add_subdirectory (pregion_mgr) +add_subdirectory (recover) diff --git a/runtime/src/Makefile b/ARP_CSFR/runtime/src/Makefile similarity index 100% rename from runtime/src/Makefile rename to ARP_CSFR/runtime/src/Makefile diff --git a/ARP_CSFR/runtime/src/README.md b/ARP_CSFR/runtime/src/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f169da51e70625b6ae0eb56759c4b8409d709f7c --- /dev/null +++ b/ARP_CSFR/runtime/src/README.md @@ -0,0 +1,93 @@ +[//]: # ( (c) Copyright 2016 Hewlett Packard Enterprise Development LP ) +[//]: # ( ) +[//]: # ( This program is free software: you can redistribute it and/or modify ) +[//]: # ( it under the terms of the GNU Lesser General Public License as ) +[//]: # ( published by the Free Software Foundation, either version 3 of the ) +[//]: # ( License, or (at your option) any later version. This program is ) +[//]: # ( distributed in the hope that it will be useful, but WITHOUT ANY ) +[//]: # ( WARRANTY; without even the implied warranty of MERCHANTABILITY or ) +[//]: # ( FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ) +[//]: # ( for more details. You should have received a copy of the GNU Lesser ) +[//]: # ( General Public License along with this program. If not, see ) +[//]: # ( . ) + + +# Atlas Runtime APIs + +Atlas is a high-level programming environment for non-volatile +memory. In-memory objects can be persisted or made durable with +relatively minor changes to code. There are 2 classes of APIs: +persistent region APIs and consistency APIs. The first class is used +to create/find/delete containers that store persistent data and can be +found in include/atlas_alloc.h. The second class is used to convey +data-consistency information to the system. Currently, this includes a +durable section (demarcated by begin_durable and end_durable) and +classical lock-based critical sections. See `include/atlas_api.h` for +these interfaces. For examples of how to write a persistent program +using Atlas, see `runtime/tests/data_structures/README.md`. + +## Building + +Atlas "runtime" uses cmake. cmake 3.1 is the minimum required +version. The library build must be in a separate build +directory. Assume that the top-level Atlas runtime directory is +`ATLAS_RUNTIME` and the build directory is `ATLAS_BUILD`. First create +`ATLAS_BUILD`. It is recommended to name this directory with the atlas +build config, e.g. `build-all`, or `build-all-persist`. Invoke cmake +within `ATLAS_BUILD`, passing the path to `ATLAS_RUNTIME` and +any variables needed for the config. Example: + + $ cd + $ mkdir build-all + $ cd build-all + $ cmake .. + $ make + +There are a number of modes for building the runtime. See +`runtime/CMakeLists.txt` for the supported ones. For example, to turn on +Atlas statistics, the cmake config line above should be: + + $ cmake .. -DNVM_STATS=true + +To rebuild Atlas runtime when changes are made to the sources, +just invoke `make` again. + +# Testing + +Persistent memory is simulated using Linux tmpfs, so make sure +`/dev/shm` is available, has enough space, and has `rwx` +permissions. After making, invoke `/tests/run_quick_test` +to do some basic testing. For developers: make sure that +`/tools/run_tests` passes before checking in. + +# Organization + +`ATLAS_RUNTIME` has the following subdirectories: + +`include`: contains the headers with exported interfaces. These are +the only headers that should be included in applications. + +`src`: the source files + +`src/internal_includes`: internal header files + +`src/pregion_mgr`: persistent region support + +`src/pmalloc`: persistent allocator support + +`src/logger`: support for logging updates to persistent memory + +`src/consistency`: automatic computation of consistent states and log pruning + +`src/cache_flush`: optimized cache line flush support + +`src/recover`: support for recovery after a failure + +`src/util`: common routines + +`tools`: `/tools/run_tests` goes through a variety of +build targets and does some basic testing for each of them. + +`tests`: directory used for testing. Contains binaries, inputs, +outputs, reference files, etc. See the READMEs in the individual +subdirectories. diff --git a/runtime/src/cache_flush/CMakeLists.txt b/ARP_CSFR/runtime/src/cache_flush/CMakeLists.txt similarity index 100% rename from runtime/src/cache_flush/CMakeLists.txt rename to ARP_CSFR/runtime/src/cache_flush/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/cache_flush/delayed.cpp b/ARP_CSFR/runtime/src/cache_flush/delayed.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ebe3ad685349c8c415c6e3b4fbaba81a16242a0e --- /dev/null +++ b/ARP_CSFR/runtime/src/cache_flush/delayed.cpp @@ -0,0 +1,87 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +// TODO Cache flush functionality should be in its own class + +namespace Atlas { + +#if (defined(_FLUSH_LOCAL_COMMIT) || defined(_FLUSH_GLOBAL_COMMIT)) && \ + !(defined DISABLE_FLUSHES) + +void LogMgr::collectCacheLines(SetOfInts *cl_set, void *addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!sz) return; + + char *last_addr = (char*)addr + sz - 1; + char *line_addr = (char*)((uint64_t)addr & + PMallocUtil::get_cache_line_mask()); + char *last_line_addr = (char*)((uint64_t)last_addr & + PMallocUtil::get_cache_line_mask()); + do { +// (*cl_set).insert((uint64_t)line_addr); + NVM_FLUSH(line_addr); + line_addr += PMallocUtil::get_cache_line_size(); + }while (line_addr < last_line_addr+1); +} + +void LogMgr::flushCacheLines(const SetOfInts & cl_set) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + full_fence(); + return; + SetOfInts::const_iterator ci_end = cl_set.end(); + for (SetOfInts::const_iterator ci = cl_set.begin(); ci != ci_end; ++ ci) { + assert(*ci); + // We are assuming that a user persistent region is not closed + // within a critical or atomic section. +#ifdef _FLUSH_GLOBAL_COMMIT + // This is the only scenario today where the helper thread is + // flushing data (i.e. essentially writing) data into a user + // persistent region. But this region may have been closed by + // the user by this point. So need to check for this + // situation. This is still not full-proof since the region + // can be closed between the check and the actual flush. + // This will at least prevent a fault but more needs to be done + // to ensure consistency. + if (!NVM_IsInOpenPR((void*)*ci, 1 /*dummy*/)) + continue; +#endif + NVM_CLFLUSH((char*)*ci); + } + full_fence(); +} + +void LogMgr::flushCacheLinesUnconstrained(const SetOfInts & cl_set) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + SetOfInts::const_iterator ci_end = cl_set.end(); + for (SetOfInts::const_iterator ci = cl_set.begin(); ci != ci_end; ++ ci) { + assert(*ci); + NVM_CLFLUSH((char*)*ci); + } +} +#endif + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/cache_flush/generic.cpp b/ARP_CSFR/runtime/src/cache_flush/generic.cpp new file mode 100644 index 0000000000000000000000000000000000000000..afa60d9e719a1bed779aabb92e0d4bb4b7cd2123 --- /dev/null +++ b/ARP_CSFR/runtime/src/cache_flush/generic.cpp @@ -0,0 +1,61 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +namespace Atlas { + +void LogMgr::psyncWithAcquireBarrier(void *start_addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (sz <= 0) return; + + char *last_addr = (char*)start_addr + sz - 1; + + char *cacheline_addr = + (char*)(((uint64_t)start_addr) & PMallocUtil::get_cache_line_mask()); + char *last_cacheline_addr = + (char*)(((uint64_t)last_addr) & PMallocUtil::get_cache_line_mask()); + + full_fence(); + do { + NVM_CLFLUSH(cacheline_addr); + cacheline_addr += PMallocUtil::get_cache_line_size(); + }while (cacheline_addr < last_cacheline_addr+1); +} + +void LogMgr::psync(void *start_addr, size_t sz) +{ + psyncWithAcquireBarrier(start_addr, sz); + full_fence(); +} + +void LogMgr::flushAtEndOfFase() +{ +#if defined(_FLUSH_LOCAL_COMMIT) && !defined(DISABLE_FLUSHES) + assert(TL_FaseFlushPtr_); + if (!TL_FaseFlushPtr_->empty()) { + flushCacheLines(*TL_FaseFlushPtr_); + TL_FaseFlushPtr_->clear(); + } +#elif defined(_USE_TABLE_FLUSH) && !defined(DISABLE_FLUSHES) + syncDataFlush(); +#endif +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/cache_flush/table_based.cpp b/ARP_CSFR/runtime/src/cache_flush/table_based.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a3229bfa8241c375dc056ce45a95a6d0f69c8a47 --- /dev/null +++ b/ARP_CSFR/runtime/src/cache_flush/table_based.cpp @@ -0,0 +1,125 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +void AsyncDataCacheFlush(void *p); +void AsyncMemOpDataCacheFlush(void *dst, size_t sz); +void SyncDataCacheFlush(); + +namespace Atlas { + +#if 0 // unused +void LogMgr::asyncLogFlush(void *p) +{ + // Since this is a log entry, we don't need to check whether it is + // persistent or not. It must be persistent. + intptr_t *entry = TL_LogFlushTab_ + + (((intptr_t)p >> kFlushShift) & kFlushTableMask); + intptr_t cache_line = (intptr_t)p & PMallocUtil::get_cache_line_mask(); + + if (*entry != cache_line) { + if (*entry) { + full_fence(); + NVM_CLFLUSH(*entry); + } + *entry = cache_line; + } +} + +void LogMgr::syncLogFlush() +{ + int i; + full_fence(); + for (i=0; i> kFlushShift) & kFlushTableMask); + intptr_t cache_line = (intptr_t)p & PMallocUtil::get_cache_line_mask(); + + if (*entry != cache_line) { + if (*entry) { + full_fence(); + NVM_CLFLUSH(*entry); + } + *entry = cache_line; + } +} + +void LogMgr::asyncMemOpDataFlush(void *dst, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!NVM_IsInOpenPR(dst, 1)) return; + + if (sz <= 0) return; + + char *last_addr = (char*)dst + sz - 1; + char *cacheline_addr = + (char*)(((uint64_t)dst) & PMallocUtil::get_cache_line_mask()); + char *last_cacheline_addr = + (char*)(((uint64_t)last_addr) & PMallocUtil::get_cache_line_mask()); + + intptr_t *entry; + full_fence(); + do { + entry = TL_DataFlushTab_ + + (((intptr_t)cacheline_addr >> kFlushShift) & kFlushTableMask); + if (*entry != (intptr_t)cacheline_addr) { + if (*entry) NVM_CLFLUSH(*entry); + *entry = (intptr_t)cacheline_addr; + } + cacheline_addr += PMallocUtil::get_cache_line_size(); + }while (cacheline_addr < last_cacheline_addr+1); +} + +void LogMgr::syncDataFlush() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int i; + full_fence(); + for (i=0; i. + */ + + +#include +#include + +#include "atlas_api.h" +#include "util.hpp" + +#include "pregion_mgr.hpp" +#include "log_mgr.hpp" +#include "consistency_mgr.hpp" +#include "circular_buffer.hpp" + +namespace Atlas { + +bool CSMgr::isFoundInExistingLog(LogEntry *le, uint64_t gen_num) const +{ + Helper::MapLog2Int::const_iterator ci = ExistingRelMap_->find(le); + if (ci != ExistingRelMap_->end() && ci->second == gen_num) return true; + return false; +} + +// Build a Failure Atomic Section (FASection) given the starting log +// entry for the FASE. This data structure is used by the helper +// thread alone. The builder starts with a provided log entry and +// traverses the thread-specific logs until it either runs out of them +// or comes across the end of an outermost critical section. If the +// former, a FASE is not built. If the latter, a FASE is built and +// returned. +FASection *CSMgr::buildFASection(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uint32_t lock_count = 0; + LogEntry *first_le = le; + while (le) { + LogEntry *next_le = le->Next.load(std::memory_order_acquire); + if (!next_le) return nullptr; // always keep one non-null log entry + + if (le->isAcquire() || le->isRWLockRdLock() || le->isRWLockWrLock() + || le->isBeginDurable()) ++lock_count; + + if (le->isRelease() || le->isRWLockUnlock() || le->isEndDurable()) { + if (lock_count > 0) --lock_count; + if (!lock_count) + return new FASection(first_le, le); + } + le = next_le; + } + assert(0 && "FASE construction in an unexpected code path!"); + return nullptr; +} + +void CSMgr::destroyFASections() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + FaseVec::iterator ci_end = AllFases_.end(); + for (FaseVec::iterator ci = AllFases_.begin(); ci != ci_end; ++ci) + delete *ci; +} + +// +// Examine the pending list, trying to find the log entry that +// immediately happens before it, adding to the durability graph in +// the process. At the end of this function, the pending list is left +// with log entries that cannot be resolved in the current round. +void CSMgr::resolvePendingList() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (PendingList_.empty()) { + traceHelper("Pending list is empty: graph unchanged\n"); + return; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + // Track the resolved entries using a vector + typedef std::vector DelVec; + DelVec del_vec; + + PendingList::iterator ci_end = PendingList_.end(); + for (PendingList::iterator ci = PendingList_.begin(); ci != ci_end; ++ci) { + LogEntry *le = ci->first; + + assert(le); + assert(le->isAcquire()); + assert(le->ValueOrPtr); + + const DGraph::NodeInfo& node_info = + Graph_.getTargetNodeInfo( + reinterpret_cast(le->ValueOrPtr)); + + if (node_info.NodeType_ == DGraph::kAvail) { + Graph_.createEdge(ci->second, node_info.NodeId_); + // Now that this entry is resolved, tag it for deletion + del_vec.push_back(ci); + } + // Mark the corresponding node unstable only if target is absent. + else if (node_info.NodeType_ == DGraph::kAbsent) + if (le->ValueOrPtr) + set_is_stable(ci->second, false); + } + // Actual removal of tagged resolved entries + DelVec::const_iterator del_ci_end = del_vec.end(); + for (DelVec::const_iterator del_ci = del_vec.begin(); + del_ci != del_ci_end; ++ del_ci) + PendingList_.erase(*del_ci); + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in graph after pending list resolution\n"); + traceGraph(); +} + +// This routine removes nodes (from the durability graph) that cannot +// be resolved +void CSMgr::removeUnresolvedNodes() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (PendingList_.empty()) { + traceHelper("Pending list is empty: graph unchanged\n"); + return; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + MapNodes removed_nodes; + std::pair vp; + for (vp = vertices(Graph_.get_directed_graph()); + vp.first != vp.second; ++ vp.first) { + DGraph::VDesc nid = *(vp.first); + + // This node has been already processed + if (removed_nodes.find(nid) != removed_nodes.end()) { + assert(!is_stable(nid)); + continue; + } + + if (is_stable(nid)) continue; + handleUnresolved(nid, &removed_nodes); + } + + // Actually remove the nodes + MapNodes::const_iterator rm_ci_end = removed_nodes.end(); + MapNodes::const_iterator rm_ci = removed_nodes.begin(); + for (; rm_ci != rm_ci_end; ++ rm_ci) + { + Graph_.clear_vertex(rm_ci->first); + Graph_.remove_vertex(rm_ci->first); + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in resolved graph\n"); + traceGraph(); +} + +// +// Given an unstable node, mark other "happen-after" nodes unstable +// as well. +// +void CSMgr::handleUnresolved(DGraph::VDesc nid, MapNodes *removed_nodes) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // already handled + if (removed_nodes->find(nid) != removed_nodes->end()) return; + + (*removed_nodes)[nid] = true; + + // if nid is removed, examine all in-edges and for a given in-edge, + // remove the source node as well + std::pair iep; + for (iep = in_edges(nid, Graph_.get_directed_graph()); + iep.first != iep.second; ++iep.first) { + DGraph::EDesc eid = *iep.first; + DGraph::VDesc src = source(eid, Graph_.get_directed_graph()); + + if (removed_nodes->find(src) != removed_nodes->end()) { + assert(!is_stable(src)); + continue; + } + set_is_stable(src, false); + handleUnresolved(src, removed_nodes); + } +} + +// +// At this point, a node is in the graph if an only if it belongs to +// the corresponding consistent state. This routine creates a new +// version of the log structure and adds it to the list of such +// outstanding new versions. This new version has new thread-specific +// headers that point to log entries in a way that excludes the FASEs +// corresponding to the graph nodes that belong to this consistent state. +// +void CSMgr::createVersions(Helper::LogVersions *log_v) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!get_num_graph_vertices()) return; + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + // All nodes in the graph at this point are complete and have been + // resolved. So all of the corresponding FASEs are marked deletable. + std::pair vp; + for (vp = vertices(Graph_.get_directed_graph()); + vp.first != vp.second; ++ vp.first) { + FASection *fase = Graph_.get_fase(*vp.first); + assert(fase); + assert(!fase->IsDeleted); + fase->IsDeleted = true; + } + + // TODO cache these instances? + LogStructure *lsp = IsInRecovery_ ? + LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire) : + LogMgr::getInstance().getLogPointer(std::memory_order_acquire); + assert(lsp); + + LogStructure *new_header = 0; + LogStructure *last_ls = 0; + // We walk the log-structure-header, and for every entry in it, + // walk through that thread's FASEs and find the first undeleted + // one. + + Log2Bool deletable_logs; // log entries to be deleted in this version + while (lsp) { + FASection *fase = getFirstFase(lsp); + bool found_undeleted = false; + if (!fase) { + found_undeleted = true; + addLogStructure(lsp->Le, &new_header, &last_ls); + } + FASection *last_fase = nullptr; + while (fase) { + if (!found_undeleted && !fase->IsDeleted) { + found_undeleted = true; + addLogStructure(fase->First, &new_header, &last_ls); + last_fase = fase; + fase = fase->Next; + break; + } + else { + collectLogs(&deletable_logs, fase); + last_fase = fase; + fase = fase->Next; + } + } + // For a given thread, we always leave the last log entry around. + + // We may not have found an undeleted FASE if all created + // FASEs are in the consistent state + if (!found_undeleted) { + assert(last_fase); + assert(last_fase->Last); + assert(last_fase->Last->Next); + addLogStructure(last_fase->Last->Next, &new_header, &last_ls); + } + lsp = lsp->Next; + } + assert(new_header); + (*log_v).push_back(Helper::LogVer(new_header, deletable_logs)); + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif +} + +/// +/// @brief Add a new thread specific log header +/// @param le Log entry the new header points to +/// @param header A pointer to a future global header +/// @param last_header The last thread specific log header in sequence +/// +/// Create a new thread specific log header. If this is the first in +/// the sequence of thread specific log headers, set the future global +/// header, otherwise have the last thread specific header to point to +/// this newly created one. +void CSMgr::addLogStructure(LogEntry *le, LogStructure **header, + LogStructure **last_header) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(header); + assert(last_header); + // TODO ensure that new_ls is getting flushed + LogStructure *new_ls = LogMgr::getInstance().createLogStructure(le); + if (!*header) *header = new_ls; + else { + assert(*last_header); + (*last_header)->Next = new_ls; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(&(*last_header)->Next); +#endif + } + *last_header = new_ls; +} + +// Add all log entries of the provided FASE to the map +void CSMgr::collectLogs(Log2Bool *logs, FASection *fase) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(fase); + assert(fase->Last); + assert(fase->IsDeleted); + + LogEntry *curr = fase->First; + do { + assert(curr); + (*logs)[curr] = true; + if (curr == fase->Last) break; + curr = curr->Next; + }while (true); +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/consistency/consistency_mgr.cpp b/ARP_CSFR/runtime/src/consistency/consistency_mgr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc49833ee912b1e04e70092911f813e94c79b6dc --- /dev/null +++ b/ARP_CSFR/runtime/src/consistency/consistency_mgr.cpp @@ -0,0 +1,85 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "consistency_mgr.hpp" + +namespace Atlas { + +CSMgr *CSMgr::Instance_{nullptr}; + +/// +/// @brief Main entry point for a single round of consistent state gen +/// @param lsp Pointer to the first thread specific header +/// @param log_v Pointer to the versions of consistent states +/// @param is_in_recovery Whether invoked online or during recovery +/// +/// Build a graph of completed failure atomic sections (FASE) with +/// durability edges among them. All log entries of a FASE are in a +/// consistent state if all log entries they transitively happen-after +/// are also in the same consistent state. Failure-atomically removing +/// these log entries advances the persistent consistent state. +/// +void CSMgr::doConsistentUpdate(LogStructure *lsp, + Helper::LogVersions *log_v, + bool is_in_recovery) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + IsInRecovery_ = is_in_recovery; + + // TODO incorporate consistency analysis profiling if required + + buildInitialGraph(lsp); + + if (IsParentDone_) return; + + // If there is any pending entry from the initial graph created + // above, examine whether it can be resolved. + resolvePendingList(); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // If there is still any unresolved log entry, it cannot belong to + // a consistent state. + removeUnresolvedNodes(); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // TODO: If we are in recovery phase and the resolved graph is + // empty, we should increase the candidate log entries chosen and + // then try again. + if (IsInRecovery_ && !get_num_graph_vertices()) return; + + // Create versions of consistent states + createVersions(log_v); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // Remove the log entries failure-atomically. + destroyLogs(log_v); + + // Clean up FASEs created for this round. + destroyFASections(); +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/consistency/durability_graph_builder.cpp b/ARP_CSFR/runtime/src/consistency/durability_graph_builder.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ee73237efcba4df2893407789e95dbb1303c6352 --- /dev/null +++ b/ARP_CSFR/runtime/src/consistency/durability_graph_builder.cpp @@ -0,0 +1,474 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "consistency_configs.hpp" +#include "consistency_mgr.hpp" +#include "durability_graph.hpp" +#include "helper.hpp" + +namespace Atlas { + +static inline void addThreadNode( + CSMgr::MapNodes *thread_nodes, DGraph::VDesc nid) +{ + assert(thread_nodes->find(nid) == thread_nodes->end()); + thread_nodes->insert(std::make_pair(nid, true)); +} + +static inline bool hasThreadNode( + const CSMgr::MapNodes& thread_nodes, DGraph::VDesc nid) +{ + return thread_nodes.find(nid) != thread_nodes.end(); +} + +void CSMgr::buildInitialGraph(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_build = atlas_rdtsc(); +#endif + + // This loop goes through the log entries of one thread at a time + while (lsp) { + LogEntry *current_le = lsp->Le; + assert(current_le); + + DGraph::VDesc prev_nid = 0; + FASection *prev_fase = nullptr; + bool is_first_node = true; + uint32_t fase_count = 0; + MapNodes thread_nodes; + // This loop goes through the FASEs + while (true) { + ++fase_count; + + // TODO: If a consistent state is not found, the number + // of FASEs examined should be increased. + + // There is a configurable maximum number of FASEs chosen + // from a given thread in a given analysis step + if (fase_count > kFaseAnalysisLimit) break; + + if (areUserThreadsDone()) { + IsParentDone_ = true; + break; + } + + // Build a FASE starting with this log entry + FASection *current_fase = buildFASection(current_le); + if (!current_fase) break; // this thread is done + else { + if (!isFirstFaseFound(lsp)) + addFirstFase(lsp, current_fase); + addFaseToVec(current_fase); + } + + if (prev_fase) prev_fase->Next = current_fase; + + DGraph::VDesc nid = Graph_.createNode(current_fase); + addThreadNode(&thread_nodes, nid); + + if (!is_first_node) { + assert(prev_nid); + Graph_.createEdge(nid, prev_nid); + } + + is_first_node = false; + prev_nid = nid; + + // This loop goes through the log entries of a FASE + do { + addSyncEdges(thread_nodes, current_le, nid); + + if (current_le == current_fase->Last) break; + + // No need for an atomic read, we are guaranteed + // at this point that the next ptr won't change. + current_le = current_le->Next; + + }while (true); + + prev_fase = current_fase; + current_le = current_le->Next.load(std::memory_order_acquire); + } + if (IsParentDone_) break; + lsp = lsp->Next; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_build = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphBuildTime( + stop_graph_build - start_graph_build); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in initial graph\n"); + traceGraph(); +} + +// TODO Take care of reentrant locking. +// Keeping a thread-local map to filter out locks held at a certain point +// of time can help here. + +/// +/// @brief Add synchronizes-with edges between log entries +/// @param thread_nodes Nodes created till now by this thread +/// @param le Log entry to be processed +/// @param nid Node id of the FASE containing le +/// +/// An acquire log entry is examined to see whether a +/// synchronizes-with relation should be created. A number of +/// scenarios can arise: +/// (1) The acquire log entry does not synchronize-with anything. +/// (2) This is an online analysis phase and the acquire log entry "le" +/// synchronizes-with a release log entry "rle" but "rle" was deleted +/// earlier while computing a consistent state. In such a case, no +/// synchronizes-with relation needs to be added. +/// (3) If this is invoked during recovery and #2 does not hold and +/// the acquire log entry "le" synchronizes-with a release log entry +/// "rle" but "rle" is not found in the log entries left over at the +/// start of recovery, no synchronizes-with relation needs to be +/// added. +/// (4) If the above are not satisfied and the acquire log entry "le" +/// synchronizes-with a release log entry "rle" and "rle" belongs to an +/// existing node "tgt" of the graph, add a synchronizes-with edge +/// from nid to tgt. +/// (5) If the acquire log entry "le" synchronizes with a release log +/// entry "rle" and "rle" does not belong to an existing node of the +/// graph, "le" is added to a pending list to be examined again after +/// all the nodes of the graph are created. If it cannot be resolved +/// even then, this FASE cannot belong to the consistent state under +/// creation. +/// If "le" is of release type, track it for future synchronizes-with +/// relationship creation. +/// +// TODO: do other log types need handling? free and rw-type +void CSMgr::addSyncEdges( + const MapNodes& thread_nodes, LogEntry *le, DGraph::VDesc nid) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // First filter out the scenario where the target is already deleted + if (le->isAcquire() && le->ValueOrPtr) { + LogEntry *rel_le = (LogEntry*)(le->ValueOrPtr); + + // Note: the following call deletes the found entry. + // ValueOrPtr is currently not of atomic type. This + // is still ok as long as there is a single helper + // thread. + if (Helper::getInstance().isDeletedByHelperThread(rel_le, le->Size)) + le->ValueOrPtr = 0; + else if (IsInRecovery_ && !isFoundInExistingLog(rel_le, le->Size)) + le->ValueOrPtr = 0; + } + + if (le->isAcquire() && le->ValueOrPtr) { + const DGraph::NodeInfo& node_info = + Graph_.getTargetNodeInfo((LogEntry *)le->ValueOrPtr); + if (node_info.NodeType_ == DGraph::kAvail) { + if (!hasThreadNode(thread_nodes, node_info.NodeId_)) + Graph_.createEdge(nid, node_info.NodeId_); + } + else if (node_info.NodeType_ == DGraph::kAbsent) + addToPendingList(le, nid); + } + else if (le->isRelease()) + Graph_.addToNodeInfoMap(le, nid, DGraph::kAvail); +} + +DGraph::NodeInfo DGraph::getTargetNodeInfo(LogEntry *tgt_le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + NodeInfoMap::const_iterator ci = NodeInfoMap_.find(tgt_le); + if (ci == NodeInfoMap_.end()) + return NodeInfo(static_cast(0) /* dummy */, kAbsent); + else return ci->second; +} + +void DGraph::addToNodeInfoMap(LogEntry *le, VDesc nid, NodeType node_type) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(node_type == kAvail); // currently + NodeInfoMap_.insert(std::make_pair(le, NodeInfo(nid, node_type))); +} + +void DGraph::trace() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + std::pair vp; + for (vp = vertices(DirectedGraph_); vp.first != vp.second; ++ vp.first) + { + VDesc nid = *vp.first; + FASection *fase = DirectedGraph_[nid].Fase_; + + traceHelper("======================\n"); + traceHelper("\tNode id: "); + traceHelper(nid); + traceHelper("\tFASE: "); + traceHelper(fase); + traceHelper(" isStable: "); + traceHelper(DirectedGraph_[nid].isStable_); + + traceHelper("\n\tHere are the log records:\n"); + PrintLogs(fase); + + std::pair iep; + int count = 0; + traceHelper("\n\tHere are the sources:\n"); + for (iep = in_edges(nid, DirectedGraph_); + iep.first != iep.second; ++ iep.first) + { + EDesc eid = *iep.first; + VDesc src = source(eid, DirectedGraph_); + FASection *src_fase = DirectedGraph_[src].Fase_; + ++count; + traceHelper("\t\tNode id: "); + traceHelper(src); + traceHelper(" FASE: "); + traceHelper(src_fase); + } + traceHelper("\n\t# incoming edges: "); + traceHelper(count); + traceHelper('\n'); + } +} + +void DGraph::PrintLogs(FASection *fase) +{ + LogEntry *current_le = fase->First; + assert(current_le); + + LogEntry *last_le = fase->Last; + assert(last_le); + + do + { + switch(current_le->Type) + { + case LE_dummy: + PrintDummyLog(current_le); + break; + case LE_acquire: + PrintAcqLog(current_le); + break; + case LE_rwlock_rdlock: + PrintRdLockLog(current_le); + break; + case LE_rwlock_wrlock: + PrintWrLockLog(current_le); + break; + case LE_begin_durable: + PrintBeginDurableLog(current_le); + break; + case LE_release: + PrintRelLog(current_le); + break; + case LE_rwlock_unlock: + PrintRWUnlockLog(current_le); + break; + case LE_end_durable: + PrintEndDurableLog(current_le); + break; + case LE_str: + PrintStrLog(current_le); + break; + case LE_memset: + case LE_memcpy: + case LE_memmove: + PrintMemOpLog(current_le); + break; + case LE_strcpy: + case LE_strcat: + PrintStrOpLog(current_le); + break; + case LE_alloc: + PrintAllocLog(current_le); + break; + case LE_free: + PrintFreeLog(current_le); + break; + default: + assert(0); + } + if (current_le == last_le) break; + current_le = current_le->Next; + }while (true); +} + +// TODO The following should call a LogEntry interface with the +// appropriate stream +void DGraph::PrintDummyLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type dummy\n"); +} + +void DGraph::PrintAcqLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = acq next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintRdLockLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = rw_rd next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintWrLockLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = rw_wr next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintBeginDurableLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type = begin_durable next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintRelLog(LogEntry *le) +{ + assert(!le->ValueOrPtr); + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" type = rel next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintRWUnlockLog(LogEntry *le) +{ + assert(!le->ValueOrPtr); + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" type = rw_unlock next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintEndDurableLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type = end_durable next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintStrLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper(le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = str next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintMemOpLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = memop next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintStrOpLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = strop next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintAllocLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper((void*)le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = alloc next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintFreeLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper((void*)le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = free next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/consistency/helper_driver.cpp b/ARP_CSFR/runtime/src/consistency/helper_driver.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f34c8f2e58f54d8e8202ab1c2996dd3f2926438d --- /dev/null +++ b/ARP_CSFR/runtime/src/consistency/helper_driver.cpp @@ -0,0 +1,184 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include + +#include "atlas_api.h" + +#include "helper.hpp" +#include "log_mgr.hpp" +#include "consistency_mgr.hpp" + +namespace Atlas { + +uint64_t removed_log_count = 0; + +Helper *Helper::Instance_{nullptr}; + +void *helper(void *arg_lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef _DISABLE_HELPER + return nullptr; +#endif + + Helper::createInstance(); + Helper::getInstance().doConsistentUpdate(arg_lsp); + + if (!arg_lsp) Helper::getInstance().printStats(); + +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + std::cout << + "[Atlas-log-pruner] Traces written to /tmp/atlas_log_pruner.txt" << + std::endl; +#endif + + Helper::deleteInstance(); + + std::cout << "[Atlas-log-pruner] # log entries removed: " << + removed_log_count << std::endl; + return 0; +} + +void Helper::collectRelLogEntries(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + while (lsp) { + LogEntry *le = lsp->Le; + while (le) { + if (le->isRelease()) // TODO: how about free and other rel types? + ExistingRelMap_.insert(std::make_pair(le, (uint64_t)le->Size)); + le = le->Next; + } + lsp = lsp->Next; + } +} + +void Helper::doConsistentUpdate(void *arg_lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // During normal execution, the argument is NULL. + if (arg_lsp) + { + fprintf(stderr, + "[Atlas] Advancing consistent state before undoing ...\n"); + collectRelLogEntries((LogStructure*)arg_lsp); + } + +// Have the helper thread work in _small_ chunks. Given that an +// iteration of the helper thread can be quite expensive, we want to +// make sure that the helper thread can be joined as soon as the user +// thread is done. An alternative is for the user thread to send a signal +// to the helper thread. + + do { + + ++IterNum_; + + LogStructure *lsp = 0; + + if (!arg_lsp) { + LogMgr::getInstance().acquireLogReadyLock(); + // We don't want to check this condition within a loop since we + // need to do some work. If a spurious wakeup happens and that + // should be rare, the helper thread may go through a round of + // analysis that may or may not result in wasted work. + if (!areUserThreadsDone()) LogMgr::getInstance().waitLogReady(); + LogMgr::getInstance().releaseLogReadyLock(); + + if (areUserThreadsDone()) break; + + lsp = LogMgr::getInstance().getLogPointer( + std::memory_order_acquire); + } + else if (!LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire)) { + IsInRecovery_ = true; + lsp = (LogStructure*)arg_lsp; + LogMgr::getInstance().setRecoveryLogPointer( + lsp, std::memory_order_release); + } + else lsp = LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire); + + // Can't assert during normal execution since a spurious wakeup + // may have happened + if (!arg_lsp && !lsp) continue; + + CSMgr& cs_mgr = CSMgr::createInstance(); + if (IsInRecovery_) + cs_mgr.set_existing_rel_map(&ExistingRelMap_); + cs_mgr.doConsistentUpdate(lsp, &LogVersions_, IsInRecovery_); + + if (IsInRecovery_ && !cs_mgr.get_num_graph_vertices()) { + CSMgr::deleteInstance(); + break; + } + + CSMgr::deleteInstance(); + + }while (!areUserThreadsDone()); +} + +bool Helper::isDeletedByHelperThread(LogEntry *le, uint64_t gen_num) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + std::pair del_iter = DeletedRelLogs_.equal_range(le); + for (DelIter di = del_iter.first; di != del_iter.second; ++di) { + if (di->second == gen_num) { + DeletedRelLogs_.erase(di); + // Must return since the iterator is broken by the above erase. + // Any subsequent use of the iterator may fail. + return true; + } + } + return false; +} + +void Helper::printStats() +{ + // TODO The lock should be owned by Stats, not Logger +#if defined(NVM_STATS) + LogMgr::getInstance().acquireStatsLock(); + std::cout << "[Atlas-log-pruner] Thread " << pthread_self() << std::endl; +#ifdef _PROFILE_HT + std::cout << "[Atlas-log-pruner] " << "Total graph creation cycles: " << + TotalGraphBuildTime_ << std::endl; + std::cout << "[Atlas-log-pruner] " << "Total graph resolution cycles: " << + TotalGraphResolveTime_ << std::endl; + std::cout << "[Atlas-log-pruner] " << "Total log prune cycles: " << + TotalPruneTime_ << std::endl; +#endif + std::cout << "[Atlas-log-pruner] # iterations: " << + Helper::getInstance().get_iter_num() << std::endl; + std::cout << "[Atlas-log-pruner] # flushes from this thread: " << + num_flushes << std::endl; + LogMgr::getInstance().releaseStatsLock(); +#endif +} + +} // namespace Atlas + diff --git a/ARP_CSFR/runtime/src/consistency/log_pruner.cpp b/ARP_CSFR/runtime/src/consistency/log_pruner.cpp new file mode 100644 index 0000000000000000000000000000000000000000..36dad12de8a8f12cdf52ca1eb2b8db8356948368 --- /dev/null +++ b/ARP_CSFR/runtime/src/consistency/log_pruner.cpp @@ -0,0 +1,527 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "atlas_alloc.h" + +#include "consistency_mgr.hpp" +#include "helper.hpp" + +namespace Atlas { + +extern uint64_t removed_log_count; + +bool CSMgr::areLogicallySame(LogStructure *gh, LogStructure *cand_gh) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + while (gh) { + if (gh == cand_gh) return true; + gh = gh->Next; + } + return false; +} + +uint32_t CSMgr::getNumNewEntries(LogStructure *new_e, LogStructure *old_e) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uint32_t new_count = 0; + uint32_t old_count = 0; + while (new_e) { + ++new_count; + new_e = new_e->Next; + } + while (old_e) { + ++old_count; + old_e = old_e->Next; + } + assert(!(new_count < old_count)); + return new_count - old_count; +} + +void CSMgr::destroyLogs(Helper::LogVersions *log_v) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Nothing to do + if (!log_v->size()) return; + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_log_prune = atlas_rdtsc(); +#endif + + LogIterVec deleted_lsp; + LogEntryVec deleted_log_entries; + + LogStructure *cand_gh = 0; + Helper::LogVersions::iterator logs_ci_end = log_v->end(); + Helper::LogVersions::iterator logs_ci = log_v->begin(); + Helper::LogVersions::iterator last_logs_ci = logs_ci_end; + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + bool did_cas_succeed = true; +#endif + + // Go through each version + while (logs_ci != logs_ci_end) { + // Get the current pointer to the log + LogStructure *gh = !CSMgr::getInstance().isInRecovery() ? + LogMgr::getInstance().getLogPointer(std::memory_order_acquire) : + LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire); + assert(gh); + + LogStructure *tmp_gh = gh; + + // This is the candidate pointer to the log representing the + // new consistent state. We would like to move the log pointer + // to this candidate in a single pointer switch + // (failure-atomically), essentially moving the program state + // to the next consistent state. + cand_gh = (*logs_ci).LS_; + assert(cand_gh); + LogStructure *tmp_cand_gh = cand_gh; + + const Log2Bool& deletable_logs = (*logs_ci).Del_; + + // Initially, gh is not part of log_v. But if a new gh is formed, + // gh may actually be the same as cand_gh. In such a case, we just + // need to skip to the next candidate. Additionally, we need to + // check for logical identity, meaning that if logs for a new thread + // were added in between "setting the GH last by the helper thread" + // and "setting the GH by an application thread because of a new + // thread creation", we need to identify that scenario as well. + if (areLogicallySame(gh, cand_gh)) { + last_logs_ci = logs_ci; + ++logs_ci; + continue; + } + + // Since the time of creation of cand_gh, entries may have been + // added at the head of gh. By comparing the number of + // *threads*, we can tell whether this has indeed happened. If + // yes, the new entries are always found at the head. + uint32_t num_new_entries = getNumNewEntries(tmp_gh, tmp_cand_gh); + + // We can't just use "deletable_logs" to collect logs for + // removal since the elements in "deletable_logs" may have + // been split into different versions. For removal purposes, + // we need to collect for only the versions that can be + // removed. + LogEntryVec tmp_deleted_log_entries; + LSVec new_entries; + while (tmp_gh) { + if (num_new_entries) { + new_entries.push_back(tmp_gh); + tmp_gh = tmp_gh->Next; + // Do not advance tmp_cand_gh + --num_new_entries; + continue; + } + + LogEntry *curr_le = tmp_gh->Le; + + assert(tmp_cand_gh); + LogEntry *end_le = tmp_cand_gh->Le; + assert(end_le); + + do + { + assert(curr_le); + + // Both creation/destruction of threads during log + // pruning are supported. + + // Check whether this log entry is scheduled to be + // deleted. The cumulative list of deletable + // log entries is found for every version and that is + // used to check here. + + if (deletable_logs.find(curr_le) == deletable_logs.end()) + break; + + // Add it tentatively to the list of logs to be + // deleted + tmp_deleted_log_entries.push_back(curr_le); + + // This Next ptr has been read before, so no atomic + // operation is required. + curr_le = curr_le->Next; + }while (curr_le != end_le); + + // We compare the number of headers in GH and cand_GH and + // if unequal, the difference at the head of GH are the + // new entries. For this to work, insertions must always + // be made at the head. + tmp_gh = tmp_gh->Next; + tmp_cand_gh = tmp_cand_gh->Next; + } + + // If new_entries have been found, we need to add those entries + // to this version before deleting it. + + if (new_entries.size()) { + fixupNewEntries(&cand_gh, new_entries); + (*logs_ci).LS_ = cand_gh; + } + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + if (did_cas_succeed) flushGlobalCommit(tmp_deleted_log_entries); +#endif + + // Atomically flip the global log structure header pointer + + // Note that cache line flushing for this CAS is tricky. The current + // ad-hoc solution is for user-threads to flush this + // location after reading it. Since reads of this location are + // rare enough, this should not hurt performance. + bool status = !CSMgr::getInstance().isInRecovery() ? + LogMgr::getInstance().cmpXchngWeakLogPointer( + gh, cand_gh, + std::memory_order_acq_rel, std::memory_order_relaxed) : + LogMgr::getInstance().cmpXchngWeakRecoveryLogPointer( + gh, cand_gh, + std::memory_order_acq_rel, std::memory_order_relaxed); + + if (status) + { +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + if (!CSMgr::getInstance().isInRecovery()) + LogMgr::getInstance().flushLogPointer(); + else LogMgr::getInstance().flushRecoveryLogPointer(); +#endif + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + did_cas_succeed = true; +#endif + // During the first time through the top-level vector elements, + // gh is not in log_v. So this special handling must be done + // where we are destroying the old gh that is not in the vector. + if (logs_ci == log_v->begin()) destroyLS(gh); + else { + assert(last_logs_ci != logs_ci_end); + deleted_lsp.push_back(last_logs_ci); + } + + // This builds the list of log entries which *will* be + // deleted + copyDeletedLogEntries(&deleted_log_entries, + tmp_deleted_log_entries); + last_logs_ci = logs_ci; + ++logs_ci; + } +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + else did_cas_succeed = false; +#endif + // If the above CAS failed, we don't advance the version but + // instead try again. + } + + // Once the root GH pointer has been swung, it does not matter when + // the log entries are removed or the other stuff is removed. No one can + // reach these any more. + destroyLogEntries(deleted_log_entries); + + // No need for any cache flushes for any deletions. + + LogIterVec::iterator del_ci_end = deleted_lsp.end(); + LogIterVec::iterator del_ci = deleted_lsp.begin(); + LogIterVec::iterator last_valid_ci; + for (; del_ci != del_ci_end; ++ del_ci) + { + destroyLS((**del_ci).LS_); + last_valid_ci = del_ci; + } + + del_ci = deleted_lsp.begin(); + if (del_ci != del_ci_end) + { + Helper::LogVersions::iterator lvi = *last_valid_ci; + assert(lvi != log_v->end()); + ++lvi; + (*log_v).erase(*del_ci, lvi); + } +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_log_prune = atlas_rdtsc(); + Helper::getInstance().incrementTotalPruneTime( + stop_log_prune - start_log_prune); +#endif +} + +void CSMgr::destroyLS(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(lsp); + if (!CSMgr::getInstance().isInRecovery()) + assert(lsp != LogMgr::getInstance().getLogPointer( + std::memory_order_acquire)); + else assert(lsp != LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire)); + + traceHelper("[Atlas] Destroying log header "); + + while (lsp) + { + LogStructure *del_lsp = lsp; + lsp = lsp->Next; + + traceHelper(del_lsp); + + // TODO freeMem should call destructor. Use NVM_Destroy + if (!CSMgr::getInstance().isInRecovery()) + PRegionMgr::getInstance().freeMem(del_lsp, true /* do not log */); + } + traceHelper('\n'); +} + +void CSMgr::destroyLogEntries(const LogEntryVec& le_vec) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + traceHelper("[Atlas] Destroying log entries "); + + LogEntryVec::const_iterator ci_end = le_vec.end(); + for (LogEntryVec::const_iterator ci = le_vec.begin(); ci != ci_end; ++ ci) + { + traceHelper(*ci); + + if ((*ci)->isRelease() || (*ci)->isRWLockUnlock() || (*ci)->isFree()) + { + // Add it to a helper map so that the helper elides any + // happens-after relation from a later-examined log entry + // to this one + Helper::getInstance().addEntryToDeletedMap(*ci, (*ci)->Size); + + // Update the logger table that tracks happens-after + // between log entries + if (!CSMgr::getInstance().isInRecovery()) LogMgr::getInstance().deleteOwnerInfo(*ci); + } + + if (!CSMgr::getInstance().isInRecovery()) + { +#if defined(_LOG_WITH_MALLOC) + if ((*ci)->isMemop() || (*ci)->isStrop()) + free((void*)(*ci)->ValueOrPtr); + free(*ci); +#elif defined(_LOG_WITH_NVM_ALLOC) + if ((*ci)->isMemop() || (*ci)->isStrop()) + PRegionMgr::getInstance().freeMem((void*)(*ci)->ValueOrPtr, true); + PRegionMgr::getInstance().freeMem(*ci, true /* do not log */); +#else + if ((*ci)->isMemop() || (*ci)->isStrop()) + PRegionMgr::getInstance().freeMem((void*)(*ci)->ValueOrPtr, true); + // TODO cache LogMgr instance + LogMgr::getInstance().deleteEntry(*ci); +#endif + } + ++removed_log_count; + } + + traceHelper('\n'); +} + +void CSMgr::copyDeletedLogEntries(LogEntryVec *deleted_les, + const LogEntryVec & tmp_deleted_les) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogEntryVec::const_iterator ci_end = tmp_deleted_les.end(); + for (LogEntryVec::const_iterator ci = tmp_deleted_les.begin(); + ci != ci_end; ++ ci) + (*deleted_les).push_back(*ci); +} + +void CSMgr::fixupNewEntries(LogStructure **cand, const LSVec & new_entries) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogStructure *new_header = 0; + LogStructure *last_ls = 0; + LSVec::const_iterator ci_end = new_entries.end(); + + traceHelper("[Atlas] Fixup: created header nodes: "); + for (LSVec::const_iterator ci = new_entries.begin(); ci != ci_end; ++ci) + { + LogStructure *ls = (LogStructure *) + nvm_alloc(sizeof(LogStructure), + LogMgr::getInstance().getRegionId()); + assert(ls); + + traceHelper(ls); + traceHelper(" "); + + ls->Le = (*ci)->Le; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(ls); +#endif + if (!new_header) new_header = ls; + else + { + assert(last_ls); + last_ls->Next = ls; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(&last_ls->Next); +#endif + } + last_ls = ls; + } + + traceHelper('\n'); + + last_ls->Next = *cand; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(last_ls); +#endif + (*cand) = new_header; +} + +// TODO: the region may have been closed by this point. One solution is +// to check whether the address belongs to an open region before every +// clflush operation. This would slow down the helper thread but probably +// does not matter. Additionally, more logic needs to be employed in the +// helper thread in the global-flush mode so that if an address in a closed +// region is seen, the helper thread has to stop since no new consistent +// state can be found. This is tied with the observation that in this +// global mode, the consistent state cannot be moved forward during the +// recovery phase. +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) +// This is not thread-safe. Currently, only the serial helper thread +// can call this interface. +void CSMgr::flushGlobalCommit(const LogEntryVec& logs) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(GlobalFlush_); + assert(GlobalFlush_->empty()); + LogEntryVec::const_iterator ci_end = logs.end(); + for (LogEntryVec::const_iterator ci = logs.begin(); ci != ci_end; ++ci) + if ((*ci)->isStr() || (*ci)->isMemop() || (*ci)->isStrop()) + LogMgr::getInstance().collectCacheLines( + GlobalFlush_, (*ci)->Addr, (*ci)->Size); + LogMgr::getInstance().flushCacheLines(*GlobalFlush_); + GlobalFlush_->clear(); +} + +#endif + +template +void LogMgr::deleteSlot(CbLog *cb, T *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(!cb->isEmpty()); + if(addr!=&(cb->LogArray[cb->Start.load(std::memory_order_acquire)])) { + std:: cout << addr << ":" << &(cb->LogArray[cb->Start.load(std::memory_order_acquire)]) << std::endl; + std::cout << std::flush; + } + assert(addr == &(cb->LogArray[cb->Start.load(std::memory_order_acquire)])); + cb->Start.store( + (cb->Start.load(std::memory_order_acquire)+1) % cb->Size, + std::memory_order_release); +} + + + +//FIXME: Inspect of last_cb_used can improve performance here, not using it right now. +void LogMgr::deleteEntry(const std::atomic*> & cb_list, LogEntry *addr, CbListNode* &last_cb_used) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Instead of searching every time, we keep track of the last Cb used. +// static CbListNode *last_cb_used = 0; +// CbListNode *last_cb_used = 0; +// if (last_cb_used && +// ((uintptr_t)addr >= (uintptr_t)last_cb_used->StartAddr && +// (uintptr_t)addr <= (uintptr_t)last_cb_used->EndAddr)) { +// deleteSlot(last_cb_used->Cb, addr); +// if (last_cb_used->Cb->isEmpty() && +// last_cb_used->Cb->isFilled.load(std::memory_order_acquire)) +// last_cb_used->isAvailable.store(true, std::memory_order_release); +// return; +// } + CbListNode *curr = cb_list.load(std::memory_order_acquire); + assert(curr); + while (curr) { + if ((uintptr_t)addr >= (uintptr_t)curr->StartAddr && + (uintptr_t)addr <= (uintptr_t)curr->EndAddr) { +// last_cb_used = curr; + deleteSlot(curr->Cb, addr); + // A buffer that got filled and then emptied implies that + // the user thread moved on to a new buffer. Hence, mark it + // available so that it can be reused. + if (curr->Cb->isEmpty() && + curr->Cb->isFilled.load(std::memory_order_acquire)) + curr->isAvailable.store(true, std::memory_order_release); + break; + } + curr = curr->Next; + } +} + + +template +void LogMgr::deleteEntry(const std::atomic*> & cb_list, T *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Instead of searching every time, we keep track of the last Cb used. + static CbListNode *last_cb_used = 0; +// CbListNode *last_cb_used = 0; + if (last_cb_used && + ((uintptr_t)addr >= (uintptr_t)last_cb_used->StartAddr && + (uintptr_t)addr <= (uintptr_t)last_cb_used->EndAddr)) { + deleteSlot(last_cb_used->Cb, addr); + if (last_cb_used->Cb->isEmpty() && + last_cb_used->Cb->isFilled.load(std::memory_order_acquire)) + last_cb_used->isAvailable.store(true, std::memory_order_release); + return; + } + CbListNode *curr = cb_list.load(std::memory_order_acquire); + assert(curr); + while (curr) { + if ((uintptr_t)addr >= (uintptr_t)curr->StartAddr && + (uintptr_t)addr <= (uintptr_t)curr->EndAddr) { + last_cb_used = curr; + deleteSlot(curr->Cb, addr); + // A buffer that got filled and then emptied implies that + // the user thread moved on to a new buffer. Hence, mark it + // available so that it can be reused. + if (curr->Cb->isEmpty() && + curr->Cb->isFilled.load(std::memory_order_acquire)) + curr->isAvailable.store(true, std::memory_order_release); + break; + } + curr = curr->Next; + } +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/include/atlas_alloc.h b/ARP_CSFR/runtime/src/include/atlas_alloc.h new file mode 100644 index 0000000000000000000000000000000000000000..46ea81ce1472858602d0034800af5eee4bad9be0 --- /dev/null +++ b/ARP_CSFR/runtime/src/include/atlas_alloc.h @@ -0,0 +1,194 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_H +#define ATLAS_ALLOC_H + +#include +#include +#include + +// +// Persistent region API +// These are interfaces for creating and managing persistent regions, +// entities that contain persistent data. Once a persistent region is +// created, objects can be allocated out of the region, e.g. by using +// nvm_alloc. Any data not in a persistent region is considered +// transient. +// +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// @brief Create a named persistent region. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region created +/// +/// This interface does not check for an existing entry with +/// the same name. If a region with the same name already exists, the +/// behavior of the program is undefined. +/// +uint32_t NVM_CreateRegion(const char *name, int flags); + +/// +/// @brief Create a persistent region with the provided name. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @param is_created Indicator whether the region got created as a +/// result of the call +/// @return Id of the region found or created +/// +/// If the region already exists, the existing id of the region is returned. +/// Otherwise a region is created and its newly assigned id returned. +/// +uint32_t NVM_FindOrCreateRegion(const char *name, int flags, int *is_created); + +/// +/// @brief Find the id of a region when it is known to exist already +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region found +/// +/// This interface should be used over NVM_FindOrCreateRegion for +/// efficiency reasons if the region is known to exist. If a region +/// with the provided name does not exist, an assertion failure will +/// occur. +/// +uint32_t NVM_FindRegion(const char *name, int flags); + +/// +/// @brief Delete the region with the provided name. +/// @param name Name of the persistent region +/// +/// Use this interface to completely destroy a region. If the region +/// does not exist, an assertion failure will occur. +/// +void NVM_DeleteRegion(const char *name); + +/// +/// @brief Close a persistent region +/// @param rid Region id +/// +/// After closing, it won't be available to the calling process +/// without calling NVM_FindOrCreateRegion. The region will stay in +/// NVM even after calling this interface. This interface allows +/// closing a region with normal bookkeeping. +/// +void NVM_CloseRegion(uint32_t rid); + +/// +/// @brief Get the root pointer of the persistent region +/// @param rid Region id +/// @return Root pointer of the region +/// +/// The region must have been created already. Currently, only one +/// root is implemented for a given region. The idea is that anything +/// within a region that is not reachable from the root after program +/// termination is assumed to be garbage and can be recycled. During +/// execution, anything within a region that is not reachable from the +/// root or from other _roots_ (in the GC sense) is assumed to be +/// garbage as well. +/// +void *NVM_GetRegionRoot(uint32_t rid); + +/// +/// @brief Set the root pointer of an existing persistent region +/// @param rid Region id +/// @param root The new root of the region +/// +void NVM_SetRegionRoot(uint32_t rid, void *root); + +/// +/// @brief Determines if a memory location is within a region +/// @param ptr Queried address +/// @param sz Size of the location in bytes +/// @return 1 if within the region, otherwise 0 +/// +int NVM_IsInRegion(void *ptr, size_t sz); + +/// +/// @brief Determines if the addresses are on different cache lines +/// +/// @param p1 First address +/// @param p2 Second address +/// @return Indicates whether the addresses are on different cache +/// lines +/// +/// The objects under consideration must not cross cache lines, +/// otherwise this interface is inadequate. +/// +int isOnDifferentCacheLine(void *p1, void *p2); + +/// +/// @brief Determines if a memory location is aligned to a cache line +/// +/// @param p Address of memory location under consideration +/// @return Indicates whether the memory location is cache line +/// aligned +/// +int isCacheLineAligned(void *p); + +/// +/// @brief Malloc style interface for allocation from a persistent +/// region +/// +/// @param sz Size of location to be allocated +/// @param rid Id of persistent region for allocation +/// @return Address of memory location allocated +/// +void *nvm_alloc(size_t sz, uint32_t rid); + +/// +/// @brief Calloc style interface for allocation from a persistent +/// region +/// +/// @param nmemb Number of elements in the array to be allocated +/// @param sz Size of each element +/// @param rid Id of persistent region for allocation +/// @return Pointer to allocated memory +/// +void *nvm_calloc(size_t nmemb, size_t sz, uint32_t rid); + +/// +/// @brief Realloc style interface for allocation from a persistent +/// region +/// +/// @param ptr Address of memory block provided +/// @param sz New size of allocation +/// @param rid Id of persistent region for allocation +/// @return Pointer to re-allocated memory +/// +void *nvm_realloc(void *ptr, size_t sz, uint32_t rid); + +/// +/// @brief Deallocation interface for persistent data +/// +/// @param ptr Address of memory location to be freed. +/// +/// Though the usual use case would be for the location to be in +/// persistent memory, this interface will also work for transient +/// data. The implementation is required to transparently handle +/// this case as well. +/// +void nvm_free(void *ptr); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/ARP_CSFR/runtime/src/include/atlas_alloc_cpp.hpp b/ARP_CSFR/runtime/src/include/atlas_alloc_cpp.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9f201bb76c36d36ff9bc9c51c9f370e1e09324fb --- /dev/null +++ b/ARP_CSFR/runtime/src/include/atlas_alloc_cpp.hpp @@ -0,0 +1,120 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_CPP_H +#define ATLAS_ALLOC_CPP_H + +// Forward declarations +namespace Atlas +{ + class PRegion; +} + +/// +/// @brief Get a handle to a persistent region +/// @param rid Region identifier +/// @return Pointer to the corresponding persistent region +/// +/// Currently, this interface is to be used by a client only for the +/// placement new operations +/// +Atlas::PRegion *NVM_GetRegion(uint32_t rid); + +/// +/// @brief Object allocation for C++ +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the C++ placement new operator. The +/// corresponding delete operation is NVM_Destroy. +/// +void* operator new(size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Array form allocation for C++, type must have explicit +/// destructor +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the array form C++ placement new +/// operator. The type of the array elements must have an explicit +/// destructor. The corresponding delete operation is +/// NVM_Destroy_Array. +/// +void* operator new[](size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Object destruction for C++ +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an object that was +/// created from a persistent region using the single-object new +/// operator. The implementation calls the destructor followed by +/// actual deallocation. This interface can also be called for +/// destroying an object that was created using the default +/// single-object new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default single-object delete operator. This interface must not be +/// called for deallocating an object created in any other way, e.g. a +/// placement new operator where the placement address is not within a +/// persistent region. +/// +template static inline void NVM_Destroy(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete ptr; + return; + } + ptr->~T(); + void nvm_delete(void*); + nvm_delete(ptr); +} + +/// +/// @brief Array form destruction for C++, type must have explicit +/// destructor +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an array of objects +/// that was created from a persistent region using the array-form new +/// operator. The implementation calls the destructors for all objects +/// of the array followed by actual deallocation. Note that the type +/// of the array elements must have an explicit destructor for this +/// interface to work correctly. This interface can also be called for +/// destroying an array of objects that was created using the default +/// array-form new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default array-form delete operator. This interface must not be +/// called for deallocating an object created in any other way. +/// +template static inline void NVM_Destroy_Array(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete [] ptr; + return; + } + char *delete_ptr = reinterpret_cast(ptr) - sizeof(size_t); + size_t count = *reinterpret_cast(delete_ptr); + for (int i=count-1; i>=0; --i) (ptr+i)->~T(); + void nvm_delete(void*); + nvm_delete(delete_ptr); +} + +#endif diff --git a/ARP_CSFR/runtime/src/include/atlas_api.h b/ARP_CSFR/runtime/src/include/atlas_api.h new file mode 100644 index 0000000000000000000000000000000000000000..e2076651a227bf3838ceb39a1db070d0b1e2f53e --- /dev/null +++ b/ARP_CSFR/runtime/src/include/atlas_api.h @@ -0,0 +1,179 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_API_H +#define ATLAS_API_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// +// Here are the APIs for initializing/finalizing Atlas. Each of the +// following 2 interfaces must be called only once. + +/// +/// Initialize Atlas internal data structures. This should be +/// called before persistent memory access. +/// +void NVM_Initialize(); + +/// +/// Finalize Atlas internal data structures. This should be called +/// before normal program exit. If not called, the implementation +/// will assume that program exit was abnormal and will require +/// invocation of recovery before restart. +/// +void NVM_Finalize(); + + +void NVM_UsrDone(); + + +// +// No special interfaces are required for lock-based critical +// sections if compiler support is available. Use the +// compiler-plugin to take advantage of automatic instrumentation +// of critical sections. +// + +/// +/// The following 2 interfaces demarcate a failure-atomic section +/// of code, i.e. code where persistent locations are updated and +/// all-or-nothing behavior of those updates is required. Note that +/// no isolation among threads is provided by these 2 interfaces. +/// +void nvm_begin_durable(); +void nvm_end_durable(); + +// +// The following interfaces are for low-level programming of +// persistent memory, where the high-level consistency support +// afforded by Atlas is not used. Instead, persistence is explicitly +// managed by the following interfaces. +// + +/// +/// Is the following address with associated size within an open +/// persistent region? +/// +int NVM_IsInOpenPR(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses +/// +void nvm_psync(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses without a trailing barrier +/// +void nvm_psync_acq(void *addr, size_t sz /* in bytes */); + +// This may be invoked by a user program to print out Atlas statistics +#ifdef NVM_STATS + void NVM_PrintStats(); +#endif + +#ifdef __cplusplus +} +#endif + +// End of Atlas APIs + +#ifdef NVM_STATS +extern __thread uint64_t num_flushes; +#endif + +// Useful macros +#define NVM_BEGIN_DURABLE() nvm_begin_durable() +#define NVM_END_DURABLE() nvm_end_durable() + +#define NVM_CLFLUSH(p) nvm_clflush((char*)(void*)(p)) + +#ifndef DISABLE_FLUSHES +#define NVM_FLUSH(p) \ + { full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } + +#define NVM_FLUSH_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } \ + } + +#define NVM_FLUSH_ACQ(p) \ + { full_fence(); \ + NVM_CLFLUSH(p); \ + } + +#define NVM_FLUSH_ACQ_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH(p); \ + } \ + } + +#define NVM_PSYNC(p1,s) nvm_psync(p1,s) + +#define NVM_PSYNC_COND(p1,s) \ + { if (NVM_IsInOpenPR(p1, s)) nvm_psync(p1,s); } + +#define NVM_PSYNC_ACQ(p1,s) \ + { \ + nvm_psync_acq(p1,s); \ + } \ + +#define NVM_PSYNC_ACQ_COND(p1,s) \ + { \ + if (NVM_IsInOpenPR(p1, s)) nvm_psync_acq(p1, s); \ + } \ + +#else +#define NVM_FLUSH(p) +#define NVM_FLUSH_COND(p) +#define NVM_FLUSH_ACQ(p) +#define NVM_FLUSH_ACQ_COND(p) +#define NVM_PSYNC(p1,s) +#define NVM_PSYNC_COND(p1,s) +#define NVM_PSYNC_ACQ(p1,s) +#define NVM_PSYNC_ACQ_COND(p1,s) +#endif + +static __inline void nvm_clflush(const void *p) +{ +#ifndef DISABLE_FLUSHES +#ifdef NVM_STATS + ++num_flushes; +#endif + __asm__ __volatile__ ( + "clflush %0 \n" : "+m" (*(char*)(p)) + ); +#endif +} + +// Used in conjunction with clflush. +static __inline void full_fence() { + __asm__ __volatile__ ("mfence" ::: "memory"); + } + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/cache_flush_configs.hpp b/ARP_CSFR/runtime/src/internal_includes/cache_flush_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..3b2c08f48563e9dc62a729c259c05dbee3e4031b --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/cache_flush_configs.hpp @@ -0,0 +1,29 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CACHE_FLUSH_CONFIGS_HPP +#define CACHE_FLUSH_CONFIGS_HPP + +namespace Atlas { + +const int32_t kFlushTableSize = 8; +const int32_t kFlushTableMask = kFlushTableSize - 1; +// TODO the following should be derived from cache line size +const uint32_t kFlushShift = 6; // log(cache line size) + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/circular_buffer.hpp b/ARP_CSFR/runtime/src/internal_includes/circular_buffer.hpp new file mode 100644 index 0000000000000000000000000000000000000000..088a038c3b1536a5ff4918e4085aa855844358b3 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/circular_buffer.hpp @@ -0,0 +1,91 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef _LOG_ALLOC_H +#define _LOG_ALLOC_H + +#include + +namespace Atlas { + +template +struct CbLog +{ + explicit CbLog(uint32_t sz, uint32_t is_filled, + uint32_t start_cb, uint32_t end_cb) + : Size{sz}, + isFilled{is_filled}, + Start{start_cb}, + End{end_cb}, + LogArray{nullptr} {} + CbLog() = delete; + CbLog(const CbLog&) = delete; + CbLog(CbLog&&) = delete; + CbLog& operator=(const CbLog&) = delete; + CbLog& operator=(CbLog&&) = delete; + + uint32_t Size; + std::atomic isFilled; + std::atomic Start; + std::atomic End; + T *LogArray; + + bool isFull() { + return (End.load(std::memory_order_acquire)+1) % Size == + Start.load(std::memory_order_acquire); + } + + bool isEmpty() { + return Start.load(std::memory_order_acquire) == + End.load(std::memory_order_acquire); + } +}; + +template +struct CbListNode +{ + explicit CbListNode(CbLog *cb, char *start_addr, char *end_addr) + : Cb{cb}, + StartAddr{start_addr}, + EndAddr{end_addr}, + Next{nullptr}, + Tid{pthread_self()}, + isAvailable{false} {} + CbListNode() = delete; + CbListNode(const CbListNode&) = delete; + CbListNode(CbListNode&&) = delete; + CbListNode& operator=(const CbListNode&) = delete; + CbListNode& operator=(CbListNode&&) = delete; + + CbLog *Cb; + char *StartAddr; + char *EndAddr; + CbListNode *Next; + pthread_t Tid; + std::atomic isAvailable; +}; + +// CbList is a data structure shared among threads. When a new slot is +// requested, if the current buffer is found full, the current thread +// creates a new buffer, adds it to the CbList and +// return the first slot from this new buffer. If a buffer ever becomes +// empty, it can be reused. A partially empty buffer cannot be reused. + +// TODO eventual GC on cb_list + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/consistency_configs.hpp b/ARP_CSFR/runtime/src/internal_includes/consistency_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..dbc0c0b5abb4eeb562a3c2461d7a5b8a62f3eb0b --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/consistency_configs.hpp @@ -0,0 +1,28 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CONSISTENCY_CONFIGS_HPP +#define CONSISTENCY_CONFIGS_HPP + +#include + +namespace Atlas { + +const uint32_t kFaseAnalysisLimit = 8; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/consistency_mgr.hpp b/ARP_CSFR/runtime/src/internal_includes/consistency_mgr.hpp new file mode 100644 index 0000000000000000000000000000000000000000..28e1245bed87603edfeb440d32b18359f2228ac0 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/consistency_mgr.hpp @@ -0,0 +1,196 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CONSISTENCY_MGR_HPP +#define CONSISTENCY_MGR_HPP + +#include +#include +#include +#include +#include + +#include "helper.hpp" +#include "log_mgr.hpp" +#include "durability_graph.hpp" +#include "fase.hpp" + +namespace Atlas { + +// This class manages consistency of persistent data. It is either +// invoked by the helper thread during program execution or during +// recovery after a failure. Currently, there is at most one instance +// of this class. +class CSMgr { + static CSMgr *Instance_; +public: + typedef std::map MapNodes; + + // serial mode only + static CSMgr& createInstance() { + assert(!Instance_); + Instance_ = new CSMgr(); + return *Instance_; + } + + // serial mode only + static void deleteInstance() { + assert(Instance_); + delete Instance_; + Instance_ = nullptr; + } + + // serial mode only + static CSMgr& getInstance() { + assert(Instance_); + return *Instance_; + } + + void doConsistentUpdate(LogStructure*, + Helper::LogVersions*, bool is_in_recovery); + + void set_existing_rel_map(Helper::MapLog2Int *m) + { ExistingRelMap_ = m; } + + boost::graph_traits::vertices_size_type + get_num_graph_vertices() const { return Graph_.get_num_vertices(); } + + void set_is_stable(DGraph::VDesc vertex, bool b) + { Graph_.set_is_stable(vertex, b); } + bool is_stable(DGraph::VDesc vertex) const + { return Graph_.is_stable(vertex); } + +private: + + typedef std::pair PendingPair; + typedef std::vector PendingList; + + typedef std::vector LSVec; + typedef std::vector LogIterVec; + typedef std::map Addr2Bool; + typedef std::map FaseMap; + typedef std::vector FaseVec; + + bool IsParentDone_; // Is the parent user thread done? + bool IsInRecovery_; + DGraph Graph_; + + // A mapping from a release type log entry to its generation + // number. This is currently used only during recovery. Populated + // once and not changed later on at all. + Helper::MapLog2Int *ExistingRelMap_; + + // A list of acquire type log entries whose targets are not yet found + PendingList PendingList_; + + // Maps a log header to the first FASE in an analysis round + FaseMap FirstFaseOfHeader_; + + // Vector of all FASEs created in an analysis round + FaseVec AllFases_; + + SetOfInts *GlobalFlush_; + + explicit CSMgr() : + IsParentDone_{false}, + IsInRecovery_{false}, + Graph_{}, + ExistingRelMap_{nullptr}, + PendingList_{}, + FirstFaseOfHeader_{}, + AllFases_{}, +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + GlobalFlush_{new SetOfInts} +#else + GlobalFlush_{nullptr} +#endif + {} + + ~CSMgr() + { +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + if (GlobalFlush_) { + delete GlobalFlush_; + GlobalFlush_ = nullptr; + } +#endif + } + CSMgr(const CSMgr&) = delete; + CSMgr(CSMgr&&) = delete; + CSMgr& operator=(const CSMgr&) = delete; + CSMgr& operator=(CSMgr&&) = delete; + + bool isFirstFaseFound(LogStructure *ls) const + { return FirstFaseOfHeader_.find(ls) != FirstFaseOfHeader_.end(); } + void addFirstFase(LogStructure *ls, FASection *fase) { + assert(FirstFaseOfHeader_.find(ls) == FirstFaseOfHeader_.end()); + FirstFaseOfHeader_.insert(std::make_pair(ls, fase)); + } + void addFaseToVec(FASection *fase) + { AllFases_.push_back(fase); } + void addToPendingList(LogEntry *le, DGraph::VDesc nid) { + PendingPair pp = std::make_pair(le, nid); + PendingList_.push_back(pp); + } + FASection *getFirstFase(LogStructure *ls) { + FaseMap::const_iterator ci = FirstFaseOfHeader_.find(ls); + if (ci != FirstFaseOfHeader_.end()) return ci->second; + else return NULL; + } + + void buildInitialGraph(LogStructure *lsp); + void addSyncEdges(const MapNodes&, LogEntry*, DGraph::VDesc); + bool isFoundInExistingLog(LogEntry *le, uint64_t gen_num) const; + void removeUnresolvedNodes(); + void createVersions(Helper::LogVersions *log_v); + void resolvePendingList(); + void handleUnresolved(DGraph::VDesc nid, MapNodes *rm); + void destroyLogs(Helper::LogVersions*); + void fixupNewEntries(LogStructure**, const LSVec&); + void copyDeletedLogEntries(LogEntryVec*, const LogEntryVec&); + void destroyLogEntries(const LogEntryVec&); + void destroyLS(LogStructure*); + FASection *buildFASection(LogEntry *le); + void addLogStructure(LogEntry *le, LogStructure **header, + LogStructure **last_header); + void collectLogs(Log2Bool *logs, FASection *fase); + bool areLogicallySame(LogStructure *gh, LogStructure *cand_gh); + uint32_t getNumNewEntries(LogStructure *new_e, LogStructure *old_e); + void destroyFASections(); + + void flushGlobalCommit(const LogEntryVec& logs); + + bool isInRecovery() const { return IsInRecovery_; } + bool areUserThreadsDone() const + { return LogMgr::getInstance().areUserThreadsDone(); } + void traceGraph() { +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + Graph_.trace(); +#endif + } + template void traceHelper(T s) { +#if defined (_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + Helper::getInstance().trace(s); +#endif + } + +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/durability_graph.hpp b/ARP_CSFR/runtime/src/internal_includes/durability_graph.hpp new file mode 100644 index 0000000000000000000000000000000000000000..61745b9f02a6573d48c6c485c8d39a23e351217a --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/durability_graph.hpp @@ -0,0 +1,148 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef DURABILITY_GRAPH_HPP +#define DURABILITY_GRAPH_HPP + +#include + +#include +#include +#include + +#include "helper.hpp" +#include "fase.hpp" + +namespace Atlas { + +// This is the durability graph built for consistency management of +// persistent data. A node denotes a failure-atomic section of code +// (FASE). An edge denotes a happens-after relationship. So if there +// is an edge from src to dest, src "happens-after" dest. +class DGraph { + +public: + + // Vertex properties. A vertex, corresponding to a FASE, is stable + // and is included in a consistent state if all FASEs that happen + // before it are also stable and are included in the consistent + // state. + struct VProp { + VProp(FASection *fase, bool is_stable) + : Fase_(fase), isStable_(is_stable) {} + VProp() = delete; + + FASection *Fase_; + bool isStable_; + }; + + typedef boost::adjacency_list< + boost::setS /* OutEdges: not allowing multi-graph */, + boost::listS /* Vertices: don't tolerate renumbered vertex indices */, + boost::bidirectionalS /* required for durability graph */, + VProp> DirectedGraph; + + typedef boost::graph_traits::vertex_descriptor VDesc; + typedef boost::graph_traits::edge_descriptor EDesc; + typedef boost::graph_traits::vertex_iterator VIter; + typedef boost::graph_traits::in_edge_iterator IEIter; + + // Status of a node in a given consistent state + enum NodeType {kAvail, kAbsent}; + + struct NodeInfo { + NodeInfo(VDesc nid, NodeType node_type) + : NodeId_(nid), NodeType_(node_type) {} + NodeInfo() = delete; + + VDesc NodeId_; + NodeType NodeType_; + }; + + typedef std::map NodeInfoMap; + + boost::graph_traits::vertices_size_type + get_num_vertices() const + { return boost::num_vertices(DirectedGraph_); } + + void set_is_stable(VDesc vertex, bool b) + { DirectedGraph_[vertex].isStable_ = b; } + bool is_stable(VDesc vertex) const + { return DirectedGraph_[vertex].isStable_; } + + void addToNodeInfoMap(LogEntry *le, VDesc nid, NodeType nt); + NodeInfo getTargetNodeInfo(LogEntry *tgt_le); + + VDesc createNode(FASection *fase); + EDesc createEdge(VDesc src, VDesc tgt); + + const DirectedGraph& get_directed_graph() const + { return DirectedGraph_; } + + void clear_vertex(VDesc vertex) + { boost::clear_vertex(vertex, DirectedGraph_); } + void remove_vertex(VDesc vertex) + { boost::remove_vertex(vertex, DirectedGraph_); } + + FASection *get_fase(VDesc vertex) const + { return DirectedGraph_[vertex].Fase_; } + + void trace(); + template void traceHelper(T tt) + { Helper::getInstance().trace(tt); } + +private: + + DirectedGraph DirectedGraph_; + NodeInfoMap NodeInfoMap_; + + void PrintLogs(FASection *fase); + void PrintDummyLog(LogEntry *le); + void PrintAcqLog(LogEntry *le); + void PrintRdLockLog(LogEntry *le); + void PrintWrLockLog(LogEntry *le); + void PrintBeginDurableLog(LogEntry *le); + void PrintRelLog(LogEntry *le); + void PrintRWUnlockLog(LogEntry *le); + void PrintEndDurableLog(LogEntry *le); + void PrintStrLog(LogEntry *le); + void PrintMemOpLog(LogEntry *le); + void PrintStrOpLog(LogEntry *le); + void PrintAllocLog(LogEntry *le); + void PrintFreeLog(LogEntry *le); +}; + +inline DGraph::VDesc DGraph::createNode(FASection *fase) +{ + // default attribute is stable. If any contained log entry is + // unresolved, the stable bit is flipped and the corresponding node + // removed from the graph + return boost::add_vertex(VProp(fase, true /* stable */), + DirectedGraph_); +} + +inline DGraph::EDesc DGraph::createEdge(VDesc src, VDesc tgt) +{ + // TODO: are we creating a multi-graph? Or does add_edge filter + // that out? + std::pair edge_pair = + boost::add_edge(src, tgt, DirectedGraph_); + return edge_pair.first; +} + +} // end namespace + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/fail.hpp b/ARP_CSFR/runtime/src/internal_includes/fail.hpp new file mode 100644 index 0000000000000000000000000000000000000000..1dfeb0fd0d5c8d99d8999afdaaca76d73a458f9b --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/fail.hpp @@ -0,0 +1,44 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef FAIL +#define FAIL + +#include +#include +#include +#include +#define FAIL_MAX 100 +static std::atomic fail_chance(0); +inline void fail_program () { + if (rand() % FAIL_MAX <= fail_chance.load()){ + void *array[10]; + size_t size; + char **strings; + size_t i; + + size = backtrace (array, 10); + strings = backtrace_symbols (array, size); + + for (i = 0; i < size; i++) + std::cout << strings[i] << "\n"; + delete (strings); + std::exit(0); + } else { + ++fail_chance; + } +} +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/fase.hpp b/ARP_CSFR/runtime/src/internal_includes/fase.hpp new file mode 100644 index 0000000000000000000000000000000000000000..55acdc8b91df34a13fc88637aab45a1c5f1b2a50 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/fase.hpp @@ -0,0 +1,45 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef FASE_HPP +#define FASE_HPP + +#include "log_mgr.hpp" + +namespace Atlas { + +// Represent a failure atomic section of code. +struct FASection { + explicit FASection(LogEntry *first, LogEntry *last) + : First{first}, + Last{last}, + Next{nullptr}, + IsDeleted{false} {} + FASection() = delete; + FASection(const FASection&) = delete; + FASection(FASection&&) = delete; + FASection& operator=(const FASection&) = delete; + FASection& operator=(FASection&&) = delete; + + LogEntry *First; + LogEntry *Last; + FASection *Next; + bool IsDeleted; +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/fsync.hpp b/ARP_CSFR/runtime/src/internal_includes/fsync.hpp new file mode 100644 index 0000000000000000000000000000000000000000..bc9df7f436952bf15a0d52a42822180a9d73ff4d --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/fsync.hpp @@ -0,0 +1,74 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FP (void)fprintf + +static void bail(char *msg, int line) { + FP(stderr, "%s:%d: %s: %s\n", __FILE__, line, msg, strerror(errno)); + exit(EXIT_FAILURE); +} +#define BAIL(msg) bail(msg, __LINE__) + +static void trim_rightmost_path_component(char *p) { + char *s = p + strlen(p) - 1; + if ('/' == *s) + *s-- = '\0'; + while (s > p && '/' != *s) + s--; + *++s = '\0'; +} + +static int fsync_paranoid(const char *name) { + char rp[1+PATH_MAX], *file = (char *) malloc(sizeof(char)*(strlen(name)+1)); + strcpy(file, name); + FP(stderr, "fsync to root '%s'\n", file); + if (NULL == realpath(file, rp)) BAIL("realpath failed"); + FP(stderr, " realpath '%s'\n", rp); + do { + int fd; + FP(stderr, " fsync-ing '%s'\n", rp); + if (-1 == (fd = open(rp, O_RDONLY))) BAIL("open failed"); + if (-1 == fsync(fd)) BAIL("fsync failed"); + if (-1 == close(fd)) BAIL("close failed"); + trim_rightmost_path_component(rp); + } while (*rp); + FP(stderr, " done\n"); + free(file); + return 0; +} + +static int fsync_dir(const char *name) +{ + char *file = (char*) malloc(sizeof(char)*(strlen(name)+1)); + strcpy(file, name); + trim_rightmost_path_component(file); + FP(stderr, " fsync-ing '%s'\n", file); + int fd; + if (-1 == (fd = open(file, O_RDONLY))) BAIL("open failed"); + if (-1 == fsync(fd)) BAIL("fsync failed"); + if (-1 == close(fd)) BAIL("close failed"); + free(file); + return 0; +} diff --git a/ARP_CSFR/runtime/src/internal_includes/happens_before.hpp b/ARP_CSFR/runtime/src/internal_includes/happens_before.hpp new file mode 100644 index 0000000000000000000000000000000000000000..dbfb76d2ca7814cb14ec1f110f3c15f11eaca223 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/happens_before.hpp @@ -0,0 +1,85 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef HAPPENS_BEFORE_HPP +#define HAPPENS_BEFORE_HPP + +#include +#include + +#include "log_structure.hpp" + +namespace Atlas { + +typedef std::map MapOfLockInfo; + +// This structure is currently used in a write-once manner. It contains +// the core information within an entry in a hash table. If any of the +// components needs to be changed, the update is done in a copy-on-write +// manner. +struct ImmutableInfo +{ + explicit ImmutableInfo(LogEntry *le, MapOfLockInfo *linfo, bool is_del) + : LogAddr{le}, + LockInfoPtr{linfo}, + IsDeleted{is_del} {} + ImmutableInfo() = delete; + ImmutableInfo(const ImmutableInfo&) = delete; + ImmutableInfo(ImmutableInfo&&) = delete; + ImmutableInfo& operator=(const ImmutableInfo&) = delete; + ImmutableInfo& operator=(ImmutableInfo&&) = delete; + + // Here LogAddr_ is the address of the log entry of the last release + // operation of the corresponding synchronization object. + LogEntry *LogAddr; + + // The following map contains the set of locks (and their counts) + // that *this* lock *depends* on. This *dependence* relation is + // established at the point *this* lock is released. At any point + // of time, there can be at most one writer since only one thread + // can release *this* lock. But there can be multiple readers who + // may be examining this map (e.g. rw-locks). + MapOfLockInfo *LockInfoPtr; + + // The following field indicates whether this entry is obsolete + bool IsDeleted; +}; + +struct LastReleaseInfo +{ + explicit LastReleaseInfo(ImmutableInfo *ii) + : Immutable{ii}, + Next{nullptr} {} + LastReleaseInfo() = delete; + LastReleaseInfo(const LastReleaseInfo&) = delete; + LastReleaseInfo(LastReleaseInfo&&) = delete; + LastReleaseInfo& operator=(const LastReleaseInfo&) = delete; + LastReleaseInfo& operator=(LastReleaseInfo&&) = delete; + + // This is updated with a read-modify-write operation since there may + // be multiple concurrent writers. A worker thread may be a writer. The + // helper thread may try to delete this element making it a writer too. + std::atomic Immutable; + + // The Next_ field typically will be atomic but in this case, it + // turns out that this field is updated before it is published. It is + // also write-once. + LastReleaseInfo *Next; +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/helper.hpp b/ARP_CSFR/runtime/src/internal_includes/helper.hpp new file mode 100644 index 0000000000000000000000000000000000000000..86f43981b2594e2a83a8f88f42b1620da8d8a9e9 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/helper.hpp @@ -0,0 +1,136 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef HELPER_HPP +#define HELPER_HPP + +#include +#include +#include +#include +#include +#include +#include + +#include "log_mgr.hpp" + +namespace Atlas { + +typedef std::map Log2Bool; + +// The top-level instance of the helper thread +class Helper { + static Helper *Instance_; + +public: + + struct LogVer { + explicit LogVer(LogStructure *ls, Log2Bool del_logs) + : LS_(ls), Del_(del_logs) {} + LogVer() = delete; + + LogStructure *LS_; + Log2Bool Del_; + }; + + typedef std::vector LogVersions; + typedef std::map MapLog2Int; + typedef std::multimap MultiMapLog2Int; + typedef MultiMapLog2Int::iterator DelIter; + + static Helper& createInstance() { + assert(!Instance_); + Instance_ = new Helper(); + return *Instance_; + } + + static void deleteInstance() { + assert(Instance_); + delete Instance_; + Instance_ = nullptr; + } + + static Helper& getInstance() { + assert(Instance_); + return *Instance_; + } + + uint64_t get_iter_num() const { return IterNum_; } + + void doConsistentUpdate(void*); + void addEntryToDeletedMap(LogEntry *le, uint64_t gen_num) + { DeletedRelLogs_.insert(std::make_pair(le, gen_num)); } + + bool isDeletedByHelperThread(LogEntry *le, uint64_t gen_num); + template void trace(T s) + { TraceStream_ << s; } + + void incrementTotalGraphBuildTime(uint64_t inc) + { TotalGraphBuildTime_ += inc; } + void incrementTotalGraphResolveTime(uint64_t inc) + { TotalGraphResolveTime_ += inc; } + void incrementTotalPruneTime(uint64_t inc) + { TotalPruneTime_ += inc; } + + void printStats(); + +private: + + Helper() : + IterNum_{0}, + IsInRecovery_{false}, + LogVersions_{}, + DeletedRelLogs_{}, + ExistingRelMap_{}, +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + TraceStream_{"/tmp/atlas_log_pruner.txt"}, +#endif + TotalGraphBuildTime_{0}, + TotalGraphResolveTime_{0}, + TotalPruneTime_{0} + { +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + assert(TraceStream_ && "Error opening trace file"); +#endif + } + + ~Helper() { +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + TraceStream_.close(); +#endif + + } + + uint64_t IterNum_; + bool IsInRecovery_; + LogVersions LogVersions_; + MultiMapLog2Int DeletedRelLogs_; + MapLog2Int ExistingRelMap_; + std::ofstream TraceStream_; + + // there is only 1 helper thread today + uint64_t TotalGraphBuildTime_; + uint64_t TotalGraphResolveTime_; + uint64_t TotalPruneTime_; + + void collectRelLogEntries(LogStructure *lsp); + bool areUserThreadsDone() const + { return LogMgr::getInstance().areUserThreadsDone(); } +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/internal_api.h b/ARP_CSFR/runtime/src/internal_includes/internal_api.h new file mode 100644 index 0000000000000000000000000000000000000000..04720084e85c91098f027fb42fc689e3548e1221 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/internal_api.h @@ -0,0 +1,316 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#ifndef INTERNAL_API +#define INTERNAL_API + +#ifdef __cplusplus +extern "C" { +#endif + // TODO document these APIs. + void nvm_acquire(void *lock_address); + void nvm_rwlock_rdlock(void *lock_address); + void nvm_rwlock_wrlock(void *lock_address); + void nvm_release(void *lock_address); + void nvm_rwlock_unlock(void *lock_address); + void nvm_store(void *addr, size_t size); + void nvm_log_alloc(void *addr); + void nvm_log_free(void *addr); + void nvm_memset(void *addr, size_t sz); + void nvm_memcpy(void *dst, size_t sz); + void nvm_memmove(void *dst, size_t sz); + void nvm_strcpy(char *dst, size_t sz); + void nvm_strcat(char *dst, size_t sz); + size_t nvm_strlen(char *dst);//returns strlen + 1 - accounts for null char + // TODO nvm_barrier should really be inlined. For that to happen, + // the compiler must manually inline its instructions. Don't use this + // interface within the library, instead use NVM_FLUSH + void nvm_barrier(void*); + +#if defined(_USE_TABLE_FLUSH) + void AsyncDataFlush(void *p); + void AsyncMemOpDataFlush(void *dst, size_t sz); +#endif + + +#ifdef __cplusplus +} +#endif + +// Read timestamp (x86) +static inline uint64_t atlas_rdtsc() { + uint32_t lo, hi; + __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi)); + return lo | ((uint64_t)hi << 32); +} + +#define NVM_LOG(var, size) { \ + nvm_store((void*)&(var), (size)); \ + } \ + +#define NVM_LOCK(lock) { \ + pthread_mutex_lock(&(lock)); \ + nvm_acquire((void*)&(lock)); \ + } \ + +#define NVM_UNLOCK(lock) { \ + nvm_release((void*)&(lock)); \ + pthread_mutex_unlock(&(lock)); \ + } \ + +#define NVM_RWLOCK_RDLOCK(rwlock) { \ + pthread_rwlock_rdlock(&(rwlock)); \ + nvm_rwlock_rdlock((void *)&(rwlock)); \ + } \ + +#define NVM_RWLOCK_WRLOCK(rwlock) { \ + pthread_rwlock_wrlock(&(rwlock)); \ + nvm_rwlock_wrlock((void *)&(rwlock)); \ + } \ + +#define NVM_RWLOCK_UNLOCK(rwlock) { \ + nvm_rwlock_unlock((void *)&(rwlock)); \ + pthread_rwlock_unlock(&(rwlock)); \ + } \ + +#if defined(_FLUSH_LOCAL_COMMIT) || defined(_FLUSH_GLOBAL_COMMIT) + +#define NVM_STR(var,val,size) { \ + nvm_store((void*)&(var),((size)*8)); \ + var=val; \ + } \ + +#define NVM_STR2(var,val,size) { \ + nvm_store((void*)&(var),(size)); \ + var=val; \ + } \ + +#define NVM_MEMSET(s,c,n) { \ + nvm_memset((void *)(s), (size_t)(n)); \ + memset(s, c, n); \ + } \ + +#define NVM_MEMCPY(dst, src, n) { \ + nvm_memcpy((void *)(dst), (size_t)(n)); \ + memcpy(dst, src, n); \ + } \ + +#define NVM_MEMMOVE(dst, src, n) { \ + nvm_memmove((void *)(dst), (size_t)(n)); \ + memmove(dst, src, n); \ + } \ + +#define NVM_STRCPY(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcpy((void *)(dst),(size_t)(sz)); \ + strcpy(dst, src); \ + } \ + +#define NVM_STRNCPY(dst, src, n) { \ + nvm_strcpy((void *)(dst),(size_t)(n)); \ + strncpy(dst, src, n); \ + } \ + +#define NVM_STRCAT(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strcat(dst, src); \ + } \ + +#define NVM_STRNCAT(dst, src, n) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strncat(dst, src, n); \ + } \ + + +#elif defined(_DISABLE_DATA_FLUSH) + +#define NVM_STR(var,val,size) { \ + nvm_store((void*)&(var),((size)*8)); \ + var=val; \ + } \ + +#define NVM_STR2(var,val,size) { \ + nvm_store((void*)&(var),(size)); \ + var=val; \ + } \ + +#define NVM_MEMSET(s,c,n) { \ + nvm_memset((void *)(s), (size_t)(n)); \ + memset(s, c, n); \ + } \ + +#define NVM_MEMCPY(dst, src, n) { \ + nvm_memcpy((void *)(dst), (size_t)(n)); \ + memcpy(dst, src, n); \ + } \ + +#define NVM_MEMMOVE(dst, src, n) { \ + nvm_memmove((void *)(dst), (size_t)(n)); \ + memmove(dst, src, n); \ + } \ + +#define NVM_STRCPY(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcpy((void *)(dst),(size_t)(sz)); \ + strcpy(dst, src); \ + } \ + +#define NVM_STRNCPY(dst, src, n) { \ + nvm_strcpy((void *)(dst),(size_t)(n)); \ + strncpy(dst, src, n); \ + } \ + +#define NVM_STRCAT(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strcat(dst, src); \ + } \ + +#define NVM_STRNCAT(dst, src, n) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strncat(dst, src, n); \ + } \ + +#elif defined(_USE_TABLE_FLUSH) + +#define NVM_STR(var,val,size) { \ + nvm_store((void*)&(var),((size)*8)); \ + var=val; \ + AsyncDataFlush((void*)&(var)); \ + } \ + +#define NVM_STR2(var,val,size) { \ + nvm_store((void*)&(var),(size)); \ + var=val; \ + AsyncDataFlush((void*)&(var)); \ + } \ + +#define NVM_MEMSET(s,c,n) { \ + nvm_memset((void *)(s), (size_t)(n)); \ + memset(s, c, n); \ + AsyncMemOpDataFlush((void*)(s), n); \ + } \ + +#define NVM_MEMCPY(dst, src, n) { \ + nvm_memcpy((void *)(dst), (size_t)(n)); \ + memcpy(dst, src, n); \ + AsyncMemOpDataFlush((void*)(dst), n); \ + } \ + +#define NVM_MEMMOVE(dst, src, n) { \ + nvm_memmove((void *)(dst), (size_t)(n)); \ + memmove(dst, src, n); \ + AsyncMemOpDataFlush((void*)(dst), n); \ + } \ + +#define NVM_STRCPY(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcpy((dst),(size_t)(sz)); \ + strcpy(dst, src); \ + AsyncMemOpDataFlush((void*)(dst), sz); \ + } \ + +#define NVM_STRNCPY(dst, src, n) { \ + nvm_strcpy((dst),(size_t)(n)); \ + strncpy(dst, src, n); \ + AsyncMemOpDataFlush((void*)(dst), n); \ + } \ + +#define NVM_STRCAT(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((dst),(size_t)(sz)); \ + strcat(dst, src); \ + AsyncMemOpDataFlush((void*)(dst), sz); \ + } \ + +#define NVM_STRNCAT(dst, src, n) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((dst),(size_t)(sz)); \ + strncat(dst, src, n); \ + AsyncMemOpDataFlush((void*)(dst), sz); \ + } \ + +#else + +// TODO for transient locations, a filter avoids logging and flushing. +// Currently, this filter is being called twice. This should be optimized +// to call once only. Ensure that the fix is done in the compiled code-path +// as well, i.e. it should be there for nvm_barrier as well. + +#define NVM_STR(var,val,size) { \ + nvm_store((void*)&(var),((size)*8)); \ + var=val; \ + NVM_FLUSH_ACQ_COND(&var); \ + } \ + +#define NVM_STR2(var,val,size) { \ + nvm_store((void*)&(var),(size)); \ + var=val; \ + NVM_FLUSH_ACQ_COND(&var); \ + } \ + +#define NVM_MEMSET(s,c,n) { \ + nvm_memset((void *)(s), (size_t)(n)); \ + memset(s, c, n); \ + NVM_PSYNC_ACQ_COND(s, n); \ + } \ + +#define NVM_MEMCPY(dst, src, n) { \ + nvm_memcpy((void *)(dst), (size_t)(n)); \ + memcpy(dst, src, n); \ + NVM_PSYNC_ACQ_COND(dst, n); \ + } \ + +#define NVM_MEMMOVE(dst, src, n) { \ + nvm_memmove((void *)(dst), (size_t)(n)); \ + memmove(dst, src, n); \ + NVM_PSYNC_ACQ_COND(dst, n); \ + } \ + +#define NVM_STRCPY(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcpy((void *)(dst),(size_t)(sz)); \ + strcpy(dst, src); \ + NVM_PSYNC_ACQ_COND(dst, sz); \ + } \ + +#define NVM_STRNCPY(dst, src, n) { \ + nvm_strcpy((void *)(dst),(size_t)(n)); \ + strncpy(dst, src, n); \ + NVM_PSYNC_ACQ_COND(dst, n); \ + } \ + +#define NVM_STRCAT(dst, src) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strcat(dst, src); \ + NVM_PSYNC_ACQ_COND(dst, sz); \ + } \ + +#define NVM_STRNCAT(dst, src, n) { \ + size_t sz=nvm_strlen(dst); \ + nvm_strcat((void *)(dst),(size_t)(sz)); \ + strncat(dst, src, n); \ + NVM_PSYNC_ACQ_COND(dst, sz); \ + } \ + +#endif + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/log_configs.hpp b/ARP_CSFR/runtime/src/internal_includes/log_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..24de248d2ccb5c11f12b5ac897a912aa3140887d --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/log_configs.hpp @@ -0,0 +1,41 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef LOG_CONFIGS_HPP +#define LOG_CONFIGS_HPP + +#include + +namespace Atlas { + +const uint64_t kHashTableSize = 1 << 10; +const uint64_t kHashTableMask = kHashTableSize - 1; +const uint32_t kShift = 3; +const uint32_t kWorkThreshold = 100; +const uint32_t kCircularBufferSize = 1024 * 16 - 1; + +// At limit for using 4 bits +// Combined strncat and strcat, strcpy and strncpy +enum LogType { + LE_dummy, LE_acquire, LE_rwlock_rdlock, LE_rwlock_wrlock, + LE_begin_durable, LE_release, LE_rwlock_unlock, LE_end_durable, + LE_str, LE_memset, LE_memcpy, LE_memmove, + LE_strcpy, LE_strcat, LE_alloc, LE_free +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/log_elision.hpp b/ARP_CSFR/runtime/src/internal_includes/log_elision.hpp new file mode 100644 index 0000000000000000000000000000000000000000..969dc361b6579b3e8ae8f290e885ef29938a1aa8 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/log_elision.hpp @@ -0,0 +1,43 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef LOG_ELISION_HPP +#define LOG_ELISION_HPP + +#include + +namespace Atlas { + +struct LockReleaseCount +{ + explicit LockReleaseCount(void *addr, uint64_t count) + : LockAddr{addr}, + Count{count}, + Next{nullptr} {} + LockReleaseCount() = delete; + LockReleaseCount(const LockReleaseCount&) = delete; + LockReleaseCount(LockReleaseCount&&) = delete; + LockReleaseCount& operator=(const LockReleaseCount&) = delete; + LockReleaseCount& operator=(LockReleaseCount&&) = delete; + + void *LockAddr; + std::atomic Count; + LockReleaseCount *Next; +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/log_mgr.hpp b/ARP_CSFR/runtime/src/internal_includes/log_mgr.hpp new file mode 100644 index 0000000000000000000000000000000000000000..6f6e23dd3630fddc1e2d59e5143fdf9d93790652 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/log_mgr.hpp @@ -0,0 +1,521 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef LOG_MGR_HPP +#define LOG_MGR_HPP + +#include +#include +#include + +#include +#include + +#include "atlas_api.h" + +#include "pregion_configs.hpp" +#include "pregion_mgr.hpp" +#include "log_configs.hpp" +#include "log_structure.hpp" +#include "happens_before.hpp" +#include "cache_flush_configs.hpp" +#include "circular_buffer.hpp" +#include "log_elision.hpp" +#include "stats.hpp" + +#include "util.hpp" + +namespace Atlas { + +void * helper(void*); + +typedef std::vector LogEntryVec; + +class LogMgr { + static LogMgr *Instance_; +public: + + // serial mode only + static LogMgr& createInstance() { + assert(!Instance_); + Instance_ = new LogMgr(); + Instance_->init(); + return *Instance_; + } + + // serial mode only + static LogMgr& createRecoveryInstance() { + assert(!Instance_); + Instance_ = new LogMgr(); + return *Instance_; + } + + // serial mode only + static void deleteInstance() { + if (Instance_) { + Instance_->finalize(); + delete Instance_; + Instance_ = nullptr; + } + } + + static LogMgr& getInstance() { + assert(Instance_); + return *Instance_; + } + + static bool hasInstance() { + if (!Instance_) return false; + return Instance_->IsInitialized_; + } + + void setRegionId(region_id_t id) { RegionId_ = id; } + region_id_t getRegionId() const { return RegionId_; } + + void acquireLogReadyLock() + { int status = pthread_mutex_lock(&HelperLock_); assert(!status); } + void releaseLogReadyLock() + { int status = pthread_mutex_unlock(&HelperLock_); assert(!status); } + void waitLogReady() { + int status = pthread_cond_wait(&HelperCondition_, &HelperLock_); + assert(!status); + } + void signalLogReady() + { int status = pthread_cond_signal(&HelperCondition_); assert(!status); } + + bool cmpXchngWeakLogPointer(LogStructure *expected, + LogStructure *desired, + std::memory_order success, + std::memory_order failure) { + return LogStructureHeaderPtr_->compare_exchange_weak( + expected, desired, success, failure); + } + bool cmpXchngWeakRecoveryLogPointer(LogStructure *expected, + LogStructure *desired, + std::memory_order success, + std::memory_order failure) { + return RecoveryTimeLsp_.compare_exchange_weak( + expected, desired, success, failure); + } + + // Log creation + void logNonTemporal( + LogEntry *le, void *addr, size_t sz, LogType le_type); + void logAcquire(void*); + void logRelease(void*); + void logRdLock(void*); + void logWrLock(void*); + void logRWUnlock(void*); + void logBeginDurable(); + void logEndDurable(); + void logStore(void *addr, size_t sz); + void logMemset(void *addr, size_t sz); + void logMemcpy(void *dst, size_t sz); + void logMemmove(void *dst, size_t sz); + void logStrcpy(void *dst, size_t sz); + void logStrcat(void *dst, size_t sz); + void logAlloc(void *addr); + void logFree(void *addr); + + LogStructure *createLogStructure(LogEntry *le); + + // Cache flush handling + // TODO separate flush object + void psync(void *start_addr, size_t sz); + void psyncWithAcquireBarrier(void *start_addr, size_t sz); + void asyncLogFlush(void *p); + void syncLogFlush(); + + void asyncDataFlush(void *p); + void asyncMemOpDataFlush(void *dst, size_t sz); + void syncDataFlush(); + + void flushAtEndOfFase(); + void collectCacheLines(SetOfInts *cl_set, void *addr, size_t sz); + void flushCacheLines(const SetOfInts & cl_set); + void flushCacheLinesUnconstrained(const SetOfInts & cl_set); + void flushLogUncond(void*); + void flushLogPointer() { NVM_FLUSH(LogStructureHeaderPtr_); } + void flushRecoveryLogPointer() { NVM_FLUSH(&RecoveryTimeLsp_); } + + bool areUserThreadsDone() const + { return AllDone_.load(std::memory_order_acquire) == 1; } + + LogStructure *getRecoveryLogPointer(std::memory_order mem_order) const + { return RecoveryTimeLsp_.load(mem_order); } + void setRecoveryLogPointer(LogStructure *log_ptr, + std::memory_order mem_order) + { RecoveryTimeLsp_.store(log_ptr, mem_order); } + LogStructure *getLogPointer(std::memory_order mem_order) const + { return (*LogStructureHeaderPtr_).load(mem_order); } + + void deleteOwnerInfo(LogEntry *le); + void deleteEntry(LogEntry *addr) + { deleteEntry(CbLogList_, addr); } + void deleteEntry(LogEntry *addr, CbListNode* &last_cb) + { deleteEntry(CbLogList_, addr, last_cb); } + + void acquireStatsLock() + { assert(Stats_); Stats_->acquireLock(); } + void releaseStatsLock() + { assert(Stats_); Stats_->releaseLock(); } + void printStats() const + { assert(Stats_); Stats_->print(); } + +private: + + // All member of LogMgr are transient. The logs themselves are persistent + // and maintained in a persistent region + + /// + /// The following are shared between threads + /// + + region_id_t RegionId_; // Persistent region holding the logs + + // This is the helper thread that is created at initialization time + // and joined at finalization time. It is manipulated by the main thread + // alone avoiding a race. + pthread_t HelperThread_; + + // pointer to the list of circular buffers containing the log entries + std::atomic*> CbLogList_; + + // This is the topmost pointer to the entire global log structure + std::atomic *LogStructureHeaderPtr_; + + // Same as above but during recovery + std::atomic RecoveryTimeLsp_; + + // indicator whether the user threads are done + std::atomic AllDone_; + + // Condition variable thru which user threads signal the helper thread + pthread_cond_t HelperCondition_; + + // Mutex for the above condition variable + pthread_mutex_t HelperLock_; + + // Used to map a lock address to a pointer to LastReleaseInfo, the + // structure used to maintain information about the last release + // of the lock + std::atomic ReleaseInfoTab_[kHashTableSize]; + + // Used to map a lock address to a pointer to LockReleaseCount + // that maintains the total number of releases of that lock. Used + // in log elision analysis. + std::atomic LockReleaseHistory_[kHashTableSize]; + + Stats *Stats_; + + bool IsInitialized_; + + // + // Start of thread local members + // + + // Used to signal helper thread once a certain number of log entries + // has been created by this thread + thread_local static uint32_t TL_LogCount_; + + // TODO this is passed around in the code unnecessarily + + // pointer to the current log circular buffer that is used to + // satisfy new allocation requests for log entries + thread_local static CbLog *TL_CbLog_; + + // Every time the information in a log entry is over-written (either + // because it is newly created or because it is repurposed), a + // monotonically increasing generation number is assigned to + // it. Since these circular buffers are never de-allocated, there + // is no way a log entry address can be used by multiple + // threads. So a thread local generation number suffices. + thread_local static uint64_t TL_GenNum_; + + // Log tracker pointing to the first log entry of this thread + thread_local static LogEntry *TL_FirstLogEntry_; + + // Log tracker pointing to the log header of this thread + thread_local static LogStructure *TL_LogStructure_; + + // Log tracker pointing to the last log entry of this thread + thread_local static LogEntry *TL_LastLogEntry_; + + // Count of locks held. A non-zero value indicates that execution is + // within a Failure Atomic SEction (FASE). POSIX says that if an + // unlock is attempted on an already-released lock, undefined + // behavior results. So this simple detection of FASE is sufficient. + thread_local static intptr_t TL_NumHeldLocks_; + + // A set of locks on which the current thread is conditioned. In + // other words, the current thread's execution may have to be + // undone if there is a failure and at least one of those locks + // has not been released one more time. Used in log elision analysis. + thread_local static MapOfLockInfo *TL_UndoLocks_; + + // A tracker indicating whether a user thread just executed the + // first statement that is outside a critical section + thread_local static bool TL_IsFirstNonCSStmt_; + + // A cache with the current intention + thread_local static bool TL_ShouldLogNonCSStmt_; + + // Total number of logs created by this thread + thread_local static uint64_t TL_LogCounter_; + + // Set of cache lines that need to be flushed at end of FASE + thread_local static SetOfInts *TL_FaseFlushPtr_; + + // Used to track unique address/size pair within a consistent section + thread_local static SetOfPairs *TL_UniqueLoc_; + +#if 0 // unused + thread_local static intptr_t TL_LogFlushTab_[kFlushTableSize]; +#endif + + thread_local static intptr_t TL_DataFlushTab_[kFlushTableSize]; + + // + // End of thread local members + // + + // TODO ensure all are initialized + LogMgr() : + RegionId_{kMaxNumPRegions_}, + CbLogList_{nullptr}, + LogStructureHeaderPtr_{nullptr}, + RecoveryTimeLsp_{nullptr}, + AllDone_{0}, + Stats_{nullptr}, + IsInitialized_{false} + { + pthread_cond_init(&HelperCondition_, nullptr); + pthread_mutex_init(&HelperLock_, nullptr); + } + + ~LogMgr() + { +#if defined(_FLUSH_LOCAL_COMMIT) && !defined(DISABLE_FLUSHES) + delete TL_FaseFlushPtr_; + TL_FaseFlushPtr_ = nullptr; +#endif + } + + void init(); + void finalize(); + + // Given a lock address, get a pointer to the bucket for the last + // release + std::atomic *getLastReleaseRoot(void *addr) { + return ReleaseInfoTab_ + ( + ((reinterpret_cast(addr)) >> kShift) & + kHashTableMask); } + + std::atomic *getLockReleaseCountRoot(void *addr) { + return LockReleaseHistory_ + ( + ((reinterpret_cast(addr)) >> kShift) & + kHashTableMask); } + + // Log entry creation functions + LogEntry *allocLogEntry(); + LogEntry *createSectionLogEntry( + void *lock_address, LogType le_type); + LogEntry *createAllocationLogEntry( + void *addr, LogType le_type); + LogEntry *createStrLogEntry( + void * addr, size_t size_in_bits); + LogEntry *createMemStrLogEntry( + void *addr, size_t sz, LogType le_type); + LogEntry *createDummyLogEntry(); + + void pruneLogEntries(); + void publishLogEntry( + LogEntry *le); + void signalHelper(); + void finishAcquire( + void *lock_address, LogEntry *le); + void finishRelease( + LogEntry *le, const MapOfLockInfo& undo_locks); + void markEndFase( + LogEntry *le); + void finishWrite( + LogEntry * le, void * addr); + void assertOneCacheLine(LogEntry *le) { +#if !defined(_LOG_WITH_NVM_ALLOC) && !defined(_LOG_WITH_MALLOC) + // The entire log entry must be on the same cache line + assert(!PMallocUtil::is_on_different_cache_line(le, LAST_LOG_ELEM(le))); +#endif + } + + // Happens before tracker + LastReleaseInfo *getLastReleaseHeader( + void *lock_address); + LastReleaseInfo *findLastReleaseOfLock( + void *hash_address); + LastReleaseInfo *findLastReleaseOfLogEntry( + LogEntry *candidate_le); + void addLogToLastReleaseInfo( + LogEntry *le, const MapOfLockInfo& undo_locks); + ImmutableInfo *createNewImmutableInfo( + LogEntry *le, const MapOfLockInfo& undo_locks, bool is_deleted); + LastReleaseInfo *createNewLastReleaseInfo( + LogEntry *le, const MapOfLockInfo& undo_locks); + void setHappensBeforeForAllocFree( + LogEntry *le); + + // Log elision + bool tryLogElision( + void *addr, size_t sz); + bool doesNeedLogging( + void *addr, size_t sz); + bool canElideLogging(); + void addLockReleaseCount( + void *lock_address, uint64_t count); + LockReleaseCount *getLockReleaseCountHeader( + void *lock_address); + LockReleaseCount *findLockReleaseCount( + void *lock_address); + uint64_t removeLockFromUndoInfo( + void *lock_address); + + bool isAddrSizePairAlreadySeen( + void *addr, size_t sz); + + // Circular buffer management + void deleteEntry( + const std::atomic*>& cb_list, LogEntry *addr, CbListNode * &last_cb_used); + template CbLog *getNewCb( + uint32_t size, uint32_t rid, CbLog **log_p, + std::atomic*> *cb_list_p); + template T *getNewSlot( + uint32_t rid, CbLog **log_p, + std::atomic*> *cb_list_p); + template void deleteEntry( + const std::atomic*>& cb_list, T *addr); + template void deleteSlot( + CbLog *cb, T *addr); + +}; + +inline void LogMgr::logAcquire(void *lock_address) +{ + LogEntry *le = createSectionLogEntry(lock_address, LE_acquire); + assert(le); + + finishAcquire(lock_address, le); +} + +inline void LogMgr::logRdLock(void *lock_address) +{ + LogEntry *le = createSectionLogEntry(lock_address, LE_rwlock_rdlock); + assert(le); + + finishAcquire(lock_address, le); +} + +inline void LogMgr::logWrLock(void *lock_address) +{ + LogEntry *le = createSectionLogEntry(lock_address, LE_rwlock_wrlock); + assert(le); + + finishAcquire(lock_address, le); +} + +inline void LogMgr::logBeginDurable() +{ + LogEntry *le = createSectionLogEntry(NULL, LE_begin_durable); + assert(le); + + finishAcquire(NULL, le); +} + +inline void LogMgr::logStore(void *addr, size_t sz) +{ + if (!NVM_IsInOpenPR(addr, sz/8)) return; +// if (tryLogElision(addr, sz/8)) return; + LogEntry *le = createStrLogEntry(addr, sz); + finishWrite(le, addr); +} + +inline void LogMgr::logMemset(void *addr, size_t sz) +{ + if (!NVM_IsInOpenPR(addr, sz)) return; + if (tryLogElision(addr, sz)) return; + LogEntry *le = createMemStrLogEntry(addr, sz, LE_memset); + finishWrite(le, addr); +} + +inline void LogMgr::logMemcpy(void *dst, size_t sz) +{ + if (!NVM_IsInOpenPR(dst, sz)) return; + if (tryLogElision(dst, sz)) return; + LogEntry *le = createMemStrLogEntry(dst, sz, LE_memcpy); + finishWrite(le, dst); +} + +inline void LogMgr::logMemmove(void *dst, size_t sz) +{ + if (!NVM_IsInOpenPR(dst, sz)) return; + if (tryLogElision(dst, sz)) return; + LogEntry *le = createMemStrLogEntry(dst, sz, LE_memmove); + finishWrite(le, dst); +} + +inline void LogMgr::logStrcpy(void *dst, size_t sz) +{ + if (!NVM_IsInOpenPR((void *)dst, sz)) return; + if (tryLogElision((void *)dst, sz)) return; + LogEntry *le = createMemStrLogEntry((void *)dst, sz, LE_strcpy); + finishWrite(le, dst); +} + +inline void LogMgr::logStrcat(void *dst, size_t sz) +{ + if (!NVM_IsInOpenPR(dst, sz)) return; + if (tryLogElision(dst, sz)) return; + LogEntry *le = createMemStrLogEntry(dst, sz, LE_strcat); + finishWrite(le, dst); +} + +inline LastReleaseInfo *LogMgr::getLastReleaseHeader(void *lock_address) +{ + std::atomic *table_ptr = + getLastReleaseRoot(lock_address); + return (*table_ptr).load(std::memory_order_acquire); +} + +inline LockReleaseCount *LogMgr::getLockReleaseCountHeader(void *lock_address) +{ + std::atomic *entry = + getLockReleaseCountRoot(lock_address); + return (*entry).load(std::memory_order_acquire); +} + +inline void LogMgr::flushLogUncond(void *p) +{ +#if (!defined(DISABLE_FLUSHES) && !defined(_DISABLE_LOG_FLUSH)) +#if defined(_LOG_FLUSH_OPT) + // TODO: this needs more work. It is incomplete. + AsyncLogFlush(p); +#else + NVM_CLFLUSH(p); +#endif +#endif +} + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/log_structure.hpp b/ARP_CSFR/runtime/src/internal_includes/log_structure.hpp new file mode 100644 index 0000000000000000000000000000000000000000..a83b480001ef90dcec9f0794b234561c7448558d --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/log_structure.hpp @@ -0,0 +1,194 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef LOG_STRUCTURE_HPP +#define LOG_STRUCTURE_HPP + +#include + +#include +#include + +#include "log_configs.hpp" + +namespace Atlas { + +// Structure of an undo log entry +struct LogEntry +{ + LogEntry(void *addr, uintptr_t val_or_ptr, LogEntry *next, + size_t sz, LogType type) + : Addr{addr}, ValueOrPtr{val_or_ptr}, Next{next}, + Size{sz}, Type{type} {} + + void *Addr; /* address of mloc or lock object */ + uintptr_t ValueOrPtr; /* either value or ptr (for sync ops) */ + std::atomic Next; /* ptr to next log entry in program order */ + size_t Size:60; /* mloc size or a generation # for sync ops */ + LogType Type:4; + + bool isDummy() const { return Type == LE_dummy; } + bool isAcquire() const { return Type == LE_acquire; } + bool isRWLockRdLock() const { return Type == LE_rwlock_rdlock; } + bool isRWLockWrLock() const { return Type == LE_rwlock_wrlock; } + bool isBeginDurable() const { return Type == LE_begin_durable; } + bool isRelease() const { return Type == LE_release; } + bool isRWLockUnlock() const { return Type == LE_rwlock_unlock; } + bool isEndDurable() const { return Type == LE_end_durable; } + bool isStr() const { return Type == LE_str; } + bool isMemset() const { return Type == LE_memset; } + bool isMemcpy() const { return Type == LE_memcpy; } + bool isMemmove() const { return Type == LE_memmove; } + bool isMemop() const { + return Type == LE_memset || Type == LE_memcpy || Type == LE_memmove; + } + bool isAlloc() const { return Type == LE_alloc; } + bool isFree() const { return Type == LE_free; } + bool isStrcpy() const { return Type == LE_strcpy; } + bool isStrcat() const { return Type == LE_strcat; } + bool isStrop() const { return Type == LE_strcpy || Type == LE_strcat; } + bool isStartSection() const { + return isAcquire() || isRWLockRdLock() || isRWLockWrLock() || + isBeginDurable(); + } + bool isEndSection() const + { return isRelease() || isRWLockUnlock() || isEndDurable(); } +}; + +#define LAST_LOG_ELEM(p) ((char*)(p)+24) + +// Log structure header: A shared statically allocated header points at +// the start of this structure, so it is available to all threads. Every +// entry has a pointer to a particular thread's log structure and a next +// pointer +struct LogStructure +{ + LogStructure(LogEntry *le, LogStructure *next) + : Le{le}, + Next{next} {} + + LogEntry *Le; // points to first non-deleted thread-specific log entry + // Insertion happens at the head, so the following is write-once before + // getting published. + LogStructure *Next; +}; + +static inline bool isDummy(LogType le_type) +{ + return le_type == LE_dummy; +} + +static inline bool isAcquire(LogType le_type) +{ + return le_type == LE_acquire; +} + +static inline bool isRWLockRdLock(LogType le_type) +{ + return le_type == LE_rwlock_rdlock; +} + +static inline bool isRWLockWrLock(LogType le_type) +{ + return le_type == LE_rwlock_wrlock; +} + +static inline bool isBeginDurable(LogType le_type) +{ + return le_type == LE_begin_durable; +} + +static inline bool isRelease(LogType le_type) +{ + return le_type == LE_release; +} + +static inline bool isRWLockUnlock(LogType le_type) +{ + return le_type == LE_rwlock_unlock; +} + +static inline bool isEndDurable(LogType le_type) +{ + return le_type == LE_end_durable; +} + +static inline bool isStr(LogType le_type) +{ + return le_type == LE_str; +} + +static inline bool isMemset(LogType le_type) +{ + return le_type == LE_memset; +} + +static inline bool isMemcpy(LogType le_type) +{ + return le_type == LE_memcpy; +} + +static inline bool isMemmove(LogType le_type) +{ + return le_type == LE_memmove; +} + +static inline bool isMemop(LogType le_type) +{ + return le_type == LE_memset || le_type == LE_memcpy || + le_type == LE_memmove; +} + +static inline bool isAlloc(LogType le_type) +{ + return le_type == LE_alloc; +} + +static inline bool isFree(LogType le_type) +{ + return le_type == LE_free; +} + +static inline bool isStrcpy(LogType le_type) +{ + return le_type == LE_strcpy; +} + +static inline bool isStrcat(LogType le_type) +{ + return le_type == LE_strcat; +} + +static inline bool isStrop(LogType le_type) +{ + return le_type == LE_strcpy || le_type == LE_strcat; +} + +static inline bool isStartSection(LogType le_type) +{ + return isAcquire(le_type) || isRWLockRdLock(le_type) || + isRWLockWrLock(le_type) || isBeginDurable(le_type); +} + +static inline bool isEndSection(LogType le_type) +{ + return isRelease(le_type) || isRWLockUnlock(le_type) || + isEndDurable(le_type); +} + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/pmalloc.hpp b/ARP_CSFR/runtime/src/internal_includes/pmalloc.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9533579dd57e92542837f8074ec6ca6c35565b43 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pmalloc.hpp @@ -0,0 +1,145 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PMALLOC_HPP +#define PMALLOC_HPP + +#include +#include +#include +#include + +#include + +#include "pregion_configs.hpp" + +#include "atlas_api.h" + +namespace Atlas { + +typedef std::map MemMap; +typedef std::map FreeList; + +// Physically persistent arena, contains logically transient data as well +class PArena { +public: + explicit PArena() : CurrAllocAddr_{nullptr}, StartAddr_{nullptr}, + EndAddr_{nullptr}, ActualAlloced_{0}, FreeList_{new FreeList} + { pthread_mutex_init(&Lock_, NULL); flushDirtyCacheLines(); } + + ~PArena() + { if (FreeList_) { delete FreeList_; FreeList_ = nullptr; } } + + PArena(const PArena&) = delete; + PArena(PArena&&) = delete; + PArena& operator=(const PArena&) = delete; + PArena& operator=(PArena&&) = delete; + + void initAllocAddresses(void *start_addr); + void initTransients(); + + void *get_curr_alloc_addr() const { return CurrAllocAddr_; } + void *get_start_addr() const { return StartAddr_; } + void *get_end_addr() const { return EndAddr_; } + uint64_t get_actual_alloced() const { return ActualAlloced_; } + + bool doesRangeCheck(void *start, size_t sz) const + { return start >= StartAddr_ && + (static_cast(start) + sz) < + static_cast(EndAddr_); } + + void *allocMem( + size_t sz, bool does_need_cache_line_alignment, + bool does_need_logging); + void *allocFromFreeList( + size_t sz, bool does_need_cache_line_alignment, + bool does_need_logging); + void *allocFromUpdatedFreeList( + size_t sz, bool does_need_cache_line_alignment, + bool does_need_logging); + void *allocRawMem(size_t); + + void freeMem(void *ptr, bool should_log); + + void Lock() { pthread_mutex_lock(&Lock_); } + int tryLock() { return pthread_mutex_trylock(&Lock_); } + void Unlock() { pthread_mutex_unlock(&Lock_); } + +private: + // The 3 addresses below are persistent. Their updates are flushed + // but not logged. + void *CurrAllocAddr_; // bump pointer + void *StartAddr_; + void *EndAddr_; + + // The following is persistent as well. Its update is flushed + // but not logged. For accuracy purposes, start with a fresh + // region when the stats are turned on --- otherwise, allocation + // from a prior run may not be captured. + // This field is unconditionally included here to avoid + // layout incompatibility but updated only under the stats flag. + uint64_t ActualAlloced_; + + // The following are considered logically transient and hence not + // flushed. They must be reset at init time. + pthread_mutex_t Lock_; + FreeList *FreeList_; + + void flushDirtyCacheLines() + { NVM_FLUSH(&CurrAllocAddr_); NVM_FLUSH(&ActualAlloced_); } + + void *carveExtraMem(char *mem, size_t actual_sz, size_t actual_free_sz); + + void insertToFreeList(uint32_t bin_no, void *mem); + void deleteFromFreeList(uint32_t bin_no, void *mem); + + void incrementActualAllocedStats(size_t sz); + void decrementActualAllocedStats(size_t sz); +}; + +inline void PArena::initAllocAddresses(void *start_addr) +{ + StartAddr_ = CurrAllocAddr_ = start_addr; + EndAddr_ = static_cast( + static_cast(start_addr) + kArenaSize_); + flushDirtyCacheLines(); +} + +inline void PArena::initTransients() +{ + pthread_mutex_init(&Lock_, NULL); + FreeList_ = new FreeList; +} + +inline void PArena::incrementActualAllocedStats(size_t sz) +{ +#if defined(ATLAS_ALLOC_STATS) + ActualAlloced_ += sz; + NVM_FLUSH(&ActualAlloced_); +#endif +} + +inline void PArena::decrementActualAllocedStats(size_t sz) +{ +#if defined(ATLAS_ALLOC_STATS) + ActualAlloced_ -= sz; + NVM_FLUSH(&ActualAlloced_); +#endif +} + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/pmalloc_util.hpp b/ARP_CSFR/runtime/src/internal_includes/pmalloc_util.hpp new file mode 100644 index 0000000000000000000000000000000000000000..53538dfe962430999470c126ecd60d2976f56745 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pmalloc_util.hpp @@ -0,0 +1,129 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PMALLOC_UTIL_HPP +#define PMALLOC_UTIL_HPP + +namespace Atlas { + +class PMallocUtil { +public: + static void set_default_tl_curr_arena(region_id_t rid) + { TL_CurrArena_[rid] = kNumArenas_; /* set to invalid */} + + static void set_tl_curr_arena(region_id_t rid, uint32_t val) + { TL_CurrArena_[rid] = val; } + + static uint32_t get_tl_curr_arena(region_id_t rid) + { return TL_CurrArena_[rid]; } + + static uint32_t get_tl_next_arena(region_id_t rid) + { return (get_tl_curr_arena(rid) + 1) % kNumArenas_; } + + static bool is_valid_tl_curr_arena(region_id_t rid) + { return TL_CurrArena_[rid] != kNumArenas_; } + + static void set_cache_line_size(uint32_t sz) + { CacheLineSize_ = sz; } + + static void set_cache_line_mask(uintptr_t mask) + { CacheLineMask_ = mask; } + + static uint32_t get_cache_line_size() + { assert(CacheLineSize_ != UINT32_MAX); return CacheLineSize_; } + + static uintptr_t get_cache_line_mask() + { assert(CacheLineMask_ != UINTPTR_MAX); return CacheLineMask_; } + + static void *mem2ptr(void *mem) + { return static_cast( + static_cast(mem) + get_metadata_size()); } + + static void *ptr2mem(void *ptr) + { return static_cast( + static_cast(ptr) - get_metadata_size()); } + + static size_t get_alignment() + { return 2*sizeof(size_t); } + + static size_t get_alignment_mask() + { return get_alignment() - 1; } + + static size_t get_metadata_size() + { return 2*sizeof(size_t); } + + static size_t get_smallest_actual_alloc_size() + { return get_metadata_size(); } + + static size_t get_actual_alloc_size(size_t sz) + { return (sz + get_metadata_size() + get_alignment_mask()) & + ~get_alignment_mask(); } + + static size_t get_requested_alloc_size_from_mem(void *mem) + { return *(static_cast(mem)); } + + static size_t get_requested_alloc_size_from_ptr(void *ptr) + { void *mem = ptr2mem(ptr); + return *(static_cast(mem)); } + + static size_t *get_is_allocated_ptr_from_mem(void *mem) + { return reinterpret_cast( + static_cast(mem) + sizeof(size_t)); } + + static size_t *get_is_allocated_ptr_from_ptr(void *ptr) + { void *mem = ptr2mem(ptr); + return reinterpret_cast( + static_cast(mem) + sizeof(size_t)); } + + static bool is_mem_allocated(void *mem) + { return *get_is_allocated_ptr_from_mem(mem) == true; } + + static bool is_ptr_allocated(void *ptr) + { return *get_is_allocated_ptr_from_ptr(ptr) == true; } + + static uint32_t get_next_bin_number(uint32_t bin_number) + { + assert(bin_number && "Non-zero bin number!"); + assert(!(bin_number % get_alignment()) && "Unaligned bin number!"); + return bin_number + get_alignment(); + } + + static bool is_cache_line_aligned(void *p) + { return (reinterpret_cast(p) & + PMallocUtil::get_cache_line_mask()) == + reinterpret_cast(p); } + + static bool is_on_different_cache_line(void *p1, void *p2) + { return (reinterpret_cast(p1) & + PMallocUtil::get_cache_line_mask()) != + (reinterpret_cast(p2) & + PMallocUtil::get_cache_line_mask()); } + + static uint32_t get_bin_number(size_t sz) + { + return (sz < kMaxFreeCategory_) ? + (sz + get_alignment_mask()) & ~get_alignment_mask() : + kMaxFreeCategory_; + } +private: + static uint32_t CacheLineSize_; + static uintptr_t CacheLineMask_; + static thread_local uint32_t TL_CurrArena_[kMaxNumPRegions_]; +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/pregion.hpp b/ARP_CSFR/runtime/src/internal_includes/pregion.hpp new file mode 100644 index 0000000000000000000000000000000000000000..f558cd4afebb94d441dd85657142b55ed65b91f4 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pregion.hpp @@ -0,0 +1,177 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PREGION_HPP +#define PREGION_HPP + +#include +#include + +#include "atlas_api.h" +#include "internal_api.h" + +#include "pmalloc.hpp" +#include "pmalloc_util.hpp" + +namespace Atlas { + +class PRegion { +public: + explicit PRegion(const char *nm, region_id_t rid, void *ba) + : Id_{rid}, BaseAddr_{ba}, IsMapped_{true}, IsDeleted_{false}, + FileDesc_{-1} { + assert(strlen(nm) < kMaxlen_+1); + std::strcpy(Name_, nm); + initArenaAllocAddresses(); + PMallocUtil::set_default_tl_curr_arena(rid); + flushDirtyCacheLines(); + } + ~PRegion() = default; + PRegion(const PRegion&) = delete; + PRegion(PRegion&&) = delete; + PRegion& operator=(const PRegion&) = delete; + PRegion& operator=(PRegion&&) = delete; + + void set_is_mapped(bool im) { IsMapped_ = im; NVM_FLUSH(&IsMapped_); } + void set_is_deleted(bool id) { IsDeleted_ = id; NVM_FLUSH(&IsDeleted_); } + void set_file_desc(int fd) { FileDesc_ = fd; } + + region_id_t get_id() const { return Id_; } + void *get_base_addr() const { return BaseAddr_; } + bool is_mapped() const { return IsMapped_; } + bool is_deleted() const { return IsDeleted_; } + int get_file_desc() const { return FileDesc_; } + const char *get_name() const { return Name_; } + + bool doesRangeCheck(const void *ptr, size_t sz) const + { return ptr >= BaseAddr_ && + (static_cast(ptr) + sz) < + (static_cast(BaseAddr_) + kPRegionSize_); } + + PArena *getArena(uint32_t index) + { assert(index < kNumArenas_); return &Arena_[index]; } + + void *allocMem( + size_t sz, bool does_need_cache_line_alignment, + bool does_need_logging); + void *callocMem(size_t nmemb, size_t sz); + void *reallocMem(void*, size_t); + void freeMem(void *ptr, bool should_log); + + void setRoot(void *new_root) + { + // TODO: This should not be logged for the helper + // thread. This looks like a bogus comment. The helper + // thread does not call setRoot. Check back later. + + // More problems: Though the following may be ok, it + // is better to mfence after the following flush. NVM_STR2 + // may not call flush (for table-based scheme) until later + // and does not call mfence until later. + NVM_STR2(*(static_cast( + PMallocUtil::mem2ptr(BaseAddr_))), + reinterpret_cast(new_root), + sizeof(intptr_t)*8); + full_fence(); + } + + void *getRoot() const + { return reinterpret_cast( + *(static_cast( + PMallocUtil::mem2ptr(BaseAddr_)))); + } + + void *allocRoot() + { + // Must be at a known offset, so bypass regular allocation + assert(kNumArenas_); + return Arena_[0].allocRawMem(sizeof(intptr_t)); + } + + void initArenaTransients() + { + for (uint32_t i = 0; i < kNumArenas_; ++i) + getArena(i)->initTransients(); + } + + void dumpDebugInfo() const; + void printStats(); + +private: + // Region metadata follows. Except for the file descriptor, all of + // them are persistent and must be properly flushed out. + + // If any change to the following layout is made, the flushing + // code may need to change as well. + region_id_t Id_; + void *BaseAddr_; + bool IsMapped_; + bool IsDeleted_; + int FileDesc_; + char Name_[kMaxlen_]; + PArena Arena_[kNumArenas_]; + + void initArenaAllocAddresses(); + void *allocMemFromArenas( + size_t sz, bool should_update_free_list, + bool does_need_cache_line_alignment, bool does_need_logging); + void flushDirtyCacheLines(); +}; + +inline void PRegion::freeMem(void *ptr, bool should_log) +{ + uint32_t arena_index = (reinterpret_cast(ptr) - + reinterpret_cast(BaseAddr_))/kArenaSize_; + getArena(arena_index)->freeMem(ptr, should_log); +} + +inline void PRegion::initArenaAllocAddresses() +{ + for (uint32_t i = 0; i < kNumArenas_; ++i) + getArena(i)->initAllocAddresses( + static_cast(BaseAddr_) + i * kArenaSize_); +} + +/// +/// Used with the debug flag below +/// +inline void PRegion::dumpDebugInfo() const +{ +#if defined(ATLAS_ALLOC_DUMP) + std::cout << Name_ << " " << Id_ << " " << BaseAddr_ << " " << + (IsMapped_ ? "mapped " : "unmapped ") << + (IsDeleted_ ? "deleted " : "valid ") << std::endl; +#endif +} + +/// +/// Used with the stats flag below +/// +inline void PRegion::printStats() +{ +#if defined(ATLAS_ALLOC_STATS) + uint64_t total_alloced = 0; + for (uint32_t i = 0; i < kNumArenas_; ++i) + total_alloced += getArena(i)->get_actual_alloced(); + std::cout << "[Atlas] Total bytes allocated in region " << + Name_ << ":" << total_alloced << std::endl; +#endif +} + +} // namespace Atlas + +#endif + diff --git a/ARP_CSFR/runtime/src/internal_includes/pregion_configs.hpp b/ARP_CSFR/runtime/src/internal_includes/pregion_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..121ebef40166e137888341ef40fa46515cc357d6 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pregion_configs.hpp @@ -0,0 +1,44 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PREGION_CONFIGS_HPP +#define PREGION_CONFIGS_HPP + +namespace Atlas { + +typedef uint32_t region_id_t; + +const uint32_t kDCacheLineSize_ = 64; +const uint32_t kMaxlen_ = kDCacheLineSize_; + +const uint64_t kByte_ = 1024; +#ifdef _NVDIMM_PROLIANT + const uint64_t kPRegionSize_ = 1 * kByte_ * kByte_ * kByte_; /* 1GB */ +#else + const uint64_t kPRegionSize_ = 4 * kByte_ * kByte_ * kByte_; /* 4GB */ +#endif +const uint32_t kMaxNumPRegions_ = 100; +const uint32_t kNumArenas_ = 64; +const uint32_t kArenaSize_ = kPRegionSize_ / kNumArenas_; +const uint32_t kMaxFreeCategory_ = 128; +const uint32_t kInvalidPRegion_ = kMaxNumPRegions_; +const uint32_t kMaxBits_ = 48; +const uint64_t kPRegionsBase_ = + (((uint64_t)1 << (kMaxBits_ - 1)) - (kPRegionSize_ * kMaxNumPRegions_))/2; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/pregion_mgr.hpp b/ARP_CSFR/runtime/src/internal_includes/pregion_mgr.hpp new file mode 100644 index 0000000000000000000000000000000000000000..8db27f724b0143a0e30ba4596d551ac07150be09 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pregion_mgr.hpp @@ -0,0 +1,313 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PREGION_MGR_HPP +#define PREGION_MGR_HPP + +#include +#include +#include +#include + +#include +#include +#include + +#include "pregion_configs.hpp" +#include "pregion_mgr_util.hpp" +#include "pregion.hpp" + +namespace Atlas { + +class PRegionMgr { + static PRegionMgr *Instance_; +public: + // serial mode only + static PRegionMgr& createInstance() { + assert(!Instance_); + Instance_ = new PRegionMgr(); + Instance_->initPRegionTable(); + Instance_->setCacheParams(); + return *Instance_; + } + + // serial mode only + static void deleteInstance() { + if (Instance_) { + Instance_->shutPRegionTable(); + delete Instance_; + Instance_ = nullptr; + } + } + + static PRegionMgr& getInstance() { + assert(Instance_); + return *Instance_; + } + + static bool hasInstance() { return Instance_ != nullptr; } + + region_id_t getOpenPRegionId(const void *addr, size_t sz) const; + + bool isInOpenPRegion(const void *addr, size_t sz) const + { return getOpenPRegionId(addr, sz) != kInvalidPRegion_; } + + PRegion *getPRegion(region_id_t rid) const { + assert(rid < getNumPRegions() && "Region index out of range!"); + return instantiateNewPRegion(rid); + } + + void *allocMem( + size_t sz, region_id_t rid, + bool does_need_cache_line_alignment, bool does_need_logging) const; + void *callocMem(size_t nmemb, size_t sz, region_id_t) const; + void *reallocMem(void*, size_t, region_id_t) const; + void freeMem(void *ptr, bool should_log = true) const; + void deleteMem(void *ptr, bool should_log = true) const; + void freeMemImpl(region_id_t rgn_id, void *ptr, bool should_log) const; + + void *allocMemWithoutLogging(size_t sz, region_id_t rid) const; + void *allocMemCacheLineAligned( + size_t sz, region_id_t rid, bool should_log) const; + + region_id_t findOrCreatePRegion(const char *name, int flags, + int *is_created = nullptr); + region_id_t findPRegion(const char *name, int flags, + bool is_in_recovery = false); + region_id_t createPRegion(const char *name, int flags); + void closePRegion(region_id_t, bool is_deleting = false); + void deletePRegion(const char *name); + void deleteForcefullyPRegion(const char *name); + void deleteForcefullyAllPRegions(); + + void *getPRegionRoot(region_id_t) const; + void setPRegionRoot(region_id_t, void *new_root) const; + + PRegion* searchPRegion(const char *name) const; + + // TODO the following should take the size into consideration + std::pair + ensurePRegionMapped(void *addr); + + void dumpDebugInfo() const; +private: + // PRegionMgr is logically transient + void *PRegionTable_; // pointer to regions metadata + int PRegionTableFD_; // file holding the metadata + pthread_mutex_t PRegionTableLock_; // mediator across threads + std::atomic ExtentMap_; // region extent tracker + + enum OpType { kCreate_, kFind_, kClose_, kDelete_ }; + + PRegionMgr() : PRegionTable_{nullptr}, PRegionTableFD_{-1}, + ExtentMap_{new PRegionExtentMap()} + { pthread_mutex_init(&PRegionTableLock_, NULL); } + + ~PRegionMgr() { delete ExtentMap_.load(std::memory_order_relaxed); } + + PRegionMgr(const PRegionMgr&) = delete; + PRegionMgr(PRegionMgr&&) = delete; + PRegionMgr& operator=(const PRegionMgr&) = delete; + PRegionMgr& operator=(PRegionMgr&&) = delete; + + void acquireTableLock() + { pthread_mutex_lock(&PRegionTableLock_); } + void releaseTableLock() + { pthread_mutex_unlock(&PRegionTableLock_); } + + // Mediates metadata management across processes (advisory locking) + void acquireExclusiveFLock() + { flock(PRegionTableFD_, LOCK_EX); } + void releaseFLock() + { flock(PRegionTableFD_, LOCK_UN); } + + uint32_t getNumPRegions() const + { return *(static_cast(PRegionTable_)); } + + void setNumPRegions(uint32_t); + + void *computePRegionBaseAddr(void *addr) const; + + PRegion *instantiateNewPRegion(region_id_t rid) const { + return reinterpret_cast( + static_cast(PRegionTable_) + + sizeof(uint32_t) + rid * sizeof(PRegion)); + } + + void *computeNewPRegionBaseAddr() const; + + PRegion *getPRegionArrayPtr() const; + + void initPRegionTable(); + void shutPRegionTable(); + + void setCacheParams(); + int getCacheLineSize() const; + + void initPRegionRoot(PRegion*); + + region_id_t initNewPRegionImpl(const char *name, int flags); + region_id_t mapNewPRegion(const char *name, int flags, void *base_addr); + void mapNewPRegionImpl( + PRegion *rgn, const char *name, region_id_t rid, + int flags, void *base_addr); + void initExistingPRegionImpl(PRegion *preg, const char *name, int flags); + void mapExistingPRegion(PRegion *preg, const char *name, int flags); + int mapFile(const char *name, int flags, void *base_addr, bool does_exist); + + void deleteForcefullyPRegion(PRegion*); + + void insertExtent(void *first_addr, void *last_addr, region_id_t rid); + void deleteExtent(void *first_addr, void *last_addr, region_id_t rid); + + void tracePRegion(region_id_t, OpType) const; + void statsPRegion(region_id_t) const; +}; + +inline void *PRegionMgr::allocMem( + size_t sz, region_id_t rid, bool does_need_cache_line_alignment, + bool does_need_logging) const +{ + return getPRegion(rid)->allocMem( + sz, does_need_cache_line_alignment, does_need_logging); +} + +inline void *PRegionMgr::callocMem( + size_t nmemb, size_t sz, region_id_t rid) const +{ + return getPRegion(rid)->callocMem(nmemb, sz); +} + +inline void *PRegionMgr::reallocMem( + void *ptr, size_t sz, region_id_t rid) const +{ + return getPRegion(rid)->reallocMem(ptr, sz); +} + +inline void *PRegionMgr::allocMemWithoutLogging( + size_t sz, region_id_t rid) const +{ + bool does_need_cache_line_alignment = false; + bool does_need_logging = false; + + return allocMem( + sz, rid, does_need_cache_line_alignment, does_need_logging); +} + +inline void *PRegionMgr::allocMemCacheLineAligned( + size_t sz, region_id_t rid, bool should_log) const +{ + bool does_need_cache_line_alignment = true; + return allocMem( + sz, rid, does_need_cache_line_alignment, should_log); +} + +inline PRegion *PRegionMgr::getPRegionArrayPtr() const +{ + return reinterpret_cast( + static_cast(PRegionTable_) + sizeof(uint32_t)); +} + +inline void *PRegionMgr::getPRegionRoot(region_id_t rid) const +{ + return getPRegion(rid)->getRoot(); +} + +/// +/// Given an address, return the base address of the corresponding +/// persistent region +/// +inline void *PRegionMgr::computePRegionBaseAddr(void *addr) const +{ + assert(addr >= (static_cast(PRegionTable_) + kPRegionSize_) && + addr < (static_cast(PRegionTable_) + + kPRegionSize_ * (kMaxNumPRegions_ + 1)) && + "Location not in any persistent region!"); + return static_cast(PRegionTable_) + kPRegionSize_ * + ((reinterpret_cast(addr) - + reinterpret_cast(PRegionTable_))/kPRegionSize_); +} + +/// +/// Compute the base address of the next new persistent region +/// +inline void *PRegionMgr::computeNewPRegionBaseAddr() const +{ + uint32_t num_regions = getNumPRegions(); + if (!num_regions) return (char*)kPRegionsBase_ + kPRegionSize_; + else return static_cast( + reinterpret_cast( + reinterpret_cast(getPRegionArrayPtr()) + + (num_regions - 1) * sizeof(PRegion))-> + get_base_addr()) + kPRegionSize_; +} + +/// +/// Used with the debug flag below +/// +/// Serial mode only or if appropriate locks are held +/// +inline void PRegionMgr::dumpDebugInfo() const +{ +#if defined(ATLAS_ALLOC_DUMP) + assert(Instance_ && "Region manager does not exist!"); + std::cout << "------- Start of region information -------" << std::endl; + std::cout << "Region table base: " << PRegionTable_ << std::endl; + PRegion *pregion_arr_ptr = getPRegionArrayPtr(); + uint32_t curr = 0; + for (; curr < getNumPRegions(); ++curr, ++pregion_arr_ptr) + pregion_arr_ptr->dumpDebugInfo(); + std::cout << "------- End of region information -------" << std::endl; +#endif +} + +/// +/// Used with the trace flag below +/// +/// Serial mode only or if appropriate locks are held +/// +inline void PRegionMgr::tracePRegion(region_id_t rid, OpType op) const +{ +#if defined(ATLAS_ALLOC_TRACE) + PRegion *rgn = getPRegion(rid); + std::cout << "[Atlas] " << + (op == kCreate_ ? "Created " : + op == kFind_ ? "Found " : + op == kClose_ ? "Closed " : + op == kDelete_ ? "Deleted " : + "Unknown") + << "region with name=" << rgn->get_name() + << " id " << rgn->get_id() << " address " << rgn->get_base_addr() + << std::endl; +#endif +} + +/// +/// Used with the stats flag below +/// +/// Serial mode only or if appropriate locks are held +/// +inline void PRegionMgr::statsPRegion(region_id_t rid) const +{ +#if defined(ATLAS_ALLOC_STATS) + getPRegion(rid)->printStats(); +#endif +} + + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/pregion_mgr_util.hpp b/ARP_CSFR/runtime/src/internal_includes/pregion_mgr_util.hpp new file mode 100644 index 0000000000000000000000000000000000000000..d2593c191748abe6d39bbb791394a19056bc3a02 --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/pregion_mgr_util.hpp @@ -0,0 +1,71 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef PREGION_MGR_UTIL_HPP +#define PREGION_MGR_UTIL_HPP + +#include +#include + +#include "pregion_configs.hpp" + +namespace Atlas { + +class PRegionExtentMap { +public: + typedef std::pair IntPtrPair; + class CmpIntPtr { + public: + bool operator()( + const IntPtrPair & c1, const IntPtrPair & c2) const { + return (c1.first < c2.first) && + (c1.second < c2.second); + } + }; + typedef std::map MapInterval; + + PRegionExtentMap() = default; + PRegionExtentMap(const PRegionExtentMap& from) { + MapInterval::const_iterator ci_end = from.Extents_.end(); + for (MapInterval::const_iterator ci = + from.Extents_.begin(); ci != ci_end; ++ ci) + insertExtent(ci->first.first, ci->first.second, ci->second); + } + + void insertExtent(intptr_t first, intptr_t last, uint32_t id) + { Extents_[std::make_pair(first,last)] = id; } + + void deleteExtent(intptr_t first, intptr_t last, uint32_t id) { + MapInterval::iterator ci = Extents_.find( + std::make_pair(first,last)); + if (ci != Extents_.end()) Extents_.erase(ci); + } + + uint32_t findExtent(intptr_t first, intptr_t last) const { + MapInterval::const_iterator ci = Extents_.find( + std::make_pair(first,last)); + if (ci != Extents_.end()) return ci->second; + return kInvalidPRegion_; + } +private: + MapInterval Extents_; +}; + +} // namespace Atlas + +#endif + + diff --git a/ARP_CSFR/runtime/src/internal_includes/stats.hpp b/ARP_CSFR/runtime/src/internal_includes/stats.hpp new file mode 100644 index 0000000000000000000000000000000000000000..30099b1b8cbf7d47a866a0d07eb5e02212e05e8c --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/stats.hpp @@ -0,0 +1,106 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef STATS_HPP +#define STATS_HPP + +#include +#include + +#include +#include + +namespace Atlas { + +class Stats { + static Stats *Instance_; +public: + + static Stats& createInstance() { + assert(!Instance_); + Instance_ = new Stats(); + return *Instance_; + } + + static void deleteInstance() { + assert(Instance_); + delete Instance_; + Instance_ = nullptr; + } + + static Stats& getInstance() { + assert(Instance_); + return *Instance_; + } + + void acquireLock() + { int status = pthread_mutex_lock(&Lock_); assert(!status); } + void releaseLock() + { int status = pthread_mutex_unlock(&Lock_); assert(!status); } + + void incrementCriticalSectionCount() + { ++TL_CriticalSectionCount; } + void incrementNestedCriticalSectionCount() + { ++TL_NestedCriticalSectionCount; } + void incrementLoggedStoreCount() + { ++TL_LoggedStoreCount; } + void incrementCriticalLoggedStoreCount() + { ++TL_CriticalLoggedStoreCount; } + void incrementUnloggedStoreCount() + { ++TL_UnloggedStoreCount; } + void incrementLogElisionFailCount() + { ++TL_LogElisionFailCount; } + void incrementUnloggedCriticalStoreCount() + { ++TL_UnloggedCriticalStoreCount; } + void incrementLogMemUse(size_t sz) + { TL_LogMemUse += sz; } + + void print(); + +private: + pthread_mutex_t Lock_; + + // Computed as the number of lock acquires + thread_local static uint64_t TL_CriticalSectionCount; + + // Given a lock acquire operation, if there is a lock already held + thread_local static uint64_t TL_NestedCriticalSectionCount; + + // Total number of writes logged (memset/memcpy, etc. counted as 1) + thread_local static uint64_t TL_LoggedStoreCount; + + // Total number of writes encountered within critical sections + thread_local static uint64_t TL_CriticalLoggedStoreCount; + + // Total number of writes not logged + thread_local static uint64_t TL_UnloggedStoreCount; + + // Total number of writes for which log elision failed + thread_local static uint64_t TL_LogElisionFailCount; + + // Total number of writes not logged within critical sections + thread_local static uint64_t TL_UnloggedCriticalStoreCount; + + // Total memory used by the program log + thread_local static uint64_t TL_LogMemUse; + + // Total number of CPU cache flushes for logging + thread_local static uint64_t TL_NumLogFlushes; +}; + +} // namespace Atlas + +#endif diff --git a/ARP_CSFR/runtime/src/internal_includes/util.hpp b/ARP_CSFR/runtime/src/internal_includes/util.hpp new file mode 100644 index 0000000000000000000000000000000000000000..ac346cca1266452c64b0409427b7bd9068be7c6c --- /dev/null +++ b/ARP_CSFR/runtime/src/internal_includes/util.hpp @@ -0,0 +1,134 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef _UTIL_H +#define _UTIL_H + +#include +#include +#include +#include +#include + +typedef std::pair UInt64Pair; +class CmpUInt64 +{ +public: + bool operator()(const UInt64Pair & c1, const UInt64Pair & c2) const + { + return (c1.first < c2.first) && (c1.second < c2.second); + } +}; +typedef std::map MapInterval; + +typedef std::pair AddrSizePairType; +class CmpAddrSizePair +{ +public: + bool operator()(const AddrSizePairType & c1, const AddrSizePairType & c2) const + { + if ((uintptr_t)c1.first < (uintptr_t)c2.first) return true; + if ((uintptr_t)c1.first > (uintptr_t)c2.first) return false; + if (c1.second < c2.second) return true; + return false; + } +}; +typedef std::set SetOfPairs; + +// This is not thread safe. Currently ok to call from recovery code but +// not from anywhere else. +inline void InsertToMapInterval( + MapInterval *m, uint64_t e1, uint64_t e2, uint32_t e3) +{ + (*m)[std::make_pair(e1,e2)] = e3; +} + +// This can be called from anywhere. +inline MapInterval::const_iterator FindInMapInterval( + const MapInterval & m, const uint64_t e1, const uint64_t e2) +{ + return m.find(std::make_pair(e1, e2)); +} + +inline void InsertSetOfPairs(SetOfPairs *setp, void *addr, size_t sz) +{ + (*setp).insert(std::make_pair(addr, sz)); +} + +inline SetOfPairs::const_iterator FindSetOfPairs( + const SetOfPairs & setp, void *addr, size_t sz) +{ + return setp.find(std::make_pair(addr, sz)); +} + +typedef std::set SetOfInts; + +template +class ElemInfo +{ +public: + ElemInfo(void *addr, const ElemType & elem) + { Addr_ = addr; Elem_ = new ElemType(elem); Next_ = 0; } +private: + void *Addr_; + std::atomic Elem_; + ElemInfo *Next_; +}; + +template +class SimpleHashTable +{ +public: + SimpleHashTable(uint32_t size=0) + { + if (size) Size_ = size; + Tab_ = new std::atomic*> [Size_]; + memset((void*)Tab_, 0, Size_*sizeof(std::atomic*>)); + } + void Insert(void*, const ElemType &); + ElemInfo *Find(void*); +private: + std::atomic*> *Tab_; + static uint32_t Size_; + + std::atomic*> *GetTableEntry(void *addr) + { return (Tab_ + (((uintptr_t(addr)+128) >> 3) & (Size_-1))); } + + ElemInfo *GetElemInfoHeader(void *addr) + { + std::atomic*> *entry = GetTableEntry(addr); + return (*entry).load(std::memory_order_acquire); + } + std::atomic*> *GetPointerToElemInfoHeader(void *addr) + { + return GetTableEntry(addr); + } +}; + +char *NVM_GetRegionTablePath(); +char *NVM_GetUserDir(); +char *NVM_GetLogDir(); +void NVM_CreateUserDir(); +void NVM_CreateLogDir(); +char *NVM_GetFullyQualifiedRegionName(const char *name); + +// Derive the log name from the program name for the running process +char *NVM_GetLogRegionName(); +char *NVM_GetLogRegionName(const char *prog_name); +bool NVM_doesLogExist(const char *log_path_name); +void NVM_qualifyPathName(char *s, const char *name); + +#endif diff --git a/runtime/src/logger/CMakeLists.txt b/ARP_CSFR/runtime/src/logger/CMakeLists.txt similarity index 100% rename from runtime/src/logger/CMakeLists.txt rename to ARP_CSFR/runtime/src/logger/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/logger/circular_buffer.cpp b/ARP_CSFR/runtime/src/logger/circular_buffer.cpp new file mode 100644 index 0000000000000000000000000000000000000000..de442a9351fade910dd3723f10889afaaf78201a --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/circular_buffer.cpp @@ -0,0 +1,142 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include + +#include "log_mgr.hpp" + +namespace Atlas { + +LogEntry *LogMgr::allocLogEntry() +{ + // note that ctor may not be called +#if defined(_LOG_WITH_MALLOC) + return (LogEntry *) malloc(sizeof(LogEntry)); +#elif defined(_LOG_WITH_NVM_ALLOC) + return (LogEntry *) Atlas::PRegionMgr::getInstance().allocMemWithoutLogging( + sizeof(LogEntry), RegionId_); +#else + LogEntry *le = getNewSlot(RegionId_, &TL_CbLog_, &CbLogList_); + assertOneCacheLine(le); + return le; +#endif +} + +// This function is called when the caller needs a new circular buffer +template +CbLog *LogMgr::getNewCb(uint32_t size, uint32_t rid, CbLog **log_p, + std::atomic*> *cb_list_p) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // The data structures used in managing the circular buffer need + // not be in persistent memory. After program termination, the + // circular buffer metadata is not used. During normal termination, + // the log file is deleted automatically releasing all the + // resources for the remaining log entries. In the case of + // abnormal program termination, the recovery phase never needs + // these management data structures and the log file is again + // deleted after successful recovery. The helper thread would free + // a circular buffer if it is empty but that does not require + // persistence. + + if (*log_p) (*log_p)->isFilled.store(true, std::memory_order_release); + + // Search through the list of cbl_nodes looking for one that is + // available and is owned by this thread. If found, set isAvailable + // to false, isfilled to false, and return it. + CbListNode *curr_search = (*cb_list_p).load(std::memory_order_acquire); + while (curr_search) + { + if (curr_search->isAvailable.load(std::memory_order_acquire) && + pthread_equal(curr_search->Tid, pthread_self())) + { + assert(curr_search->Cb); + assert(curr_search->Cb->isFilled.load(std::memory_order_acquire)); + + *log_p = curr_search->Cb; + + curr_search->Cb->isFilled.store(false, std::memory_order_relaxed); + curr_search->Cb->Start.store(0, std::memory_order_relaxed); + curr_search->Cb->End.store(0, std::memory_order_relaxed); + + curr_search->isAvailable.store(false, std::memory_order_release); + + return curr_search->Cb; + } + curr_search = curr_search->Next; + } + + uint32_t is_filled, start_cb, end_cb; + is_filled = start_cb = end_cb = 0; + + CbLog *cb = new CbLog(size+1, is_filled, start_cb, end_cb); + + cb->LogArray = (T*)PRegionMgr::getInstance().allocMemCacheLineAligned( + cb->Size*sizeof(T), RegionId_, false); + +#ifdef NVM_STATS + Stats_->incrementLogMemUse(cb->Size*sizeof(T)); +#endif + + *log_p = cb; + + // New cbl_node must be inserted at the head + CbListNode *cbl_node = new CbListNode( + cb, + (char*)(cb->LogArray), + (char*)(cb->LogArray) + cb->Size*sizeof(T) - 1); + + CbListNode *first_p = (*cb_list_p).load(std::memory_order_acquire); + do { + cbl_node->Next = first_p; + }while (!cb_list_p->compare_exchange_weak( + first_p, cbl_node, + std::memory_order_acq_rel, std::memory_order_relaxed)); + + return cb; +} + +// A user thread is the only entity that adds a CB slot +// The helper thread is the only entity that deletes a CB slot +template +inline T *LogMgr::getNewSlot(uint32_t rid, CbLog **log_p, + std::atomic*> *cb_list_p) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!*log_p || (*log_p)->isFull()) + getNewCb(kCircularBufferSize, rid, log_p, cb_list_p); + + ++ TL_LogCounter_; + if (TL_LogCounter_ % kCircularBufferSize == 0) ++TL_GenNum_; + + T *r = &((*log_p)->LogArray[(*log_p)->End.load( + std::memory_order_consume)]); + (*log_p)->End.store( + (((*log_p)->End).load(std::memory_order_acquire)+1) & + ((*log_p)->Size-1), + std::memory_order_release); + + return r; +} + +} // namespace Atlas + + diff --git a/ARP_CSFR/runtime/src/logger/happens_before.cpp b/ARP_CSFR/runtime/src/logger/happens_before.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2811fbf510df6769d4bd73f83ec84b0e2a13da3f --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/happens_before.cpp @@ -0,0 +1,191 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include + +#include "log_mgr.hpp" +#include "log_structure.hpp" +#include "happens_before.hpp" + +namespace Atlas { + +LastReleaseInfo *LogMgr::findLastReleaseOfLock(void *hash_address) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LastReleaseInfo *oip = getLastReleaseHeader(hash_address); + while (oip) { + ImmutableInfo *ii = oip->Immutable.load(std::memory_order_acquire); + assert(ii); + if (ii->IsDeleted) { + oip = oip->Next; + continue; + } + LogEntry *le = ii->LogAddr; + assert(le); + assert(le->isRelease() || le->isRWLockUnlock() || le->isFree()); + if ((le->isFree() && !hash_address) || le->Addr == hash_address) + return oip; + oip = oip->Next; + } + return nullptr; +} + +LastReleaseInfo *LogMgr::findLastReleaseOfLogEntry(LogEntry *candidate_le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LastReleaseInfo *oip = getLastReleaseHeader(candidate_le->Addr); + while (oip) { + ImmutableInfo *ii = oip->Immutable.load(std::memory_order_acquire); + assert(ii); + if (ii->IsDeleted) { + oip = oip->Next; + continue; + } + LogEntry *le = ii->LogAddr; + assert(le); + // TODO free not handled? + assert(le->isRelease() || le->isRWLockUnlock() || le->isFree()); + if (le->Addr != candidate_le->Addr) { + oip = oip->Next; + continue; + } + else if (le == candidate_le) return oip; + else return nullptr; + } + return nullptr; +} + +void LogMgr::addLogToLastReleaseInfo(LogEntry *le, + const MapOfLockInfo& undo_locks) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(le->isRelease() || le->isRWLockUnlock() || le->isFree()); + + void *hash_addr = le->isFree() ? NULL : le->Addr; + bool done = false; + while (!done) { + LastReleaseInfo *oi = findLastReleaseOfLock(hash_addr); + + // TODO: Does reusing a deleted entry help in any way? + if (oi) { + ImmutableInfo *new_ii = + createNewImmutableInfo(le, undo_locks, false); + ImmutableInfo *curr_ii; + do { + curr_ii = oi->Immutable.load(std::memory_order_acquire); + + // Even if it was found earlier, it may have been deleted + // by the helper thread since then. So need to find again. + oi = findLastReleaseOfLock(hash_addr); + if (!oi) break; + }while (!oi->Immutable.compare_exchange_weak( + curr_ii, new_ii, + std::memory_order_acq_rel, std::memory_order_relaxed)); + + // It is ok to delete the old map since any read/write of the + // map can be done only while holding a lock + if (oi) { + assert(!oi->Immutable.load(std::memory_order_relaxed)->IsDeleted); + done = true; + delete curr_ii->LockInfoPtr; + } + } + else { + // TODO + // This is a bug in a certain way for rwlock. For rwlock, we + // need to call FindOwnerInfo here again (or within a CAS-loop). + // Otherwise, two entries for the same lock within the hash table + // may exist which may or may not create problems. + LastReleaseInfo *new_entry = createNewLastReleaseInfo(le, undo_locks); + LastReleaseInfo *first_oip; + do { + first_oip = getLastReleaseHeader(hash_addr); + // Insertion at the head + new_entry->Next = first_oip; + }while (!getLastReleaseRoot(hash_addr)->compare_exchange_weak( + first_oip, new_entry, + std::memory_order_acq_rel, std::memory_order_relaxed)); + done = true; + } + } +} + +void LogMgr::deleteOwnerInfo(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(le->isRelease() || le->isRWLockUnlock() || le->isFree()); + + // An owner info may not be found since the one that existed before + // for this log entry may have been overwritten by one of the user + // threads. + LastReleaseInfo *oi = findLastReleaseOfLogEntry(le); + if (oi) { + ImmutableInfo *curr_ii = oi->Immutable.load(std::memory_order_acquire); + ImmutableInfo *new_ii = createNewImmutableInfo( + curr_ii->LogAddr, *curr_ii->LockInfoPtr, true); + bool succeeded = oi->Immutable.compare_exchange_weak( + curr_ii, new_ii, std::memory_order_acq_rel, + std::memory_order_relaxed); + if (succeeded) delete curr_ii->LockInfoPtr; + } +} + +ImmutableInfo *LogMgr::createNewImmutableInfo( + LogEntry *le, const MapOfLockInfo & undo_locks, bool is_deleted) +{ + return new ImmutableInfo(le, new MapOfLockInfo(undo_locks), is_deleted); +} + +LastReleaseInfo *LogMgr::createNewLastReleaseInfo( + LogEntry *le, const MapOfLockInfo & undo_locks) +{ + return new LastReleaseInfo(createNewImmutableInfo(le, undo_locks, false)); +} + +void LogMgr::setHappensBeforeForAllocFree(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Happens-after from free -> free and malloc -> free may be set up. + // For a free (source) -> free (target) relation, the source generation + // number is already set at this point. But this routine re-sets it to + // that of the target. We argue that this is not a problem. First, note + // that the source and target log entries will have different address. If + // subsequently a malloc (m) log entry leads to another happens-after + // relation such that m -> free (source) -> free (target) and then + // the target node is deleted, the HA-link from node m will not be + // nullified since the target and source log entries will not match. + LastReleaseInfo *oi = Atlas::LogMgr::getInstance().findLastReleaseOfLock(NULL); + if (oi) + { + ImmutableInfo *ii = oi->Immutable.load(std::memory_order_acquire); + le->ValueOrPtr = reinterpret_cast(ii->LogAddr); + + assert(reinterpret_cast(le->ValueOrPtr)->isFree()); + le->Size = reinterpret_cast(le->ValueOrPtr)->Size; + } +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/logger/log_elision.cpp b/ARP_CSFR/runtime/src/logger/log_elision.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e827260bef288f696c0f1050cd2abcd7683fb2bc --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/log_elision.cpp @@ -0,0 +1,196 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include + +#include "log_mgr.hpp" + +namespace Atlas { + +void LogMgr::addLockReleaseCount(void *lock_address, uint64_t count) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LockReleaseCount *lc = findLockReleaseCount(lock_address); + if (lc) lc->Count.store(count, std::memory_order_release); + else { + LockReleaseCount *new_entry = + new LockReleaseCount(lock_address, count); + LockReleaseCount *first_lcp; + do { + first_lcp = getLockReleaseCountHeader(lock_address); + new_entry->Next = first_lcp; + }while (!getLockReleaseCountRoot(lock_address)-> + compare_exchange_weak( + first_lcp, new_entry, + std::memory_order_acq_rel, std::memory_order_relaxed)); + } +} + +LockReleaseCount *LogMgr::findLockReleaseCount(void *lock_address) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LockReleaseCount *lcp = getLockReleaseCountHeader(lock_address); + while (lcp) { + if (lcp->LockAddr == lock_address) return lcp; + lcp = lcp->Next; + } + return nullptr; +} + +uint64_t LogMgr::removeLockFromUndoInfo(void *lock_address) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(TL_UndoLocks_); + MapOfLockInfo::iterator ci = TL_UndoLocks_->find(lock_address); + assert(ci != TL_UndoLocks_->end()); + uint64_t lock_count = ci->second; + TL_UndoLocks_->erase(ci); + return lock_count; +} + +bool LogMgr::canElideLogging() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // if the thread-local table of undo locks is not yet created, it + // means that critical sections haven't been executed by this thread + // yet. So nothing needs to be undone. + if (!TL_UndoLocks_) return true; + + typedef std::vector ItrVec; + ItrVec itr_vec; + bool ret = true; + MapOfLockInfo::iterator ci_end = TL_UndoLocks_->end(); + for (MapOfLockInfo::iterator ci = TL_UndoLocks_->begin(); + ci != ci_end; ++ ci) { + void *lock_address = ci->first; + uint64_t lock_count = ci->second; + LockReleaseCount *lc = findLockReleaseCount(lock_address); + assert(lc); + if (lc->Count.load(std::memory_order_acquire) <= lock_count) { + ret = false; + continue; + } + itr_vec.push_back(ci); + } + ItrVec::iterator itr_ci_end = itr_vec.end(); + for (ItrVec::iterator itr_ci = itr_vec.begin(); + itr_ci != itr_ci_end; ++ itr_ci) + TL_UndoLocks_->erase(*itr_ci); + return ret; +} + +bool LogMgr::isAddrSizePairAlreadySeen(void *addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(TL_UniqueLoc_); + if (FindSetOfPairs(*TL_UniqueLoc_, addr, sz) != TL_UniqueLoc_->end()) + return true; + InsertSetOfPairs(TL_UniqueLoc_, addr, sz); + return false; +} + +bool LogMgr::doesNeedLogging(void *addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#if defined(_ALWAYS_LOG) + return true; +#endif + + // if inside a consistent section, logging can be elided if this + // address/size pair has been seen before in this section + if (TL_NumHeldLocks_ > 0) { + // TODO more evaluation of the following +#ifdef _OPT_UNIQ_LOC + if (isAddrSizePairAlreadySeen(addr, sz)) { +#ifdef NVM_STATS + Stats_->incrementUnloggedCriticalSectionStoreCount(); +#endif + return false; + } +#endif + return true; + } + // If we are here, it means that this write is outside a critical section +#if defined(_SRRF) || defined(_NO_NEST) + return false; +#endif + + if (TL_IsFirstNonCSStmt_) { + // Since we end a failure-atomic section at the end of a critical + // section, this is also the first statement of the failure- + // atomic section. Hence, this address/size pair couldn't have + // been seen earlier. + + TL_ShouldLogNonCSStmt_ = !canElideLogging(); + TL_IsFirstNonCSStmt_ = false; + return TL_ShouldLogNonCSStmt_; + } + else { +#ifdef _OPT_UNIQ_LOC + if (TL_ShouldLogNonCSStmt_) + if (isAddrSizePairAlreadySeen(addr, sz)) + return false; +#endif + return TL_ShouldLogNonCSStmt_; + } + return true; +} + +bool LogMgr::tryLogElision(void *addr, size_t sz) +{ + // TODO warn for the following scenario: + // If the region table does not exist when we reach here, it means + // that the compiler instrumented an access that is executed before + // the region table is initialized. This can happen in legal situations + // if the compiler cannot prove that this access is to a transient + // memory location. But it can also happen if this is a synchronization + // operation. In both these cases, it is ok not to log this operation. + // But it could also be the result of incorrect programming where the + // user specifies a non-existent persistent region or something like + // that. So it is a good idea to warn. +// if (!region_table_addr) return true; + + // TODO be consistent with the defines +#if defined(_FLUSH_LOCAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + assert(TL_FaseFlushPtr_); + collectCacheLines(TL_FaseFlushPtr_, addr, sz); +#endif +// if (!doesNeedLogging(addr, sz)) { +//#ifdef NVM_STATS +// Stats_->incrementUnloggedStoreCount(); +//#endif +// return true; +// } +#ifdef NVM_STATS + if (!TL_NumHeldLocks_) Stats_->incrementLogElisionFailCount(); +#endif + return false; +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/logger/log_entry_create.cpp b/ARP_CSFR/runtime/src/logger/log_entry_create.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4a43a50cb1798431e899d3fd543c8ae61e8a16a9 --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/log_entry_create.cpp @@ -0,0 +1,244 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" +#include "log_structure.hpp" +#include "happens_before.hpp" + +namespace Atlas { + +/// +/// @brief Given a (non-populated) log entry in persistent memory, +/// populate it using non-temporal stores +/// @param le Pointer to allocated log entry to be populated +/// @param addr Address of memory location or lock +/// @param le_type Type of access to be logged +/// +#if defined(_USE_MOVNT) +void LogMgr::logNonTemporal( + LogEntry *le, void *addr, size_t sz, LogType le_type) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uintptr_t le_val_or_ptr = 0; + LogEntry *le_next = nullptr; + LogEntry le_nt(addr, le_val_or_ptr, le_next, sz, le_type); + + if (isStr(le_type)) + memcpy(static_cast(&le_nt.ValueOrPtr), addr, sz/8); + else if (isMemop(le_type) || isStrop(le_type)) { + le_nt.ValueOrPtr = + reinterpret_cast( + PRegionMgr::getInstance().allocMemWithoutLogging( + sz, RegionId_)); + assert(le_nt.ValueOrPtr); + // TODO mov_nt here + memcpy((void*)le_nt.ValueOrPtr, addr, sz); + } + else assert(isDummy(le_type) || isAlloc(le_type) || isFree(le_type) || + isStartSection(le_type) || isEndSection(le_type)); + + long long unsigned int *from = + reinterpret_cast(&le_nt); + long long unsigned int *to = + reinterpret_cast(le); + uint32_t i; + assert(sizeof(le_nt) % 8 == 0); + for (i=0; i < sizeof(le_nt)/8; ++i) + __builtin_ia32_movntq( + (__attribute__((__vector_size__(1*sizeof(long long)))) long long*) + (to+i), + (__attribute__((__vector_size__(1*sizeof(long long)))) long long) + *(from+i)); +#if !defined(_NO_SFENCE) + __builtin_ia32_sfence(); +#endif +} +#endif + +/// +/// @brief Create a log entry for +/// lock-acquire/lock-release/begin_durable/end_durable +/// @param le address of lock (NULL for begin/end-durable) +/// @param le_type Type of access to be logged +/// @retval Pointer to created log entry +/// +LogEntry *LogMgr::createSectionLogEntry(void *lock_address, LogType le_type) +{ + assert(le_type == LE_acquire || le_type == LE_release || + le_type == LE_begin_durable || le_type == LE_end_durable || + le_type == LE_rwlock_rdlock || le_type == LE_rwlock_wrlock || + le_type == LE_rwlock_unlock); + + LogEntry *le = allocLogEntry(); + assert(le); + +#if defined(_USE_MOVNT) + logNonTemporal(le, lock_address, 0, le_type); +#else + // The generation number is currently set for release log entries only. + uintptr_t le_val_or_ptr = 0 /* initial value */; + LogEntry *le_next = nullptr; /* initial value */ + new (le) LogEntry( + lock_address, le_val_or_ptr, le_next, + isRelease(le_type) ? TL_GenNum_ : sizeof(uintptr_t) /* ignored */, + le_type); +#endif + return le; +} + +/// +/// @brief Create log entry for allocation/deallocation. The address +/// corresponds to that of the isAllocated bit +/// @param addr Address of memory location to be logged +/// @param le_type Type of access to be logged +/// @retval Pointer to created log entry +/// +LogEntry *LogMgr::createAllocationLogEntry(void *addr, LogType le_type) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(le_type == LE_alloc || le_type == LE_free); + + LogEntry *le = allocLogEntry(); + assert(le); + + // The ValueOrPtr field stores the address of the happens-before + // log entry instead of the last value of the isAllocated bit. The + // last value is known depending on the type of the log entry. + // The recovery phase is cognizant of this aspect. + uintptr_t le_val_or_ptr = 0 /* initial value */; + LogEntry *le_next = nullptr; /* initial value */ + new (le) LogEntry(addr, le_val_or_ptr, le_next, + isFree(le_type) ? TL_GenNum_ : sizeof(size_t), + le_type); + return le; +} + +/// +/// @brief Create log entry for the store instruction +/// @param addr Address of memory location stored into +/// @param size_in_bits Size (in bits) of the location stored into +/// @retval Pointer to created log entry +/// +LogEntry *LogMgr::createStrLogEntry(void *addr, size_t size_in_bits) +{ + assert(size_in_bits <= 8*sizeof(uintptr_t)); + assert(!(size_in_bits % 8)); + + LogEntry *le = allocLogEntry(); + assert(le); + +#if defined(_USE_MOVNT) + logNonTemporal(le, addr, size_in_bits, LE_str); +#else + uintptr_t le_val_or_ptr = 0 /* initial value */; + LogEntry *le_next = nullptr; /* initial value */ + new (le) LogEntry(addr, le_val_or_ptr, le_next, size_in_bits, LE_str); + memcpy(reinterpret_cast(&le->ValueOrPtr), addr, size_in_bits/8); +#endif + return le; +} + +/// +/// @brief Create log entry for memop/strop instructions +/// @param addr Address of target memory location +/// @param sz Size of operation +/// @param le_type Type of operation +/// @retval Pointer to created log entry +/// +LogEntry *LogMgr::createMemStrLogEntry(void *addr, size_t sz, LogType le_type) +{ + assert(le_type == LE_memset || le_type == LE_memcpy || + le_type == LE_memmove || + le_type == LE_strcpy || le_type == LE_strcat); + + LogEntry *le = allocLogEntry(); + assert(le); + +#if defined(_USE_MOVNT) + logNonTemporal(le, addr, sz, le_type); +#else + uintptr_t le_val_or_ptr = 0 /* ignored */; + LogEntry *le_next = nullptr; /* initial value */ + new (le) LogEntry(addr, le_val_or_ptr, le_next, sz, le_type); + + // For a memop/strop, ValueOrPtr is a pointer to the sequence of + // old values +#if defined(_LOG_WITH_MALLOC) + le->ValueOrPtr = (intptr_t)(char *) malloc(sz); +#else +//#elif defined(_LOG_WITH_NVM_ALLOC) // no special casing required + le->ValueOrPtr = + reinterpret_cast( + PRegionMgr::getInstance().allocMemWithoutLogging(sz, RegionId_)); +#endif + assert(le->ValueOrPtr); + memcpy(reinterpret_cast(le->ValueOrPtr), addr, sz); + NVM_PSYNC(reinterpret_cast(le->ValueOrPtr), sz); +#endif + return le; +} + +/// +/// @brief Create a dummy log entry +/// @retval Pointer to created log entry +/// +LogEntry *LogMgr::createDummyLogEntry() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogEntry *le = allocLogEntry(); + assert(le); + +#if defined(_USE_MOVNT) + logNonTemporal(le, 0, 0, LE_dummy); +#else + memset(le, 0, sizeof(LogEntry)); + le->Type = LE_dummy; +#endif + return le; +} + +/// +/// @brief Create a thread specific log header +/// @param le First log entry for this thread +/// @retval Pointer to the log header created +/// +/// The following is called by the helper thread alone (today). +/// +LogStructure *LogMgr::createLogStructure(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogStructure *lsp = static_cast( + PRegionMgr::getInstance().allocMemWithoutLogging( + sizeof(LogStructure), RegionId_)); + assert(lsp); + + new (lsp) LogStructure(le, nullptr); + + // Because of 16-byte alignment of all allocated memory on NVRAM, the above + // two fields will always be on the same cache line + flushLogUncond(lsp); + return lsp; +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/logger/log_entry_publish.cpp b/ARP_CSFR/runtime/src/logger/log_entry_publish.cpp new file mode 100644 index 0000000000000000000000000000000000000000..89b3b4f1c25eb4ba6ed30e5652ab3c413e112626 --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/log_entry_publish.cpp @@ -0,0 +1,253 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" +#include "log_structure.hpp" +#include "happens_before.hpp" + +#include "atlas_alloc.h" + +namespace Atlas { + + +void LogMgr::pruneLogEntries() +{ + if(!TL_LogStructure_) return; + + LogEntry* le = TL_LogStructure_->Le; + LogEntry* leNext; + TL_LogStructure_->Le = nullptr; +// TL_FirstLogEntry_->Next.store(nullptr,std::memory_order_release); + static CbListNode *last_cb_used = 0; + while(le) { + leNext = le->Next.load(std::memory_order_acquire); + #if defined(_LOG_WITH_MALLOC) + if (le->isMemop() || le->isStrop()) + free((void*)le->ValueOrPtr); + free(le); + #elif defined(_LOG_WITH_NVM_ALLOC) + if (le->isMemop() || le->isStrop()) + PRegionMgr::getInstance().freeMem((void*)le->ValueOrPtr, true); + PRegionMgr::getInstance().freeMem(le,true); + #else + if (le->isMemop() || le->isStrop()) + PRegionMgr::getInstance().freeMem((void*)le->ValueOrPtr, true); + LogMgr::getInstance().deleteEntry(le,last_cb_used); + #endif + le = leNext; + } + LogEntry *dummy_le = createDummyLogEntry(); + flushLogUncond(dummy_le); + TL_LogStructure_->Le = dummy_le; + TL_LastLogEntry_ = dummy_le; +// TL_LastLogEntry_ = TL_FirstLogEntry_; + return; +} + +/// +/// @brief Given a log entry, publish it to other threads +/// @param le Pointer to the already populated log entry +/// +void LogMgr::publishLogEntry(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // if TL_LastLogEntry_ is null, it means that this is the first + // log entry created in this thread. In that case, allocate space + // for the thread-specific header, set a pointer to this log entry, + // and insert the header into the list of headers. + if (!TL_LastLogEntry_) { + LogStructure *ls = + static_cast( + PRegionMgr::getInstance().allocMemWithoutLogging( + sizeof(LogStructure), RegionId_)); + assert(ls); + // Creating dummy entry at the top to ensure that there is atleast one entry + // after pruning at the end of the FASE +// LogEntry *dummy_le = createDummyLogEntry(); + + + new (ls) LogStructure(le, nullptr); + TL_LogStructure_ = ls; + + flushLogUncond(le); + + LogStructure *tmp; + do { + tmp = (*LogStructureHeaderPtr_).load(std::memory_order_acquire); + // Ensure that data modified by read-modify-write + // instructions reach persistent memory before being consumed + flushLogUncond(LogStructureHeaderPtr_); + + ls->Next = tmp; + // 16-byte alignment guarantees that an element of type + // LogStructure is on the same cache line + assert(!isOnDifferentCacheLine(&ls->Next, &ls->Le)); + flushLogUncond(&ls->Next); + + }while (!LogStructureHeaderPtr_->compare_exchange_weak( + tmp, ls, + std::memory_order_acq_rel, std::memory_order_relaxed)); + flushLogUncond(LogStructureHeaderPtr_); + TL_LastLogEntry_ = le; + +// // Adding the actual entry to the log structure now +// publishLogEntry(le); + } + else { + // "le" will be attached to the thread specific list of log entries + + // In the default mode: + // If "le" is the first entry in its cache line, flush "le", + // reset the Next field and flush Next (2 cache line flushes). + // If "le" is not the first entry in its cache line, assert + // that *TL_LastLogEntry_ is in the same cache line as le, set + // TL_LastLogEntry_->Next and flush the corresponding cache + // line (1 cache line flush). +#if defined(_USE_MOVNT) + long long unsigned int *from = (long long unsigned int*)≤ + __builtin_ia32_movntq( + (__attribute__((__vector_size__(1*sizeof(long long)))) long long*) + (long long unsigned int*)&TL_LastLogEntry_->Next, + (__attribute__((__vector_size__(1*sizeof(long long)))) long long) + *from); +#if !defined(_NO_SFENCE) + __builtin_ia32_sfence(); +#endif +#else + if (isCacheLineAligned(le)) { + flushLogUncond(le); + TL_LastLogEntry_->Next.store(le, std::memory_order_release); + flushLogUncond(&TL_LastLogEntry_->Next); + } + else { +#if !defined(_LOG_WITH_NVM_ALLOC) && !defined(_LOG_WITH_MALLOC) // default + assert(!PMallocUtil::is_on_different_cache_line( + le, static_cast(&TL_LastLogEntry_->Next))); + TL_LastLogEntry_->Next.store(le, std::memory_order_release); + flushLogUncond(le); +#else + // TODO: _LOG_WITH_MALLOC may not have proper alignment, + // requiring more cache line flushes. To be fixed. + if (PMallocUtil::is_on_different_cache_line( + le, (void*)&TL_LastLogEntry_->Next)) { + flushLogUncond(le); + TL_LastLogEntry_->Next.store(le, std::memory_order_release); + flushLogUncond(&TL_LastLogEntry_->Next); + } + else { + TL_LastLogEntry_->Next.store(le, std::memory_order_release); + flushLogUncond(le); + } +#endif + } +#endif + TL_LastLogEntry_ = le; + } +} + +/// +/// @brief After a log entry is created for a lock acquire, perform +/// some other bookkeeping tasks +/// @param lock_address +/// @param le Log entry for the lock acquire +/// +void LogMgr::finishAcquire(void *lock_address, LogEntry *le) +{ + assert(TL_NumHeldLocks_ >= 0); + + ++TL_NumHeldLocks_; + +#ifdef NVM_STATS + Stats_->incrementCriticalSectionCount(); + if (TL_NumHeldLocks_ > 1) Stats_->incrementNestedCriticalSectionCount(); +#endif + + publishLogEntry(le); +// TL_LastLogEntry_ = le; + flushAtEndOfFase(); + full_fence(); + //flush and delete the logs now + pruneLogEntries(); + full_fence(); + +} + +void LogMgr::finishRelease(LogEntry *le, const MapOfLockInfo& undo_locks) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // TODO Fails on wrongly syncrhonized programs + assert(TL_NumHeldLocks_ > 0); + -- TL_NumHeldLocks_; + + publishLogEntry(le); + + +// TL_LastLogEntry_ = le; + + flushAtEndOfFase(); + full_fence(); + //flush and delete the logs now + pruneLogEntries(); + full_fence(); + +// if (!TL_NumHeldLocks_) markEndFase(le); +} + +void LogMgr::markEndFase(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef _OPT_UNIQ_LOC + if (TL_UniqueLoc_) TL_UniqueLoc_->clear(); +#endif + + flushAtEndOfFase(); + + TL_IsFirstNonCSStmt_ = true; + + // Since this is the end of a failure-atomic section, create a + // dummy log entry. A dummy log entry ensures that there is at least + // one outstanding log entry even if all other log entries are pruned + // out. Note that currently we are adding a dummy log entry for + // every failure-atomic section. This can be costly. Static + // analysis should be used to elide this dummy log entry if it can + // prove that there is either a failure-atomic section or a store + // instruction following this failure-atomic section. + LogEntry *dummy_le = createDummyLogEntry(); + publishLogEntry(dummy_le); +// TL_LastLogEntry_ = dummy_le; +} + +void LogMgr::finishWrite(LogEntry * le, void * addr) +{ + assert(le); + +#ifdef NVM_STATS + Stats_->incrementLoggedStoreCount(); + if (TL_NumHeldLocks_ > 0) Stats_->incrementCriticalLoggedStoreCount(); +#endif + + publishLogEntry(le); +// TL_LastLogEntry_ = le; + signalHelper(); // TODO: why here? +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/logger/log_mgr.cpp b/ARP_CSFR/runtime/src/logger/log_mgr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5ccdd8b0591b8e9f649970b101e9ba6878cb549d --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/log_mgr.cpp @@ -0,0 +1,280 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" +#include "log_structure.hpp" +#include "happens_before.hpp" + +#include "atlas_alloc.h" + +namespace Atlas { + +thread_local uint32_t LogMgr::TL_LogCount_{0}; +thread_local CbLog *LogMgr::TL_CbLog_{nullptr}; +thread_local uint64_t LogMgr::TL_GenNum_{0}; +thread_local LogEntry *LogMgr::TL_FirstLogEntry_{nullptr}; +thread_local LogStructure *LogMgr::TL_LogStructure_{nullptr}; +thread_local LogEntry *LogMgr::TL_LastLogEntry_{nullptr}; +thread_local intptr_t LogMgr::TL_NumHeldLocks_{0}; +thread_local MapOfLockInfo *LogMgr::TL_UndoLocks_{nullptr}; +thread_local bool LogMgr::TL_IsFirstNonCSStmt_{true}; +thread_local bool LogMgr::TL_ShouldLogNonCSStmt_{true}; +thread_local uint64_t LogMgr::TL_LogCounter_{0}; +#if defined(_FLUSH_LOCAL_COMMIT) && !defined(DISABLE_FLUSHES) + thread_local SetOfInts *LogMgr::TL_FaseFlushPtr_{new SetOfInts}; +#else + thread_local SetOfInts *LogMgr::TL_FaseFlushPtr_{nullptr}; +#endif +#if defined(_OPT_UNIQ_LOC) + thread_local SetOfPairs *LogMgr::TL_UniqueLoc_{new SetOfPairs}; +#else + thread_local SetOfPairs *LogMgr::TL_UniqueLoc_{nullptr}; +#endif + +#if 0 // unused +thread_local intptr_t LogMgr::TL_LogFlushTab_[kFlushTableSize] = {}; +#endif + +thread_local intptr_t LogMgr::TL_DataFlushTab_[kFlushTableSize] = {}; + +LogMgr *LogMgr::Instance_{nullptr}; + +/// +/// @brief Initialize the log manager, sets the log root, creates the +/// helper thread. Called by NVM_Initialize which must be called by +/// only one thread. +/// +void LogMgr::init() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + std::cout << "[Atlas] -- Started --" << std::endl; + + char *log_name = NVM_GetLogRegionName(); + if (NVM_doesLogExist(NVM_GetFullyQualifiedRegionName(log_name))) { + std::cout << + "[Atlas] The program crashed earlier, please run recovery ..." << + std::endl; + std::cout << "[Atlas] -- Finished --" << std::endl; + exit(0); + } + +#ifdef NVM_STATS + Stats_ = &Stats::createInstance(); +#endif + + PRegionMgr::createInstance(); + + RegionId_ = NVM_CreateRegion(log_name, O_RDWR); + + free(log_name); // Log naming functions allocate + + LogStructureHeaderPtr_ = static_cast*>( + PRegionMgr::getInstance().allocMemWithoutLogging( + sizeof(std::atomic), RegionId_)); + assert(LogStructureHeaderPtr_); + new (LogStructureHeaderPtr_) std::atomic; + + (*LogStructureHeaderPtr_).store(0, std::memory_order_release); + NVM_FLUSH(LogStructureHeaderPtr_); + + // Enough has been initialized + IsInitialized_ = true; + + // The memory for LogStructureHeaderPtr_ is leaked if there is a + // failure before assigning the root below. + NVM_SetRegionRoot(RegionId_, (void *)LogStructureHeaderPtr_); + + // create the helper thread here +// int status = pthread_create(&HelperThread_, nullptr, +// (void *(*)(void *))helper, nullptr); +// assert(!status); +} + +/// +/// @brief Finalize the log manager, joins the helper thread and does +/// other bookkeeping. Called by NVM_Finalize which must be called by +/// only one thread. +/// +void LogMgr::finalize() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + acquireLogReadyLock(); + AllDone_.store(1, std::memory_order_release); + releaseLogReadyLock(); + signalLogReady(); + +// int status = pthread_join(HelperThread_, nullptr); +// assert(!status); + +// TODO PrintLog(); + + NVM_DeleteRegion(NVM_GetLogRegionName()); + + PRegionMgr::deleteInstance(); + +#ifdef NVM_STATS + Stats_->deleteInstance(); +#endif + + std::cout << "[Atlas] -- Finished --" << std::endl; + +} + +/// +/// @brief Signals the helper thread indicating that there are log +/// entries to process +/// +void LogMgr::signalHelper() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + ++TL_LogCount_; + if (TL_LogCount_ == kWorkThreshold) { + int status = pthread_cond_signal(&HelperCondition_); + assert(!status); + TL_LogCount_ = 0; + } +} + +/// +/// @brief Entry point into log manager for a lock release +/// @param lock_address Address of the lock object to be released +/// +void LogMgr::logRelease(void *lock_address) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // This should really be an assert + // TODO: VG: This will fail for C++ atomics + if (TL_NumHeldLocks_ <= 0) return; + + LogEntry *le = createSectionLogEntry(lock_address, LE_release); + assert(le); + +#ifndef _NO_NEST // default + // Support for log elision: Since this lock is being released, + // execution need not be predicated on it any more. So stop + // tracking it. + uint64_t lock_count = removeLockFromUndoInfo(lock_address); + + // clean up the thread-local table + canElideLogging(); +#endif + + finishRelease(le, *TL_UndoLocks_); + +#ifndef _NO_NEST + // The following must happen after publishing + addLockReleaseCount(lock_address, lock_count+1); +#endif + + signalHelper(); +} + +void LogMgr::logRWUnlock(void *lock_address) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogEntry *le = createSectionLogEntry(lock_address, LE_rwlock_unlock); + assert(le); + + uint64_t lock_count = removeLockFromUndoInfo(lock_address); + + // clean up the thread-local table + canElideLogging(); + + finishRelease(le, *TL_UndoLocks_); + + // The following must happen after publishing + addLockReleaseCount(lock_address, lock_count+1); + + signalHelper(); +} + +void LogMgr::logEndDurable() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogEntry *le = createSectionLogEntry(NULL, LE_end_durable); + assert(le); + + assert(TL_NumHeldLocks_ > 0); + -- TL_NumHeldLocks_; + + publishLogEntry(le); +// TL_LastLogEntry_ = le; + + if (!TL_NumHeldLocks_) markEndFase(nullptr); + signalHelper(); +} + +void LogMgr::logAlloc(void *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // TODO: use the arena lock for log elision + if (tryLogElision(NULL, 0)) return; + + LogEntry *le = createAllocationLogEntry(addr, LE_alloc); + +#ifndef _NO_NEST + // An allocation is currently treated as an acquire operation + setHappensBeforeForAllocFree(le); +#endif + + publishLogEntry(le); + +// TL_LastLogEntry_ = le; +} + +void LogMgr::logFree(void *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // TODO: use the arena lock for log elision + if (tryLogElision(NULL, 0)) return; + + LogEntry *le = createAllocationLogEntry(addr, LE_free); + +#ifndef _NO_NEST + // If there is a previous free, create a happens after link free -> free + // In that case, the following call will set the Size_ of the new + // log entry as well + setHappensBeforeForAllocFree(le); +#endif + + publishLogEntry(le); + +#ifndef _NO_NEST + addLogToLastReleaseInfo(le, *new MapOfLockInfo); +#endif + +// TL_LastLogEntry_ = le; +} + +} // namespace Atlas + + diff --git a/ARP_CSFR/runtime/src/logger/log_mgr_api.cpp b/ARP_CSFR/runtime/src/logger/log_mgr_api.cpp new file mode 100644 index 0000000000000000000000000000000000000000..917ab306d0bd430c29f76c465eb3380a8a116a09 --- /dev/null +++ b/ARP_CSFR/runtime/src/logger/log_mgr_api.cpp @@ -0,0 +1,194 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include + +#include "log_mgr.hpp" + +#include "atlas_alloc.h" + +// TODO: trylock is not handled. It is unclear how to handle it in the +// general case. + +void NVM_Initialize() +{ + assert(!Atlas::LogMgr::hasInstance()); +#ifdef _FORCE_FAIL + //Seed prng for random failing of Atlas + stand(time(NULL)); +#endif + Atlas::LogMgr::createInstance(); +} + +void NVM_Finalize() +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::deleteInstance(); +} + +void NVM_UsrDone() +{ +} + +void nvm_acquire(void *lock_address) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logAcquire(lock_address); +} + +void nvm_release(void *lock_address) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logRelease(lock_address); +} + +void nvm_rwlock_rdlock(void *lock_address) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logRdLock(lock_address); +} + +void nvm_rwlock_wrlock(void *lock_address) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logWrLock(lock_address); +} + +void nvm_rwlock_unlock(void *lock_address) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logRWUnlock(lock_address); +} + +void nvm_begin_durable() +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logBeginDurable(); +} + +void nvm_end_durable() +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logEndDurable(); +} + +// TODO: bit store support + +void nvm_store(void *addr, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logStore(addr, sz); +} + +void nvm_memset(void *addr, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logMemset(addr, sz); +} + +void nvm_memcpy(void *dst, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logMemcpy(dst, sz); +} + +void nvm_memmove(void *dst, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logMemmove(dst, sz); +} + +size_t nvm_strlen(char *dst) +{ + return strlen(dst)+1; +} + +void nvm_strcpy(char *dst, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logStrcpy(dst, sz); +} + +void nvm_strcat(char *dst, size_t sz) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logStrcat(dst, sz); +} + +void nvm_log_alloc(void *addr) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logAlloc(addr); +} + +void nvm_log_free(void *addr) +{ + if (!Atlas::LogMgr::hasInstance()) return; + Atlas::LogMgr::getInstance().logFree(addr); +} + +void nvm_barrier(void *p) +{ + if (!NVM_IsInOpenPR(p, 1)) return; +#if (!defined(DISABLE_FLUSHES) && !defined(_DISABLE_DATA_FLUSH)) + full_fence(); + nvm_clflush((char*)p); + full_fence(); +#endif +} + +// TODO: should this belong to the log manager or the region +// manger. An argument could be made either way. It is part of +// consistency support, so probably belongs to the logger. But if +// someone wants to use the region manager alone, the other option +// could be more attractive. +void nvm_psync(void *start_addr, size_t sz) +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::getInstance().psync(start_addr, sz); +} + +// TODO: The way the LLVM NVM instrumenter is working today, this introduces +// a bug since we are not checking whether start_addr is in the NVM space. +void nvm_psync_acq(void *start_addr, size_t sz) +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::getInstance().psyncWithAcquireBarrier(start_addr, sz); +} + +#if defined(_USE_TABLE_FLUSH) +void AsyncDataFlush(void *p) +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::getInstance().asyncDataFlush(p); +} + +void AsyncMemOpDataFlush(void *dst, size_t sz) +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::getInstance().asyncMemOpDataFlush(dst, sz); +} +#endif + +#ifdef NVM_STATS +void NVM_PrintStats() +{ + assert(Atlas::LogMgr::hasInstance()); + Atlas::LogMgr::getInstance().printStats(); +} +#endif + + diff --git a/runtime/src/pmalloc/CMakeLists.txt b/ARP_CSFR/runtime/src/pmalloc/CMakeLists.txt similarity index 100% rename from runtime/src/pmalloc/CMakeLists.txt rename to ARP_CSFR/runtime/src/pmalloc/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/pmalloc/pmalloc.cpp b/ARP_CSFR/runtime/src/pmalloc/pmalloc.cpp new file mode 100644 index 0000000000000000000000000000000000000000..2b9821baf9655d065fa3401a3af0e785dc0af5d1 --- /dev/null +++ b/ARP_CSFR/runtime/src/pmalloc/pmalloc.cpp @@ -0,0 +1,441 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include +#include + +#include "pmalloc.hpp" +#include "pmalloc_util.hpp" +#include "internal_api.h" +#include "atlas_alloc.h" + +namespace Atlas { + +uint32_t PMallocUtil::CacheLineSize_{UINT32_MAX}; +uintptr_t PMallocUtil::CacheLineMask_{UINTPTR_MAX}; +thread_local uint32_t PMallocUtil::TL_CurrArena_[kMaxNumPRegions_] = {}; + +/// +/// Given a pointer to persistent memory, mark the location free and +/// add it to the free list. +/// +void PArena::freeMem(void *ptr, bool should_log) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + Lock(); + + if (!PMallocUtil::is_ptr_allocated(ptr)) + { + fprintf(stderr, "[Atlas-pheap] assert: %p %ld %ld\n", + ptr, *((size_t *)ptr), + *(size_t *)((char *)ptr+sizeof(size_t))); + assert(PMallocUtil::is_ptr_allocated(ptr) && + "free called on unallocated memory"); + } + + char *mem = (char*)PMallocUtil::ptr2mem(ptr); + assert(doesRangeCheck(mem, *(reinterpret_cast(mem))) && + "Attempt to free memory outside of arena range!"); + +#ifndef _DISABLE_ALLOC_LOGGING + if (should_log) nvm_log_free(mem + sizeof(size_t)); +#endif + + *(size_t*)(mem + sizeof(size_t)) = false; + NVM_FLUSH(mem + sizeof(size_t)); + + insertToFreeList(PMallocUtil::get_bin_number( + PMallocUtil::get_requested_alloc_size_from_ptr(ptr)), + PMallocUtil::ptr2mem(ptr)); + + decrementActualAllocedStats( + PMallocUtil::get_actual_alloc_size( + PMallocUtil::get_requested_alloc_size_from_ptr(ptr))); + + Unlock(); +} + +/// +/// Given a size, allocate memory using the bump pointer. If it +/// reaches the end of the arena, return null. +/// +void *PArena::allocMem( + size_t sz, bool does_need_cache_line_alignment, bool does_need_logging) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // lock already acquired + size_t alloc_sz = PMallocUtil::get_actual_alloc_size(sz); + char *curr_alloc_addr_c = static_cast(CurrAllocAddr_); + intptr_t curr_alloc_addr_i = reinterpret_cast(CurrAllocAddr_); + if (does_need_cache_line_alignment) + { + intptr_t cache_line = curr_alloc_addr_i & + PMallocUtil::get_cache_line_mask(); + intptr_t next_cache_line = cache_line + + PMallocUtil::get_cache_line_size(); + if (reinterpret_cast( + curr_alloc_addr_c + PMallocUtil::get_metadata_size()) != + next_cache_line) + { + if (reinterpret_cast(next_cache_line) - + PMallocUtil::get_metadata_size() + alloc_sz > + static_cast(EndAddr_)) + return nullptr; + + intptr_t diff = next_cache_line - curr_alloc_addr_i - + PMallocUtil::get_metadata_size(); + assert(diff >= static_cast( + PMallocUtil::get_smallest_actual_alloc_size()) && + "Insufficient space for metadata!"); + + *(static_cast(CurrAllocAddr_)) = + diff - PMallocUtil::get_metadata_size(); + + // No need to log the following since it is not user visible + + // Mark it free + *(reinterpret_cast( + curr_alloc_addr_c + sizeof(size_t))) = false; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + curr_alloc_addr_c, curr_alloc_addr_c + sizeof(size_t))); + + NVM_FLUSH(curr_alloc_addr_c); + + insertToFreeList(PMallocUtil::get_bin_number( + diff - PMallocUtil::get_metadata_size()), + curr_alloc_addr_c); + CurrAllocAddr_ = reinterpret_cast( + next_cache_line - PMallocUtil::get_metadata_size()); + NVM_FLUSH(&CurrAllocAddr_); + curr_alloc_addr_c = static_cast(CurrAllocAddr_); + } + } + if ((curr_alloc_addr_c + alloc_sz - 1) < static_cast(EndAddr_)) + { + *(static_cast(CurrAllocAddr_)) = sz; + +#ifndef _DISABLE_ALLOC_LOGGING + if (does_need_logging) nvm_log_alloc( + curr_alloc_addr_c + sizeof(size_t)); +#endif + + *(reinterpret_cast( + curr_alloc_addr_c + sizeof(size_t))) = true; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + curr_alloc_addr_c, curr_alloc_addr_c + sizeof(size_t))); + + NVM_FLUSH(curr_alloc_addr_c); + + // If we fail somewhere above, the above memory will be + // considered unallocated because CurrAllocAddr_ is not yet set. + CurrAllocAddr_ = static_cast(curr_alloc_addr_c + alloc_sz); + NVM_FLUSH(&CurrAllocAddr_); + + // If we fail here or later, the above memory may be leaked. + + if (does_need_cache_line_alignment) + assert(PMallocUtil::is_cache_line_aligned( + curr_alloc_addr_c + PMallocUtil::get_metadata_size())); + + incrementActualAllocedStats(alloc_sz); + + return static_cast( + curr_alloc_addr_c + PMallocUtil::get_metadata_size()); + } + return nullptr; +} + +/// +/// Given a size, allocate memory from the arena free list, if +/// possible. +/// +void *PArena::allocFromFreeList( + size_t sz, bool does_need_cache_line_alignment, bool does_need_logging) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // TODO: add support for cache line alignment + if (does_need_cache_line_alignment) return nullptr; + + if (FreeList_->empty()) return nullptr; + + size_t actual_sz = PMallocUtil::get_actual_alloc_size(sz); + uint32_t bin_number = PMallocUtil::get_bin_number(sz); + while (bin_number < kMaxFreeCategory_ + 1) + { + FreeList::iterator ci = FreeList_->find(bin_number); + // Look in the existing bin. We don't look for additional memory + // that may have been freed. We will do that later. + if (ci != FreeList_->end()) + { + MemMap & mem_map = ci->second; + MemMap::iterator mem_ci_end = mem_map.end(); + for (MemMap::iterator mem_ci = mem_map.begin(); + mem_ci != mem_ci_end; ++mem_ci) + { + char *mem = static_cast(mem_ci->first); + assert(!PMallocUtil::is_mem_allocated(mem) && + "Location in free list is marked allocated!"); + + void *carved_mem = nullptr; + if (bin_number == kMaxFreeCategory_) + { + // carve out the extra memory if possible + size_t actual_free_sz = PMallocUtil::get_actual_alloc_size( + *(reinterpret_cast(mem))); + + if (actual_sz > actual_free_sz) // cannot satisfy + continue; + else if (actual_sz + + PMallocUtil::get_smallest_actual_alloc_size() <= + actual_free_sz) + carved_mem = carveExtraMem( + mem, actual_sz, actual_free_sz); + else assert(actual_sz == actual_free_sz); + } + // If we fail here, the above carving does not take effect + + *(reinterpret_cast(mem)) = sz; + + // If we fail here or anywhere above, no memory is leaked + +#ifndef _DISABLE_ALLOC_LOGGING + if (does_need_logging) nvm_log_alloc(mem + sizeof(size_t)); +#endif + + *(reinterpret_cast(mem + sizeof(size_t))) = true; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + mem, mem + sizeof(size_t))); + + NVM_FLUSH(mem); + + // If we fail here, the above allocated memory may be leaked + + mem_map.erase(mem_ci); + + if (carved_mem) insertToFreeList( + PMallocUtil::get_bin_number( + *(static_cast(carved_mem))), + carved_mem); + + incrementActualAllocedStats(actual_sz); + + return static_cast(mem + + PMallocUtil::get_metadata_size()); + } + } + bin_number = PMallocUtil::get_next_bin_number(bin_number); + } + return nullptr; +} + +/// +/// Given a size, traverse the arena from the start while looking for +/// a free chunk of memory that can satisfy the allocation +/// request. The arena free list is updated as the traversal is +/// performed. +/// +void *PArena::allocFromUpdatedFreeList( + size_t sz, bool does_need_cache_line_alignment, bool does_need_logging) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // TODO: add support for cache line alignment + if (does_need_cache_line_alignment) return nullptr; + + size_t actual_sz = PMallocUtil::get_actual_alloc_size(sz); + char *mem = static_cast(StartAddr_); + + while (mem < (char*)CurrAllocAddr_) + { + size_t mem_sz = PMallocUtil::get_requested_alloc_size_from_mem(mem); + size_t actual_mem_sz = PMallocUtil::get_actual_alloc_size(mem_sz); + if (!PMallocUtil::is_mem_allocated(mem)) + { + if (actual_sz > actual_mem_sz) + { + // This address may be in the free list already. But the + // implementation ensures no duplicates are added. + insertToFreeList( + PMallocUtil::get_bin_number( + *(reinterpret_cast(mem))), + mem); + mem += actual_mem_sz; + continue; + } + + void *carved_mem = nullptr; + if (actual_sz + PMallocUtil::get_smallest_actual_alloc_size() <= + actual_mem_sz) + carved_mem = carveExtraMem(mem, actual_sz, actual_mem_sz); + else assert(actual_sz == actual_mem_sz); + + // If we fail here, the above carving does not take effect + + *(reinterpret_cast(mem)) = sz; + + // If we fail here or anywhere above, no memory is leaked + +#ifndef _DISABLE_ALLOC_LOGGING + if (does_need_logging) nvm_log_alloc(mem + sizeof(size_t)); +#endif + + *(reinterpret_cast(mem + sizeof(size_t))) = true; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + mem, mem + sizeof(size_t))); + + NVM_FLUSH(mem); + + // If we fail here, the above allocated memory may be leaked + deleteFromFreeList(PMallocUtil::get_bin_number(mem_sz), mem); + + if (carved_mem) + insertToFreeList( + PMallocUtil::get_bin_number( + *(reinterpret_cast(carved_mem))), + carved_mem); + + incrementActualAllocedStats(actual_sz); + + return static_cast(mem + PMallocUtil::get_metadata_size()); + } + mem += actual_mem_sz; + } + return nullptr; +} + +/// +/// Special form of "raw" memory allocation using the bump pointer. +/// +void *PArena::allocRawMem(size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + size_t alloc_sz = PMallocUtil::get_actual_alloc_size(sz); + assert((static_cast(CurrAllocAddr_)+alloc_sz-1) < + static_cast(EndAddr_) && "Out of arena memory!"); + + void *ret = static_cast(static_cast(CurrAllocAddr_) + + PMallocUtil::get_metadata_size()); + + *(static_cast(CurrAllocAddr_)) = sz; + + // Note that raw allocation is not logged + + *(reinterpret_cast( + static_cast(CurrAllocAddr_) + sizeof(size_t))) = true; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + CurrAllocAddr_, + static_cast(CurrAllocAddr_) + sizeof(size_t))); + + NVM_FLUSH(CurrAllocAddr_); + + // If a crash happens here, the memory appears allocated but it is not + // assigned to any program-visible entity, hence it is essentially lost. + + CurrAllocAddr_ = static_cast( + static_cast(CurrAllocAddr_) + alloc_sz); + NVM_FLUSH(&CurrAllocAddr_); + + incrementActualAllocedStats(alloc_sz); + + return ret; +} + +/// +/// Add the specified chunk to a particular bin of the arena freelist +/// +void PArena::insertToFreeList(uint32_t bin_no, void *mem) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + FreeList::iterator ci = FreeList_->find(bin_no); + if (ci == FreeList_->end()) { + MemMap mem_map; + mem_map.insert(std::make_pair(mem, true)); + FreeList_->insert(std::make_pair(bin_no, mem_map)); + } + else ci->second.insert(std::make_pair(mem, true)); +} + +/// +/// Delete the specified chunk from a particular bin of the freelist +/// +void PArena::deleteFromFreeList(uint32_t bin_no, void *mem) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + FreeList::iterator ci = FreeList_->find(bin_no); + if (ci == FreeList_->end()) return; // tolerate absence of entry + else + { + MemMap & mem_map = ci->second; + MemMap::iterator mem_ci = mem_map.find(mem); + if (mem_ci == mem_map.end()) return; + else mem_map.erase(mem_ci); + } +} + +/// +/// Given a free chunk, an allocatable size, and the original free +/// size, carve it into two such that the second one is the new free +/// chunk after considering the first one as the allocated chunk. +/// +void *PArena::carveExtraMem( + char *mem, size_t actual_alloc_sz, size_t actual_free_sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + void *carved_mem = static_cast(mem + actual_alloc_sz); + *(static_cast(carved_mem)) = + actual_free_sz - actual_alloc_sz - PMallocUtil::get_metadata_size(); + + // No need to log the following since it is not user visible + *(reinterpret_cast( + static_cast(carved_mem) + sizeof(size_t))) = false; + + // The above metadata updates are to the same cache line + assert(!isOnDifferentCacheLine( + carved_mem, static_cast(carved_mem) + sizeof(size_t))); + + NVM_FLUSH(carved_mem); + + return carved_mem; +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/pmalloc/pregion.cpp b/ARP_CSFR/runtime/src/pmalloc/pregion.cpp new file mode 100644 index 0000000000000000000000000000000000000000..4fef75430c7d38bfcbad8a3fce373945d7394664 --- /dev/null +++ b/ARP_CSFR/runtime/src/pmalloc/pregion.cpp @@ -0,0 +1,193 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include + +#include "pregion.hpp" + +namespace Atlas { + +/// +/// Entry point for region-based allocation +/// +void *PRegion::allocMem( + size_t sz, bool does_need_cache_line_alignment, bool does_need_logging) +{ + assert(!IsDeleted_ && "Attempt to allocate memory from deleted region!"); + assert(IsMapped_ && "Attempt to allocate memory from unmapped region!"); + + // adjust current arena if required + if (!PMallocUtil::is_valid_tl_curr_arena(Id_)) + PMallocUtil::set_tl_curr_arena( + Id_, (uint64_t)pthread_self() % kNumArenas_); + + void *alloc_ptr = nullptr; + bool should_update_free_list = false; + if ((alloc_ptr = allocMemFromArenas( + sz, should_update_free_list, + does_need_cache_line_alignment, does_need_logging))) { + assert(doesRangeCheck(alloc_ptr, + PMallocUtil::get_actual_alloc_size(sz)) && + "Attempt to allocate memory outside the requested region!"); + return alloc_ptr; + } + + // Now the expensive part since free lists need updating: This is done + // only when all arenas appear full, including the existing free lists. + should_update_free_list = true; + if ((alloc_ptr = allocMemFromArenas( + sz, should_update_free_list, + does_need_cache_line_alignment, does_need_logging))) { + assert(doesRangeCheck(alloc_ptr, + PMallocUtil::get_actual_alloc_size(sz)) && + "Attempt to allocate memory outside the requested region!"); + return alloc_ptr; + } + + // TODO msgs + fprintf(stderr, "[Atlas-pheap] Allocation failed in region %d\n", Id_); +#ifdef _ATLAS_ALLOC_STATS + fprintf(stderr, "[Atlas-pheap] Requested = %ld Alloced = %ld\n", + pheap->requested_sz, pheap->alloced_sz); +#endif + assert(alloc_ptr && "Out of memory in this persistent region!"); + return nullptr; +} + +/// +/// Traverse the arenas, try to allocate available memory from an +/// unlocked one, otherwise use the free list +/// +void *PRegion::allocMemFromArenas( + size_t sz, bool should_update_free_list, + bool does_need_cache_line_alignment, bool does_need_logging) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(PMallocUtil::get_tl_curr_arena(Id_) < kNumArenas_ && + "Arena index is out of range!"); + + bool arena_tracker[kNumArenas_]; + memset(arena_tracker, 0, sizeof(arena_tracker)); + + // Start with the arena used the last time, reducing false sharing + uint32_t arena_count = 0; + do { + // look inside an arena only once + if (arena_tracker[PMallocUtil::get_tl_curr_arena(Id_)]) { + PMallocUtil::set_tl_curr_arena( + Id_, PMallocUtil::get_tl_next_arena(Id_)); + continue; + } + + PArena *parena = getArena(PMallocUtil::get_tl_curr_arena(Id_)); + int status; + // loop until an arena can be locked by this thread + while ((status = parena->tryLock())) { + assert(status == EBUSY && "Trylock returned unexpected status!"); + PMallocUtil::set_tl_curr_arena( + Id_, PMallocUtil::get_tl_next_arena(Id_)); + parena = getArena(PMallocUtil::get_tl_curr_arena(Id_)); + } + arena_tracker[PMallocUtil::get_tl_curr_arena(Id_)] = true; + + void *alloc_ptr = nullptr; + if (!should_update_free_list) { + if ((alloc_ptr = parena->allocMem( + sz, does_need_cache_line_alignment, does_need_logging))) { + parena->Unlock(); + return alloc_ptr; + } + if ((alloc_ptr = parena->allocFromFreeList( + sz, does_need_cache_line_alignment, does_need_logging))) { + parena->Unlock(); + return alloc_ptr; + } + } + else if ((alloc_ptr = parena->allocFromUpdatedFreeList( + sz, does_need_cache_line_alignment, + does_need_logging))) { + parena->Unlock(); + return alloc_ptr; + } + + parena->Unlock(); + + ++arena_count; + + // round robin if the current arena is full + PMallocUtil::set_tl_curr_arena( + Id_, PMallocUtil::get_tl_next_arena(Id_)); + }while (arena_count < kNumArenas_); + + return nullptr; +} + +/// +/// Entry point for region-based calloc +/// +void *PRegion::callocMem(size_t nmemb, size_t sz) +{ + bool does_need_cache_line_alignment = false; + bool does_need_logging = true; + void *calloc_mem = allocMem(nmemb * sz, does_need_cache_line_alignment, + does_need_logging); + memset(calloc_mem, 0, nmemb * sz); + return calloc_mem; +} + +/// +/// Entry point for region-based realloc +/// +void *PRegion::reallocMem(void *ptr, size_t sz) +{ + bool does_need_cache_line_alignment = false; + bool does_need_logging = true; + if (!ptr && sz) return allocMem(sz, does_need_cache_line_alignment, + does_need_logging); + if (!sz) { + freeMem(ptr, does_need_logging); + return nullptr; + } + size_t curr_sz = PMallocUtil::get_requested_alloc_size_from_ptr(ptr); + void *realloced_ptr = allocMem(sz, does_need_cache_line_alignment, + does_need_logging); + memcpy(realloced_ptr, ptr, curr_sz < sz ? curr_sz : sz); + freeMem(ptr, does_need_logging); + return realloced_ptr; +} + +/// +/// Flush out persistent metadata of a persistent region +/// +void PRegion::flushDirtyCacheLines() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + NVM_FLUSH(&Id_); + if (PMallocUtil::is_on_different_cache_line(&Id_, &IsDeleted_)) + NVM_FLUSH(&IsDeleted_); + assert(kMaxlen_); + NVM_FLUSH(&Name_[0]); + if (PMallocUtil::is_on_different_cache_line( + &Name_[0], &Name_[kMaxlen_ - 1])) + NVM_FLUSH(&Name_[kMaxlen_ - 1]); + // arenas flushed out separately +} + +} // namespace Atlas diff --git a/runtime/src/pregion_mgr/CMakeLists.txt b/ARP_CSFR/runtime/src/pregion_mgr/CMakeLists.txt similarity index 100% rename from runtime/src/pregion_mgr/CMakeLists.txt rename to ARP_CSFR/runtime/src/pregion_mgr/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr.cpp b/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d7aed09e6aa350d9a4b61945598ef4d0d36cf4ab --- /dev/null +++ b/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr.cpp @@ -0,0 +1,753 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include "pregion_mgr.hpp" +#include "log_mgr.hpp" +#include "util.hpp" +#include "fail.hpp" + +#ifdef _NVDIMM_PROLIANT +#include "fsync.hpp" +#endif + +namespace Atlas { + +PRegionMgr *PRegionMgr::Instance_{nullptr}; + +/// +/// Entry point for freeing a persistent location +/// +void PRegionMgr::freeMem(void *ptr, bool should_log) const +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Correct size unknown at this point since it may be in transient mem + region_id_t rgn_id = getOpenPRegionId(ptr, 1 /* dummy */); + if (rgn_id == kInvalidPRegion_) { // transient memory + free(ptr); + return; + } + freeMemImpl(rgn_id, ptr, should_log); +} + +/// +/// Entry point for deleting a persistent location +/// +void PRegionMgr::deleteMem(void *ptr, bool should_log) const +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + + // ptr must be in a persistent region + region_id_t rgn_id = getOpenPRegionId(ptr, 1 /* dummy */); + freeMemImpl(rgn_id, ptr, should_log); +} + +void PRegionMgr::freeMemImpl( +region_id_t rgn_id, void *ptr, bool should_log) const +{ + // Now that we can find out the correct size, assert that all the + // bytes of the memory location indeed belong to this region + assert((getOpenPRegionId( + ptr, PMallocUtil::get_actual_alloc_size( + PMallocUtil::get_requested_alloc_size_from_ptr(ptr))) == + rgn_id) && "Location to be freed crosses regions!"); + + PRegion *preg = getPRegion(rgn_id); + assert((!preg->is_deleted() && preg->is_mapped()) && + "Pointer to be freed belongs to a deleted or unmapped region!"); + preg->freeMem(ptr, should_log); +} + +/// +/// Given a persistent region name and corresponding attributes, +/// return its id, creating it if necessary +/// +region_id_t PRegionMgr::findOrCreatePRegion( + const char *name, int flags, int *is_created) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(name); + assert(std::strlen(name) < kMaxlen_+1); + + acquireTableLock(); + acquireExclusiveFLock(); + + PRegion *rgn = searchPRegion(name); + if (rgn && !rgn->is_deleted()) { + initExistingPRegionImpl(rgn, name, flags); + + releaseFLock(); + releaseTableLock(); + + if (is_created) *is_created = false; + + tracePRegion(rgn->get_id(), kFind_); + statsPRegion(rgn->get_id()); + + return rgn->get_id(); + } + else if (rgn) { // previously deleted region + // reuse id and base_address + mapNewPRegionImpl( + rgn, name, rgn->get_id(), flags, rgn->get_base_addr()); + + releaseFLock(); + releaseTableLock(); + + if (is_created) *is_created = true; + + tracePRegion(rgn->get_id(), kCreate_); + statsPRegion(rgn->get_id()); + + return rgn->get_id(); + } + else { + region_id_t rgn_id = initNewPRegionImpl(name, flags); + + releaseFLock(); + releaseTableLock(); + + if (is_created) *is_created = true; + + tracePRegion(rgn_id, kCreate_); + statsPRegion(rgn_id); + + return rgn_id; + } +} + +/// +/// Find a persistent region by its name and return its id +/// +region_id_t PRegionMgr::findPRegion(const char *name, int flags, + bool is_in_recovery) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(name); + assert(std::strlen(name) < kMaxlen_+1); + + acquireTableLock(); + acquireExclusiveFLock(); + + PRegion *rgn = searchPRegion(name); + // If there was a failure earlier, we want to reuse the region entry + if (!rgn || (rgn->is_deleted() && !is_in_recovery)) { + releaseFLock(); + releaseTableLock(); + return kInvalidPRegion_; + } + else if (rgn->is_deleted() && is_in_recovery) { + // If there was a failure earlier, we may find a previously + // deleted region. Reuse id and base address in such a + // case but it is ok to re-initialize the root. + mapNewPRegionImpl( + rgn, name, rgn->get_id(), flags, rgn->get_base_addr()); + + releaseFLock(); + releaseTableLock(); + } + else { + initExistingPRegionImpl(rgn, name, flags); + + releaseFLock(); + releaseTableLock(); + } + + tracePRegion(rgn->get_id(), kFind_); + statsPRegion(rgn->get_id()); + + return rgn->get_id(); +} + +/// +/// Create a new persistent region with the given name and attributes +/// +region_id_t PRegionMgr::createPRegion(const char *name, int flags) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(name); + assert(std::strlen(name) < kMaxlen_+1); + + acquireTableLock(); + acquireExclusiveFLock(); + + region_id_t rgn_id = kInvalidPRegion_; + PRegion *rgn = searchPRegion(name); + if (rgn && rgn->is_deleted()) { + // reuse id and base address + mapNewPRegionImpl( + rgn, name, rgn->get_id(), flags, rgn->get_base_addr()); + rgn_id = rgn->get_id(); + } + else if (rgn) + assert(!rgn && "Region exists, use a different region!"); + else rgn_id = initNewPRegionImpl(name, flags); + + releaseFLock(); + releaseTableLock(); + + tracePRegion(rgn_id, kCreate_); + statsPRegion(rgn_id); + + + return rgn_id; +} + +/// +/// Remove the mappings of a persistent region from memory. It cannot +/// be subsequently used without "finding" it again. +/// +void PRegionMgr::closePRegion(region_id_t rid, bool is_deleting) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!is_deleting) { + acquireTableLock(); + acquireExclusiveFLock(); + } + + PRegion *preg = getPRegion(rid); + assert(preg && "Region to be closed not found!"); + assert((is_deleting || !preg->is_deleted()) && + "Region to be closed already deleted!"); + assert(preg->is_mapped() && "Region to be closed not mapped!"); + + int status = munmap(preg->get_base_addr(), kPRegionSize_); + if (status) { + perror("munmap"); + assert(!status && "munmap of user region failed!"); + } + preg->set_is_mapped(false); + close(preg->get_file_desc()); + + preg->~PRegion(); + + if (!is_deleting) { + releaseFLock(); + releaseTableLock(); + } + + tracePRegion(preg->get_id(), kClose_); + statsPRegion(preg->get_id()); +} + +/// +/// Delete a persistent region by name. All data within it will +/// disappear as well +/// +void PRegionMgr::deletePRegion(const char *name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(name); + assert(std::strlen(name) < kMaxlen_+1); + + acquireTableLock(); + acquireExclusiveFLock(); + + PRegion *preg = searchPRegion(name); + assert(preg && "Region to be deleted not found!"); + assert(!preg->is_deleted() && "Region to be deleted already deleted!"); + + preg->set_is_deleted(true); + + if (preg->is_mapped()) { + bool is_deleting = true; + closePRegion(preg->get_id(), is_deleting); + } + + char *s = NVM_GetFullyQualifiedRegionName(name); + unlink(s); +#ifdef _NVDIMM_PROLIANT + char *parent = strdup(s); + fsync_dir(parent); + free(parent); +#endif + free(s); + + releaseFLock(); + releaseTableLock(); + + tracePRegion(preg->get_id(), kDelete_); +} + +/// +/// Delete a persistent region without considering its attributes +/// +void PRegionMgr::deleteForcefullyPRegion(const char *name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(name); + assert(std::strlen(name) < kMaxlen_+1); + + acquireTableLock(); + acquireExclusiveFLock(); + + PRegion *preg = searchPRegion(name); + assert(preg && "Region to be deleted forcefully not found!"); + + deleteForcefullyPRegion(preg); + + releaseFLock(); + releaseTableLock(); +} + +void PRegionMgr::deleteForcefullyPRegion(PRegion *preg) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(preg); + + preg->set_is_mapped(false); + preg->set_is_deleted(true); + char *s = NVM_GetFullyQualifiedRegionName(preg->get_name()); + unlink(s); +#ifdef _NVDIMM_PROLIANT + char *parent = strdup(s); + fsync_dir(parent); + free(parent); +#endif + free(s); +} + +/// +/// Delete all persistent regions without considering their attributes +/// +void PRegionMgr::deleteForcefullyAllPRegions() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + acquireTableLock(); + acquireExclusiveFLock(); + + uint32_t num_entries = getNumPRegions(); + PRegion *preg_ptr = getPRegionArrayPtr(); + uint32_t curr = 0; + while (curr < num_entries) { + deleteForcefullyPRegion(preg_ptr); + ++ curr; ++ preg_ptr; + } + + releaseFLock(); + releaseTableLock(); +} + +/// +/// Set the root of a region to the provided new root. +/// +void PRegionMgr::setPRegionRoot(region_id_t rid, void *new_root) const +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // This must act like a release operation so that all prior + // writes to NVRAM are flushed out. + if (LogMgr::hasInstance()) + LogMgr::getInstance().flushAtEndOfFase(); + + getPRegion(rid)->setRoot(new_root); +} + +// +// end of public interface implementation +// + +/// +/// Set the number of persistent regions to count +/// +void PRegionMgr::setNumPRegions(uint32_t count) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(count >= 0 && count < kMaxNumPRegions_ + && "Maximum region count exceeded!"); + *(static_cast(PRegionTable_)) = count; + NVM_FLUSH(PRegionTable_); +} + +/// +/// Initialize the metadata for the persistent regions. The metadata +/// itself is persistent and resides at a fixed address. +/// +void PRegionMgr::initPRegionTable() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + NVM_CreateUserDir(); + NVM_CreateLogDir(); // TODO rename to RegionDir + + char *region_table_name = NVM_GetRegionTablePath(); + + struct stat stat_buffer; + bool does_region_table_exist = stat(region_table_name, &stat_buffer) ? + false : true; + + PRegionTable_ = (void *)kPRegionsBase_; + PRegionTableFD_ = mapFile(region_table_name, O_RDWR, PRegionTable_, + does_region_table_exist); + + // initialize number of entries + if (!does_region_table_exist) setNumPRegions(0); + + free(region_table_name); +} + +/// +/// Remove the mappings of the persistent region metadata from memory +/// +void PRegionMgr::shutPRegionTable() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int status = munmap(PRegionTable_, kPRegionSize_); + if (status) { + perror("munmap"); + assert(!status && "munmap failed!"); + } +} + +/// +/// The next few routines map a persistent region into a process +/// address space and insert the available address range into the +/// region manager metadata +/// +region_id_t PRegionMgr::initNewPRegionImpl(const char *name, int flags) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + void *base_addr = computeNewPRegionBaseAddr(); + region_id_t rgn_id = mapNewPRegion(name, flags, base_addr); + return rgn_id; +} + +region_id_t PRegionMgr::mapNewPRegion( + const char *name, int flags, void *base_addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uint32_t num_entries = getNumPRegions(); + PRegion *rgn = instantiateNewPRegion(num_entries); + + mapNewPRegionImpl(rgn, name, num_entries, flags, base_addr); + + // Incrementing the number of regions commits the region + // metadata. If there is a failure before this increment, none of + // the region creation changes are visible as if they never happened + setNumPRegions(num_entries + 1); + + return num_entries; +} + +// TODO: bug fix: this routine is not failure-atomic. The fix is to +// change the region ctor to set the deleted bit to true. Then once +// all the changes below are done, set the deleted bit to +// false. +void PRegionMgr::mapNewPRegionImpl( + PRegion *rgn, const char *name, region_id_t rid, + int flags, void *base_addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(rgn && "To-be-mapped region not found!"); + + new (rgn) PRegion(name, rid, base_addr); + bool does_exist = false; + char *fully_qualified_name = NVM_GetFullyQualifiedRegionName(name); + rgn->set_file_desc( + mapFile(fully_qualified_name, flags, base_addr, does_exist)); + + insertExtent(base_addr, (char*)base_addr + kPRegionSize_ - 1, rid); + + free(fully_qualified_name); + + initPRegionRoot(rgn); +} + +void PRegionMgr::initExistingPRegionImpl( + PRegion *preg, const char *name, int flags) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(preg && "Existing region not found!"); + assert(!preg->is_deleted()); + assert(preg->get_base_addr() != nullptr); + + mapExistingPRegion(preg, name, flags); +} + +void PRegionMgr::mapExistingPRegion(PRegion *preg, const char *name, int flags) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + preg->initArenaTransients(); + PMallocUtil::set_default_tl_curr_arena(preg->get_id()); + + bool does_exist = true; + + char *fully_qualified_name = NVM_GetFullyQualifiedRegionName(name); + preg->set_file_desc(mapFile(fully_qualified_name, + flags, preg->get_base_addr(), does_exist)); + + insertExtent(preg->get_base_addr(), + (char*)preg->get_base_addr() + kPRegionSize_ - 1, + preg->get_id()); + + free(fully_qualified_name); + + preg->set_is_mapped(true); +} + +int PRegionMgr::mapFile( + const char *name, int flags, void *base_addr, bool does_exist) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int fd = open( + name, does_exist ? flags : flags | +#ifdef _NVDIMM_PROLIANT + O_DIRECT | +#endif + O_CREAT, + flags == O_RDONLY ? S_IRUSR : (S_IRUSR | S_IWUSR)); + if (fd == -1) { + perror("open"); + assert(fd != -1 && "Error opening to-be-mapped file!"); + } + + if (!does_exist) { + int status = ftruncate(fd, kPRegionSize_); + assert(!status); + } + + void *addr = mmap(base_addr, kPRegionSize_, + flags == O_RDONLY ? PROT_READ : PROT_READ | PROT_WRITE, + MAP_SHARED, fd, 0); + if (addr == MAP_FAILED) { + perror("mmap"); + assert(addr != MAP_FAILED && "mmap failed!"); + } + assert(addr == base_addr && "mmap returned address is not as requested!"); + +#ifdef _NVDIMM_PROLIANT + if (!does_exist) { + // Try to pre-allocate storage space + int allocate_status = posix_fallocate(fd, 0, kPRegionSize_); + assert(!allocate_status); + + // At least on some kernels, posix_fallocate does not appear to + // be sufficient. Do a memset to force pre-allocation to make sure + // all filesystem metadata changes are made. + memset(addr, 0, kPRegionSize_); + + // Force filesystem metadata changes to backing store + fsync_paranoid(name); + } +#endif + + return fd; +} + +/// +/// Initialize the persistent region root +/// +void PRegionMgr::initPRegionRoot(PRegion *preg) +{ + intptr_t *root_ptr = static_cast(preg->allocRoot()); + // Flushed but not logged + *root_ptr = 0; + NVM_FLUSH(root_ptr); +} + +/// +/// Given a name, search the persistent region metadata and return a +/// pointer to the corresponding metadata entry if it exists +/// +PRegion* PRegionMgr::searchPRegion(const char *name) const +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + PRegion *pregion_arr_ptr = getPRegionArrayPtr(); + uint32_t curr = 0; + for (; curr < getNumPRegions(); ++curr, ++pregion_arr_ptr) + if (!strcmp(name, pregion_arr_ptr->get_name())) + return pregion_arr_ptr; + return nullptr; +} + +/// +/// Given a memory address and a size, return the id of the open +/// persistent region that it belongs to +/// +region_id_t PRegionMgr::getOpenPRegionId( + const void *addr, size_t sz) const { + return ExtentMap_.load(std::memory_order_acquire)->findExtent( + reinterpret_cast(addr), + reinterpret_cast(static_cast(addr)+sz-1)); +} + +/// +/// Given an address, make sure that the persistent regions it belongs +/// to is mapped +/// +std::pair PRegionMgr::ensurePRegionMapped(void *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + region_id_t rgn_id = getOpenPRegionId(addr, 1 /* dummy */); + if (rgn_id != kInvalidPRegion_) + return std::make_pair(getPRegion(rgn_id)->get_base_addr(), rgn_id); + + PRegion *curr_rgn = getPRegionArrayPtr(); + uint32_t num_rgn = getNumPRegions(); + uint32_t curr = 0; + for(; curr < num_rgn; ++curr, ++curr_rgn) { + if (curr_rgn->is_deleted()) continue; + + if (addr >= curr_rgn->get_base_addr() && + static_cast(addr) < + static_cast(curr_rgn->get_base_addr())+kPRegionSize_) { + initExistingPRegionImpl(curr_rgn, curr_rgn->get_name(), O_RDWR); + + tracePRegion(curr_rgn->get_id(), kFind_); + statsPRegion(curr_rgn->get_id()); + + return std::make_pair( + curr_rgn->get_base_addr(), curr_rgn->get_id()); + } + } + assert(0 && "Address does not belong to any persistent region!"); + return std::make_pair(nullptr, kInvalidPRegion_); +} + + +/// +/// Add a range of addresses and the corresponding region id to the +/// region manager metadata +/// + +// The following assumes interference-freedom, i.e. a lock must be held + +// TODO Is the old map leaked? +void PRegionMgr::insertExtent( + void *first_addr, void *last_addr, region_id_t rid) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + PRegionExtentMap *old_map_ptr = ExtentMap_.load(std::memory_order_acquire); + PRegionExtentMap *new_map_ptr = nullptr; + do { + new_map_ptr = new PRegionExtentMap(*old_map_ptr); + new_map_ptr->insertExtent(reinterpret_cast(first_addr), + reinterpret_cast(last_addr), rid); + }while (!ExtentMap_.compare_exchange_weak( + old_map_ptr, new_map_ptr, + std::memory_order_acq_rel, std::memory_order_relaxed)); +} + +/// Delete a range of addresses and the corresponding region id from +/// the region manager metadata +/// + +// The following assumes interference-freedom, i.e. a lock must be held + +// TODO Is the old map leaked? +void PRegionMgr::deleteExtent( + void *first_addr, void *last_addr, region_id_t rid) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + PRegionExtentMap *old_map_ptr = ExtentMap_.load(std::memory_order_acquire); + PRegionExtentMap *new_map_ptr = nullptr; + do { + new_map_ptr = new PRegionExtentMap(*old_map_ptr); + new_map_ptr->deleteExtent(reinterpret_cast(first_addr), + reinterpret_cast(last_addr), rid); + }while (!ExtentMap_.compare_exchange_weak( + old_map_ptr, new_map_ptr, + std::memory_order_acq_rel, std::memory_order_relaxed)); +} + +int PRegionMgr::getCacheLineSize() const +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int size; + FILE * fp = fopen("/sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size", "r"); + if (fp) { + int n = fscanf(fp, "%d", &size); + assert(n == 1); + int status = fclose(fp); + assert(!status); + } + else { + size = kDCacheLineSize_; + std::cout << "[Atlas] WARNING: Config file not found: Using default cache line size of " << size << " bytes" << std::endl; + } + return size; +} + +void PRegionMgr::setCacheParams() +{ + uint32_t cache_line_size = getCacheLineSize(); + PMallocUtil::set_cache_line_size(cache_line_size); + PMallocUtil::set_cache_line_mask(0xffffffffffffffff - cache_line_size + 1); +} + +} // namespace Atlas diff --git a/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr_api.cpp b/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr_api.cpp new file mode 100644 index 0000000000000000000000000000000000000000..184f1ba0c4d5f1df35690726ed1cf8e42603afec --- /dev/null +++ b/ARP_CSFR/runtime/src/pregion_mgr/pregion_mgr_api.cpp @@ -0,0 +1,133 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "atlas_alloc.h" +#include "atlas_alloc_cpp.hpp" +#include "pregion_mgr.hpp" + +using namespace Atlas; + +uint32_t NVM_FindOrCreateRegion(const char *name, int flags, int *is_created) +{ + return PRegionMgr::getInstance().findOrCreatePRegion( + name, flags, is_created); +} + +uint32_t NVM_FindRegion(const char *name, int flags) +{ + // TODO What is the behavior if the region is not found? + return PRegionMgr::getInstance().findPRegion(name, flags); +} + +uint32_t NVM_CreateRegion(const char *name, int flags) +{ + return PRegionMgr::getInstance().createPRegion(name, flags); +} + +void NVM_CloseRegion(uint32_t rid) +{ + PRegionMgr::getInstance().closePRegion(rid); +} + +void NVM_DeleteRegion(const char *name) +{ + PRegionMgr::getInstance().deletePRegion(name); +} + +void *NVM_GetRegionRoot(uint32_t rid) +{ + return PRegionMgr::getInstance().getPRegionRoot(rid); +} + +void NVM_SetRegionRoot(uint32_t rid, void *new_root) +{ + PRegionMgr::getInstance().setPRegionRoot(rid, new_root); +} + +void *nvm_alloc(size_t sz, uint32_t rid) +{ + bool does_need_cache_line_alignment = false; + bool does_need_logging = true; + return PRegionMgr::getInstance().allocMem( + sz, rid, does_need_cache_line_alignment, does_need_logging); +} + +void *nvm_calloc(size_t nmemb, size_t sz, uint32_t rid) +{ + return PRegionMgr::getInstance().callocMem(nmemb, sz, rid); +} + +void *nvm_realloc(void *ptr, size_t sz, uint32_t rid) +{ + return PRegionMgr::getInstance().reallocMem(ptr, sz, rid); +} + +void nvm_free(void *ptr) +{ + PRegionMgr::getInstance().freeMem(ptr); +} + +void nvm_delete(void *ptr) +{ + PRegionMgr::getInstance().deleteMem(ptr); +} + +// TODO: The following should probably go away, they are really not +// part of the API. +int NVM_IsInOpenPR(void *addr, size_t sz) +{ + // PRegion manager has to be present to proceed with logging + if (!PRegionMgr::hasInstance()) return false; +#if defined(_ALL_PERSISTENT) + return true; +#else + return PRegionMgr::getInstance().isInOpenPRegion(addr, sz); +#endif +} + +int isOnDifferentCacheLine(void *p1, void *p2) +{ + return PMallocUtil::is_on_different_cache_line(p1, p2); +} + +int isCacheLineAligned(void *p) +{ + return PMallocUtil::is_cache_line_aligned(p); +} + +int NVM_IsInRegion(void *ptr, size_t sz) +{ + return PRegionMgr::getInstance().isInOpenPRegion(ptr, sz); +} + +PRegion *NVM_GetRegion(uint32_t rid) +{ + return PRegionMgr::getInstance().getPRegion(rid); +} + +void* operator new(size_t sz, Atlas::PRegion *rgn) noexcept +{ + assert(rgn); + return nvm_alloc(sz, rgn->get_id()); +} + +void* operator new[](size_t sz, Atlas::PRegion *rgn) noexcept +{ + assert(rgn); + return nvm_alloc(sz, rgn->get_id()); +} + + diff --git a/runtime/src/recover/CMakeLists.txt b/ARP_CSFR/runtime/src/recover/CMakeLists.txt similarity index 100% rename from runtime/src/recover/CMakeLists.txt rename to ARP_CSFR/runtime/src/recover/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/recover/clean_mem.cpp b/ARP_CSFR/runtime/src/recover/clean_mem.cpp new file mode 100644 index 0000000000000000000000000000000000000000..79cc8385552dc800668d2548fb7e4fc50d6ce2d1 --- /dev/null +++ b/ARP_CSFR/runtime/src/recover/clean_mem.cpp @@ -0,0 +1,66 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include + +#include + +#include "atlas_alloc.h" +#include "util.hpp" +#include "pregion_configs.hpp" +#include "pregion_mgr.hpp" + +using namespace Atlas; + +int main(int argc, char **argv) +{ + char input[kMaxlen_]; + + assert(argc < 3); + +// if (argc == 1) +// { +// fprintf(stderr, +// "Are you sure you want to delete all regions (yes/no)? "); +// while (true) +// { +// char *s = fgets(input, kMaxlen_, stdin); +// if (!strcmp(s, "yes\n")) break; +// else if (!strcmp(s, "no\n")) return 0; +// else fprintf(stderr, "Please enter yes or no: "); +// } +// } +// else if (strcmp(argv[1], "-f")) +// { +// fprintf(stderr, "Unknown option: use clean_mem -f\n"); +// return 0; +// } + + PRegionMgr::createInstance(); + + PRegionMgr::getInstance().deleteForcefullyAllPRegions(); + + PRegionMgr::deleteInstance(); + + char *rgn_tab = NVM_GetRegionTablePath(); + unlink(rgn_tab); + free(rgn_tab); + fprintf(stderr, "All region data/metadata removed successfully\n"); + return 0; +} + diff --git a/ARP_CSFR/runtime/src/recover/del_log.cpp b/ARP_CSFR/runtime/src/recover/del_log.cpp new file mode 100644 index 0000000000000000000000000000000000000000..3bb1beaa1d3d93d58d3ac987f05285676f2a05df --- /dev/null +++ b/ARP_CSFR/runtime/src/recover/del_log.cpp @@ -0,0 +1,62 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include + +#include "atlas_alloc.h" +#include "util.hpp" +#include "pregion_configs.hpp" +#include "pregion_mgr.hpp" + +using namespace Atlas; + +// The input should be the name of the executable whose log is to be deleted +int main(int argc, char **argv) +{ + char input[kMaxlen_]; + + assert(argc == 2); + + PRegionMgr::createInstance(); + + char *log_name = NVM_GetLogRegionName(argv[1]); + PRegion *rgn = nullptr; + if (!(rgn = PRegionMgr::getInstance().searchPRegion(log_name))) { + fprintf(stderr, "Log for %s not found, nothing to do\n", argv[1]); + return 0; + } + fprintf(stderr, "Are you sure you want to delete log for %s (yes/no)? ", + argv[1]); + + while (true) + { + char *s = fgets(input, kMaxlen_, stdin); + if (!strcmp(s, "yes\n")) + { + PRegionMgr::getInstance().deleteForcefullyPRegion(log_name); + + PRegionMgr::deleteInstance(); + + fprintf(stderr, "Log for %s successfully deleted\n", argv[1]); + break; + } + else if (!strcmp(s, "no\n")) break; + else fprintf(stderr, "Please enter yes or no: "); + } + return 0; +} + diff --git a/ARP_CSFR/runtime/src/recover/del_rgn.cpp b/ARP_CSFR/runtime/src/recover/del_rgn.cpp new file mode 100644 index 0000000000000000000000000000000000000000..cb9c600fc10adaaff5e4a002800b83c6faecfb28 --- /dev/null +++ b/ARP_CSFR/runtime/src/recover/del_rgn.cpp @@ -0,0 +1,60 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include + +#include "atlas_alloc.h" +#include "util.hpp" +#include "pregion_configs.hpp" +#include "pregion_mgr.hpp" + +using namespace Atlas; + +// The input should be the name of a region +int main(int argc, char **argv) +{ + char input[kMaxlen_]; + + assert(argc == 2); + + PRegionMgr::createInstance(); + + PRegion *rgn = nullptr; + if (!(rgn = PRegionMgr::getInstance().searchPRegion(argv[1]))) { + fprintf(stderr, "Region %s not found, nothing to do\n", argv[1]); + return 0; + } + fprintf(stderr, "Are you sure you want to delete region %s (yes/no)? ", + argv[1]); + while (true) + { + char *s = fgets(input, kMaxlen_, stdin); + if (!strcmp(s, "yes\n")) + { + PRegionMgr::getInstance().deletePRegion(argv[1]); + + PRegionMgr::deleteInstance(); + + fprintf(stderr, "Region %s successfully deleted\n", argv[1]); + break; + } + else if (!strcmp(s, "no\n")) break; + else fprintf(stderr, "Please enter yes or no: "); + } + return 0; +} diff --git a/ARP_CSFR/runtime/src/recover/recover.cpp b/ARP_CSFR/runtime/src/recover/recover.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c67c1a09ac28cde503439858775eb92607449ed0 --- /dev/null +++ b/ARP_CSFR/runtime/src/recover/recover.cpp @@ -0,0 +1,369 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "util.hpp" +#include "atlas_alloc.h" +#include "pregion_mgr.hpp" +#include "pregion_configs.hpp" +#include "log_mgr.hpp" +#include "recover.hpp" + +using namespace Atlas; + +//namespace Atlas { + +Tid2Log first_log_tracker; +Tid2Log last_log_tracker; +MapR2A map_r2a; + +// TODO: need to factor in the generation number. Does free with overloaded +// gen_num still work? +MapLog2Bool replayed_entries; +MapInt2Bool done_threads; +MapLog2Log prev_log_mapper; + +// All open persistent regions must have an entry in the following data +// structure that maps a region address range to its region id. +// TODO: is this still required with the new persistent region manager? +MapInterval mapped_prs; + +uint64_t replayed_count = 0; + +//} + +int main(int argc, char **argv) +{ + assert(argc == 2); + + R_Initialize(argv[1]); + + LogStructure *lsp = GetLogStructureHeader(); + + // This can happen if logs were never created by the user threads + // or if the log entry was deleted by the region manager but there + // was a failure before the log file was removed. + + // Note that if logs are ever created, there should be some remnants + // after a crash since the helper thread never removes everything. + if (!lsp) + { + fprintf(stderr, "[Atlas] Warning: No logs present\n"); + R_Finalize(argv[1]); + exit(0); + } + +#if !defined(_FLUSH_GLOBAL_COMMIT) + helper(lsp); +#endif + + LogStructure *recovery_lsp = + LogMgr::getInstance().getRecoveryLogPointer(std::memory_order_acquire); + if (recovery_lsp) lsp = recovery_lsp; + + CreateRelToAcqMappings(lsp); + + Recover(); + + R_Finalize(argv[1]); +} + +void R_Initialize(const char *s) +{ +// NVM_SetupRegionTable(s); + + PRegionMgr::createInstance(); + LogMgr::createRecoveryInstance(); + + // The exact mechanism to find the regions that need to be reverted + // remains to be done. One possibility is to look at all logs on + // persistent memory, conceivably from a certain pre-specified region. + // For now, the recovery process requires the name of the process + // whose crash we are trying to recover from. Using this information, + // the recovery phase constructs the name of the corresponding log and + // finds the regions needing recovery from this log. + char *log_name = NVM_GetLogRegionName(s); + if (!NVM_doesLogExist(NVM_GetFullyQualifiedRegionName(log_name))) + { + fprintf(stderr, "[Atlas] No log file exists, nothing to do ...\n"); + free(log_name); + exit(0); + } + + bool is_in_recovery = true; + region_id_t nvm_logs_id = + PRegionMgr::getInstance().findPRegion(log_name, O_RDWR, + is_in_recovery); + assert(nvm_logs_id != kInvalidPRegion_ && + "Log region not found in region table!"); + + LogMgr::getInstance().setRegionId(nvm_logs_id); + + void *log_base_addr = + PRegionMgr::getInstance().getPRegion( + Atlas::LogMgr::getInstance().getRegionId())->get_base_addr(); + InsertToMapInterval(&mapped_prs, + (uint64_t)log_base_addr, + (uint64_t)((char*)log_base_addr+kPRegionSize_), + Atlas::LogMgr::getInstance().getRegionId()); + free(log_name); +} + +// TODO probably want to have a deleteRecoveryInstance +void R_Finalize(const char *s) +{ + MapInterval::const_iterator ci_end = mapped_prs.end(); + for (MapInterval::const_iterator ci = mapped_prs.begin(); + ci != ci_end; ++ ci) + PRegionMgr::getInstance().closePRegion(ci->second); + + char *log_name = NVM_GetLogRegionName(s); + NVM_DeleteRegion(log_name); + free(log_name); + fprintf(stderr, "[Atlas] Done bookkeeping\n"); +} + +LogStructure *GetLogStructureHeader() +{ + // TODO use atomics + LogStructure **lsh_p = + (LogStructure**)NVM_GetRegionRoot( + Atlas::LogMgr::getInstance().getRegionId()); + if (!lsh_p) { + std::cout << + "[Atlas] Region root is null: did you forget to set it?" + << std::endl; + return nullptr; + } + return (LogStructure*)*lsh_p; +} + +void CreateRelToAcqMappings(LogStructure *lsp) +{ + // just use a logical thread id + int tid = 0; + // The very first log for a given thread must be found. This will be + // the last node replayed for this thread. Note that most of the time + // this first log will point to null but that cannot be guaranteed. The + // helper thread commits changes atomically by switching the log structure + // header pointer. The logs are destroyed after this atomic switch. + while (lsp) + { + LogEntry *last_log = 0; // last log written in program order + LogEntry *le = lsp->Le; + if (le) + { + assert(first_log_tracker.find(tid) == first_log_tracker.end()); + first_log_tracker[tid] = le; + } + while (le) + { + if (le->isAcquire() || le->isAlloc() || le->isFree()) + AddToMap(le, tid); + prev_log_mapper[le] = last_log; + last_log = le; + le = le->Next; + } + if (last_log) + { + assert(last_log_tracker.find(tid) == last_log_tracker.end()); + last_log_tracker.insert(make_pair(tid, last_log)); + } + ++ tid; + lsp = lsp->Next; + } +} + +void AddToMap(LogEntry *acq_le, int tid) +{ + LogEntry *rel_le = (LogEntry *)(acq_le->ValueOrPtr); + + if (rel_le) { +#if 0 // We can't assert this since a log entry may be reused. +#ifdef DEBUG + if (map_r2a.find(rel_le) != map_r2a.end()) + { + assert(rel_le->isRWLockUnlock()); + assert(acq_le->isRWLockRdLock()); + } +#endif +#endif + map_r2a.insert(make_pair(rel_le, make_pair(acq_le, tid))); + } +} + +#ifdef _NVM_TRACE +template void RecoveryTrace(void *p) +{ + fprintf(stderr, "%p %ld\n", p, *(T*)p); +} +#endif + +// The first time an address in a given persistent region (PR) is found, +// that PR is opened and all open PRs must have an entry in mapped_prs. +// Every time an address has to be replayed, it is looked up in the above +// mapper to determine whether it is already mapped. The same mapper data +// structure is used during logging as well to track all open PRs. We assume +// that no transient location is logged since it must have been filtered +// out using this mapper during logging. +void Replay(LogEntry *le) +{ + assert(le); + assert(le->isStr() || le->isMemop() || le->isAlloc() || + le->isFree() || le->isStrop()); + + void *addr = le->Addr; + if (FindInMapInterval(mapped_prs, + (uint64_t)addr, + (uint64_t)((char*)addr+le->Size-1)) == + mapped_prs.end()) { + pair mapper_result = + PRegionMgr::getInstance().ensurePRegionMapped(addr); + InsertToMapInterval(&mapped_prs, + (uint64_t)(char*)mapper_result.first, + (uint64_t)((char*)mapper_result.first+kPRegionSize_), + mapper_result.second); + } + + if (le->isStr()) { + // TODO bit access is not supported? + assert(!(le->Size % 8)); + memcpy(addr, (void*)&(le->ValueOrPtr), le->Size/8); + } + else if (le->isMemop() || le->isStrop()) { + assert(le->ValueOrPtr); + memcpy(addr, (void*)(le->ValueOrPtr), le->Size); + } + else if (le->isAlloc()) *((size_t*)addr) = false; // undo allocation + else if (le->isFree()) *((size_t*)addr) = true; // undo de-allocation + else assert(0 && "Bad log entry type"); + + ++ replayed_count; +} + +LogEntry *GetPrevLogEntry(LogEntry *le) +{ + assert(le); + if (prev_log_mapper.find(le) != prev_log_mapper.end()) + return prev_log_mapper.find(le)->second; + else return NULL; +} + +// We start from an arbitrary thread (say, tid 0), grab its last log and +// start playing back. If we hit an acquire node, we do nothing. If we +// hit a release node, we look up the map to see if it has a corresponding +// acquire node. If yes, we switch to this other thread, grab its last +// log and start playing it. This method is followed until all logs have +// been played. We need to update the last log of a given thread whenever +// we switch threads. If all logs in a given thread are exhausted, we delete +// that thread entry from the last-log-tracker. + +void Recover() +{ + Tid2Log::iterator ci_end = last_log_tracker.end(); + for (Tid2Log::iterator ci = last_log_tracker.begin(); ci != ci_end; ++ ci) + Recover(ci->first); + fprintf(stderr, "[Atlas] Done undoing %ld log entries\n", replayed_count); +} + +void Recover(int tid) +{ + if (done_threads.find(tid) != done_threads.end()) return; + + // All replayed logs must have been filtered already. + Tid2Log::iterator ci = last_log_tracker.find(tid); + if (ci == last_log_tracker.end()) return; + + LogEntry *le = ci->second; + + assert(first_log_tracker.find(tid) != first_log_tracker.end()); + LogEntry *stop_node = first_log_tracker.find(tid)->second; + + while (le) { +#ifdef _NVM_TRACE + fprintf(stderr, + "Replaying tid = %d le = %p, addr = %p, val = %ld Type = %s\n", + tid, le, le->Addr, le->ValueOrPtr, + le->Type == LE_acquire ? "acq" : + le->Type == LE_release ? "rel" : + le->Type == LE_str ? "str" : + le->isMemset() ? "memset" : + le->isMemcpy() ? "memcpy" : + le->isMemmove() ? "memmove" : + le->isStrcpy() ? "strcpy" : + le->isStrcat() ? "strcat" : "don't-care"); +#endif + // TODO: handle other kinds of locks during recovery. + if (le->isRelease() || le->isFree()) { + pair r2a_iter = map_r2a.equal_range(le); + if (r2a_iter.first != r2a_iter.second) { + // We are doing a switch, so adjust the last log + // from where a subsequent visit should start + ci->second = GetPrevLogEntry(le); + } + for (R2AIter ii = r2a_iter.first; ii != r2a_iter.second; ++ii) { + LogEntry *new_tid_acq = ii->second.first; + int new_tid = ii->second.second; + + if (!isAlreadyReplayed(new_tid_acq)) Recover(new_tid); + } + if (le->isFree()) { + Replay(le); + if (done_threads.find(tid) != done_threads.end()) break; + MarkReplayed(le); + } + } + else if (le->isAcquire() || le->isAlloc()) { + if (le->isAlloc()) Replay(le); + + if (done_threads.find(tid) != done_threads.end()) break; + MarkReplayed(le); + } + else if (le->isStr() || + le->isMemset() || le->isMemcpy() || le->isMemmove() || + le->isStrcpy() || le->isStrcat()) + Replay(le); + + if (le == stop_node) { + done_threads.insert(make_pair(tid, true)); + break; + } + le = GetPrevLogEntry(le); + } +} + +void MarkReplayed(LogEntry *le) +{ + assert(le->isAcquire() || le->isAlloc() || le->isFree()); + assert(replayed_entries.find(le) == replayed_entries.end()); + replayed_entries[le] = true; +} + +bool isAlreadyReplayed(LogEntry *le) +{ + assert(le->isAcquire() || le->isAlloc() || le->isFree()); + return replayed_entries.find(le) != replayed_entries.end(); +} + diff --git a/runtime/src/recover/recover.hpp b/ARP_CSFR/runtime/src/recover/recover.hpp similarity index 100% rename from runtime/src/recover/recover.hpp rename to ARP_CSFR/runtime/src/recover/recover.hpp diff --git a/runtime/src/src/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/CMakeFiles/progress.marks diff --git a/runtime/src/src/Makefile b/ARP_CSFR/runtime/src/src/Makefile similarity index 100% rename from runtime/src/src/Makefile rename to ARP_CSFR/runtime/src/src/Makefile diff --git a/runtime/src/src/cache_flush/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/DependInfo.cmake diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/build.make b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/build.make similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/build.make rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/build.make diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/cmake_clean.cmake diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/depend.make b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/depend.make similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/depend.make rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/depend.make diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/flags.make b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/flags.make similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/flags.make rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/flags.make diff --git a/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/progress.make b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/progress.make similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/progress.make rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/Cache_flush.dir/progress.make diff --git a/runtime/src/src/cache_flush/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/cache_flush/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/cache_flush/CMakeFiles/progress.marks diff --git a/runtime/src/src/cache_flush/Makefile b/ARP_CSFR/runtime/src/src/cache_flush/Makefile similarity index 100% rename from runtime/src/src/cache_flush/Makefile rename to ARP_CSFR/runtime/src/src/cache_flush/Makefile diff --git a/runtime/src/src/cache_flush/cmake_install.cmake b/ARP_CSFR/runtime/src/src/cache_flush/cmake_install.cmake similarity index 100% rename from runtime/src/src/cache_flush/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/cache_flush/cmake_install.cmake diff --git a/runtime/src/src/cmake_install.cmake b/ARP_CSFR/runtime/src/src/cmake_install.cmake similarity index 100% rename from runtime/src/src/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/cmake_install.cmake diff --git a/runtime/src/src/consistency/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/DependInfo.cmake diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/build.make b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/build.make similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/build.make rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/build.make diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/cmake_clean.cmake diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/depend.make b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/depend.make similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/depend.make rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/depend.make diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/flags.make b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/flags.make similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/flags.make rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/flags.make diff --git a/runtime/src/src/consistency/CMakeFiles/Consistency.dir/progress.make b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/progress.make similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/Consistency.dir/progress.make rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/Consistency.dir/progress.make diff --git a/runtime/src/src/consistency/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/consistency/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/consistency/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/consistency/CMakeFiles/progress.marks diff --git a/runtime/src/src/consistency/Makefile b/ARP_CSFR/runtime/src/src/consistency/Makefile similarity index 100% rename from runtime/src/src/consistency/Makefile rename to ARP_CSFR/runtime/src/src/consistency/Makefile diff --git a/runtime/src/src/consistency/cmake_install.cmake b/ARP_CSFR/runtime/src/src/consistency/cmake_install.cmake similarity index 100% rename from runtime/src/src/consistency/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/consistency/cmake_install.cmake diff --git a/runtime/src/src/logger/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/logger/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/DependInfo.cmake diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/build.make b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/build.make similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/build.make rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/build.make diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/cmake_clean.cmake diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/depend.make b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/depend.make similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/depend.make rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/depend.make diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/flags.make b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/flags.make similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/flags.make rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/flags.make diff --git a/runtime/src/src/logger/CMakeFiles/Logger.dir/progress.make b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/progress.make similarity index 100% rename from runtime/src/src/logger/CMakeFiles/Logger.dir/progress.make rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/Logger.dir/progress.make diff --git a/runtime/src/src/logger/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/logger/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/logger/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/logger/CMakeFiles/progress.marks diff --git a/runtime/src/src/logger/Makefile b/ARP_CSFR/runtime/src/src/logger/Makefile similarity index 100% rename from runtime/src/src/logger/Makefile rename to ARP_CSFR/runtime/src/src/logger/Makefile diff --git a/runtime/src/src/logger/cmake_install.cmake b/ARP_CSFR/runtime/src/src/logger/cmake_install.cmake similarity index 100% rename from runtime/src/src/logger/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/logger/cmake_install.cmake diff --git a/runtime/src/src/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/DependInfo.cmake diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/build.make b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/build.make similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/build.make rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/build.make diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/cmake_clean.cmake diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/depend.make b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/depend.make similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/depend.make rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/depend.make diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/flags.make b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/flags.make similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/flags.make rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/flags.make diff --git a/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/progress.make b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/progress.make similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/progress.make rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/Pmalloc.dir/progress.make diff --git a/runtime/src/src/pmalloc/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/pmalloc/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/pmalloc/CMakeFiles/progress.marks diff --git a/runtime/src/src/pmalloc/Makefile b/ARP_CSFR/runtime/src/src/pmalloc/Makefile similarity index 100% rename from runtime/src/src/pmalloc/Makefile rename to ARP_CSFR/runtime/src/src/pmalloc/Makefile diff --git a/runtime/src/src/pmalloc/cmake_install.cmake b/ARP_CSFR/runtime/src/src/pmalloc/cmake_install.cmake similarity index 100% rename from runtime/src/src/pmalloc/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/pmalloc/cmake_install.cmake diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/DependInfo.cmake diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/build.make diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/cmake_clean.cmake diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/depend.make b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/depend.make similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/depend.make rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/depend.make diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/flags.make b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/flags.make similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/flags.make rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/flags.make diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/progress.make b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/progress.make similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/progress.make rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/Pregion_mgr.dir/progress.make diff --git a/runtime/src/src/pregion_mgr/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/pregion_mgr/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/pregion_mgr/CMakeFiles/progress.marks diff --git a/runtime/src/src/pregion_mgr/Makefile b/ARP_CSFR/runtime/src/src/pregion_mgr/Makefile similarity index 100% rename from runtime/src/src/pregion_mgr/Makefile rename to ARP_CSFR/runtime/src/src/pregion_mgr/Makefile diff --git a/runtime/src/src/pregion_mgr/cmake_install.cmake b/ARP_CSFR/runtime/src/src/pregion_mgr/cmake_install.cmake similarity index 100% rename from runtime/src/src/pregion_mgr/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/pregion_mgr/cmake_install.cmake diff --git a/runtime/src/src/recover/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/DependInfo.cmake diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/build.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/build.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/build.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/build.make diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/cmake_clean.cmake diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/depend.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/depend.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/depend.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/depend.make diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/flags.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/flags.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/flags.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/flags.make diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/link.txt b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/link.txt similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/link.txt rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/link.txt diff --git a/runtime/src/src/recover/CMakeFiles/clean_mem.dir/progress.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/progress.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/clean_mem.dir/progress.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/clean_mem.dir/progress.make diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/DependInfo.cmake diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/build.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/build.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/build.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/build.make diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/cmake_clean.cmake diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/depend.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/depend.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/depend.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/depend.make diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/flags.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/flags.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/flags.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/flags.make diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/link.txt b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/link.txt similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/link.txt rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/link.txt diff --git a/runtime/src/src/recover/CMakeFiles/del_log.dir/progress.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/progress.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_log.dir/progress.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_log.dir/progress.make diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/DependInfo.cmake diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/build.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/build.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/build.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/build.make diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/cmake_clean.cmake diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/depend.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/depend.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/depend.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/depend.make diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/flags.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/flags.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/flags.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/flags.make diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/link.txt b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/link.txt similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/link.txt rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/link.txt diff --git a/runtime/src/src/recover/CMakeFiles/del_rgn.dir/progress.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/progress.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/del_rgn.dir/progress.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/del_rgn.dir/progress.make diff --git a/runtime/src/src/recover/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/recover/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/progress.marks diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/DependInfo.cmake diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/build.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/build.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/build.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/build.make diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/cmake_clean.cmake diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/depend.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/depend.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/depend.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/depend.make diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/flags.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/flags.make similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/flags.make rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/flags.make diff --git a/runtime/src/src/recover/CMakeFiles/recover.dir/link.txt b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/link.txt similarity index 100% rename from runtime/src/src/recover/CMakeFiles/recover.dir/link.txt rename to ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/link.txt diff --git a/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/progress.make b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..92cb53a3794e032cbcf16285d0fc28c647c45f1d --- /dev/null +++ b/ARP_CSFR/runtime/src/src/recover/CMakeFiles/recover.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 67 +CMAKE_PROGRESS_2 = 68 + diff --git a/runtime/src/src/recover/Makefile b/ARP_CSFR/runtime/src/src/recover/Makefile similarity index 100% rename from runtime/src/src/recover/Makefile rename to ARP_CSFR/runtime/src/src/recover/Makefile diff --git a/runtime/src/src/recover/cmake_install.cmake b/ARP_CSFR/runtime/src/src/recover/cmake_install.cmake similarity index 100% rename from runtime/src/src/recover/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/recover/cmake_install.cmake diff --git a/runtime/src/src/util/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/src/util/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/src/util/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/DependInfo.cmake similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/DependInfo.cmake diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/build.make b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/build.make similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/build.make rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/build.make diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/cmake_clean.cmake diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/depend.make b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/depend.make similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/depend.make rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/depend.make diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/flags.make b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/flags.make similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/flags.make rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/flags.make diff --git a/runtime/src/src/util/CMakeFiles/Util.dir/progress.make b/ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/progress.make similarity index 100% rename from runtime/src/src/util/CMakeFiles/Util.dir/progress.make rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/Util.dir/progress.make diff --git a/runtime/src/src/util/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/src/util/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/src/util/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/src/util/CMakeFiles/progress.marks diff --git a/runtime/src/src/util/Makefile b/ARP_CSFR/runtime/src/src/util/Makefile similarity index 100% rename from runtime/src/src/util/Makefile rename to ARP_CSFR/runtime/src/src/util/Makefile diff --git a/runtime/src/src/util/cmake_install.cmake b/ARP_CSFR/runtime/src/src/util/cmake_install.cmake similarity index 100% rename from runtime/src/src/util/cmake_install.cmake rename to ARP_CSFR/runtime/src/src/util/cmake_install.cmake diff --git a/runtime/src/tests/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/tests/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/tests/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/ARP_CSFR/runtime/src/tests/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..dde92ddc1a594acd912b467305f36d9f26da45f3 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/CMakeFiles/progress.marks @@ -0,0 +1 @@ +82 diff --git a/runtime/src/tests/Makefile b/ARP_CSFR/runtime/src/tests/Makefile similarity index 100% rename from runtime/src/tests/Makefile rename to ARP_CSFR/runtime/src/tests/Makefile diff --git a/runtime/src/tests/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/cmake_install.cmake similarity index 100% rename from runtime/src/tests/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/cmake_install.cmake diff --git a/runtime/src/tests/consistency/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/DependInfo.cmake diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/build.make b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/build.make similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/build.make rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/build.make diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/cmake_clean.cmake diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/depend.make b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/depend.make similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/depend.make rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/depend.make diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/flags.make b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/flags.make similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/flags.make rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/flags.make diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/link.txt b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/link.txt similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/link.txt rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/link.txt diff --git a/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/progress.make b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/progress.make similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/progress.make rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/malloc_free_test.dir/progress.make diff --git a/runtime/src/tests/consistency/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/tests/consistency/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/tests/consistency/CMakeFiles/progress.marks diff --git a/runtime/src/tests/consistency/Makefile b/ARP_CSFR/runtime/src/tests/consistency/Makefile similarity index 100% rename from runtime/src/tests/consistency/Makefile rename to ARP_CSFR/runtime/src/tests/consistency/Makefile diff --git a/runtime/src/tests/consistency/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/consistency/cmake_install.cmake similarity index 100% rename from runtime/src/tests/consistency/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/consistency/cmake_install.cmake diff --git a/runtime/src/tests/consistency/test_consistency b/ARP_CSFR/runtime/src/tests/consistency/test_consistency similarity index 100% rename from runtime/src/tests/consistency/test_consistency rename to ARP_CSFR/runtime/src/tests/consistency/test_consistency diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1ee5edbd2b9db912d31f2ae93dfd7e08fb8f26c6 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..889050054b9fd0ef0e089c4026b4dfe54ca1a1fb --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/alarm_clock.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/alarm_clock.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/alarm_clock.dir/flags.make + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o: tests/data_structures/CMakeFiles/alarm_clock.dir/flags.make +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o: ../tests/data_structures/alarm_clock.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/alarm_clock.dir/alarm_clock.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock.c + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/alarm_clock.dir/alarm_clock.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock.c > CMakeFiles/alarm_clock.dir/alarm_clock.c.i + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/alarm_clock.dir/alarm_clock.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock.c -o CMakeFiles/alarm_clock.dir/alarm_clock.c.s + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.requires + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.provides: tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock.dir/build.make tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.provides + +tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.provides.build: tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o + + +# Object files for target alarm_clock +alarm_clock_OBJECTS = \ +"CMakeFiles/alarm_clock.dir/alarm_clock.c.o" + +# External object files for target alarm_clock +alarm_clock_EXTERNAL_OBJECTS = + +tests/data_structures/alarm_clock: tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o +tests/data_structures/alarm_clock: tests/data_structures/CMakeFiles/alarm_clock.dir/build.make +tests/data_structures/alarm_clock: tests/data_structures/CMakeFiles/alarm_clock.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking C executable alarm_clock" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/alarm_clock.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/alarm_clock.dir/build: tests/data_structures/alarm_clock + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/build + +tests/data_structures/CMakeFiles/alarm_clock.dir/requires: tests/data_structures/CMakeFiles/alarm_clock.dir/alarm_clock.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/requires + +tests/data_structures/CMakeFiles/alarm_clock.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/alarm_clock.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/clean + +tests/data_structures/CMakeFiles/alarm_clock.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/alarm_clock.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9d25d86fdee8f65c206ddd97607d126769e0396b --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/alarm_clock.dir/alarm_clock.c.o" + "alarm_clock.pdb" + "alarm_clock" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/alarm_clock.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..86d3960fcfb12a858ed36d444d3ecd1c6ba74bd3 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for alarm_clock. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6057a66c0ab6f42a132d4dfb01e29813a0518972 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..00b0b724b902dc6921b4157f3fef94d34419dfaf --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/link.txt @@ -0,0 +1 @@ +clang -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/alarm_clock.dir/alarm_clock.c.o -o alarm_clock -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..783d35b1dbf149359d330661ac65ed41fdfaca60 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 22 +CMAKE_PROGRESS_2 = 23 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..2c77004de1e1f9b4aee1a9b04e453603975134ef --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock_nvm.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..294c82e8c315043c55a0baee7f361eb01de56b89 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/flags.make +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o: ../tests/data_structures/alarm_clock_nvm.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock_nvm.c + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock_nvm.c > CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.i + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/alarm_clock_nvm.c -o CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.s + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.requires + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.provides: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.provides + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.provides.build: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o + + +# Object files for target alarm_clock_nvm +alarm_clock_nvm_OBJECTS = \ +"CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o" + +# External object files for target alarm_clock_nvm +alarm_clock_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/alarm_clock_nvm: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o +tests/data_structures/alarm_clock_nvm: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build.make +tests/data_structures/alarm_clock_nvm: lib/libatlas.a +tests/data_structures/alarm_clock_nvm: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable alarm_clock_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/alarm_clock_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build: tests/data_structures/alarm_clock_nvm + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/build + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/requires: tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/requires + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/alarm_clock_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/clean + +tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..19bdc8e39baa5bdc1f84988aaf3850bf2590a15c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o" + "alarm_clock_nvm.pdb" + "alarm_clock_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/alarm_clock_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..deb9e254e1f936a2a691ce1365eda45975f245a0 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for alarm_clock_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..af424d5c3745e4d49ec755a89c9a511b35533d07 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..5df1647ef200c23df272d1a4cb641efc96f18e0c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/alarm_clock_nvm.dir/alarm_clock_nvm.c.o -o alarm_clock_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..59fdd588864b0bad7ef5fde96f4b908403ded43b --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/alarm_clock_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 24 +CMAKE_PROGRESS_2 = 25 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..6ef6b3ad6fd73857f4f23ca7ee41d192e92c5bcd --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..6dca9bd215a09b6c429ccb0570ccf9e2cb9b7aaf --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/cow_array_list.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/cow_array_list.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/cow_array_list.dir/flags.make + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o: tests/data_structures/CMakeFiles/cow_array_list.dir/flags.make +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o: ../tests/data_structures/cow_array_list.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/cow_array_list.dir/cow_array_list.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list.c + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/cow_array_list.dir/cow_array_list.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list.c > CMakeFiles/cow_array_list.dir/cow_array_list.c.i + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/cow_array_list.dir/cow_array_list.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list.c -o CMakeFiles/cow_array_list.dir/cow_array_list.c.s + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.requires + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.provides: tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list.dir/build.make tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.provides + +tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.provides.build: tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o + + +# Object files for target cow_array_list +cow_array_list_OBJECTS = \ +"CMakeFiles/cow_array_list.dir/cow_array_list.c.o" + +# External object files for target cow_array_list +cow_array_list_EXTERNAL_OBJECTS = + +tests/data_structures/cow_array_list: tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o +tests/data_structures/cow_array_list: tests/data_structures/CMakeFiles/cow_array_list.dir/build.make +tests/data_structures/cow_array_list: tests/data_structures/CMakeFiles/cow_array_list.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking C executable cow_array_list" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/cow_array_list.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/cow_array_list.dir/build: tests/data_structures/cow_array_list + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/build + +tests/data_structures/CMakeFiles/cow_array_list.dir/requires: tests/data_structures/CMakeFiles/cow_array_list.dir/cow_array_list.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/requires + +tests/data_structures/CMakeFiles/cow_array_list.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/cow_array_list.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/clean + +tests/data_structures/CMakeFiles/cow_array_list.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/cow_array_list.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c6f50d6cb7ec4f02511934061dfbdc34be75267d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/cow_array_list.dir/cow_array_list.c.o" + "cow_array_list.pdb" + "cow_array_list" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/cow_array_list.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..152e2f09cec685cfa3d1c131b104d86a99b88c2c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for cow_array_list. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6057a66c0ab6f42a132d4dfb01e29813a0518972 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..057216994cf07c27d2d60d36100fbbb52d72585b --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/link.txt @@ -0,0 +1 @@ +clang -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/cow_array_list.dir/cow_array_list.c.o -o cow_array_list -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..df87bc244ce4039e055f6767a4aa722f58c33625 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 29 +CMAKE_PROGRESS_2 = 30 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f2b9b42bf229bc9504e7f643e1bf149127b517c8 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list_nvm.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..984cfdae65910cc305f1c63b132128c4fb5122e2 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/flags.make +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o: ../tests/data_structures/cow_array_list_nvm.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list_nvm.c + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list_nvm.c > CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.i + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/cow_array_list_nvm.c -o CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.s + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.requires + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.provides: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.provides + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.provides.build: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o + + +# Object files for target cow_array_list_nvm +cow_array_list_nvm_OBJECTS = \ +"CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o" + +# External object files for target cow_array_list_nvm +cow_array_list_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/cow_array_list_nvm: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o +tests/data_structures/cow_array_list_nvm: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build.make +tests/data_structures/cow_array_list_nvm: lib/libatlas.a +tests/data_structures/cow_array_list_nvm: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable cow_array_list_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/cow_array_list_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build: tests/data_structures/cow_array_list_nvm + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/build + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/requires: tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/requires + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/cow_array_list_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/clean + +tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..984a12757d33481d772257465c3edbfe7493e233 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o" + "cow_array_list_nvm.pdb" + "cow_array_list_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/cow_array_list_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..3356f7b582cf7115b20bf9a0c3cffb0cbfcd5890 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for cow_array_list_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..af424d5c3745e4d49ec755a89c9a511b35533d07 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..9997a81f62168d51b70c2f0b48561f23c26a16e7 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/cow_array_list_nvm.dir/cow_array_list_nvm.c.o -o cow_array_list_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..b1ca4935691f32e9479071d2f65e60232e242a70 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/cow_array_list_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 31 +CMAKE_PROGRESS_2 = 32 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c63356c9d165db874ff30625bcec6b4d270a2e77 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/linked_list_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..41db1fa12164697888693180e2102d8b09efe0a6 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/linked_list_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/linked_list_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o: tests/data_structures/CMakeFiles/linked_list_nvm.dir/flags.make +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o: ../tests/data_structures/linked_list_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/linked_list_nvm.cc + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/linked_list_nvm.cc > CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.i + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/linked_list_nvm.cc -o CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.s + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.requires + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.provides: tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.provides + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.provides.build: tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o + + +# Object files for target linked_list_nvm +linked_list_nvm_OBJECTS = \ +"CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o" + +# External object files for target linked_list_nvm +linked_list_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/linked_list_nvm: tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o +tests/data_structures/linked_list_nvm: tests/data_structures/CMakeFiles/linked_list_nvm.dir/build.make +tests/data_structures/linked_list_nvm: lib/libatlas.a +tests/data_structures/linked_list_nvm: tests/data_structures/CMakeFiles/linked_list_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable linked_list_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/linked_list_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/linked_list_nvm.dir/build: tests/data_structures/linked_list_nvm + +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/build + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/requires: tests/data_structures/CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o.requires + +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/requires + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/linked_list_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/clean + +tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..7a3d6e385d48ac222f9c1e5e3b37412b9134c8a1 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o" + "linked_list_nvm.pdb" + "linked_list_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/linked_list_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..f8deb631bd06068fe11f89ba1b132f590816c356 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for linked_list_nvm. +# This may be replaced when dependencies are built. diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/flags.make similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/flags.make rename to ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/flags.make diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..932ad39729961c780e6186dea14a8fe6fd92895b --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/linked_list_nvm.dir/linked_list_nvm.cc.o -o linked_list_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..3b1f03a283674d85998962d5dc3890e786829890 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/linked_list_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 52 +CMAKE_PROGRESS_2 = 53 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..c770063f3385cdcb8396a55152f6e36e96b0c1b6 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/pc_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..71c80a6aef56b32aef9b2bfba9d017572d7f9c04 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/pc_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/pc_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/pc_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o: tests/data_structures/CMakeFiles/pc_nvm.dir/flags.make +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o: ../tests/data_structures/pc_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/pc_nvm.dir/pc_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/pc_nvm.cc + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/pc_nvm.dir/pc_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/pc_nvm.cc > CMakeFiles/pc_nvm.dir/pc_nvm.cc.i + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/pc_nvm.dir/pc_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/pc_nvm.cc -o CMakeFiles/pc_nvm.dir/pc_nvm.cc.s + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.requires + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.provides: tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/pc_nvm.dir/build.make tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.provides + +tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.provides.build: tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o + + +# Object files for target pc_nvm +pc_nvm_OBJECTS = \ +"CMakeFiles/pc_nvm.dir/pc_nvm.cc.o" + +# External object files for target pc_nvm +pc_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/pc_nvm: tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o +tests/data_structures/pc_nvm: tests/data_structures/CMakeFiles/pc_nvm.dir/build.make +tests/data_structures/pc_nvm: lib/libatlas.a +tests/data_structures/pc_nvm: tests/data_structures/CMakeFiles/pc_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable pc_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/pc_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/pc_nvm.dir/build: tests/data_structures/pc_nvm + +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/build + +tests/data_structures/CMakeFiles/pc_nvm.dir/requires: tests/data_structures/CMakeFiles/pc_nvm.dir/pc_nvm.cc.o.requires + +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/requires + +tests/data_structures/CMakeFiles/pc_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/pc_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/clean + +tests/data_structures/CMakeFiles/pc_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/pc_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..aef07482dfe2f1f5155085b25ff808dfe3557f44 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/pc_nvm.dir/pc_nvm.cc.o" + "pc_nvm.pdb" + "pc_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/pc_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..32c3600f3ff51bb4e4aea96a8f77567d45be3b0e --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for pc_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..af90ebca1385175fd662e3a5cecb47b0ae5d0b0c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/pc_nvm.dir/pc_nvm.cc.o -o pc_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..42baabaf6ede815f395cb5dc3002cfda912190f9 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/pc_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 58 +CMAKE_PROGRESS_2 = 59 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..69a893aa31141827125ddaaee26966b7aed3de74 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/progress.marks @@ -0,0 +1 @@ +66 diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f60e16d2d9c7afa1e7461bfd82f87cbdda08795c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/queue.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..d43efb9046a60d84df050954dde59ff0c05f4e08 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/queue.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/queue.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/queue.dir/flags.make + +tests/data_structures/CMakeFiles/queue.dir/queue.c.o: tests/data_structures/CMakeFiles/queue.dir/flags.make +tests/data_structures/CMakeFiles/queue.dir/queue.c.o: ../tests/data_structures/queue.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/queue.dir/queue.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/queue.dir/queue.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue.c + +tests/data_structures/CMakeFiles/queue.dir/queue.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/queue.dir/queue.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue.c > CMakeFiles/queue.dir/queue.c.i + +tests/data_structures/CMakeFiles/queue.dir/queue.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/queue.dir/queue.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue.c -o CMakeFiles/queue.dir/queue.c.s + +tests/data_structures/CMakeFiles/queue.dir/queue.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/queue.dir/queue.c.o.requires + +tests/data_structures/CMakeFiles/queue.dir/queue.c.o.provides: tests/data_structures/CMakeFiles/queue.dir/queue.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/queue.dir/build.make tests/data_structures/CMakeFiles/queue.dir/queue.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/queue.dir/queue.c.o.provides + +tests/data_structures/CMakeFiles/queue.dir/queue.c.o.provides.build: tests/data_structures/CMakeFiles/queue.dir/queue.c.o + + +# Object files for target queue +queue_OBJECTS = \ +"CMakeFiles/queue.dir/queue.c.o" + +# External object files for target queue +queue_EXTERNAL_OBJECTS = + +tests/data_structures/queue: tests/data_structures/CMakeFiles/queue.dir/queue.c.o +tests/data_structures/queue: tests/data_structures/CMakeFiles/queue.dir/build.make +tests/data_structures/queue: tests/data_structures/CMakeFiles/queue.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking C executable queue" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/queue.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/queue.dir/build: tests/data_structures/queue + +.PHONY : tests/data_structures/CMakeFiles/queue.dir/build + +tests/data_structures/CMakeFiles/queue.dir/requires: tests/data_structures/CMakeFiles/queue.dir/queue.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/queue.dir/requires + +tests/data_structures/CMakeFiles/queue.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/queue.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/queue.dir/clean + +tests/data_structures/CMakeFiles/queue.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/queue.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5d8f0c58b5d08bea2944645dbe7eae1bf3075e99 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/queue.dir/queue.c.o" + "queue.pdb" + "queue" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/queue.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..83ed62fe137f672bbb0e75c222b8c0e8a8c51775 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for queue. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6057a66c0ab6f42a132d4dfb01e29813a0518972 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..2e9b7fb2e2fa24b25fdba7a237fd321a5008adcd --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/link.txt @@ -0,0 +1 @@ +clang -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/queue.dir/queue.c.o -o queue -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..554ea331c3730ec3d2c7fdc41d6c4d5381f26af1 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 60 +CMAKE_PROGRESS_2 = 61 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..298dcb924bf0cdeb938513128d4b03d48711558c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue_nvm.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..c243b387e6172640ee181c78a548312b87a8735d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/queue_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/queue_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/queue_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o: tests/data_structures/CMakeFiles/queue_nvm.dir/flags.make +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o: ../tests/data_structures/queue_nvm.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/queue_nvm.dir/queue_nvm.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue_nvm.c + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/queue_nvm.dir/queue_nvm.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue_nvm.c > CMakeFiles/queue_nvm.dir/queue_nvm.c.i + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/queue_nvm.dir/queue_nvm.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/queue_nvm.c -o CMakeFiles/queue_nvm.dir/queue_nvm.c.s + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.requires + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.provides: tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/queue_nvm.dir/build.make tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.provides + +tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.provides.build: tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o + + +# Object files for target queue_nvm +queue_nvm_OBJECTS = \ +"CMakeFiles/queue_nvm.dir/queue_nvm.c.o" + +# External object files for target queue_nvm +queue_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/queue_nvm: tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o +tests/data_structures/queue_nvm: tests/data_structures/CMakeFiles/queue_nvm.dir/build.make +tests/data_structures/queue_nvm: lib/libatlas.a +tests/data_structures/queue_nvm: tests/data_structures/CMakeFiles/queue_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable queue_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/queue_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/queue_nvm.dir/build: tests/data_structures/queue_nvm + +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/build + +tests/data_structures/CMakeFiles/queue_nvm.dir/requires: tests/data_structures/CMakeFiles/queue_nvm.dir/queue_nvm.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/requires + +tests/data_structures/CMakeFiles/queue_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/queue_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/clean + +tests/data_structures/CMakeFiles/queue_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/queue_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..255995ad5687c00cc14f705fa25d06698f62841d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/queue_nvm.dir/queue_nvm.c.o" + "queue_nvm.pdb" + "queue_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/queue_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..40185742cb05660618334445b43816c024f53e5d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for queue_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..af424d5c3745e4d49ec755a89c9a511b35533d07 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..29283d513620049edef8d9d9de7f17d4be1741bd --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/queue_nvm.dir/queue_nvm.c.o -o queue_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..efa3e6a284a8d8babc02f14355f97ad962624f53 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/queue_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 62 +CMAKE_PROGRESS_2 = 63 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..40659716e8aedb811b329a8abde7b0da69fd6765 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll.cpp" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..803332cc0528ab7698ed13d95311df5da4efc309 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sll.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sll.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sll.dir/flags.make + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o: tests/data_structures/CMakeFiles/sll.dir/flags.make +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o: ../tests/data_structures/sll.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sll.dir/sll.cpp.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll.cpp + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sll.dir/sll.cpp.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll.cpp > CMakeFiles/sll.dir/sll.cpp.i + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sll.dir/sll.cpp.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll.cpp -o CMakeFiles/sll.dir/sll.cpp.s + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.requires + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.provides: tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sll.dir/build.make tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.provides + +tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.provides.build: tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o + + +# Object files for target sll +sll_OBJECTS = \ +"CMakeFiles/sll.dir/sll.cpp.o" + +# External object files for target sll +sll_EXTERNAL_OBJECTS = + +tests/data_structures/sll: tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o +tests/data_structures/sll: tests/data_structures/CMakeFiles/sll.dir/build.make +tests/data_structures/sll: tests/data_structures/CMakeFiles/sll.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sll" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sll.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sll.dir/build: tests/data_structures/sll + +.PHONY : tests/data_structures/CMakeFiles/sll.dir/build + +tests/data_structures/CMakeFiles/sll.dir/requires: tests/data_structures/CMakeFiles/sll.dir/sll.cpp.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sll.dir/requires + +tests/data_structures/CMakeFiles/sll.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sll.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sll.dir/clean + +tests/data_structures/CMakeFiles/sll.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sll.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..3e566183e6e96db24a862ed2ea5e113e15cfa053 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sll.dir/sll.cpp.o" + "sll.pdb" + "sll" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sll.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..d93cdfd2f1a51be90e30baa73b01c496add669a2 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sll. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..326c5658b04a6a3bcbb1f2c7bd5987f56c46853d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..b7aebcb8cb1eaddcd9150d298110aa4d170454b0 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sll.dir/sll.cpp.o -o sll -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..352b7a46f1b9b1a4ba40430735266be5ca3c639f --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 69 +CMAKE_PROGRESS_2 = 70 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b2aefe999472d7985590ebe760f9c80eb5f29438 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_ll.cpp" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..73cddc600bf31e69a7e950eb4f95a59e3b1c63a8 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sll_ll.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sll_ll.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sll_ll.dir/flags.make + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o: tests/data_structures/CMakeFiles/sll_ll.dir/flags.make +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o: ../tests/data_structures/sll_ll.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sll_ll.dir/sll_ll.cpp.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_ll.cpp + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sll_ll.dir/sll_ll.cpp.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_ll.cpp > CMakeFiles/sll_ll.dir/sll_ll.cpp.i + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sll_ll.dir/sll_ll.cpp.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_ll.cpp -o CMakeFiles/sll_ll.dir/sll_ll.cpp.s + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.requires + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.provides: tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sll_ll.dir/build.make tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.provides + +tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.provides.build: tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o + + +# Object files for target sll_ll +sll_ll_OBJECTS = \ +"CMakeFiles/sll_ll.dir/sll_ll.cpp.o" + +# External object files for target sll_ll +sll_ll_EXTERNAL_OBJECTS = + +tests/data_structures/sll_ll: tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o +tests/data_structures/sll_ll: tests/data_structures/CMakeFiles/sll_ll.dir/build.make +tests/data_structures/sll_ll: lib/libatlas.a +tests/data_structures/sll_ll: tests/data_structures/CMakeFiles/sll_ll.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sll_ll" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sll_ll.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sll_ll.dir/build: tests/data_structures/sll_ll + +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/build + +tests/data_structures/CMakeFiles/sll_ll.dir/requires: tests/data_structures/CMakeFiles/sll_ll.dir/sll_ll.cpp.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/requires + +tests/data_structures/CMakeFiles/sll_ll.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sll_ll.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/clean + +tests/data_structures/CMakeFiles/sll_ll.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sll_ll.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..47a134aa2aa9b177b2a51cea7b5f7b62736ff82c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sll_ll.dir/sll_ll.cpp.o" + "sll_ll.pdb" + "sll_ll" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sll_ll.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..f9258de7afdac7d679d4a6945d1064c37400dde3 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sll_ll. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..c609727472b138449acd74f02e4fd8ae887194a6 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sll_ll.dir/sll_ll.cpp.o -o sll_ll -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..bfbf6b1ff17f631cb7eb4c8be59a7c488ea5fa41 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_ll.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 71 +CMAKE_PROGRESS_2 = 72 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e54144deaf0d2d78ae15ec84fee5b00b1437ae4d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt.cpp" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..08dbfea56f1ed18f1aa6348c7e5adcea988ca489 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sll_mt.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sll_mt.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sll_mt.dir/flags.make + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o: tests/data_structures/CMakeFiles/sll_mt.dir/flags.make +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o: ../tests/data_structures/sll_mt.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sll_mt.dir/sll_mt.cpp.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt.cpp + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sll_mt.dir/sll_mt.cpp.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt.cpp > CMakeFiles/sll_mt.dir/sll_mt.cpp.i + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sll_mt.dir/sll_mt.cpp.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt.cpp -o CMakeFiles/sll_mt.dir/sll_mt.cpp.s + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.requires + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.provides: tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt.dir/build.make tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.provides + +tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.provides.build: tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o + + +# Object files for target sll_mt +sll_mt_OBJECTS = \ +"CMakeFiles/sll_mt.dir/sll_mt.cpp.o" + +# External object files for target sll_mt +sll_mt_EXTERNAL_OBJECTS = + +tests/data_structures/sll_mt: tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o +tests/data_structures/sll_mt: tests/data_structures/CMakeFiles/sll_mt.dir/build.make +tests/data_structures/sll_mt: tests/data_structures/CMakeFiles/sll_mt.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sll_mt" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sll_mt.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sll_mt.dir/build: tests/data_structures/sll_mt + +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/build + +tests/data_structures/CMakeFiles/sll_mt.dir/requires: tests/data_structures/CMakeFiles/sll_mt.dir/sll_mt.cpp.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/requires + +tests/data_structures/CMakeFiles/sll_mt.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sll_mt.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/clean + +tests/data_structures/CMakeFiles/sll_mt.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sll_mt.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..5f029fb8992dbb3519720a2eb40233f3f72bc4af --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sll_mt.dir/sll_mt.cpp.o" + "sll_mt.pdb" + "sll_mt" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sll_mt.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..827e79a0b37df419246e23dacd3597cab62fca3a --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sll_mt. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..326c5658b04a6a3bcbb1f2c7bd5987f56c46853d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..44ae82f2c0a1c4f9aee578a2aaffc15c57c33e0c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sll_mt.dir/sll_mt.cpp.o -o sll_mt -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..55f8f35ce96e2d502478fe61efcf23ce18daf8de --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 73 +CMAKE_PROGRESS_2 = 74 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..405bf8ca948e9c254be440b1f03abddaf9370555 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt_ll.cpp" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..db3e0132cf4b8e7fe1d99154024c140aa1c236f8 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sll_mt_ll.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sll_mt_ll.dir/flags.make + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o: tests/data_structures/CMakeFiles/sll_mt_ll.dir/flags.make +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o: ../tests/data_structures/sll_mt_ll.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt_ll.cpp + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt_ll.cpp > CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.i + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_mt_ll.cpp -o CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.s + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.requires + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.provides: tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.provides + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.provides.build: tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o + + +# Object files for target sll_mt_ll +sll_mt_ll_OBJECTS = \ +"CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o" + +# External object files for target sll_mt_ll +sll_mt_ll_EXTERNAL_OBJECTS = + +tests/data_structures/sll_mt_ll: tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o +tests/data_structures/sll_mt_ll: tests/data_structures/CMakeFiles/sll_mt_ll.dir/build.make +tests/data_structures/sll_mt_ll: lib/libatlas.a +tests/data_structures/sll_mt_ll: tests/data_structures/CMakeFiles/sll_mt_ll.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sll_mt_ll" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sll_mt_ll.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sll_mt_ll.dir/build: tests/data_structures/sll_mt_ll + +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/build + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/requires: tests/data_structures/CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/requires + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sll_mt_ll.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/clean + +tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..845394a3f9fc7037d36397921931d4e63bc44da3 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o" + "sll_mt_ll.pdb" + "sll_mt_ll" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sll_mt_ll.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..cbd3e18601f0da92d21770f531b24b46a0f08296 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sll_mt_ll. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..7a628090b580cc646d8490f7d0c425caf57c2493 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sll_mt_ll.dir/sll_mt_ll.cpp.o -o sll_mt_ll -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..2f0ffa437e4c1be4812f640c5de80a1730e69aa7 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_mt_ll.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 75 +CMAKE_PROGRESS_2 = 76 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..0b5487173bf3b0eb734fbb23e8805250fc5e8f6c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_nvm.cpp" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..ec93e607356c9e679f553dd26eaee5c77389271d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sll_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sll_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sll_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o: tests/data_structures/CMakeFiles/sll_nvm.dir/flags.make +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o: ../tests/data_structures/sll_nvm.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_nvm.cpp + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sll_nvm.dir/sll_nvm.cpp.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_nvm.cpp > CMakeFiles/sll_nvm.dir/sll_nvm.cpp.i + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sll_nvm.dir/sll_nvm.cpp.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sll_nvm.cpp -o CMakeFiles/sll_nvm.dir/sll_nvm.cpp.s + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.requires + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.provides: tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sll_nvm.dir/build.make tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.provides + +tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.provides.build: tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o + + +# Object files for target sll_nvm +sll_nvm_OBJECTS = \ +"CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o" + +# External object files for target sll_nvm +sll_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/sll_nvm: tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o +tests/data_structures/sll_nvm: tests/data_structures/CMakeFiles/sll_nvm.dir/build.make +tests/data_structures/sll_nvm: lib/libatlas.a +tests/data_structures/sll_nvm: tests/data_structures/CMakeFiles/sll_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sll_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sll_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sll_nvm.dir/build: tests/data_structures/sll_nvm + +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/build + +tests/data_structures/CMakeFiles/sll_nvm.dir/requires: tests/data_structures/CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/requires + +tests/data_structures/CMakeFiles/sll_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sll_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/clean + +tests/data_structures/CMakeFiles/sll_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sll_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..742930d0dac09f465560b4f62a4ed174db5e674a --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o" + "sll_nvm.pdb" + "sll_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sll_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..4ca8bb9f0e70df890956f67ec56c13d814f65d19 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sll_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..19812373603b5e9eccef8cc772de5597fc410ee1 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sll_nvm.dir/sll_nvm.cpp.o -o sll_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..ee7811fe36f39024471314df70136dd8ae54d9e9 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sll_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 77 +CMAKE_PROGRESS_2 = 78 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..e2bb01d8cdf68d568023b3b579672817165fd37c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sps_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..2b65cea6d4c3d1e3dfe5d122a39428cfdac5633a --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/sps_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/sps_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/sps_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o: tests/data_structures/CMakeFiles/sps_nvm.dir/flags.make +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o: ../tests/data_structures/sps_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/sps_nvm.dir/sps_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sps_nvm.cc + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/sps_nvm.dir/sps_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sps_nvm.cc > CMakeFiles/sps_nvm.dir/sps_nvm.cc.i + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/sps_nvm.dir/sps_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/sps_nvm.cc -o CMakeFiles/sps_nvm.dir/sps_nvm.cc.s + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.requires + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.provides: tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/sps_nvm.dir/build.make tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.provides + +tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.provides.build: tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o + + +# Object files for target sps_nvm +sps_nvm_OBJECTS = \ +"CMakeFiles/sps_nvm.dir/sps_nvm.cc.o" + +# External object files for target sps_nvm +sps_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/sps_nvm: tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o +tests/data_structures/sps_nvm: tests/data_structures/CMakeFiles/sps_nvm.dir/build.make +tests/data_structures/sps_nvm: lib/libatlas.a +tests/data_structures/sps_nvm: tests/data_structures/CMakeFiles/sps_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable sps_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/sps_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/sps_nvm.dir/build: tests/data_structures/sps_nvm + +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/build + +tests/data_structures/CMakeFiles/sps_nvm.dir/requires: tests/data_structures/CMakeFiles/sps_nvm.dir/sps_nvm.cc.o.requires + +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/requires + +tests/data_structures/CMakeFiles/sps_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/sps_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/clean + +tests/data_structures/CMakeFiles/sps_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/sps_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..eabf584e362f07ba241c7ca7eaac203c51066892 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/sps_nvm.dir/sps_nvm.cc.o" + "sps_nvm.pdb" + "sps_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/sps_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..cc3d807cb30665123b2dee2ef687691de8386454 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for sps_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..82c7bca5f342e51b3f3ec15a0b7cf6132ff78bbd --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/sps_nvm.dir/sps_nvm.cc.o -o sps_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..541af66b51d224ffc6983dd26019d0c0cebfadde --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/sps_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 79 +CMAKE_PROGRESS_2 = 80 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..8043e8579220e5eb04e682c8c15c2c3efc927441 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/DependInfo.cmake @@ -0,0 +1,22 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/stores.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..16849477bc10ad9f2975bc1db0d95a57325b9328 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/build.make @@ -0,0 +1,113 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/stores.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/stores.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/stores.dir/flags.make + +tests/data_structures/CMakeFiles/stores.dir/stores.c.o: tests/data_structures/CMakeFiles/stores.dir/flags.make +tests/data_structures/CMakeFiles/stores.dir/stores.c.o: ../tests/data_structures/stores.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/stores.dir/stores.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/stores.dir/stores.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores.c + +tests/data_structures/CMakeFiles/stores.dir/stores.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/stores.dir/stores.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores.c > CMakeFiles/stores.dir/stores.c.i + +tests/data_structures/CMakeFiles/stores.dir/stores.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/stores.dir/stores.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores.c -o CMakeFiles/stores.dir/stores.c.s + +tests/data_structures/CMakeFiles/stores.dir/stores.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/stores.dir/stores.c.o.requires + +tests/data_structures/CMakeFiles/stores.dir/stores.c.o.provides: tests/data_structures/CMakeFiles/stores.dir/stores.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/stores.dir/build.make tests/data_structures/CMakeFiles/stores.dir/stores.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/stores.dir/stores.c.o.provides + +tests/data_structures/CMakeFiles/stores.dir/stores.c.o.provides.build: tests/data_structures/CMakeFiles/stores.dir/stores.c.o + + +# Object files for target stores +stores_OBJECTS = \ +"CMakeFiles/stores.dir/stores.c.o" + +# External object files for target stores +stores_EXTERNAL_OBJECTS = + +tests/data_structures/stores: tests/data_structures/CMakeFiles/stores.dir/stores.c.o +tests/data_structures/stores: tests/data_structures/CMakeFiles/stores.dir/build.make +tests/data_structures/stores: tests/data_structures/CMakeFiles/stores.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking C executable stores" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/stores.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/stores.dir/build: tests/data_structures/stores + +.PHONY : tests/data_structures/CMakeFiles/stores.dir/build + +tests/data_structures/CMakeFiles/stores.dir/requires: tests/data_structures/CMakeFiles/stores.dir/stores.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/stores.dir/requires + +tests/data_structures/CMakeFiles/stores.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/stores.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/stores.dir/clean + +tests/data_structures/CMakeFiles/stores.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/stores.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..b1e653e85102b5716b26dbef02348cf0ae8f9f9d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/stores.dir/stores.c.o" + "stores.pdb" + "stores" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/stores.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..3d8e359967cbe3c19f4e2333465f606ab9a9aaf9 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for stores. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6057a66c0ab6f42a132d4dfb01e29813a0518972 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..e4731c107519b0ec11ab29f15412400e83f57978 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/link.txt @@ -0,0 +1 @@ +clang -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/stores.dir/stores.c.o -o stores -rdynamic -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..f85a85d9dd25035a9bd601da7f3d0d3324f8b25a --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 81 +CMAKE_PROGRESS_2 = 82 + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..acc9e34a410bda08aadcdf61f99eccb511444946 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/DependInfo.cmake @@ -0,0 +1,23 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "C" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_C + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores_nvm.c" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o" + ) +set(CMAKE_C_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_C_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..2369ebb306b1794ec1ab2d12a478c8b8287bd2b3 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/build.make @@ -0,0 +1,114 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/CMakeFiles/stores_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/CMakeFiles/stores_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/CMakeFiles/stores_nvm.dir/flags.make + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o: tests/data_structures/CMakeFiles/stores_nvm.dir/flags.make +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o: ../tests/data_structures/stores_nvm.c + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -o CMakeFiles/stores_nvm.dir/stores_nvm.c.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores_nvm.c + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing C source to CMakeFiles/stores_nvm.dir/stores_nvm.c.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores_nvm.c > CMakeFiles/stores_nvm.dir/stores_nvm.c.i + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling C source to assembly CMakeFiles/stores_nvm.dir/stores_nvm.c.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && clang $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/stores_nvm.c -o CMakeFiles/stores_nvm.dir/stores_nvm.c.s + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.requires: + +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.requires + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.provides: tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.requires + $(MAKE) -f tests/data_structures/CMakeFiles/stores_nvm.dir/build.make tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.provides.build +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.provides + +tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.provides.build: tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o + + +# Object files for target stores_nvm +stores_nvm_OBJECTS = \ +"CMakeFiles/stores_nvm.dir/stores_nvm.c.o" + +# External object files for target stores_nvm +stores_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/stores_nvm: tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o +tests/data_structures/stores_nvm: tests/data_structures/CMakeFiles/stores_nvm.dir/build.make +tests/data_structures/stores_nvm: lib/libatlas.a +tests/data_structures/stores_nvm: tests/data_structures/CMakeFiles/stores_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Linking CXX executable stores_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/stores_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/CMakeFiles/stores_nvm.dir/build: tests/data_structures/stores_nvm + +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/build + +tests/data_structures/CMakeFiles/stores_nvm.dir/requires: tests/data_structures/CMakeFiles/stores_nvm.dir/stores_nvm.c.o.requires + +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/requires + +tests/data_structures/CMakeFiles/stores_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures && $(CMAKE_COMMAND) -P CMakeFiles/stores_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/clean + +tests/data_structures/CMakeFiles/stores_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/CMakeFiles/stores_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1870cfcd9bfd20e583385c05fa8800c46b8b2b74 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/cmake_clean.cmake @@ -0,0 +1,10 @@ +file(REMOVE_RECURSE + "CMakeFiles/stores_nvm.dir/stores_nvm.c.o" + "stores_nvm.pdb" + "stores_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang C) + include(CMakeFiles/stores_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..eec4febb73c628ac096f33a31216e4a0a83af35d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for stores_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..af424d5c3745e4d49ec755a89c9a511b35533d07 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile C with clang +C_FLAGS = -O3 -Wall -Wextra -pedantic -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu11 + +C_DEFINES = + +C_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..704cc0dfd61b92ed6ce140fa61d75ccbb479f0f9 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/stores_nvm.dir/stores_nvm.c.o -o stores_nvm -rdynamic -lpthread -lrt ../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..9c096217852527b886cd074734962dab2d75695d --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CMakeFiles/stores_nvm.dir/progress.make @@ -0,0 +1,3 @@ +CMAKE_PROGRESS_1 = 83 +CMAKE_PROGRESS_2 = 84 + diff --git a/runtime/src/tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/DependInfo.cmake diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/build.make diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/cmake_clean.cmake diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/depend.make similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/depend.make rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/depend.make diff --git a/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/link.txt similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/link.txt rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/link.txt diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/progress.make similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/progress.make rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/cq_nvm.dir/progress.make diff --git a/runtime/src/tests/data_structures/CQ/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/tests/data_structures/CQ/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/CMakeFiles/progress.marks diff --git a/runtime/src/tests/data_structures/CQ/Makefile b/ARP_CSFR/runtime/src/tests/data_structures/CQ/Makefile similarity index 100% rename from runtime/src/tests/data_structures/CQ/Makefile rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/Makefile diff --git a/runtime/src/tests/data_structures/CQ/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/data_structures/CQ/cmake_install.cmake similarity index 100% rename from runtime/src/tests/data_structures/CQ/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/CQ/cmake_install.cmake diff --git a/runtime/src/tests/data_structures/Makefile b/ARP_CSFR/runtime/src/tests/data_structures/Makefile similarity index 100% rename from runtime/src/tests/data_structures/Makefile rename to ARP_CSFR/runtime/src/tests/data_structures/Makefile diff --git a/runtime/src/tests/region/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/CMakeDirectoryInformation.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/CMakeDirectoryInformation.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/CMakeDirectoryInformation.cmake diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..7273c0fa8c522b7eed7762a353d46f7768e9b6f2 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/progress.marks @@ -0,0 +1 @@ +25 diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..1c09a2f03ba8d3cabe0046d0eac428443b91df01 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/DependInfo.cmake @@ -0,0 +1,24 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o" + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..216077155176b87b24cbfa07ada6b5deb39c7171 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make @@ -0,0 +1,141 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/RB/CMakeFiles/rb_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o: ../tests/data_structures/RB/rb.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/rb_nvm.dir/rb.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb.cc + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/rb_nvm.dir/rb.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb.cc > CMakeFiles/rb_nvm.dir/rb.cc.i + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/rb_nvm.dir/rb.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb.cc -o CMakeFiles/rb_nvm.dir/rb.cc.s + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.requires: + +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.requires + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.provides: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.requires + $(MAKE) -f tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.provides.build +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.provides + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.provides.build: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o + + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o: ../tests/data_structures/RB/rb_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/rb_nvm.dir/rb_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb_nvm.cc + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/rb_nvm.dir/rb_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb_nvm.cc > CMakeFiles/rb_nvm.dir/rb_nvm.cc.i + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/rb_nvm.dir/rb_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB/rb_nvm.cc -o CMakeFiles/rb_nvm.dir/rb_nvm.cc.s + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.requires: + +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.requires + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.provides: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.provides.build +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.provides + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.provides.build: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o + + +# Object files for target rb_nvm +rb_nvm_OBJECTS = \ +"CMakeFiles/rb_nvm.dir/rb.cc.o" \ +"CMakeFiles/rb_nvm.dir/rb_nvm.cc.o" + +# External object files for target rb_nvm +rb_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/rb_nvm: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o +tests/data_structures/rb_nvm: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o +tests/data_structures/rb_nvm: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build.make +tests/data_structures/rb_nvm: lib/libatlas.a +tests/data_structures/rb_nvm: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX executable ../rb_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/rb_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build: tests/data_structures/rb_nvm + +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/build + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/requires: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb.cc.o.requires +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/requires: tests/data_structures/RB/CMakeFiles/rb_nvm.dir/rb_nvm.cc.o.requires + +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/requires + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB && $(CMAKE_COMMAND) -P CMakeFiles/rb_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/clean + +tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/RB /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..75e85296bc85acbe2a921e972fd641d2e9b4b82a --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/cmake_clean.cmake @@ -0,0 +1,11 @@ +file(REMOVE_RECURSE + "CMakeFiles/rb_nvm.dir/rb.cc.o" + "CMakeFiles/rb_nvm.dir/rb_nvm.cc.o" + "../rb_nvm.pdb" + "../rb_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/rb_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..448eb20f58a96bd1bcd8bced391c5c7d097dd358 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for rb_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..4a41e718cdba57ffac6a11810381c4494d57a5d6 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/rb_nvm.dir/rb.cc.o CMakeFiles/rb_nvm.dir/rb_nvm.cc.o -o ../rb_nvm -rdynamic -lpthread -lrt ../../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..b81d22fd99a6a6cdae8b1d56600bbc716d1248a1 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/RB/CMakeFiles/rb_nvm.dir/progress.make @@ -0,0 +1,4 @@ +CMAKE_PROGRESS_1 = 64 +CMAKE_PROGRESS_2 = 65 +CMAKE_PROGRESS_3 = 66 + diff --git a/runtime/src/tests/data_structures/RB/Makefile b/ARP_CSFR/runtime/src/tests/data_structures/RB/Makefile similarity index 100% rename from runtime/src/tests/data_structures/RB/Makefile rename to ARP_CSFR/runtime/src/tests/data_structures/RB/Makefile diff --git a/runtime/src/tests/data_structures/RB/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/data_structures/RB/cmake_install.cmake similarity index 100% rename from runtime/src/tests/data_structures/RB/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/RB/cmake_install.cmake diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5a794bd76a656da866ccd5c1b681e05e57a5e51 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/vgogte/SFR/CoupledSFR/runtime") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/vgogte/SFR/CoupledSFR/runtime/src") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..7273c0fa8c522b7eed7762a353d46f7768e9b6f2 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/progress.marks @@ -0,0 +1 @@ +25 diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..f40291864c9a6e662e88fc686931129bbfbbe7e7 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/DependInfo.cmake @@ -0,0 +1,24 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_db.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o" + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..f97eebe8a22d889324366535719875943eadf4f7 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make @@ -0,0 +1,141 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o: ../tests/data_structures/TATP/tatp_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_nvm.cc + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_nvm.cc > CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.i + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_nvm.cc -o CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.s + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.requires: + +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.requires + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.provides: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.provides.build +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.provides + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.provides.build: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o + + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o: ../tests/data_structures/TATP/tatp_db.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/tatp_nvm.dir/tatp_db.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_db.cc + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/tatp_nvm.dir/tatp_db.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_db.cc > CMakeFiles/tatp_nvm.dir/tatp_db.cc.i + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/tatp_nvm.dir/tatp_db.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP/tatp_db.cc -o CMakeFiles/tatp_nvm.dir/tatp_db.cc.s + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.requires: + +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.requires + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.provides: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.requires + $(MAKE) -f tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.provides.build +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.provides + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.provides.build: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o + + +# Object files for target tatp_nvm +tatp_nvm_OBJECTS = \ +"CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o" \ +"CMakeFiles/tatp_nvm.dir/tatp_db.cc.o" + +# External object files for target tatp_nvm +tatp_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/tatp_nvm: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o +tests/data_structures/tatp_nvm: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o +tests/data_structures/tatp_nvm: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build.make +tests/data_structures/tatp_nvm: lib/libatlas.a +tests/data_structures/tatp_nvm: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX executable ../tatp_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/tatp_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build: tests/data_structures/tatp_nvm + +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/build + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/requires: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o.requires +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/requires: tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/tatp_db.cc.o.requires + +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/requires + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP && $(CMAKE_COMMAND) -P CMakeFiles/tatp_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/clean + +tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TATP /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..9be13dea2c6ecb9ff2075cba7f564ffe851e7110 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/cmake_clean.cmake @@ -0,0 +1,11 @@ +file(REMOVE_RECURSE + "CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o" + "CMakeFiles/tatp_nvm.dir/tatp_db.cc.o" + "../tatp_nvm.pdb" + "../tatp_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/tatp_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..f081cd12f8da079a8d43486e66b0e7e7e293597e --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for tatp_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..eb66269fdd244babef4ecc9e2a0d18951d1c6c1c --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/tatp_nvm.dir/tatp_nvm.cc.o CMakeFiles/tatp_nvm.dir/tatp_db.cc.o -o ../tatp_nvm -rdynamic -lpthread -lrt ../../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..300defcab741ea2924f551e3b05b452bcfd80844 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TATP/CMakeFiles/tatp_nvm.dir/progress.make @@ -0,0 +1,4 @@ +CMAKE_PROGRESS_1 = 85 +CMAKE_PROGRESS_2 = 86 +CMAKE_PROGRESS_3 = 87 + diff --git a/runtime/src/tests/data_structures/TATP/Makefile b/ARP_CSFR/runtime/src/tests/data_structures/TATP/Makefile similarity index 100% rename from runtime/src/tests/data_structures/TATP/Makefile rename to ARP_CSFR/runtime/src/tests/data_structures/TATP/Makefile diff --git a/runtime/src/tests/data_structures/TATP/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TATP/cmake_install.cmake similarity index 100% rename from runtime/src/tests/data_structures/TATP/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/TATP/cmake_install.cmake diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5a794bd76a656da866ccd5c1b681e05e57a5e51 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/vgogte/SFR/CoupledSFR/runtime") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/vgogte/SFR/CoupledSFR/runtime/src") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/progress.marks new file mode 100644 index 0000000000000000000000000000000000000000..7273c0fa8c522b7eed7762a353d46f7768e9b6f2 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/progress.marks @@ -0,0 +1 @@ +25 diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/DependInfo.cmake new file mode 100644 index 0000000000000000000000000000000000000000..56b783690526794825a2e5f1d6532f4c5a46e165 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/DependInfo.cmake @@ -0,0 +1,24 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_db.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o" + "/home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_nvm.cc" "/home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "internal_includes" + "../include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + "/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles/atlas.dir/DependInfo.cmake" + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make new file mode 100644 index 0000000000000000000000000000000000000000..de72b0d291d7c3a9adc174414d0c7f284daaff01 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make @@ -0,0 +1,141 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /home/vgogte/SFR/CoupledSFR/runtime + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /home/vgogte/SFR/CoupledSFR/runtime/src + +# Include any dependencies generated for this target. +include tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend.make + +# Include the progress variables for this target. +include tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/progress.make + +# Include the compile flags for this target's objects. +include tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o: ../tests/data_structures/TPCC/tpcc_nvm.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_nvm.cc + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_nvm.cc > CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.i + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_nvm.cc -o CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.s + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.requires: + +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.requires + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.provides: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.requires + $(MAKE) -f tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.provides.build +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.provides + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.provides.build: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o + + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o: ../tests/data_structures/TPCC/tpcc_db.cc + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o -c /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_db.cc + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.i" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_db.cc > CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.i + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.s" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && clang++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC/tpcc_db.cc -o CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.s + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.requires: + +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.requires + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.provides: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.requires + $(MAKE) -f tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.provides.build +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.provides + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.provides.build: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o + + +# Object files for target tpcc_nvm +tpcc_nvm_OBJECTS = \ +"CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o" \ +"CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o" + +# External object files for target tpcc_nvm +tpcc_nvm_EXTERNAL_OBJECTS = + +tests/data_structures/tpcc_nvm: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o +tests/data_structures/tpcc_nvm: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o +tests/data_structures/tpcc_nvm: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build.make +tests/data_structures/tpcc_nvm: lib/libatlas.a +tests/data_structures/tpcc_nvm: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/home/vgogte/SFR/CoupledSFR/runtime/src/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX executable ../tpcc_nvm" + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/tpcc_nvm.dir/link.txt --verbose=$(VERBOSE) + +# Rule to build all files generated by this target. +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build: tests/data_structures/tpcc_nvm + +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/build + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/requires: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o.requires +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/requires: tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o.requires + +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/requires + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean: + cd /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC && $(CMAKE_COMMAND) -P CMakeFiles/tpcc_nvm.dir/cmake_clean.cmake +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/clean + +tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend: + cd /home/vgogte/SFR/CoupledSFR/runtime/src && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/vgogte/SFR/CoupledSFR/runtime /home/vgogte/SFR/CoupledSFR/runtime/tests/data_structures/TPCC /home/vgogte/SFR/CoupledSFR/runtime/src /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC /home/vgogte/SFR/CoupledSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/cmake_clean.cmake new file mode 100644 index 0000000000000000000000000000000000000000..a746477e7770eed3bba923d3dab3eb86320bfbc9 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/cmake_clean.cmake @@ -0,0 +1,11 @@ +file(REMOVE_RECURSE + "CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o" + "CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o" + "../tpcc_nvm.pdb" + "../tpcc_nvm" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/tpcc_nvm.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend.make b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend.make new file mode 100644 index 0000000000000000000000000000000000000000..9a17a59b4100392b53a26a10fee7371bf9ce9e94 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/depend.make @@ -0,0 +1,2 @@ +# Empty dependencies file for tpcc_nvm. +# This may be replaced when dependencies are built. diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make new file mode 100644 index 0000000000000000000000000000000000000000..6b84e86acf1deb42022aa5843a9f578f67380456 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# compile CXX with clang++ +CXX_FLAGS = -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG -Xclang -load -Xclang /home/vgogte/SFR/CoupledSFR/runtime/../compiler-plugin/plugin_build/NvmInstrumenter.so -pthread -std=gnu++11 + +CXX_DEFINES = + +CXX_INCLUDES = -I/home/vgogte/SFR/CoupledSFR/runtime/src/internal_includes -I/home/vgogte/SFR/CoupledSFR/runtime/include + diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/link.txt b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/link.txt new file mode 100644 index 0000000000000000000000000000000000000000..b949169e792ff9084fd01947d80112c0089e08bd --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/link.txt @@ -0,0 +1 @@ +clang++ -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline -DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE -g3 -DDEBUG CMakeFiles/tpcc_nvm.dir/tpcc_nvm.cc.o CMakeFiles/tpcc_nvm.dir/tpcc_db.cc.o -o ../tpcc_nvm -rdynamic -lpthread -lrt ../../../lib/libatlas.a -lpthread -lrt -pthread diff --git a/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/progress.make b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/progress.make new file mode 100644 index 0000000000000000000000000000000000000000..bc2e331f7210ef59d122552e551cc4683b1dfea0 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/CMakeFiles/tpcc_nvm.dir/progress.make @@ -0,0 +1,4 @@ +CMAKE_PROGRESS_1 = 88 +CMAKE_PROGRESS_2 = 89 +CMAKE_PROGRESS_3 = 90 + diff --git a/runtime/src/tests/data_structures/TPCC/Makefile b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/Makefile similarity index 100% rename from runtime/src/tests/data_structures/TPCC/Makefile rename to ARP_CSFR/runtime/src/tests/data_structures/TPCC/Makefile diff --git a/runtime/src/tests/data_structures/TPCC/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/data_structures/TPCC/cmake_install.cmake similarity index 100% rename from runtime/src/tests/data_structures/TPCC/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/TPCC/cmake_install.cmake diff --git a/runtime/src/tests/data_structures/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/data_structures/cmake_install.cmake similarity index 100% rename from runtime/src/tests/data_structures/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/data_structures/cmake_install.cmake diff --git a/runtime/src/tests/data_structures_inputs/alarm_clock.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/alarm_clock.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock.in diff --git a/runtime/src/tests/data_structures_inputs/alarm_clock.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/alarm_clock.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock.ref diff --git a/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/alarm_clock_nvm.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.in diff --git a/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/alarm_clock_nvm.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/alarm_clock_nvm.ref diff --git a/runtime/src/tests/data_structures_inputs/cow_array_list.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/cow_array_list.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list.in diff --git a/runtime/src/tests/data_structures_inputs/cow_array_list.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/cow_array_list.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list.ref diff --git a/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/cow_array_list_nvm.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.in diff --git a/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/cow_array_list_nvm.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/cow_array_list_nvm.ref diff --git a/runtime/src/tests/data_structures_inputs/queue.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/queue.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/queue.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/queue.in diff --git a/runtime/src/tests/data_structures_inputs/queue.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/queue.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/queue.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/queue.ref diff --git a/runtime/src/tests/data_structures_inputs/queue_nvm.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/queue_nvm.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/queue_nvm.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/queue_nvm.in diff --git a/runtime/src/tests/data_structures_inputs/queue_nvm.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/queue_nvm.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/queue_nvm.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/queue_nvm.ref diff --git a/runtime/src/tests/data_structures_inputs/sll.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll.in diff --git a/runtime/src/tests/data_structures_inputs/sll.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll.ref diff --git a/runtime/src/tests/data_structures_inputs/sll_ll.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_ll.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll_ll.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_ll.in diff --git a/runtime/src/tests/data_structures_inputs/sll_ll.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_ll.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll_ll.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_ll.ref diff --git a/runtime/src/tests/data_structures_inputs/sll_nvm.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_nvm.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll_nvm.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_nvm.in diff --git a/runtime/src/tests/data_structures_inputs/sll_nvm.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_nvm.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/sll_nvm.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/sll_nvm.ref diff --git a/runtime/src/tests/data_structures_inputs/stores.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/stores.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/stores.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/stores.in diff --git a/runtime/src/tests/data_structures_inputs/stores.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/stores.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/stores.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/stores.ref diff --git a/runtime/src/tests/data_structures_inputs/stores_nvm.in b/ARP_CSFR/runtime/src/tests/data_structures_inputs/stores_nvm.in similarity index 100% rename from runtime/src/tests/data_structures_inputs/stores_nvm.in rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/stores_nvm.in diff --git a/runtime/src/tests/data_structures_inputs/stores_nvm.ref b/ARP_CSFR/runtime/src/tests/data_structures_inputs/stores_nvm.ref similarity index 100% rename from runtime/src/tests/data_structures_inputs/stores_nvm.ref rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/stores_nvm.ref diff --git a/runtime/src/tests/data_structures_inputs/timing.txt b/ARP_CSFR/runtime/src/tests/data_structures_inputs/timing.txt similarity index 100% rename from runtime/src/tests/data_structures_inputs/timing.txt rename to ARP_CSFR/runtime/src/tests/data_structures_inputs/timing.txt diff --git a/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5a794bd76a656da866ccd5c1b681e05e57a5e51 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/vgogte/SFR/CoupledSFR/runtime") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/vgogte/SFR/CoupledSFR/runtime/src") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/DependInfo.cmake diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/build.make b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/build.make similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/build.make rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/build.make diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/cmake_clean.cmake diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/depend.make b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/depend.make similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/depend.make rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/depend.make diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/flags.make b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/flags.make similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/flags.make rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/flags.make diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/link.txt b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/link.txt similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/link.txt rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/link.txt diff --git a/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/progress.make b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/progress.make similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/progress.make rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/new_delete.dir/progress.make diff --git a/runtime/src/tests/pmalloc/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/tests/pmalloc/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/tests/pmalloc/CMakeFiles/progress.marks diff --git a/runtime/src/tests/pmalloc/Makefile b/ARP_CSFR/runtime/src/tests/pmalloc/Makefile similarity index 100% rename from runtime/src/tests/pmalloc/Makefile rename to ARP_CSFR/runtime/src/tests/pmalloc/Makefile diff --git a/runtime/src/tests/pmalloc/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/pmalloc/cmake_install.cmake similarity index 100% rename from runtime/src/tests/pmalloc/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/pmalloc/cmake_install.cmake diff --git a/runtime/src/tests/pmalloc/test_pmalloc b/ARP_CSFR/runtime/src/tests/pmalloc/test_pmalloc similarity index 100% rename from runtime/src/tests/pmalloc/test_pmalloc rename to ARP_CSFR/runtime/src/tests/pmalloc/test_pmalloc diff --git a/ARP_CSFR/runtime/src/tests/region/CMakeFiles/CMakeDirectoryInformation.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000000000000000000000000000000000000..d5a794bd76a656da866ccd5c1b681e05e57a5e51 --- /dev/null +++ b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/vgogte/SFR/CoupledSFR/runtime") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/vgogte/SFR/CoupledSFR/runtime/src") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/createclose.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclose.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclose.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosedelete.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosedelete.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/createclosefocclose.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/finddelete.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/finddelete.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/finddelete.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/focclose.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focclose.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focclose.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/DependInfo.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/DependInfo.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/DependInfo.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/DependInfo.cmake diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/build.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/build.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/build.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/build.make diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/cmake_clean.cmake b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/cmake_clean.cmake similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/cmake_clean.cmake rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/cmake_clean.cmake diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/depend.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/depend.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/depend.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/depend.make diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/flags.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/flags.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/flags.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/flags.make diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/link.txt b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/link.txt similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/link.txt rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/link.txt diff --git a/runtime/src/tests/region/CMakeFiles/focdelete.dir/progress.make b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/progress.make similarity index 100% rename from runtime/src/tests/region/CMakeFiles/focdelete.dir/progress.make rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/focdelete.dir/progress.make diff --git a/runtime/src/tests/region/CMakeFiles/progress.marks b/ARP_CSFR/runtime/src/tests/region/CMakeFiles/progress.marks similarity index 100% rename from runtime/src/tests/region/CMakeFiles/progress.marks rename to ARP_CSFR/runtime/src/tests/region/CMakeFiles/progress.marks diff --git a/runtime/src/tests/region/Makefile b/ARP_CSFR/runtime/src/tests/region/Makefile similarity index 100% rename from runtime/src/tests/region/Makefile rename to ARP_CSFR/runtime/src/tests/region/Makefile diff --git a/runtime/src/tests/region/cmake_install.cmake b/ARP_CSFR/runtime/src/tests/region/cmake_install.cmake similarity index 100% rename from runtime/src/tests/region/cmake_install.cmake rename to ARP_CSFR/runtime/src/tests/region/cmake_install.cmake diff --git a/runtime/src/tests/region/test_region b/ARP_CSFR/runtime/src/tests/region/test_region similarity index 100% rename from runtime/src/tests/region/test_region rename to ARP_CSFR/runtime/src/tests/region/test_region diff --git a/runtime/src/tests/run_quick_test b/ARP_CSFR/runtime/src/tests/run_quick_test similarity index 100% rename from runtime/src/tests/run_quick_test rename to ARP_CSFR/runtime/src/tests/run_quick_test diff --git a/runtime/src/util/CMakeLists.txt b/ARP_CSFR/runtime/src/util/CMakeLists.txt similarity index 100% rename from runtime/src/util/CMakeLists.txt rename to ARP_CSFR/runtime/src/util/CMakeLists.txt diff --git a/ARP_CSFR/runtime/src/util/stats.cpp b/ARP_CSFR/runtime/src/util/stats.cpp new file mode 100644 index 0000000000000000000000000000000000000000..b2e3208ddc3df0414dc15008253848e43dff3c72 --- /dev/null +++ b/ARP_CSFR/runtime/src/util/stats.cpp @@ -0,0 +1,75 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include + +#include + +#include "atlas_api.h" + +#include "stats.hpp" + +// TODO +__thread uint64_t num_flushes = 0; + +namespace Atlas { + +Stats *Stats::Instance_{nullptr}; + +thread_local uint64_t Stats::TL_CriticalSectionCount{0}; +thread_local uint64_t Stats::TL_NestedCriticalSectionCount{0}; +thread_local uint64_t Stats::TL_LoggedStoreCount{0}; +thread_local uint64_t Stats::TL_CriticalLoggedStoreCount{0}; +thread_local uint64_t Stats::TL_UnloggedStoreCount{0}; +thread_local uint64_t Stats::TL_UnloggedCriticalStoreCount{0}; +thread_local uint64_t Stats::TL_LogElisionFailCount{0}; +thread_local uint64_t Stats::TL_LogMemUse{0}; +thread_local uint64_t Stats::TL_NumLogFlushes{0}; + +// acquire this lock when printing something to stderr +void Stats::print() +{ + acquireLock(); + + std::cout << "[Atlas-stats] Begin thread " << pthread_self() << std::endl; + + std::cout << "\t# critical sections: " << + TL_CriticalSectionCount << std::endl; + std::cout << "\t# nested critical sections: " << + TL_NestedCriticalSectionCount << std::endl; + std::cout << "\t# logged stores: " << + TL_LoggedStoreCount << std::endl; + std::cout << "\t# logged stores in critical sections: " << + TL_CriticalLoggedStoreCount << std::endl; + std::cout << "\t# unlogged stores: " << + TL_UnloggedStoreCount << std::endl; + std::cout << "\t# unlogged stores in critical sections: " << + TL_UnloggedCriticalStoreCount << std::endl; + std::cout << "\t# log elision failures (outside critical sections): " << + TL_LogElisionFailCount << std::endl; + std::cout << "\tLog memory usage: " << TL_LogMemUse << std::endl; + std::cout << "\t# Log entries (total): " << + TL_CriticalSectionCount * 2 + TL_LoggedStoreCount << std::endl; + std::cout << "\t# flushes: " << num_flushes << std::endl; + + std::cout << "[Atlas-stats] End thread " << pthread_self() << std::endl; + + releaseLock(); +} + +} // namespace Atlas + diff --git a/ARP_CSFR/runtime/src/util/util.cpp b/ARP_CSFR/runtime/src/util/util.cpp new file mode 100644 index 0000000000000000000000000000000000000000..957c0365e2b25c064392af1bacfff6df2642607b --- /dev/null +++ b/ARP_CSFR/runtime/src/util/util.cpp @@ -0,0 +1,208 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "util.hpp" + +#ifndef _NVDIMM_PROLIANT + static const char mountpath[]="/dev/shm/"; +#else + static const char mountpath[]="/mnt/nvm/pmem0/"; +#endif + +char *NVM_GetRegionTablePath() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + const char *usr_name = getpwuid(geteuid())->pw_name; + char *s = (char*) malloc( + (strlen(mountpath) + strlen(usr_name) + + strlen("/__nvm_region_table") + 1) * sizeof(char)); + sprintf(s, "%s%s/__nvm_region_table", mountpath, usr_name); + return s; +} + +char *NVM_GetUserDir() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + const char *usr_name = getpwuid(geteuid())->pw_name; + char *s = (char*) malloc( + (strlen(mountpath) + strlen(usr_name) + 1) * sizeof(char)); + sprintf(s, "%s%s", mountpath, usr_name); + return s; +} + +char *NVM_GetLogDir() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef PMM_OS + return "/dev/pmmfs"; +#else + const char *usr_name = getpwuid(geteuid())->pw_name; + char *s = (char*) malloc( + (strlen(mountpath) + strlen(usr_name) + strlen("/regions") + 1) * + sizeof(char)); + sprintf(s, "%s%s/regions", mountpath, usr_name); + return s; + +#endif +} + +void NVM_CreateUserDir() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int status; + const char *usr_dir = NVM_GetUserDir(); + struct stat buf; + if (stat(usr_dir, &buf)) + { + status = + mkdir(usr_dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + assert(!status); + } + free((void*)usr_dir); +} + +void NVM_CreateLogDir() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef PMM_OS + system("mkdir -p /dev/pmmfs"); +#else + int status; + const char *usr_dir = NVM_GetUserDir(); + const char *log_dir = NVM_GetLogDir(); + struct stat buf; + if (stat(usr_dir, &buf)) + { + status = + mkdir(usr_dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + assert(!status); + + status = + mkdir(log_dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + assert(!status); + } + else + { + if (stat(log_dir, &buf)) + { + status = mkdir( + log_dir, S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH); + assert(!status); + } + } + free((void*)log_dir); + free((void*)usr_dir); +#endif +} + +#ifdef PMM_OS +char *NVM_GetFullyQualifiedRegionName(const char * name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(strlen("/dev/pmmfs/")+strlen(name) < 2*MAXLEN+1); + char *s = (char*) malloc(2*MAXLEN*sizeof(char)); + sprintf(s, "/dev/pmmfs/%s", name); + return s; +} +#else +char *NVM_GetFullyQualifiedRegionName(const char * name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + const char *usr_name = getpwuid(geteuid())->pw_name; + char *s = (char*) malloc( + (strlen(mountpath) + strlen(usr_name) + strlen("/regions/") + + strlen(name) + 1) * sizeof(char)); + sprintf(s, "%s%s/regions/%s", mountpath, usr_name, name); + return s; +} +#endif + +char *NVM_GetLogRegionName() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + extern const char *__progname; + char *s = (char*) malloc( + (strlen("logs_") + strlen(__progname) + 1) * sizeof(char)); + sprintf(s, "logs_%s", __progname); + return s; +} + +char *NVM_GetLogRegionName(const char * name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + char *s = (char*) malloc( + (strlen("logs_") + strlen(name) + 1) * sizeof(char)); + sprintf(s, "logs_%s", name); + return s; +} + +bool NVM_doesLogExist(const char *log_path_name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(log_path_name); + struct stat buf; + int status = stat(log_path_name, &buf); + return status == 0; +} + +void NVM_qualifyPathName(char *s, const char *name) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef PMM_OS + sprintf(s, "/dev/pmmfs/%s", name); +#else + sprintf(s, "%sregions/%s", mountpath, name); +#endif +} + +template<> uint32_t SimpleHashTable::Size_ = 1024; + + + diff --git a/ARP_CSFR/runtime/tests/CMakeLists.txt b/ARP_CSFR/runtime/tests/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..97a2e991b8cedb9b9fec5885b45db0d9d3546b33 --- /dev/null +++ b/ARP_CSFR/runtime/tests/CMakeLists.txt @@ -0,0 +1,22 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# tests CMakeLists.txt + +add_subdirectory (region) +#add_subdirectory (data_structures) +add_subdirectory (data_structures_instrumented) +add_subdirectory (consistency) +add_subdirectory (pmalloc) + diff --git a/runtime/tests/README.md b/ARP_CSFR/runtime/tests/README.md similarity index 100% rename from runtime/tests/README.md rename to ARP_CSFR/runtime/tests/README.md diff --git a/runtime/tests/consistency/CMakeLists.txt b/ARP_CSFR/runtime/tests/consistency/CMakeLists.txt similarity index 100% rename from runtime/tests/consistency/CMakeLists.txt rename to ARP_CSFR/runtime/tests/consistency/CMakeLists.txt diff --git a/runtime/tests/consistency/malloc_free_test.c b/ARP_CSFR/runtime/tests/consistency/malloc_free_test.c similarity index 100% rename from runtime/tests/consistency/malloc_free_test.c rename to ARP_CSFR/runtime/tests/consistency/malloc_free_test.c diff --git a/runtime/tests/consistency/test_consistency b/ARP_CSFR/runtime/tests/consistency/test_consistency similarity index 100% rename from runtime/tests/consistency/test_consistency rename to ARP_CSFR/runtime/tests/consistency/test_consistency diff --git a/ARP_CSFR/runtime/tests/data_structures/CMakeLists.txt b/ARP_CSFR/runtime/tests/data_structures/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..88da5e0b66378f9b1539549b5e1fd26fe9bfe50f --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/CMakeLists.txt @@ -0,0 +1,47 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# data_structures CMakeLists + +add_subdirectory (TATP) +add_subdirectory (RB) +add_subdirectory (TPCC) +add_subdirectory (CQ) + +set (EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/tests/data_structures) + +set (DS_ATLAS_TGTS alarm_clock_nvm queue_nvm stores_nvm cow_array_list_nvm sll_nvm sll_mt_ll sll_ll pc_nvm sps_nvm linked_list_nvm) +set (DS_NOATLAS_TGTS cow_array_list queue sll sll_mt stores alarm_clock) +set (DS_ALL_TGTS ${DS_ATLAS_TGTS} ${DS_NOATLAS_TGTS}) + +foreach (t ${DS_ALL_TGTS}) + if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${t}.c") + add_executable (${t} "${t}.c") + elseif (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${t}.cpp") + add_executable (${t} "${t}.cpp") + else () + add_executable (${t} "${t}.cc") + endif () +endforeach() + +foreach (t ${DS_ALL_TGTS}) + set_target_properties(${t} PROPERTIES COMPILE_FLAGS "${APP_FLAGS}") + target_link_libraries (${t} pthread rt) +endforeach () + +foreach (t ${DS_ATLAS_TGTS}) + get_target_property (TEMP_PROPERTY ${t} COMPILE_FLAGS) + set_target_properties (${t} PROPERTIES COMPILE_FLAGS "${NVM_INSTR_FLAGS} ${TEMP_PROPERTY}") + target_link_libraries (${t} atlas pthread rt) +endforeach () diff --git a/ARP_CSFR/runtime/tests/data_structures/CQ b/ARP_CSFR/runtime/tests/data_structures/CQ new file mode 120000 index 0000000000000000000000000000000000000000..e469d290a433472b6c0c0c056adbac83228df376 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/CQ @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/CQ \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures/RB b/ARP_CSFR/runtime/tests/data_structures/RB new file mode 120000 index 0000000000000000000000000000000000000000..cd959e0b62c95fd6b6f571e3bf11b03e35096e03 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/RB @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/RB \ No newline at end of file diff --git a/runtime/tests/data_structures/README.md b/ARP_CSFR/runtime/tests/data_structures/README.md similarity index 100% rename from runtime/tests/data_structures/README.md rename to ARP_CSFR/runtime/tests/data_structures/README.md diff --git a/ARP_CSFR/runtime/tests/data_structures/TATP b/ARP_CSFR/runtime/tests/data_structures/TATP new file mode 120000 index 0000000000000000000000000000000000000000..fbc5ebe01314a512c28cfbdbbd5be271df7c9512 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/TATP @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/TATP \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures/TPCC b/ARP_CSFR/runtime/tests/data_structures/TPCC new file mode 120000 index 0000000000000000000000000000000000000000..00b51315bfab6ad1f72e35633cfb1d23c4da37bb --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/TPCC @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/TPCC \ No newline at end of file diff --git a/runtime/tests/data_structures/alarm_clock.c b/ARP_CSFR/runtime/tests/data_structures/alarm_clock.c similarity index 100% rename from runtime/tests/data_structures/alarm_clock.c rename to ARP_CSFR/runtime/tests/data_structures/alarm_clock.c diff --git a/runtime/tests/data_structures/alarm_clock_nvm.c b/ARP_CSFR/runtime/tests/data_structures/alarm_clock_nvm.c similarity index 100% rename from runtime/tests/data_structures/alarm_clock_nvm.c rename to ARP_CSFR/runtime/tests/data_structures/alarm_clock_nvm.c diff --git a/runtime/tests/data_structures/cow_array_list.c b/ARP_CSFR/runtime/tests/data_structures/cow_array_list.c similarity index 100% rename from runtime/tests/data_structures/cow_array_list.c rename to ARP_CSFR/runtime/tests/data_structures/cow_array_list.c diff --git a/runtime/tests/data_structures/cow_array_list_nvm.c b/ARP_CSFR/runtime/tests/data_structures/cow_array_list_nvm.c similarity index 100% rename from runtime/tests/data_structures/cow_array_list_nvm.c rename to ARP_CSFR/runtime/tests/data_structures/cow_array_list_nvm.c diff --git a/runtime/tests/data_structures/cpu_util.h b/ARP_CSFR/runtime/tests/data_structures/cpu_util.h similarity index 100% rename from runtime/tests/data_structures/cpu_util.h rename to ARP_CSFR/runtime/tests/data_structures/cpu_util.h diff --git a/ARP_CSFR/runtime/tests/data_structures/linked_list_nvm.cc b/ARP_CSFR/runtime/tests/data_structures/linked_list_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..5a0ae397ff39913d919ffe26feb6cf9674ad2656 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/linked_list_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/linked_list_nvm.cc \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures/pc_nvm.cc b/ARP_CSFR/runtime/tests/data_structures/pc_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..318954e6eb3bd55297f0c69356a403412a8c233e --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/pc_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/pc_nvm.cc \ No newline at end of file diff --git a/runtime/tests/data_structures/queue.c b/ARP_CSFR/runtime/tests/data_structures/queue.c similarity index 100% rename from runtime/tests/data_structures/queue.c rename to ARP_CSFR/runtime/tests/data_structures/queue.c diff --git a/ARP_CSFR/runtime/tests/data_structures/queue_nvm.c b/ARP_CSFR/runtime/tests/data_structures/queue_nvm.c new file mode 100644 index 0000000000000000000000000000000000000000..e1e08c777e24bcba5f094bdeebd4376e61ef328c --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/queue_nvm.c @@ -0,0 +1,267 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +// Adapted from Michael & Scott, "Simple, Fast, and Practical Non-Blocking +// and Blocking Concurrent Queue Algorithms", PODC 1996. +#include +#include +#include +#include +#include + +#define NUM_ITEMS 1000000 +#define NUM_ENQS 4 +#define NUM_DEQS 4 + +// Atlas includes +#include "atlas_alloc.h" +#include "atlas_api.h" + +typedef struct node_t { + int val; + struct node_t *next; +} node_t; + +typedef struct queue_t { + node_t *head; + node_t *tail; + pthread_mutex_t *head_lock; + pthread_mutex_t *tail_lock; +} queue_t; + +queue_t *Q; + +int ready = 0; +int done = 0; + +pthread_mutex_t ready_lock; +pthread_mutex_t done_lock; + +// ID of Atlas persistent region +uint32_t queue_rgn_id; + +void traverse(); + +void initialize() { + void *rgn_root = NVM_GetRegionRoot(queue_rgn_id); + if (rgn_root) { + Q = (queue_t *)rgn_root; + Q->head_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); + pthread_mutex_init(Q->head_lock, NULL); + Q->tail_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); + pthread_mutex_init(Q->tail_lock, NULL); + + fprintf(stderr, "Found queue at %p\n", (void *)Q); + traverse(); + } else { + node_t *node = (node_t *)nvm_alloc(sizeof(node_t), queue_rgn_id); + node->val = -1; // dummy value + node->next = NULL; + Q = (queue_t *)nvm_alloc(sizeof(queue_t), queue_rgn_id); + fprintf(stderr, "Created Q at %p\n", (void *)Q); + + Q->head_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); + pthread_mutex_init(Q->head_lock, NULL); + Q->tail_lock = (pthread_mutex_t *)malloc(sizeof(pthread_mutex_t)); + pthread_mutex_init(Q->tail_lock, NULL); + + NVM_BEGIN_DURABLE(); + + Q->head = node; + Q->tail = node; + + // Set the root of the Atlas persistent region + NVM_SetRegionRoot(queue_rgn_id, Q); + + NVM_END_DURABLE(); + } +} + +// not thread safe +void traverse() { + assert(Q); + assert(Q->head); + assert(Q->tail); + + node_t *t = Q->head; + fprintf(stderr, "Contents of existing queue: "); + int elem_count = 0; + while (t) { + // fprintf(stderr, "%p %d ", t, t->val); + ++elem_count; + t = t->next; + } + fprintf(stderr, "elem_count = %d\n", elem_count); +} + +void enqueue(int val) { + node_t *node = (node_t *)nvm_alloc(sizeof(node_t), queue_rgn_id); + node->val = val; + node->next = NULL; + + pthread_mutex_lock(Q->tail_lock); + Q->tail->next = node; +#ifdef _FORCE_FAIL + if (val == NUM_ITEMS / 2) exit(0); +#endif + Q->tail = node; + pthread_mutex_unlock(Q->tail_lock); +} + +int dequeue(int *valp) { + pthread_mutex_lock(Q->head_lock); + node_t *node = Q->head; + node_t *new_head = node->next; + if (new_head == NULL) { + pthread_mutex_unlock(Q->head_lock); + return 0; + } + *valp = new_head->val; +#ifdef _FORCE_FAIL + if (*valp == NUM_ITEMS / 4) exit(0); +#endif + Q->head = new_head; + pthread_mutex_unlock(Q->head_lock); + + nvm_free(node); + return 1; +} + +void *do_work() { + pthread_mutex_lock(&ready_lock); + ready++; + pthread_mutex_unlock(&ready_lock); + + int global_count = 0; + int t = 0; + while (1) { + int val; + int status = dequeue(&val); + if (status) { + ++global_count; + } else if (t==NUM_ENQS) { + break; + } + + pthread_mutex_lock(&done_lock); + t = done; + pthread_mutex_unlock(&done_lock); + } +// fprintf(stderr, "Total # items dequeued is %d\n", global_count); +// sleep(60); + +#ifdef NVM_STATS + NVM_PrintStats(); +#endif + + return 0; +} + + +void* enqueue_work() { + int i = 0; + int t = 0; + + while(i < NUM_ITEMS/NUM_ENQS) { + enqueue(i); +// if(i%100000==0) printf("Enqueued %d\n",i); + i++; + } + pthread_mutex_lock(&done_lock); + done = done+1; + pthread_mutex_unlock(&done_lock); + while(1) { + pthread_mutex_lock(&done_lock); + t = done; + pthread_mutex_unlock(&done_lock); + if(t==NUM_ENQS) break; + } +// sleep(60); + + return 0; +} + + +int main() { + pthread_t* thread = malloc(sizeof(pthread_t)*(NUM_ENQS+NUM_DEQS)); + struct timeval tv_start; + struct timeval tv_end; + struct timeval tv_end1; + + + // Initialize Atlas + NVM_Initialize(); + // Create an Atlas persistent region + queue_rgn_id = NVM_FindOrCreateRegion("queue", O_RDWR, NULL); + // This contains the Atlas restart code to find any reusable data + initialize(); + +// printf("head lock address is %ld\n", Q->head_lock); +// printf("tail lock address is %ld\n", Q->tail_lock); +// printf("done lock address is %ld\n", &done_lock); +// printf("redy lock address is %ld\n", &ready_lock); + + gettimeofday(&tv_start, NULL); + for(int i = 0; i < NUM_DEQS; i++) { + pthread_create(&(thread[i]), 0, (void *(*)(void *))do_work, 0); + } + int t = 0; + while (t!=NUM_DEQS) { + pthread_mutex_lock(&ready_lock); + t = ready; + pthread_mutex_unlock(&ready_lock); + } + + for(int i = NUM_DEQS; i < NUM_ENQS+NUM_DEQS; i++) { + pthread_create(&(thread[i]), 0, (void *(*)(void *))enqueue_work, 0); + } + // wait for the child to be ready + +// for (int i = 0; i < NUM_ITEMS; ++i) { +// enqueue(i); +// } + +// pthread_mutex_lock(&done_lock); +// done = 1; +// pthread_mutex_unlock(&done_lock); + + for (int i = 0; i < NUM_ENQS+NUM_DEQS; i++) { + pthread_join(thread[i], NULL); + } + gettimeofday(&tv_end, NULL); +// fprintf(stderr, "time elapsed %ld us\n", +// tv_end1.tv_usec - tv_start.tv_usec + +// (tv_end1.tv_sec - tv_start.tv_sec) * 1000000); + + fprintf(stderr, "time elapsed %ld us\n", + tv_end.tv_usec - tv_start.tv_usec + + (tv_end.tv_sec - tv_start.tv_sec) * 1000000); + +// printf("Closing NVM region\n"); + // Close the Atlas persistent region + NVM_CloseRegion(queue_rgn_id); + // Optionally print Atlas stats +#ifdef NVM_STATS + NVM_PrintStats(); +#endif +// printf("Finalizing NVM region\n"); + // Atlas bookkeeping + NVM_Finalize(); + + fprintf(stderr, "Total # items enqueued is %d\n", NUM_ITEMS); + + + return 0; +} diff --git a/runtime/tests/data_structures/sll.cpp b/ARP_CSFR/runtime/tests/data_structures/sll.cpp similarity index 100% rename from runtime/tests/data_structures/sll.cpp rename to ARP_CSFR/runtime/tests/data_structures/sll.cpp diff --git a/runtime/tests/data_structures/sll_ll.cpp b/ARP_CSFR/runtime/tests/data_structures/sll_ll.cpp similarity index 100% rename from runtime/tests/data_structures/sll_ll.cpp rename to ARP_CSFR/runtime/tests/data_structures/sll_ll.cpp diff --git a/runtime/tests/data_structures/sll_mt.cpp b/ARP_CSFR/runtime/tests/data_structures/sll_mt.cpp similarity index 100% rename from runtime/tests/data_structures/sll_mt.cpp rename to ARP_CSFR/runtime/tests/data_structures/sll_mt.cpp diff --git a/runtime/tests/data_structures/sll_mt_ll.cpp b/ARP_CSFR/runtime/tests/data_structures/sll_mt_ll.cpp similarity index 100% rename from runtime/tests/data_structures/sll_mt_ll.cpp rename to ARP_CSFR/runtime/tests/data_structures/sll_mt_ll.cpp diff --git a/runtime/tests/data_structures/sll_nvm.cpp b/ARP_CSFR/runtime/tests/data_structures/sll_nvm.cpp similarity index 100% rename from runtime/tests/data_structures/sll_nvm.cpp rename to ARP_CSFR/runtime/tests/data_structures/sll_nvm.cpp diff --git a/ARP_CSFR/runtime/tests/data_structures/sps_nvm.cc b/ARP_CSFR/runtime/tests/data_structures/sps_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..d195391b9f5f3dba14d3fcdef8491af1563c83d8 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/sps_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/sps_nvm.cc \ No newline at end of file diff --git a/runtime/tests/data_structures/stores.c b/ARP_CSFR/runtime/tests/data_structures/stores.c similarity index 100% rename from runtime/tests/data_structures/stores.c rename to ARP_CSFR/runtime/tests/data_structures/stores.c diff --git a/ARP_CSFR/runtime/tests/data_structures/stores_nvm.c b/ARP_CSFR/runtime/tests/data_structures/stores_nvm.c new file mode 100644 index 0000000000000000000000000000000000000000..78e5af3d7e5db25ecffcfa362af69f8c81ed0e6a --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures/stores_nvm.c @@ -0,0 +1,101 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +#include +#include +#include + +// Atlas includes +#include "atlas_alloc.h" +#include "atlas_api.h" + +#define LOOP_COUNT 1000000 + +void bar(); + +// ID of Atlas persistent region +uint32_t stores_rgn_id; + +static inline uint64_t rdtsc() { + uint32_t lo, hi; + __asm__ __volatile__("rdtsc" : "=a"(lo), "=d"(hi)); + return lo | ((uint64_t)hi << 32); +} + +typedef int ARR_TYPE; + +int main() { + ARR_TYPE *arr; + int count = 0; + struct timeval tv_start; + struct timeval tv_end; + +#ifdef _FORCE_FAIL + srand(time(NULL)); + int randval = rand() % LOOP_COUNT; +#endif + + // Initialize Atlas + NVM_Initialize(); + // Create an Atlas persistent region + stores_rgn_id = NVM_FindOrCreateRegion("stores", O_RDWR, NULL); + // Allocate memory from the above persistent region + arr = (ARR_TYPE *)nvm_alloc(LOOP_COUNT * sizeof(ARR_TYPE), stores_rgn_id); + + assert(!gettimeofday(&tv_start, NULL)); + + uint64_t start = rdtsc(); + + int i; + + // Atlas failure-atomic section + for (i = 0; i < LOOP_COUNT; ++i) { + NVM_BEGIN_DURABLE(); + +#ifdef _FORCE_FAIL + if (i == randval) { + exit(0); + } +#endif + arr[i] = i; + + NVM_END_DURABLE(); + } + + uint64_t end = rdtsc(); + + assert(!gettimeofday(&tv_end, NULL)); + + for (i = 0; i < LOOP_COUNT; ++i) { + count += arr[i]; + } + + // Close the Atlas persistent region + NVM_CloseRegion(stores_rgn_id); + // Optionally print Atlas stats +#ifdef NVM_STATS + NVM_PrintStats(); +#endif + // Atlas bookkeeping + NVM_Finalize(); + + fprintf(stderr, "Sum of elements is %d\n", count); + fprintf(stderr, "time elapsed %ld us\n", + tv_end.tv_usec - tv_start.tv_usec + + (tv_end.tv_sec - tv_start.tv_sec) * 1000000); + fprintf(stderr, "cycles: %ld\n", end - start); + + return 0; +} diff --git a/runtime/tests/data_structures_inputs/alarm_clock.in b/ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock.in similarity index 100% rename from runtime/tests/data_structures_inputs/alarm_clock.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock.in diff --git a/runtime/tests/data_structures_inputs/alarm_clock.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock.ref similarity index 100% rename from runtime/tests/data_structures_inputs/alarm_clock.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock.ref diff --git a/runtime/tests/data_structures_inputs/alarm_clock_nvm.in b/ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock_nvm.in similarity index 100% rename from runtime/tests/data_structures_inputs/alarm_clock_nvm.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock_nvm.in diff --git a/runtime/tests/data_structures_inputs/alarm_clock_nvm.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock_nvm.ref similarity index 100% rename from runtime/tests/data_structures_inputs/alarm_clock_nvm.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/alarm_clock_nvm.ref diff --git a/runtime/tests/data_structures_inputs/cow_array_list.in b/ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list.in similarity index 100% rename from runtime/tests/data_structures_inputs/cow_array_list.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list.in diff --git a/runtime/tests/data_structures_inputs/cow_array_list.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list.ref similarity index 100% rename from runtime/tests/data_structures_inputs/cow_array_list.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list.ref diff --git a/runtime/tests/data_structures_inputs/cow_array_list_nvm.in b/ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list_nvm.in similarity index 100% rename from runtime/tests/data_structures_inputs/cow_array_list_nvm.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list_nvm.in diff --git a/runtime/tests/data_structures_inputs/cow_array_list_nvm.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list_nvm.ref similarity index 100% rename from runtime/tests/data_structures_inputs/cow_array_list_nvm.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/cow_array_list_nvm.ref diff --git a/runtime/tests/data_structures_inputs/queue.in b/ARP_CSFR/runtime/tests/data_structures_inputs/queue.in similarity index 100% rename from runtime/tests/data_structures_inputs/queue.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/queue.in diff --git a/runtime/tests/data_structures_inputs/queue.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/queue.ref similarity index 100% rename from runtime/tests/data_structures_inputs/queue.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/queue.ref diff --git a/runtime/tests/data_structures_inputs/queue_nvm.in b/ARP_CSFR/runtime/tests/data_structures_inputs/queue_nvm.in similarity index 100% rename from runtime/tests/data_structures_inputs/queue_nvm.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/queue_nvm.in diff --git a/runtime/tests/data_structures_inputs/queue_nvm.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/queue_nvm.ref similarity index 100% rename from runtime/tests/data_structures_inputs/queue_nvm.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/queue_nvm.ref diff --git a/runtime/tests/data_structures_inputs/sll.in b/ARP_CSFR/runtime/tests/data_structures_inputs/sll.in similarity index 100% rename from runtime/tests/data_structures_inputs/sll.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll.in diff --git a/runtime/tests/data_structures_inputs/sll.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/sll.ref similarity index 100% rename from runtime/tests/data_structures_inputs/sll.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll.ref diff --git a/runtime/tests/data_structures_inputs/sll_ll.in b/ARP_CSFR/runtime/tests/data_structures_inputs/sll_ll.in similarity index 100% rename from runtime/tests/data_structures_inputs/sll_ll.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll_ll.in diff --git a/runtime/tests/data_structures_inputs/sll_ll.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/sll_ll.ref similarity index 100% rename from runtime/tests/data_structures_inputs/sll_ll.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll_ll.ref diff --git a/runtime/tests/data_structures_inputs/sll_nvm.in b/ARP_CSFR/runtime/tests/data_structures_inputs/sll_nvm.in similarity index 100% rename from runtime/tests/data_structures_inputs/sll_nvm.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll_nvm.in diff --git a/runtime/tests/data_structures_inputs/sll_nvm.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/sll_nvm.ref similarity index 100% rename from runtime/tests/data_structures_inputs/sll_nvm.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/sll_nvm.ref diff --git a/runtime/tests/data_structures_inputs/stores.in b/ARP_CSFR/runtime/tests/data_structures_inputs/stores.in similarity index 100% rename from runtime/tests/data_structures_inputs/stores.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/stores.in diff --git a/runtime/tests/data_structures_inputs/stores.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/stores.ref similarity index 100% rename from runtime/tests/data_structures_inputs/stores.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/stores.ref diff --git a/runtime/tests/data_structures_inputs/stores_nvm.in b/ARP_CSFR/runtime/tests/data_structures_inputs/stores_nvm.in similarity index 100% rename from runtime/tests/data_structures_inputs/stores_nvm.in rename to ARP_CSFR/runtime/tests/data_structures_inputs/stores_nvm.in diff --git a/runtime/tests/data_structures_inputs/stores_nvm.ref b/ARP_CSFR/runtime/tests/data_structures_inputs/stores_nvm.ref similarity index 100% rename from runtime/tests/data_structures_inputs/stores_nvm.ref rename to ARP_CSFR/runtime/tests/data_structures_inputs/stores_nvm.ref diff --git a/runtime/tests/data_structures_inputs/timing.txt b/ARP_CSFR/runtime/tests/data_structures_inputs/timing.txt similarity index 100% rename from runtime/tests/data_structures_inputs/timing.txt rename to ARP_CSFR/runtime/tests/data_structures_inputs/timing.txt diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/CMakeLists.txt b/ARP_CSFR/runtime/tests/data_structures_instrumented/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..87a7d8b7af3abe797fe72c06546c96608d76ea75 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/CMakeLists.txt @@ -0,0 +1,48 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# data_structures CMakeLists + +add_subdirectory (TATP) +add_subdirectory (RB) +add_subdirectory (TPCC) +add_subdirectory (CQ) + +set (EXECUTABLE_OUTPUT_PATH ${PROJECT_BINARY_DIR}/tests/data_structures_instrumented) + +set (DS_ATLAS_TGTS sps_nvm pc_nvm linked_list_nvm) +set (DS_NOATLAS_TGTS ) +set (DS_ALL_TGTS ${DS_ATLAS_TGTS} ${DS_NOATLAS_TGTS}) + +foreach (t ${DS_ALL_TGTS}) + if (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${t}.c") + add_executable (${t} "${t}.c") + elseif (EXISTS "${CMAKE_CURRENT_LIST_DIR}/${t}.cpp") + add_executable (${t} "${t}.cpp") + else () + add_executable (${t} "${t}.cc") + endif () +endforeach() + +foreach (t ${DS_ALL_TGTS}) + set_target_properties(${t} PROPERTIES COMPILE_FLAGS "${APP_FLAGS}") + target_link_libraries (${t} pthread rt) +endforeach () + +foreach (t ${DS_ATLAS_TGTS}) + get_target_property (TEMP_PROPERTY ${t} COMPILE_FLAGS) +# set_target_properties (${t} PROPERTIES COMPILE_FLAGS "${NVM_INSTR_FLAGS} ${TEMP_PROPERTY}") + set_target_properties (${t} PROPERTIES COMPILE_FLAGS "${TEMP_PROPERTY}") + target_link_libraries (${t} atlas pthread rt) +endforeach () diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/CQ b/ARP_CSFR/runtime/tests/data_structures_instrumented/CQ new file mode 120000 index 0000000000000000000000000000000000000000..a06d033eb9ddddeb8320cb2a0f01969424f3d3dc --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/CQ @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/CQ \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/RB b/ARP_CSFR/runtime/tests/data_structures_instrumented/RB new file mode 120000 index 0000000000000000000000000000000000000000..bdd4fdb75296d7616db1971aeb51ef63157f0b5b --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/RB @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/RB \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/TATP b/ARP_CSFR/runtime/tests/data_structures_instrumented/TATP new file mode 120000 index 0000000000000000000000000000000000000000..68048d7d6174e3b5aa81d77fe85a58af68b9b731 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/TATP @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/TATP \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/TPCC b/ARP_CSFR/runtime/tests/data_structures_instrumented/TPCC new file mode 120000 index 0000000000000000000000000000000000000000..68df3a62ecb523adda8f26ad2d8f23e4ba1595dc --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/TPCC @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/TPCC \ No newline at end of file diff --git a/runtime/tests/data_structures_instrumented/cow_array_list_nvm.c b/ARP_CSFR/runtime/tests/data_structures_instrumented/cow_array_list_nvm.c similarity index 100% rename from runtime/tests/data_structures_instrumented/cow_array_list_nvm.c rename to ARP_CSFR/runtime/tests/data_structures_instrumented/cow_array_list_nvm.c diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/cpu_util.h b/ARP_CSFR/runtime/tests/data_structures_instrumented/cpu_util.h new file mode 120000 index 0000000000000000000000000000000000000000..6840a75758f7e3f4028de3c9e318b7df97c11fd9 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/cpu_util.h @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures/cpu_util.h \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/linked_list_nvm.cc b/ARP_CSFR/runtime/tests/data_structures_instrumented/linked_list_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..599e8a7633d2163a6a0617aaea2674bb781c14b0 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/linked_list_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/linked_list_nvm.cc \ No newline at end of file diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/pc_nvm.cc b/ARP_CSFR/runtime/tests/data_structures_instrumented/pc_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..425950eb399957b901e72fd66f12938b70c3ceae --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/pc_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/pc_nvm.cc \ No newline at end of file diff --git a/runtime/tests/data_structures_instrumented/queue_nvm.c b/ARP_CSFR/runtime/tests/data_structures_instrumented/queue_nvm.c similarity index 100% rename from runtime/tests/data_structures_instrumented/queue_nvm.c rename to ARP_CSFR/runtime/tests/data_structures_instrumented/queue_nvm.c diff --git a/runtime/tests/data_structures_instrumented/sll_nvm.cpp b/ARP_CSFR/runtime/tests/data_structures_instrumented/sll_nvm.cpp similarity index 100% rename from runtime/tests/data_structures_instrumented/sll_nvm.cpp rename to ARP_CSFR/runtime/tests/data_structures_instrumented/sll_nvm.cpp diff --git a/ARP_CSFR/runtime/tests/data_structures_instrumented/sps_nvm.cc b/ARP_CSFR/runtime/tests/data_structures_instrumented/sps_nvm.cc new file mode 120000 index 0000000000000000000000000000000000000000..95b01d2fb5dbfffa6ba8b630e23f4fe116c14f37 --- /dev/null +++ b/ARP_CSFR/runtime/tests/data_structures_instrumented/sps_nvm.cc @@ -0,0 +1 @@ +/home/vgogte/SFR/Atlas/runtime/tests/data_structures_instrumented/sps_nvm.cc \ No newline at end of file diff --git a/runtime/tests/data_structures_instrumented/stores_nvm.c b/ARP_CSFR/runtime/tests/data_structures_instrumented/stores_nvm.c similarity index 100% rename from runtime/tests/data_structures_instrumented/stores_nvm.c rename to ARP_CSFR/runtime/tests/data_structures_instrumented/stores_nvm.c diff --git a/runtime/tests/data_structures_instrumented/test_memfns.c b/ARP_CSFR/runtime/tests/data_structures_instrumented/test_memfns.c similarity index 100% rename from runtime/tests/data_structures_instrumented/test_memfns.c rename to ARP_CSFR/runtime/tests/data_structures_instrumented/test_memfns.c diff --git a/runtime/tests/pmalloc/CMakeLists.txt b/ARP_CSFR/runtime/tests/pmalloc/CMakeLists.txt similarity index 100% rename from runtime/tests/pmalloc/CMakeLists.txt rename to ARP_CSFR/runtime/tests/pmalloc/CMakeLists.txt diff --git a/runtime/tests/pmalloc/new_delete.cpp b/ARP_CSFR/runtime/tests/pmalloc/new_delete.cpp similarity index 100% rename from runtime/tests/pmalloc/new_delete.cpp rename to ARP_CSFR/runtime/tests/pmalloc/new_delete.cpp diff --git a/runtime/tests/pmalloc/test_pmalloc b/ARP_CSFR/runtime/tests/pmalloc/test_pmalloc similarity index 100% rename from runtime/tests/pmalloc/test_pmalloc rename to ARP_CSFR/runtime/tests/pmalloc/test_pmalloc diff --git a/runtime/tests/region/CMakeLists.txt b/ARP_CSFR/runtime/tests/region/CMakeLists.txt similarity index 100% rename from runtime/tests/region/CMakeLists.txt rename to ARP_CSFR/runtime/tests/region/CMakeLists.txt diff --git a/runtime/tests/region/README.md b/ARP_CSFR/runtime/tests/region/README.md similarity index 100% rename from runtime/tests/region/README.md rename to ARP_CSFR/runtime/tests/region/README.md diff --git a/runtime/tests/region/createclose.c b/ARP_CSFR/runtime/tests/region/createclose.c similarity index 100% rename from runtime/tests/region/createclose.c rename to ARP_CSFR/runtime/tests/region/createclose.c diff --git a/runtime/tests/region/createclosedelete.c b/ARP_CSFR/runtime/tests/region/createclosedelete.c similarity index 100% rename from runtime/tests/region/createclosedelete.c rename to ARP_CSFR/runtime/tests/region/createclosedelete.c diff --git a/runtime/tests/region/createclosefocclose.c b/ARP_CSFR/runtime/tests/region/createclosefocclose.c similarity index 100% rename from runtime/tests/region/createclosefocclose.c rename to ARP_CSFR/runtime/tests/region/createclosefocclose.c diff --git a/runtime/tests/region/finddelete.c b/ARP_CSFR/runtime/tests/region/finddelete.c similarity index 100% rename from runtime/tests/region/finddelete.c rename to ARP_CSFR/runtime/tests/region/finddelete.c diff --git a/runtime/tests/region/focclose.c b/ARP_CSFR/runtime/tests/region/focclose.c similarity index 100% rename from runtime/tests/region/focclose.c rename to ARP_CSFR/runtime/tests/region/focclose.c diff --git a/runtime/tests/region/focdelete.c b/ARP_CSFR/runtime/tests/region/focdelete.c similarity index 100% rename from runtime/tests/region/focdelete.c rename to ARP_CSFR/runtime/tests/region/focdelete.c diff --git a/runtime/tests/region/region_test.h b/ARP_CSFR/runtime/tests/region/region_test.h similarity index 100% rename from runtime/tests/region/region_test.h rename to ARP_CSFR/runtime/tests/region/region_test.h diff --git a/runtime/tests/region/test_region b/ARP_CSFR/runtime/tests/region/test_region similarity index 100% rename from runtime/tests/region/test_region rename to ARP_CSFR/runtime/tests/region/test_region diff --git a/ARP_CSFR/runtime/tests/run_quick_test b/ARP_CSFR/runtime/tests/run_quick_test new file mode 100755 index 0000000000000000000000000000000000000000..4e8a6050eb5a41d1ddf20bfa7cdd7101562a8407 --- /dev/null +++ b/ARP_CSFR/runtime/tests/run_quick_test @@ -0,0 +1,434 @@ +#!/usr/bin/env ruby + +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# + +#Runs data structure programs, comparing NVM and non NVM versions, detecting performance regressions. +#Runs crash recovery testing, checking correctness of Atlas crash/recovery capability. + +# Keep in sync with the makefile targets +test_array = [ + 'queue', 'queue_nvm', \ + 'cow_array_list', 'cow_array_list_nvm', \ + 'sll', 'sll_ll', 'sll_nvm', + 'alarm_clock', 'alarm_clock_nvm', \ + 'stores', 'stores_nvm' #'tester', \ + ] +nvm_test_array = [ + 'queue_nvm', 'cow_array_list_nvm', \ + 'sll_nvm', 'alarm_clock_nvm', \ + 'stores_nvm' #, 'tester' \ + ] + +$ruby_version_f = nil + +#### Sets global variable with version number #### +def get_version(fp, logfile) + print_msg("Ruby version " + RUBY_VERSION, fp, logfile) + $ruby_version_f = RUBY_VERSION[0] + "." + RUBY_VERSION[2] + $ruby_version_f = $ruby_version_f.to_f +end + +#### Print a message onto stdout and a provided file #### +def print_msg(msg, fp, logfile) + puts msg + fp.puts msg + headline = "echo \"#### " + msg + "\" >> " + logfile + system(headline) +end + +#### Make a target #### +def make_default(logfile, fp) + flags="-DDATA_STRUCTS_ONLY=true -DFORCE_FAIL=false" + if $failatlas == true + flags+=" -DFAIL_ATLAS=false" + end + headline = "echo \"#### cmake " + $atlas_src_dir + flags.to_s + " \" >> " + logfile + system(headline) + + cmake_cmd = "cmake " + $atlas_src_dir + " -DFORCE_FAIL=false " \ + " 1>> " + logfile + " 2>&1 " + status_cmake = system(cmake_cmd) + + if (!status_cmake) + print_msg("---- cmake failed to configure ----", fp, logfile) + return false + end + + headline = "echo \"#### make >> " + logfile + " 2>&1\" >> " +logfile + status_make = system(headline) + + make_cmd = " make >> " + logfile + " 2>&1" + status_make = system(make_cmd) + if (!status_make) + print_msg("---- Making failed ----", fp, logfile) + return false + else + return true + end +end + +#### Make recovery target #### +def make_recovery(logfile, fp) + flags="-DDATA_STRUCTS_ONLY=true -DFORCE_FAIL=true" + if $failatlas == true + flags+=" -DFAIL_ATLAS=true" + end + headline = "echo \"#### cmake " + $atlas_src_dir + flags.to_s + " \" >> " + logfile + system(headline) + + cmake_cmd = "cmake " + $atlas_src_dir + " -DFORCE_FAIL=true" \ + " 1>> " + logfile + " 2>&1 " + status_cmake = system(cmake_cmd) + + if (!status_cmake) + print_msg("---- cmake failed to configure ----", fp, logfile) + return false + end + + headline = "echo \"#### make >> " + logfile + " 2>&1\" >> " +logfile + status_make = system(headline) + + make_cmd = " make >> " + logfile + " 2>&1" + status_make = system(make_cmd) + if (!status_make) + print_msg("---- Making failed ----", fp, logfile) + return false + else + return true + end +end + +#### Populate an array with the lines in the provided file #### +def populate_array_from_file(filename) + lines_arr = [] + File.open(filename).each {|line| lines_arr << line } + return lines_arr +end + +#### Verify whether the first file is contained in the second #### +def is_file_contained(file1, file2) + file1_lines = populate_array_from_file(file1) + file2_lines = populate_array_from_file(file2) + result_lines = file1_lines - file2_lines + return result_lines.empty? +end + +#### Extract timing from output file #### +def get_timing_from_output_file(out_file) + File.open(out_file).each do |line| + tmp_str = String.new(line) + if (tmp_str.include?"time elapsed") + tmp_arr = [] + if $ruby_version_f > 1.8 then + tmp_str.split(" ").each do |one_str| + tmp_arr << one_str + end + else + tmp_str.each(separator=" ") do |one_str| + tmp_arr << one_str.chomp + end + end + return tmp_arr.at(2).to_i + end + end + return 2**30-1 +end + +#### Initialize timing information #### +def init_timing_info(timing_file, tracking_hash, nvm_hash) + timing_fp = File.open(timing_file) + timing_fp.each do |timing_line| + timing_str = String.new(timing_line) + if (timing_str.include?"#") then + next + end + tmp_arr = [] + if $ruby_version_f > 1.8 then + timing_str.split(" ").each do |one_str| + tmp_arr << one_str + end + else + timing_str.each(separator=" ") do |one_str| + tmp_arr << one_str.chomp + end + end + tracking_hash[tmp_arr.at(0)] = 0 + tracking_hash[tmp_arr.at(1)] = 0 + tmp_val = [] + tmp_val << tmp_arr.at(0) + tmp_val << tmp_arr.at(2) + tmp_val << tmp_arr.at(3) + nvm_hash[tmp_arr.at(1)] = tmp_val + end + timing_fp.close +end + +#### Update the hash table with timing information #### +def update_runtime_info(all_ver, test_name, runtime) + if (all_ver.has_key?(test_name)) + all_ver[test_name] = all_ver.fetch(test_name) + runtime + end +end + +#### Run a crash test once #### +#### This is expected to fail, so we don't capture output/status +def run_crash_test_once(test_name, test_dir, logfile, fp) + test_in = $data_struct_in_dir + test_name + ".in" + test_cmd = $data_struct_dir + test_name + \ + " `cat " + test_in + "`" + '>> ' + logfile + ' 2>&1' + #" `cat " + test_in + "`" + '> /dev/null 2>&1' + + headline = "echo \"#### " + test_cmd + "\" >> " + logfile + system(headline) + + status_run = system(test_cmd) + return true +end + +#### Run a test twice #### +def run_test_twice(test_name, test_dir, logfile, all_ver, phase, fp) + test_in = $data_struct_in_dir + test_name + ".in" + test_ref = $data_struct_in_dir + test_name + ".ref" + test_out = test_dir + test_name + "." + \ + (2*phase).to_s + '.out' + test_cmd = $data_struct_dir + test_name + \ + " `cat " + test_in + "`" + '>> ' + test_out + ' 2>&1' + + headline = "echo \"#### " + test_cmd + "\" >> " + logfile + system(headline) + + status_run1 = system(test_cmd) + headline = "echo \"#### cat test_out\" >> " + logfile + system(headline) + cat_cmd = 'cat ' + test_out + ' >> ' + logfile + system(cat_cmd) + runtime = get_timing_from_output_file(test_out) + if (!status_run1 || !is_file_contained(test_ref, test_out)) + msg = test_name + " failed (Compare " + test_ref + " and " + test_out + ")" + print_msg(msg, fp, logfile) + return false + end + rm_cmd = "/bin/rm -f " + test_out + system(rm_cmd) + test_out = test_dir + test_name + "." + \ + "." + (2*phase+1).to_s + '.out' + test_cmd = $data_struct_dir + test_name + \ + " `cat " + test_in + "`" + '>> ' + test_out + ' 2>&1' + + headline = "echo \"#### " + test_cmd + "\" >> " + logfile + system(headline) + + status_run2 = system(test_cmd) + headline = "echo \"#### cat test_out\" >> " + logfile + system(headline) + cat_cmd = 'cat ' + test_out + ' >> ' + logfile + system(cat_cmd) + runtime += get_timing_from_output_file(test_out) + update_runtime_info(all_ver, test_name, runtime) + if (!status_run2 || !is_file_contained(test_ref, test_out)) + msg = test_name + " failed (Compare " + test_ref + " and " + test_out + ")" + print_msg(msg, fp, logfile) + return false + end + rm_cmd = "/bin/rm -f " + test_out + system(rm_cmd) + return true +end + +#### Run recovery for a test #### +def run_recovery(test_name, logfile, fp) + recover_cmd = 'timeout 60s ./tools/recover ' + test_name + ' >> ' + logfile + \ + ' 2>> ' + logfile + + headline = "echo \"#### ./tools/recover " + test_name + "\" >>" + logfile + system(headline) + + recover_status = system(recover_cmd) + if (!recover_status) + return false + else + return true + end +end + +#### Main body #### + +num_passed_tests = 0 +num_failed_tests = 0 +num_perf_regression = 0 + +$atlas_src_dir = "" + +#check for input - if help display help string, if fail run with atlas failing internally +arg = ARGV[0] +if arg != nil + arg = String.new(arg).downcase + if arg == "help" + puts "run_quick_test tests two criteria. First it runs the data structure programs, comparing NVM and non NVM versions, detecting performance regressions. Secondly it runs crash/recovery testing, checking correctness of Atlas crash/recovery capability. This script can also optionally force the programs to fail within atlas to. To do so run ./run_quick_test failatlas. By default run_quick_test only fails the data_structures within their code." + elsif arg == "failatlas" + $failatlas=true + puts "Running tests with chance to fail within atlas" + else + puts "Failing in data structures only" + end +end + +if File.file?("lib/libatlas.a") and File.file?("CMakeCache.txt") + #script was invoked from top level of build dir + atlas_dir="." +elsif File.file?("../lib/libatlas.a") and File.file?("../CMakeCache.txt") + #invoked from within tests dir change directory + Dir.chdir ".." + atlas_dir="." +else + puts "Could not find a build of atlas which is not in the src directory, please create a build directory and invoke cmake followed by make" + exit 1 +end + +if File.file?("../CMakeLists.txt") and File.file?("../src/consistency/consistency.cpp") + #build directory is subdir of atlas src tree + $atlas_src_dir = ".." +else + puts "Could not find atlas src dir in order to invoke cmake, move your build directory underneath the root Atlas dir" + exit 1 +end + +atlas_dir += "/" + +test_dir = atlas_dir + "tests/" +$data_struct_dir = test_dir + "data_structures/" +$data_struct_in_dir = test_dir + "data_structures_inputs/" +logfile = test_dir + "log" +clean_cmd = '/bin/rm -f ' + logfile + ' ' + test_dir + "*.out" +clean_mem = atlas_dir + "tools/clean_mem -f" +summary_file = test_dir + "summary.txt" +timing_file = $data_struct_in_dir + "timing.txt" + +system(clean_cmd) + +all_ver = Hash.new +nvm_ver = Hash.new + +fp = File.open(summary_file, 'w') + +get_version(fp, logfile) +print_msg("Cleaning memory", fp, logfile) + +make_cmd = clean_mem + ' >> ' + logfile +system(make_cmd) + +init_timing_info(timing_file, all_ver, nvm_ver) +print_msg("#################################", fp, logfile) +print_msg("---- Performing normal testing ----", fp, logfile) +status_make = make_default(logfile, fp) +if (!status_make) + num_failed_tests += test_array.length + print_msg("#### Failed to build tests for normal testing ####", fp, logfile) +else + test_array.each do |test_name| + status_run = run_test_twice(\ + test_name, test_dir, logfile, all_ver, 0, fp) + if (!status_run) + print_msg(test_name + " failed normal testing", fp, logfile) + num_failed_tests += 1 + else + msg = test_name + ' passed' + print_msg(msg, fp, logfile) + num_passed_tests += 1 + end + end +end +print_msg("---- Performing crash/recovery testing ----", fp, logfile) +status_make = make_recovery(logfile, fp) +if (!status_make) + num_failed_tests += test_array.length + print_msg("#### Failed to build tests for recovery testing ####", fp, logfile) +else + nvm_test_array.each do |test_name| + status_run = run_crash_test_once(test_name, test_dir, logfile, fp) + if (status_run) + msg = test_name + " successfully crashed" + print_msg(msg, fp, logfile) + else + msg = test_name + " failed to crash" + print_msg(msg, fp, logfile) + num_failed_tests += 1 + nvm_test_array.delete(test_name) + end + end +end +print_msg("---- Retesting after crash/recovery testing ----", fp, logfile) +status_make = make_default(logfile, fp) +if (!status_make) + num_failed_tests += test_array.length +else + test_array.each do |test_name| + status_recover = run_recovery(test_name, logfile, fp) + if (!status_recover) + msg = test_name + " failed crash/recovery - could have timed out, longer than 60s" + print_msg(msg, fp, logfile) + num_failed_tests += 1 + else + msg = test_name + " passed crash/recovery" + print_msg(msg, fp, logfile) + num_passed_tests += 1 + end + status_run = run_test_twice(\ + test_name, test_dir, logfile, all_ver, 1, fp) + if (!status_run) + print_msg(test_name + " failed retesting after crash/recovery", fp, logfile) + num_failed_tests += 1 + else + msg = test_name + ' passed' + print_msg(msg, fp, logfile) + num_passed_tests += 1 + end + end +end +#assume that the atlas build is probably one of the 5 tgts +nvm_ver.each do |key, value| + timing_info_nvm = all_ver.fetch(key) + timing_info_orig = all_ver.fetch(value.at(0)) + if (timing_info_orig != 0) + ratio = timing_info_nvm/timing_info_orig + if (ratio < value.at(1).to_i || ratio > value.at(2).to_i) + print_msg("Possible performance regression for #{key}, (expected ratio between #{value.at(1)} & #{value.at(2)}, but found #{ratio})", fp, logfile) + num_perf_regression += 1 + end + else + puts "Warning: Base timing is 0, counting as performance regression" + num_perf_regression += 1 + end +end +all_ver.clear +nvm_ver.clear +print_msg("-----------------------", fp, logfile) + +total_tests = num_passed_tests + num_failed_tests +print_msg("Total number of tests: #{total_tests}", fp, logfile) +print_msg("Number of tests passed: #{num_passed_tests}", fp, logfile) +print_msg("Number of tests failed: #{num_failed_tests}", fp, logfile) +print_msg("Number of possible performance regressions: #{num_perf_regression}", fp, logfile) +print_msg("-----------------------", fp, logfile) +print_msg("See summary.txt, log, and *.out files in #{test_dir} for further details", fp, logfile) + +fp.close + +if (num_failed_tests != 0) + exit 1 +else + exit 0 +end diff --git a/runtime/tools/run_tests b/ARP_CSFR/runtime/tools/run_tests similarity index 100% rename from runtime/tools/run_tests rename to ARP_CSFR/runtime/tools/run_tests diff --git a/Atlas/.gitignore b/Atlas/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..63470a9bd645cf6cfe743cd90cda02c294020627 --- /dev/null +++ b/Atlas/.gitignore @@ -0,0 +1,39 @@ +# Compiled Object files +*.slo +*.lo +*.o +*.obj + +# Precompiled Headers +*.gch +*.pch + +# Compiled Dynamic libraries +*.so +*.dylib +*.dll + +# Fortran module files +*.mod + +# Compiled Static libraries +*.lai +*.la +*.a +*.lib + +# Executables +*.exe +*.out +*.app + +# Build directories +compiler-plugin/plugin_build/ +runtime/build-all/ + +# Temporary files +*.swp +*log.txt + +# Doxygen output +runtime/html/ diff --git a/Atlas/.travis.yml b/Atlas/.travis.yml new file mode 100644 index 0000000000000000000000000000000000000000..fc132adc5a4357ac57dad334c7d622639a951c3e --- /dev/null +++ b/Atlas/.travis.yml @@ -0,0 +1,14 @@ +# Ubuntu 14.04 Trusty support +sudo: required +dist: trusty + +language: cpp +compiler: + - clang +before_install: + - sudo apt-get update -qq && sudo apt-get install -qq libboost-graph-dev +script: + - cd compiler-plugin + - ./build_plugin + - cd ../runtime + - ./tools/run_tests true diff --git a/Atlas/AUTHORS b/Atlas/AUTHORS new file mode 100644 index 0000000000000000000000000000000000000000..78fff79903b51e7b9c0a18e034908bd62970b07b --- /dev/null +++ b/Atlas/AUTHORS @@ -0,0 +1,4 @@ +Dhruva R. Chakrabarti (dhruva.chakrabarti@hpe.com) +Kumud Bhandari (kumud.bhandari@hpe.com) +Timothy McPhie (timothy.mcphie@hpe.com) +Kartik Singhal (kartik.singhal@hpe.com) diff --git a/Atlas/COPYING b/Atlas/COPYING new file mode 100644 index 0000000000000000000000000000000000000000..990502c664237de68fefb2fefdf66bc673b1ee0d --- /dev/null +++ b/Atlas/COPYING @@ -0,0 +1,843 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. + + + + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. + diff --git a/Atlas/README.md b/Atlas/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d6c672d571ec9e6c69ed3f7a2533b34fa8e0b6a9 --- /dev/null +++ b/Atlas/README.md @@ -0,0 +1,151 @@ +# Atlas: Programming for Persistent Memory +[![Build Status](https://travis-ci.org/HewlettPackard/Atlas.svg?branch=master)](https://travis-ci.org/HewlettPackard/Atlas) + +Data in persistent memory survives certain tolerated events such as +process termination, OS reboots/crashes, and power +failures. Persistent memory is assumed to be directly accessible with +CPU loads and stores. This kind of programming is relevant on new +servers with NVDIMMs as well as future machines with +non-volatile memory such as memristors or 3D XPoint. Atlas provides +high level APIs that allow the programmer to persist data in a +fault-tolerant manner and reuse it later on. Any program which has +reusable data that can be exploited to achieve a faster restart or a +restart from an intermediate program point is a candidate for this +paradigm. + +A persistent memory allocator is provided for identifying data that +should be preserved regardless of machine shutdowns or failures. By +conforming to certain programming idioms and APIs, programmers can +automatically obtain failure-resilience of persistent data. The +programming model with implementation details can be found in the +[OOPSLA 2014 paper on Atlas](http://dl.acm.org/citation.cfm?id=2660224). + +The current implementation supports +POSIX threads but the implementation for C/C++11 threads should be similar. +Linux tmpfs is currently used to simulate persistent +memory. Hence, persistent data in this implementation survives process +crashes but not OS shutdowns/panics and power failures. However, the +APIs and the implementation are ready for all of the above +failures. The intention is to allow programmers to write code in a +programming style that is ready for upcoming persistent memory based +systems. + +This software is currently experimental, see `COPYING` for license +terms. Contributions and feedback are very welcome. + +## What is Included? + +APIs are provided for creation and management of persistent +regions which are implemented on top of memory mapped files. Support +for a persistent memory allocator is provided. In essence, a +programmer is able to identify data structures that must be maintained +in a persistent manner. The goal of Atlas is to ensure that persistent +data are updated in a consistent manner regardless of failures. + +The current implementation has two primary components: a +compiler-plugin and a runtime library. The programmer writes +multithreaded code, possibly using locks for synchronization, and puts +data in persistent regions as required. This code is passed through +the plugin at compile-time that results in calls to the runtime +library at appropriate program points. When this program is run, +automatic failure-atomicity (all-or-nothing) of updates to persistent +data structures is provided. If a failure occurs, recovery must be +initiated to ensure that persistent data structures are consistent. + +## Persistent Region APIs + +A preview is provided here. See `runtime/include/atlas_alloc.h` for the +actual interfaces. + +A programmer needs to create one or more named persistent regions, +entities that hold everything persistent. The interface +**_NVM_FindOrCreateRegion_** or a variant can be used for this purpose. If a +region with the provided name exists, a handle to the region is +returned. Otherwise a region is created and its handle is +returned. Interfaces to close or delete a region are available. + +To populate a persistent region, memory must be dynamically allocated +from that persistent region using **_nvm_alloc_** (or a variant) that has a +malloc-style interface. The region identifier must be provided so as +to identify the persistent region intended. An **_nvm_free_** is provided +for deallocation purposes. + +Management of persistent regions and the contained data together +identify the persistent objects used by a program. Care must be taken +to ensure that all valid data within a persistent region is reachable +from the persistent root of the region. Use the interface +**_NVM_SetRegionRoot_** for this purpose. + +## Consistency APIs + +See `runtime/include/atlas_api.h` for the actual interfaces. + +Persistent data must be kept consistent regardless of failures. The +programmer needs to call **_NVM_Initialize_** and **_NVM_Finalize_** +to start and stop Atlas support. Additionally, Atlas needs to know +code sections where program invariants are modified. If the program is +multithreaded and written using locks for synchronization, Atlas +automatically infers boundaries of regions where it must preserve +failure-atomicity (all-or-nothing) of updates to persistent +memory. Optionally, the programmer can demarcate sections of code with +calls to **_nvm_begin_durable_** and **_nvm_end_durable_** to identify +a durable or failure-atomic section of code. Note that no isolation +among threads is provided by a durable section. In contrast, if +persistent data is modified within a critical section, the critical +section provides both isolation among threads and durability to +persistent memory. + +## Restart Code + +A program might want to reuse data within a persistent region. For +this purpose, after finding a region handle, use the interface +**_NVM_GetRegionRoot_** to access the reachable data. Instead of +starting from scratch, this data can be reused to essentially restart +from where the region was left off the last time around. + +That's all, as far as Atlas APIs are concerned. Compared to a +transient program, the idea is to write persistent memory programs +with as few changes as possible. + +## Organization + +- The APIs for this model are in `runtime/include`. [API doc here](http://hewlettpackard.github.io/Atlas/runtime/doc/atlas__api_8h.html). +- Instructions on how to build the compiler-plugin are in +`compiler-plugin/README.md`. +- Instructions on how to build the runtime are in `runtime/README.md`. +- For example programs using Atlas, see `runtime/tests`. +- The Atlas library sources are in `runtime/src`. + +## Dependencies + +* Currently, we support only x86-64 CPUs +* We assume Linux OS. Linux tmpfs must be supported. Testing has been + done on RedHat and Ubuntu. +* We assume modern C/C++ compilers in the build environment that must + support C/C++11. +* The default compiler used in the build is clang. Testing has been + done with version 3.6.0 or later. The instrumentation support is + currently available only with clang/LLVM. The runtime should build + with any compiler supporting C/C++11 though clang is preferred for + uniformity purposes. +* cmake version 3.1 or later +* boost library +* bash 4.0 + +For Ubuntu 16.04, these dependencies can be installed with: + + sudo apt-get install llvm clang cmake libboost-graph-dev + +* ruby (for certain test scripts), see **Installing Ruby** at [gorails](https://gorails.com/setup/ubuntu/16.04) for instructions. + +## Discuss +Questions, feedback, comments are welcome on our public [mailing list](https://groups.google.com/forum/#!forum/atlas-discuss). Subscribe by using the Google Groups web interface or by sending an email with subject “subscribe” to atlas-discuss+subscribe [AT] googlegroups.com. + + +## Reference + +Dhruva R. Chakrabarti, Hans-J. Boehm, and Kumud Bhandari. 2014. +[Atlas: leveraging locks for non-volatile memory consistency](http://dl.acm.org/citation.cfm?id=2660224). +In _Proceedings of the 2014 ACM International Conference on Object Oriented +Programming Systems Languages & Applications_ (OOPSLA '14). ACM, New +York, NY, USA, 433-452. diff --git a/Atlas/compiler-plugin/README.md b/Atlas/compiler-plugin/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f6c9be2c08481da468d82aacd93495664015eb38 --- /dev/null +++ b/Atlas/compiler-plugin/README.md @@ -0,0 +1,34 @@ +[//]: # ( (c) Copyright 2016 Hewlett Packard Enterprise Development LP ) +[//]: # ( ) +[//]: # ( This program is free software: you can redistribute it and/or modify ) +[//]: # ( it under the terms of the GNU Lesser General Public License as ) +[//]: # ( published by the Free Software Foundation, either version 3 of the ) +[//]: # ( License, or (at your option) any later version. This program is ) +[//]: # ( distributed in the hope that it will be useful, but WITHOUT ANY ) +[//]: # ( WARRANTY; without even the implied warranty of MERCHANTABILITY or ) +[//]: # ( FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ) +[//]: # ( for more details. You should have received a copy of the GNU Lesser ) +[//]: # ( General Public License along with this program. If not, see ) +[//]: # ( . ) + + + +Compiler support for Atlas is currently in the form of an +instrumentation pass (NVM Instrumenter) built on top of the LLVM +compiler (http://llvm.org). Please ensure that LLVM/clang (version 3.6.0 or +above) is installed on your system or added to your PATH. If +required, visit http://llvm.org/releases/download.html to get the latest +binaries for this purpose. + +To build the NVM Instrumenter shared library for clang, change +directory to `compiler-plugin` and run `./build_plugin`. The file +`NvmInstrumenter.so` will be created under the subdirectory +`plugin_build`. + +Ensure the versions of clang and llvm developer tools (ie llvm-config) are the same. + +To use clang with instrumentation, it is recommended to use an +environment variable as used in the Atlas test scripts + + $ACC: clang -Xclang -load -Xclang /compiler-plugin/plugin_build/NvmInstrumenter.so + $ACXX: clang++ -Xclang -load -Xclang /compiler-plugin/plugin_build/NvmInstrumenter.so diff --git a/Atlas/compiler-plugin/build_plugin b/Atlas/compiler-plugin/build_plugin new file mode 100755 index 0000000000000000000000000000000000000000..3a892e4d71bba5a35db977bd298543ab7f982ec3 --- /dev/null +++ b/Atlas/compiler-plugin/build_plugin @@ -0,0 +1,78 @@ +#!/usr/bin/env bash + +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# + +logfile="build_log.txt" +if [ -f "$logfile" ]; then + rm $logfile +fi +srcfile="src/Instrumentation/NvmInstrumenter.cpp" +if [ "${1,,}" == "help" ];then + echo "Run with $0 to build NvmInstrumenter.so - the compiler plugin for building Atlas programs. Build commands are set to timeout after 5 minutes." + exit 0 +fi +if [ ! -f "$srcfile" ]; then + echo "Could not find plugin source file NvmInstrumenter.cpp - are you running from within Atlas/compiler-plugin?" + exit 1 +fi +clangpppath=$(which clang++; reval="$?") +if [ "$?" -ne 0 ]; then + echo "Could not find a copy of clang++, is it installed or added to PATH?" + exit 1 +else + echo "Found clang++ in $clangpppath" +fi +llvmconfigpath=$(which llvm-config; reval="$?") +if [ "$?" -ne 0 ]; then + echo "Could not find llvm-config, is it installed or added to PATH?" + exit 1 +else + echo "Found llvm-config in $llvmconfigpath" +fi +echo "Compiling object files" | tee $logfile +timeout 300s clang++ -c $srcfile `llvm-config --cxxflags` -fno-rtti >> $logfile 2>&1 +retval="$?" +if [ "$retval" == "124" ]; then + echo "Compilation took longer than 5 minutes - have you got conflicting versions of llvmretval Try building with the linked script." + exit 1 +elif [ "$retval" -ne 0 ]; then + echo "Build shared lib failed on compilation, check $logfile" + exit 1 +else + echo "Compilation successful" +fi +echo "Linking" | tee $logfile +timeout 300s clang++ -shared NvmInstrumenter.o -o NvmInstrumenter.so -fno-rtti >> $logfile 2>&1 +retval="$?" +if [ "$retval" == "124" ]; then + echo "Linking took longer than 5 minutes - have you got conflicting versions of llvmretval Try building with the linked script." + exit 1 +elif [ "$retval" -ne 0 ]; then + echo "Build shared lib failed on linking, check $logfile" + exit 1 +else + echo "Linking successful" +fi +rm NvmInstrumenter.o +if [ -f "NvmInstrumenter.so" ]; then + echo "Successfully built compiler plugin NvmInstrumenter.so" + rm $logfile +fi +if [ ! -d "plugin_build" ]; then + mkdir plugin_build +fi +mv NvmInstrumenter.so plugin_build/ +echo "NvmInstrumenter.so is under plugin_build/" diff --git a/Atlas/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp b/Atlas/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a5aa375e444798c157b34d8264b2689a4c44d31e --- /dev/null +++ b/Atlas/compiler-plugin/src/Instrumentation/NvmInstrumenter.cpp @@ -0,0 +1,637 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "llvm/Pass.h" +#include "llvm/IR/Function.h" +#include "llvm/IR/Type.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/IR/Module.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Transforms/Instrumentation.h" + +#include "llvm/Transforms/IPO/PassManagerBuilder.h" +#include "llvm/IR/LegacyPassManager.h" + +using namespace llvm; + +#define DEBUG_TYPE "nvm_instr" + +STATISTIC(NumNvmAcquire, "Number of acquires instrumented"); +STATISTIC(NumNvmRelease, "Number of releases instrumented"); +STATISTIC(NumNvmStore, "Number of stores instrumented"); +STATISTIC(NumNvmMemCpy, "Number of memcopies instrumented"); +STATISTIC(NumNvmMemMove, "Number of memmoves instrumented"); +STATISTIC(NumNvmMemSet, "Number of memsets instrumented"); +STATISTIC(NumNvmStrCpy, "Number of strcpys instrumented"); +STATISTIC(NumNvmStrCat, "Number of strcats instrumented"); + +namespace { + class NvmInstrumenter : public FunctionPass + { + public: + enum CallOpType { None, Acquire, Release, MemCpy, MemMove, MemSet, StrCpy, StrNCpy, StrCat, StrNCat }; + static char ID; + NvmInstrumenter() + : FunctionPass(ID), AcquireFuncEntry(0), ReleaseFuncEntry(0), + StoreFuncEntry(0), PsyncAcqFuncEntry(0), + MemCpyFuncEntry(0), MemMoveFuncEntry(0), MemSetFuncEntry(0), + StrCpyFuncEntry(0), StrCatFuncEntry(0), + StrLenFuncEntry(0), + BarrierFuncEntry(0), + AsyncDataFlushEntry(0), AsyncMemOpDataFlushEntry(0) + { +// initializeNvmInstrumenterPass( +// *PassRegistry::getPassRegistry()); + } + bool runOnFunction(Function &F); + const char *getPassName() const { return "nvm_instr"; } + private: + void initializeAcquire(Module &M); + void initializeRelease(Module &M); + void initializeStore(Module &M); + void initializePsyncAcqFuncEntry(Module &M); + void initializeMemCpyFuncEntry(Module &M); + void initializeMemMoveFuncEntry(Module &M); + void initializeMemSetFuncEntry(Module &M); + void initializeStrCpyFuncEntry(Module &M); + void initializeStrCatFuncEntry(Module &M); + void initializeStrLenFuncEntry(Module &M); + void initializeBarrierFuncEntry(Module &M); + void initializeAsyncDataFlushEntry(Module &M); + void initializeAsyncMemOpDataFlushEntry(Module &M); + + bool shouldInstrumentStore(StoreInst *SI); + CallOpType getCallOperationType(Instruction *I); + + bool performNvmInstrumentation( + Function &F, + const SmallVectorImpl &Stores, + const SmallVectorImpl &Acquires, + const SmallVectorImpl &Releases, + const SmallVectorImpl &MemCpys, + const SmallVectorImpl &MemMoves, + const SmallVectorImpl &MemSets, + const SmallVectorImpl &StrCpys, + const SmallVectorImpl &StrCats); + void addMemInstrumentation(Instruction *I, Function *FuncEntry); + + Function *AcquireFuncEntry; + Function *StoreFuncEntry; + Function *ReleaseFuncEntry; + Function *PsyncAcqFuncEntry; + Function *MemCpyFuncEntry; + Function *MemMoveFuncEntry; + Function *MemSetFuncEntry; + Function *StrCpyFuncEntry; + Function *StrCatFuncEntry; + Function *StrLenFuncEntry; + Function *BarrierFuncEntry; + Function *AsyncDataFlushEntry; + Function *AsyncMemOpDataFlushEntry; + }; +} + +static StringRef LockAcquireName("pthread_mutex_lock"); +static StringRef LockReleaseName("pthread_mutex_unlock"); +static StringRef MemCpy32Name("llvm.memcpy.p0i8.p0i8.i32"); +static StringRef MemCpy64Name("llvm.memcpy.p0i8.p0i8.i64"); +static StringRef MemMove32Name("llvm.memmove.p0i8.p0i8.i32"); +static StringRef MemMove64Name("llvm.memmove.p0i8.p0i8.i64"); +static StringRef MemSet32Name("llvm.memset.p0i8.i32"); +static StringRef MemSet64Name("llvm.memset.p0i8.i64"); +static StringRef StrCpyName("strcpy"); +static StringRef StrNCpyName("strncpy"); +static StringRef StrCatName("strcat"); +static StringRef StrNCatName("strncat"); + +bool NvmInstrumenter::runOnFunction(Function &F) +{ + + SmallVector Stores; + SmallVector Acquires; + SmallVector Releases; + SmallVector MemCpys; + SmallVector MemMoves; + SmallVector MemSets; + SmallVector StrCpys; + SmallVector StrCats; + + Instruction *I; + bool Res = false; + // Traverse all instructions + // Look for stores, lock acquires and releases + for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) { + BasicBlock &BB = *BI; + for (BasicBlock::iterator II = BB.begin(), IE = BB.end(); + II != IE; ++ II) { + I = dyn_cast(II); + if (isa(I) && + shouldInstrumentStore(dyn_cast(I))) { + ++NumNvmStore; + Stores.push_back(I); + } + else if (isa(I)) { + CallOpType CT = getCallOperationType(I); + if (CT == Acquire) { + ++NumNvmAcquire; + Acquires.push_back(I); + } + else if (CT == Release) { + ++NumNvmRelease; + Releases.push_back(I); + } + else if (CT == MemCpy) { + ++NumNvmMemCpy; + MemCpys.push_back(I); + } + else if (CT == MemMove) { + ++NumNvmMemMove; + MemMoves.push_back(I); + } + else if (CT == MemSet) { + ++NumNvmMemSet; + MemSets.push_back(I); + } + else if (CT == StrCpy || CT == StrNCpy) { + ++NumNvmStrCpy; + StrCpys.push_back(I); + } + else if (CT == StrCat || CT == StrNCat) { + ++NumNvmStrCat; + StrCats.push_back(I); + } + } + } + } + Res |= performNvmInstrumentation( + F, Stores, Acquires, Releases, MemCpys, MemMoves, MemSets, StrCpys, StrCats); + if ( Stores.size() || Acquires.size() || Releases.size() || MemCpys.size() || MemMoves.size() || MemSets.size() || StrCpys.size() || StrCats.size()) + errs() << "Atlas instrumentation done on " << F.getName() << "\n"; + return Res; +} + +bool NvmInstrumenter::shouldInstrumentStore(StoreInst *SI) +{ + Value *Addr = cast(SI)->getPointerOperand(); + if (isa(Addr)) return false; // local variable + return true; +} + +NvmInstrumenter::CallOpType +NvmInstrumenter::getCallOperationType(Instruction *I) +{ + CallInst *CallInstruction = cast(I); + Function *CalledFunction = CallInstruction->getCalledFunction(); + if (!CalledFunction) return None; + + if (!CalledFunction->isDeclaration()) return None; + + // TODO attribute check to make sure it is not overridden + + if (CalledFunction->getName().equals(LockAcquireName)) + return Acquire; + else if (CalledFunction->getName().equals(LockReleaseName)) + return Release; + else if (CalledFunction->getName().equals(MemCpy32Name) || + CalledFunction->getName().equals(MemCpy64Name)) + return MemCpy; + else if (CalledFunction->getName().equals(MemMove32Name) || + CalledFunction->getName().equals(MemMove64Name)) + return MemMove; + else if (CalledFunction->getName().equals(StrCpyName)) + return StrCpy; + else if (CalledFunction->getName().equals(StrNCpyName)) + return StrNCpy; + else if (CalledFunction->getName().equals(StrCatName)) + return StrCat; + else if (CalledFunction->getName().equals(StrNCatName)) + return StrNCat; + return None; +} +void NvmInstrumenter::initializeAcquire(Module &M) +{ + if (AcquireFuncEntry) return; + + IRBuilder<> IRB(M.getContext()); + AcquireFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_acquire", IRB.getVoidTy(), + Type::getInt8PtrTy(M.getContext()), NULL)); + assert(AcquireFuncEntry); +} + +void NvmInstrumenter::initializeRelease(Module &M) +{ + if (ReleaseFuncEntry) return; + + IRBuilder<> IRB(M.getContext()); + ReleaseFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_release", IRB.getVoidTy(), + Type::getInt8PtrTy(M.getContext()), NULL)); + assert(ReleaseFuncEntry); +} + +void NvmInstrumenter::initializeStore(Module &M) +{ + if (StoreFuncEntry) return; + + StoreFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_store", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(StoreFuncEntry); +} + +void NvmInstrumenter::initializeMemCpyFuncEntry(Module &M) +{ + if (MemCpyFuncEntry) return; + + MemCpyFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_memcpy", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(MemCpyFuncEntry); +} + +void NvmInstrumenter::initializeMemMoveFuncEntry(Module &M) +{ + if (MemMoveFuncEntry) return; + + MemMoveFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_memmove", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(MemMoveFuncEntry); +} + +void NvmInstrumenter::initializeMemSetFuncEntry(Module &M) +{ + if (MemSetFuncEntry) return; + + MemSetFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_memset", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(MemSetFuncEntry); +} + +void NvmInstrumenter::initializeStrCpyFuncEntry(Module &M) +{ + if (StrCpyFuncEntry) return; + + StrCpyFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_strcpy", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(StrCpyFuncEntry); +} + +void NvmInstrumenter::initializeStrCatFuncEntry(Module &M) +{ + if (StrCatFuncEntry) return; + + StrCatFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_strcat", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(StrCatFuncEntry); +} + +void NvmInstrumenter::initializeStrLenFuncEntry(Module &M) +{ + if (StrLenFuncEntry) return; + + StrLenFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_strlen", + Type::getInt64Ty(M.getContext()), + Type::getInt8PtrTy(M.getContext()), NULL)); + assert(StrLenFuncEntry); +} + +void NvmInstrumenter::initializeBarrierFuncEntry(Module &M) +{ + if (BarrierFuncEntry) return; + + BarrierFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_barrier", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), NULL)); + assert(BarrierFuncEntry); +} + +void NvmInstrumenter::initializePsyncAcqFuncEntry(Module &M) +{ + if (PsyncAcqFuncEntry) return; + + PsyncAcqFuncEntry = dyn_cast( + M.getOrInsertFunction("nvm_psync_acq", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(PsyncAcqFuncEntry); +} + +void NvmInstrumenter::initializeAsyncDataFlushEntry(Module &M) +{ + if (AsyncDataFlushEntry) return; + + AsyncDataFlushEntry = dyn_cast( + M.getOrInsertFunction("AsyncDataFlush", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), NULL)); + assert(AsyncDataFlushEntry); +} + +void NvmInstrumenter::initializeAsyncMemOpDataFlushEntry(Module &M) +{ + if (AsyncMemOpDataFlushEntry) return; + + AsyncMemOpDataFlushEntry = dyn_cast( + M.getOrInsertFunction("AsyncMemOpDataFlush", + Type::getVoidTy(M.getContext()), + Type::getInt8PtrTy(M.getContext()), + Type::getInt64Ty(M.getContext()), NULL)); + assert(AsyncMemOpDataFlushEntry); +} +bool NvmInstrumenter::performNvmInstrumentation( + Function &F, + const SmallVectorImpl &Stores, + const SmallVectorImpl &Acquires, + const SmallVectorImpl &Releases, + const SmallVectorImpl &MemCpys, + const SmallVectorImpl &MemMoves, + const SmallVectorImpl &MemSets, + const SmallVectorImpl &StrCpys, + const SmallVectorImpl &StrCats) +{ + if (Acquires.size()) initializeAcquire(*F.getParent()); + if (Releases.size()) initializeRelease(*F.getParent()); + if (MemCpys.size()) initializeMemCpyFuncEntry(*F.getParent()); + if (MemMoves.size()) initializeMemMoveFuncEntry(*F.getParent()); + if (MemSets.size()) initializeMemSetFuncEntry(*F.getParent()); + if (StrCpys.size() || StrCats.size()) initializeStrLenFuncEntry(*F.getParent()); + if (StrCpys.size()) initializeStrCpyFuncEntry(*F.getParent()); + if (StrCats.size()) initializeStrCatFuncEntry(*F.getParent()); + if (getenv("USE_TABLE_FLUSH")) { + if (Stores.size()) initializeAsyncDataFlushEntry(*F.getParent()); + if (MemCpys.size() || MemMoves.size() || MemSets.size() || StrCpys.size() || StrCats.size()) + initializeAsyncMemOpDataFlushEntry(*F.getParent()); + } + else { + if (Stores.size()) initializeBarrierFuncEntry(*F.getParent()); + if (MemCpys.size() || MemMoves.size() || MemSets.size() || StrCpys.size() || StrCats.size()) + initializePsyncAcqFuncEntry(*F.getParent()); + } + + IRBuilder<> IRB(F.getParent()->getContext()); + + for (SmallVectorImpl::const_iterator AB = Acquires.begin(), + AE = Acquires.end(); AB != AE; ++AB) { + Instruction *I = *AB; + assert(isa(I) && "Found a non-call instruction"); + + CallInst *CallInstruction = cast(I); + assert(CallInstruction->getNumArgOperands() == 1 && + "Expected 1 argument to pthread_mutex_lock"); + + PointerType *ArgType = + Type::getInt8PtrTy(F.getParent()->getContext()); + Value *OP = CallInstruction->getArgOperand(0); + Value *Arg1 = OP->getType() == ArgType ? NULL : + IRB.CreatePointerCast(OP, ArgType); + Value *Args[] = {Arg1 ? Arg1 : OP}; + CallInst *NI = CallInst::Create( + AcquireFuncEntry, ArrayRef(Args)); + NI->insertAfter(CallInstruction); + if (Arg1 && isa(Arg1)) + dyn_cast(Arg1)->insertBefore(NI); + } + for (SmallVectorImpl::const_iterator RB = Releases.begin(), + RE = Releases.end(); RB != RE; ++RB) { + Instruction *I = *RB; + assert(isa(I) && "Found a non-call instruction"); + + CallInst *CallInstruction = cast(I); + assert(CallInstruction->getNumArgOperands() == 1 && + "Expected 1 argument to pthread_mutex_unlock"); + + PointerType *ArgType = + Type::getInt8PtrTy(F.getParent()->getContext()); + Value *OP = CallInstruction->getArgOperand(0); + Value *Arg1 = OP->getType() == ArgType ? NULL : + IRB.CreatePointerCast(OP, ArgType); + Value *Args[] = {Arg1 ? Arg1 : OP}; + CallInst *NI = CallInst::Create( + ReleaseFuncEntry, ArrayRef(Args), "", CallInstruction); + if (Arg1 && isa(Arg1)) + dyn_cast(Arg1)->insertBefore(NI); + } + for (SmallVectorImpl::const_iterator SB = Stores.begin(), + SE = Stores.end(); SB != SE; ++SB) { + Instruction *I = *SB; + assert(isa(I) && "Found a non-store instruction"); + + StoreInst *StoreInstruction = cast(I); + Value *Addr = StoreInstruction->getPointerOperand(); + Value *Val = StoreInstruction->getValueOperand(); + + unsigned sz; + if (Val->getType()->isIntegerTy() || + Val->getType()->isFloatTy() || + Val->getType()->isDoubleTy() || + Val->getType()->isX86_FP80Ty() || + Val->getType()->isFP128Ty()) + sz = Val->getType()->getPrimitiveSizeInBits(); + else if (Val->getType()->isPointerTy()) sz = 64; + else { + Val->dump(); + Val->getType()->dump(); + assert(0); + } + + unsigned extra_sz = 0; + if (sz > 64) { + assert(sz <= 128 && "This type is not supported"); + extra_sz = sz - 64; + assert(!(sz % 8)); + sz = 64; + } + + PointerType *ArgType = + Type::getInt8PtrTy(F.getParent()->getContext()); + Value *Arg1 = Addr->getType() == ArgType ? NULL : + IRB.CreatePointerCast(Addr, ArgType); + Value *ConstantSize = ConstantInt::get( + Type::getInt64Ty(F.getParent()->getContext()), sz); + + Value *Args[] = {Arg1 ? Arg1 : Addr, ConstantSize}; + + CallInst *NI = NULL; + initializeStore(*F.getParent()); + NI = CallInst::Create(StoreFuncEntry, ArrayRef(Args), + "", StoreInstruction); + if (Arg1 && isa(Arg1)) + dyn_cast(Arg1)->insertBefore(NI); + + if (isa(ConstantSize)) + dyn_cast(ConstantSize)->insertBefore(NI); + + if (extra_sz) { + Value *Word = ConstantInt::get( + Type::getInt64Ty(F.getParent()->getContext()), 8); + Value *IntReprOfAddr = + IRB.CreatePtrToInt( + Addr, Type::getInt64Ty(F.getParent()->getContext())); + if (isa(IntReprOfAddr)) + dyn_cast(IntReprOfAddr)->insertBefore( + StoreInstruction); + Instruction *add_word = BinaryOperator::Create( + Instruction::Add, + IntReprOfAddr, + Word, "add_word", StoreInstruction); + + Value *PtrReprOfIncrement = + IRB.CreateIntToPtr(add_word, ArgType); + if (isa(PtrReprOfIncrement)) + dyn_cast(PtrReprOfIncrement)->insertBefore( + StoreInstruction); + Value *ExtraConstantSize = ConstantInt::get( + Type::getInt64Ty(F.getParent()->getContext()), extra_sz); + Value *ExtraArgs[] = {PtrReprOfIncrement, ExtraConstantSize}; + CallInst::Create(StoreFuncEntry, ArrayRef(ExtraArgs), + "", StoreInstruction); + } + + Value *BarrierArgs[] = {Arg1 ? Arg1 : Addr}; + if (getenv("USE_TABLE_FLUSH")) { + CallInst *TFI = CallInst::Create(AsyncDataFlushEntry, + ArrayRef(BarrierArgs)); + dyn_cast(TFI)->insertAfter(StoreInstruction); + } + else { + CallInst *BI = CallInst::Create(BarrierFuncEntry, + ArrayRef(BarrierArgs)); + dyn_cast(BI)->insertAfter(StoreInstruction); + } + } + for (SmallVectorImpl::const_iterator MCB = MemCpys.begin(), + MCE = MemCpys.end(); MCB != MCE; ++MCB) + addMemInstrumentation(*MCB, MemCpyFuncEntry); + for (SmallVectorImpl::const_iterator MMB = MemMoves.begin(), + MME = MemMoves.end(); MMB != MME; ++MMB) + addMemInstrumentation(*MMB, MemMoveFuncEntry); + for (SmallVectorImpl::const_iterator MSB = MemSets.begin(), + MSE = MemSets.end(); MSB != MSE; ++MSB) + addMemInstrumentation(*MSB, MemSetFuncEntry); + for (SmallVectorImpl::const_iterator SCB = StrCpys.begin(), + SCE = StrCpys.end(); SCB != SCE; ++SCB) { + Instruction *I = *SCB; + CallOpType CT = getCallOperationType(I); + if (CallInst *CallInstruction = dyn_cast(I)) { + Value *size; + if (CT == StrCpy) { + CallInst* CI = CallInst::Create( + StrLenFuncEntry, + ArrayRef(CallInstruction->getArgOperand(0)), "", + CallInstruction); + size = CI; + } else { + size = CallInstruction->getArgOperand(2); + } + Value *Args[] = {CallInstruction->getArgOperand(0), size}; + CallInst::Create(StrCpyFuncEntry, ArrayRef(Args), "", + CallInstruction); + if (getenv("USE_TABLE_FLUSH")) { + CallInst *TFI = CallInst::Create(AsyncMemOpDataFlushEntry, + ArrayRef(Args)); + dyn_cast(TFI)->insertAfter(CallInstruction); + } + else { + CallInst *FI = CallInst::Create(PsyncAcqFuncEntry, + ArrayRef(Args)); + dyn_cast(FI)->insertAfter(CallInstruction); + } + } + } + for (SmallVectorImpl::const_iterator SCAB = StrCats.begin(), + SCAE = StrCats.end(); SCAB != SCAE; ++SCAB) { + Instruction *I = *SCAB; + if (CallInst *CallInstruction = dyn_cast(I)) { + CallInst* DSLI = CallInst::Create( + StrLenFuncEntry, + ArrayRef(CallInstruction->getArgOperand(0)), "", + CallInstruction); + Value *Args[] = {CallInstruction->getArgOperand(0), DSLI}; + CallInst::Create(StrCatFuncEntry,ArrayRef(Args), "", + CallInstruction); + if (getenv("USE_TABLE_FLUSH")) { + CallInst *TFI = CallInst::Create(AsyncMemOpDataFlushEntry, + ArrayRef(Args)); + dyn_cast(TFI)->insertAfter(CallInstruction); + } + else { + CallInst *FI = CallInst::Create(PsyncAcqFuncEntry, + ArrayRef(Args)); + dyn_cast(FI)->insertAfter(CallInstruction); + } + } + else errs() << "Found a non-call instruction in strcpys..."; + } + + return true; +} + +void NvmInstrumenter::addMemInstrumentation( + Instruction *I, Function *FuncEntry) +{ + assert(isa(I) && "Found a non-call instruction"); + + CallInst *CallInstruction = cast(I); + assert(CallInstruction->getNumArgOperands() == 5 && + "Expected 5 arguments to memset"); + Value *Args[] = {CallInstruction->getArgOperand(0), + CallInstruction->getArgOperand(2)}; + CallInst::Create(FuncEntry, ArrayRef(Args), "", CallInstruction); + if (getenv("USE_TABLE_FLUSH")) { + CallInst *TFI = CallInst::Create(AsyncMemOpDataFlushEntry, + ArrayRef(Args)); + dyn_cast(TFI)->insertAfter(CallInstruction); + } + else { + CallInst *FI = CallInst::Create(PsyncAcqFuncEntry, + ArrayRef(Args)); + dyn_cast(FI)->insertAfter(CallInstruction); + } +} + +char NvmInstrumenter::ID = 0; +static RegisterPass +X("NvmInstrumenter", + "Instruments persistent stores and synchronization operations", + false, false); + +static void registerNvmInstrumenter(const PassManagerBuilder &, + legacy::PassManagerBase &PM) { + PM.add(new NvmInstrumenter()); +} + +static RegisterStandardPasses RegisterNvmInstrumenter(PassManagerBuilder::EP_EarlyAsPossible, registerNvmInstrumenter); diff --git a/Atlas/compiler-plugin/test/README.md b/Atlas/compiler-plugin/test/README.md new file mode 100644 index 0000000000000000000000000000000000000000..682e1a6fba17d9fb99c1cc91610b2e6a020e9c3b --- /dev/null +++ b/Atlas/compiler-plugin/test/README.md @@ -0,0 +1,54 @@ +[//]: # ( (c) Copyright 2016 Hewlett Packard Enterprise Development LP ) +[//]: # ( ) +[//]: # ( This program is free software: you can redistribute it and/or modify ) +[//]: # ( it under the terms of the GNU Lesser General Public License as ) +[//]: # ( published by the Free Software Foundation, either version 3 of the ) +[//]: # ( License, or (at your option) any later version. This program is ) +[//]: # ( distributed in the hope that it will be useful, but WITHOUT ANY ) +[//]: # ( WARRANTY; without even the implied warranty of MERCHANTABILITY or ) +[//]: # ( FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ) +[//]: # ( for more details. You should have received a copy of the GNU Lesser ) +[//]: # ( General Public License along with this program. If not, see ) +[//]: # ( . ) + +# Instrumentation Tests + +`test_instr` performs instrumentation checks on different instructions, verifying +that the compiler plugin performs the correct instrumentations, both type and quantity. + +## Usage + +To run the test script do `./test_instr false`. Run with +`./test_instr true` to see debug information, if there are errors +for example. + +## Requirements + +The LLVM toolchain must be built debug with assertions enabled. This is needed in order to +run opt with -stats, more on the LLVM Statistic class +[here](http://llvm.org/docs/ProgrammersManual.html#statistic). + +The compiler plugin `NvmInstrumenter.so` must also be built (with assertions). +If the compiler plugin is built outside of `plugin_build/`, +set environment variable PLUGIN to its location. + +If these are not met the script will return with a non zero exit code. + +## Adding New Tests + +Both C or C++ tests are allowed. + +Tests are placed in this directory `compiler-plugin/test`. + +To add a new test `test.c` a corresponding `test.ref` must be created +and placed under `compiler-plugin/test/test_refs`. + +A `.ref` file is used to check that the expected instrumentation +occured. These are generated with clang and opt. Run the following from this directory. + + $ clang -c -emit-llvm test.c &> /dev/null + $ opt -load ../plugin_build/NvmInstrumenter.so -NvmInstrumenter -stats < test.bc > /dev/null 2> test.ref; rm test.bc + $ sed -i '/Number of/!d' test.ref + +View the contents of `test.ref`. If the correct number of instrumentations have occurred, +move `test.ref` to `test_refs/`. diff --git a/Atlas/compiler-plugin/test/long_double.c b/Atlas/compiler-plugin/test/long_double.c new file mode 100644 index 0000000000000000000000000000000000000000..1afaa246867d03cb71a6294faf83eb0245bbac2f --- /dev/null +++ b/Atlas/compiler-plugin/test/long_double.c @@ -0,0 +1,19 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +void foo(long double *mloc) +{ + *mloc = 1000; +} diff --git a/Atlas/compiler-plugin/test/store_int.c b/Atlas/compiler-plugin/test/store_int.c new file mode 100644 index 0000000000000000000000000000000000000000..443392713f359cd6d95ddd866bd88ce577aa0564 --- /dev/null +++ b/Atlas/compiler-plugin/test/store_int.c @@ -0,0 +1,19 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +void foo(int *mloc) +{ + *mloc = 1000; +} diff --git a/Atlas/compiler-plugin/test/strops.c b/Atlas/compiler-plugin/test/strops.c new file mode 100644 index 0000000000000000000000000000000000000000..f1a35378d8cc0eb4749ee943153ed83aeb3bdc08 --- /dev/null +++ b/Atlas/compiler-plugin/test/strops.c @@ -0,0 +1,27 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +#include +#include +#include +#include +#include + +void foo( char *str1, char *str2){ + strcpy(str2, str1); + strncpy(str2, str1, 5); + strcat(str2, str1); + strncat(str2, str1, 5); +} diff --git a/Atlas/compiler-plugin/test/test_instr b/Atlas/compiler-plugin/test/test_instr new file mode 100755 index 0000000000000000000000000000000000000000..c8d60aa468a36a32142d1f673110cf0b3137dc04 --- /dev/null +++ b/Atlas/compiler-plugin/test/test_instr @@ -0,0 +1,143 @@ +#!/usr/bin/env bash + +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# + +debug_log=test_instr_log.txt +total_fails=0 +out="instr_out.txt" + +################################################################ +# debug_print # +################################################################ +function debug_print +{ + local err_str="[TEST_INSTR] $1" + local echoon="$2" + if [ -z "$echoon" ]; then + echoon=$debug + elif [ "${echoon,,}" == "true" ]; then + echoon="true" + fi + if [ "$echoon" == "true" ]; then + echo "$err_str" + fi + echo "$err_str" >> $debug_log +} +################################################################ +# failed_run # +################################################################ +function failed_run +{ + debug_print "Retaining .out .bc files for debugging purposes" "true" + total_fails=$(($total_fails+1)) +} +################################################################ +# test_instrumentation # +################################################################ +function test_instrumentation +{ + debug_print "Beginning instrumentation testing" "true" + test_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" + cd $test_dir + plugin="$test_dir/../plugin_build/NvmInstrumenter.so" + atlas_root="$test_dir/../.." + if [ -f "$plugin" ]; then + debug_print "Found compiler plugin build" + elif [ ! -z "$PLUGIN" ]; then + debug_print "Found compiler plugin to test instrumentation in $PLUGIN" + plugin="$PLUGIN" + else + debug_print "Cannot detect a build of atlas instrumentation plugin, ensure it is built with compiler-plugin/build_plugin." "true" + debug_print "If your build plugin is outside of compiler_plugin, set \$PLUGIN to it's location" "true" + exit 1 + fi + if ! which opt > /dev/null ; then + debug_print "Cannot find opt - cannot conduct instrumentation testing, exiting" "true" + exit 1 + fi + if opt --version | grep assert > /dev/null; then + debug_print "Found a version of opt built with asserts" + else + debug_print "No version of opt with asserts found, cannot check statistics, exiting" "true" + exit 1 + fi + + tests=($(ls -d *.c *.cpp 2> /dev/null)) + for testname in ${tests[@]}; do + testname=${testname%.*} + if [ ! -f test_refs/$testname\.ref ]; then + debug_print "Test $testname does not have a .ref file under test_refs. If this test has just been added, consult the README on how to generate a corresponding .ref file" "true" + debug_print "Counting as a failure, running next test" "true" + failed_run + continue + fi + debug_print "Generating llvm ir bitcode file for $testname" + clang -c -emit-llvm $testname\.c -I$atlas_root/runtime/include &> /dev/null + if [ "$?" -ne 0 ]; then + debug_print "Failed to generate bitcode for $testname, running next test" "true" + failed_run + continue + fi + debug_print "Using opt to get instrumentation readout of bitcode for $testname" + opt -load $plugin -NvmInstrumenter -stats < $testname\.bc > /dev/null 2> $testname\.out + if [ "$?" -ne 0 ]; then + debug_print "Failed to run opt for $testname, running next test" "true" + failed_run + continue + fi + debug_print "Using sed to sanitise $testname.out" + sed -i '/Number of/!d' $testname\.out + debug_print "Results of $testname are" "true" + cat $testname\.out | tee -a $debug_log + debug_print "Running diff, output is in $debug_log" + if diff $testname\.out test_refs/$testname\.ref >> $debug_log; then + debug_print "Instrumentation results were as expected for $testname" "true" + debug_print "Run successful - removing $testname\.out and $testname\.bc" + rm -f $testname\.out $testname\.bc + else + debug_print "Instrumentation stats did not match expected values for $testname" "true" + debug_print "Counting as a failure - view diff in $debug_log" "true" + failed_run + fi + done +} +################################################################ +# main # +################################################################ +#Run with debug flag set to true to see output of build commands and which tests are passing. +#which would have been displayed with debug flag set to true. test_region_log contains output of tests. + +help_str="USAGE: ./test_instr [debug flag: true or false] \nVerifies correctness of instrumentation by compiler_plugin. \nRequires a debug build of LLVM with assertions and the compiler plugin to be built." + +debug="$1" +if [ "${debug,,}" == "false" ]; then #bash4.0 convert to lower + debug="false" +elif [ "${debug,,}" == "true" ]; then #bash4.0 convert to lower + debug="true" +else + echo -e "$help_str" + exit 1 +fi +rm -f $debug_log +debug_print "Set debug value to $debug" +test_instrumentation +if [[ $total_fails -gt 0 ]]; then + debug_print "$total_fails fails for region tests" "true" + exit 1 +else + debug_print "No failures occurred, instrumentation testing passed" "true" + exit 0 +fi diff --git a/Atlas/compiler-plugin/test/test_refs/long_double.ref b/Atlas/compiler-plugin/test/test_refs/long_double.ref new file mode 100644 index 0000000000000000000000000000000000000000..b033ac9ef0cc3340542d35d9d97d13a5db4bc39f --- /dev/null +++ b/Atlas/compiler-plugin/test/test_refs/long_double.ref @@ -0,0 +1 @@ +1 nvm_instr - Number of stores instrumented diff --git a/Atlas/compiler-plugin/test/test_refs/store_int.ref b/Atlas/compiler-plugin/test/test_refs/store_int.ref new file mode 100644 index 0000000000000000000000000000000000000000..b033ac9ef0cc3340542d35d9d97d13a5db4bc39f --- /dev/null +++ b/Atlas/compiler-plugin/test/test_refs/store_int.ref @@ -0,0 +1 @@ +1 nvm_instr - Number of stores instrumented diff --git a/Atlas/compiler-plugin/test/test_refs/strops.ref b/Atlas/compiler-plugin/test/test_refs/strops.ref new file mode 100644 index 0000000000000000000000000000000000000000..6b2f7f6ed0b95026e9cf5492b3a29daa2439028f --- /dev/null +++ b/Atlas/compiler-plugin/test/test_refs/strops.ref @@ -0,0 +1,2 @@ +2 nvm_instr - Number of strcats instrumented +2 nvm_instr - Number of strcpys instrumented diff --git a/Atlas/runtime/CMakeLists.txt b/Atlas/runtime/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..478ffadfbd0f09998392135ef124ee847b8cd1f8 --- /dev/null +++ b/Atlas/runtime/CMakeLists.txt @@ -0,0 +1,278 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# Top level CMakeLists for Atlas project + +cmake_minimum_required (VERSION 3.1.0) + +project (Atlas) +set (Atlas_VERSION_MAJOR 1) +set (Atlas_VERSION_MINOR 0) + +if (CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR AND NOT MSVC_IDE) + message(FATAL_ERROR "In-source builds are not allowed. +Please create a directory and run cmake from there, passing the path +to this source directory as the last argument. +This process created the file `CMakeCache.txt' and the directory `CMakeFiles'. +Please delete them.") +endif () + +#need pthreads to build tests and tools - find an equivalent pthread compatible library on host +set (THREADS_PREFER_PTHREAD_FLAG ON) +find_package (Threads REQUIRED) +link_libraries (Threads::Threads) + +#helper function used to build up relative file paths to files to be copied to build dir +function (prepend_paths FILES TARGET_PATH) + set (LISTVAR "") + foreach (t ${ARGN}) + list (APPEND LISTVAR "${TARGET_PATH}/${t}") + endforeach (t) + set (${FILES} "${LISTVAR}" PARENT_SCOPE) +endfunction (prepend_paths) + +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} README.md) + +set (ATLAS_INTERNAL_INCLUDES "src/internal_includes") +set (ATLAS_INCLUDE_DIR "include") +set (ATLAS_INCLUDE_FILES atlas_alloc.h atlas_api.h atlas_alloc_cpp.hpp) +prepend_paths (ATLAS_INCLUDE_FILES ${ATLAS_INCLUDE_DIR} ${ATLAS_INCLUDE_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_INCLUDE_FILES}) + +set (ATLAS_TESTS_DIR "tests") +set (ATLAS_TESTS_FILES run_quick_test) +prepend_paths (ATLAS_TESTS_FILES ${ATLAS_TESTS_DIR} ${ATLAS_TESTS_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_TESTS_FILES}) + +set (ATLAS_TESTS_DATA_STRUCT_IN_DIR "${ATLAS_TESTS_DIR}/data_structures_inputs") +set (ATLAS_TESTS_DATA_STRUCT_IN_FILES timing.txt cow_array_list_nvm.ref cow_array_list.ref queue_nvm.ref queue.ref + sll_ll.ref sll_nvm.ref sll.ref alarm_clock.ref alarm_clock_nvm.ref cow_array_list.in + cow_array_list_nvm.in queue_nvm.in queue.in sll.in sll_ll.in sll_nvm.in alarm_clock.in + alarm_clock_nvm.in stores.ref stores_nvm.ref stores.in stores_nvm.in) +prepend_paths (ATLAS_TESTS_DATA_STRUCT_IN_FILES ${ATLAS_TESTS_DATA_STRUCT_IN_DIR} ${ATLAS_TESTS_DATA_STRUCT_IN_FILES}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_TESTS_DATA_STRUCT_IN_FILES}) + +set (ATLAS_CONSISTENCY_DIR "${ATLAS_TESTS_DIR}/consistency") +set (ATLAS_CONSISTENCY_TESTS test_consistency) +prepend_paths (ATLAS_CONSISTENCY_TESTS ${ATLAS_CONSISTENCY_DIR} ${ATLAS_CONSISTENCY_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_CONSISTENCY_TESTS}) + +set (ATLAS_REGION_DIR "${ATLAS_TESTS_DIR}/region") +set (ATLAS_REGION_TESTS test_region) +prepend_paths (ATLAS_REGION_TESTS ${ATLAS_REGION_DIR} ${ATLAS_REGION_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_REGION_TESTS}) + +set (ATLAS_PMALLOC_DIR "${ATLAS_TESTS_DIR}/pmalloc") +set (ATLAS_PMALLOC_TESTS test_pmalloc) +prepend_paths (ATLAS_PMALLOC_TESTS ${ATLAS_PMALLOC_DIR} ${ATLAS_PMALLOC_TESTS}) +set (ATLAS_COPY_FILES ${ATLAS_COPY_FILES} ${ATLAS_PMALLOC_TESTS}) + +#default to debug build if no build type specified +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + message ("No build type specified, defaulting to debug") + set (CMAKE_BUILD_TYPE "Debug" CACHE STRING "Defaulted to debug build, none specified" FORCE) +endif () + +#use clang for everything +set (CMAKE_C_COMPILER "clang") +set (CMAKE_CXX_COMPILER "clang++") + +#set flags for using instrumentation + +set (INSTR $ENV{PLUGIN}) +if (INSTR) + message ("Found environment variable PLUGIN set to ${INSTR}") +elseif (EXISTS "${CMAKE_SOURCE_DIR}/../compiler-plugin/plugin_build/NvmInstrumenter.so") + set (INSTR "${CMAKE_SOURCE_DIR}/../compiler-plugin/plugin_build/NvmInstrumenter.so") + message ("Found a compiler plugin build in ${INSTR}") +else () + message (FATAL_ERROR "Cannot find NvmInstrumenter.so, is it built in Atlas/compiler-plugin/plugin_build? If built outside of Atlas/compiler-plugin/plugin_build set environment variable PLUGIN to it's location.") +endif () +set (NVM_INSTR_FLAGS "-Xclang -load -Xclang ${INSTR}") + +#debug settings +set (CMAKE_C_FLAGS_DEBUG "-g3 -DDEBUG") +set (CMAKE_CXX_FLAGS_DEBUG "-g3 -DDEBUG") + +#Defines required for building Atlas +set (ATLAS_SPECIFIC_FLAGS "-DATLAS_ALLOC_DUMP -DATLAS_ALLOC_TRACE") + +#Cmake defines used to specify different targets for Atlas - must pass to cmake as -DVAR_NAME=true +if (ALL_PERSISTENT) + message ("Configuring for all persistent") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALL_PERSISTENT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALL_PERSISTENT") +endif () +if (NVM_STATS) + message ("Configuring for nvm stats") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNVM_STATS") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DNVM_STATS") +endif () +if (FLC) + message ("Configuring for critical section level cache flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_FLUSH_LOCAL_COMMIT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FLUSH_LOCAL_COMMIT") +endif () +if (FGC) + message ("Configuring for global consistent point cache flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_FLUSH_GLOBAL_COMMIT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_FLUSH_GLOBAL_COMMIT") +endif () +if (USE_TABLE_FLUSH) + message ("Configuring for table based flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_TABLE_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_TABLE_FLUSH") +endif () +if (DISABLE_FLUSH) + message ("Configuring disabling all cache line flushes") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DDISABLE_FLUSHES") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DDISABLE_FLUSHES") +endif () +if (DISABLE_HELPER) + message ("Configuring disabling helper") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_HELPER") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_HELPER") +endif () +if (DISABLE_ALLOC_LOGGING) + message ("Configuring disabling alloc logging") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_ALLOC_LOGGING") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_ALLOC_LOGGING") +endif () +if (DISABLE_LOG_FLUSH) + message ("Configuring disabling log flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_LOG_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_LOG_FLUSH") +endif () +if (DISABLE_DATA_FLUSH) + message ("Configuring disabling data flush") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_DISABLE_DATA_FLUSH") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_DISABLE_DATA_FLUSH") +endif () +if (PROFILE_HT) + message ("Configuring profile helper thread") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_PROFILE_HT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_PROFILE_HT") +endif () +if (USE_MOVNT) + message ("Configuring use movnt") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MOVNT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_MOVNT") +endif () +if (NO_SFENCE) + message ("Configuring for movnt use with no sfence") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NO_SFENCE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NO_SFENCE") +endif () +if (LOG_FLUSH_OPT) + message ("Configuring to log flush optimization") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_FLUSH_OPT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_FLUSH_OPT") +endif () +if (LOG_WITH_NVM_ALLOC) + message ("Configuring to log with nvm alloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_WITH_NVM_ALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_WITH_NVM_ALLOC") +endif () +if (LOG_WITH_MALLOC) + message ("Configuring to log with malloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_LOG_WITH_MALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_LOG_WITH_MALLOC") +endif () +if (USE_MALLOC) + message ("Configuring to use malloc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_USE_MALLOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_USE_MALLOC") +endif () +if (OPT_UNIQ_LOC) + message ("Configuring to opt uniq loc") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_OPT_UNIQ_LOC") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_OPT_UNIQ_LOC") +endif () +if (ALWAYS_LOG) + message ("Configuring to always log") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALWAYS_LOG") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALWAYS_LOG") +endif () +if (ALWAYS_MAP) + message ("Configuring to always map") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_ALWAYS_MAP") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_ALWAYS_MAP") +endif () +if (TRACE) + message ("Configuring to use trace") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVM_TRACE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVM_TRACE") +endif () +if (FORCE_FAIL) + message ("Configuring to perform process crash testing") + set (APP_FLAGS "-D_FORCE_FAIL") +endif () +if (FAIL_ATLAS) + message ("Configuring atlas to fail internally") + set (ATLAS_SPECIFIC_FLAGS "${ATLAS_SPECIFIC_FLAGS} -D_FORCE_FAIL -rdynamic") +endif () +if (VERBOSE_TRACE) + message ("Configuring for verbose trace") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVM_VERBOSE_TRACE") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVM_VERBOSE_TRACE") +endif () +if (SRRF) + message ("Configuring for strong restart race freedom") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_SRRF") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_SRRF") +endif () +if (NVDIMM_PROLIANT) + message ("Configuring for ProLiant NVDIMM") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NVDIMM_PROLIANT") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NVDIMM_PROLIANT") +endif () +if (NO_NEST) + message ("Configuring for no nesting of critical sections") + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D_NO_NEST") + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D_NO_NEST") +endif () +if (CONSISTENCY_FAIL) + message ("Setting consistency tests to fail") + set (CONSISTENCY_FAIL_FLAG "-DCONSISTENCY_FAIL") +endif () + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) +set(CMAKE_C_STANDARD 11) +set(CMAKE_C_STANDARD_REQUIRED ON) +set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall -Wextra -pedantic -Wno-unused-parameter -Winline ${ATLAS_SPECIFIC_FLAGS}") +set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O3 -Wall -Wextra -pedantic -Winline ${ATLAS_SPECIFIC_FLAGS}") + +#copy necessary files from the src dir to the build dir +foreach (t ${ATLAS_COPY_FILES}) + configure_file (${CMAKE_SOURCE_DIR}/${t} ${PROJECT_BINARY_DIR}/${t} COPYONLY) +endforeach (t) + +include_directories (${CMAKE_SOURCE_DIR}/${ATLAS_INTERNAL_INCLUDES} ${CMAKE_SOURCE_DIR}/${ATLAS_INCLUDE_DIR}) + +set (LIBRARY_OUTPUT_PATH ${PROJECT_BINARY_DIR}/lib) + +#variable to build only data structures in tests +if (NOT DATA_STRUCTS_ONLY) + message ("Defaulting to build all tests") + add_subdirectory (tests) +else () + message ("Building only data structures") + add_subdirectory (tests/data_structures) +endif () + +add_subdirectory (src) +add_library (atlas $ $ $ $ $ $) #defaults to static build + +#install () diff --git a/Atlas/runtime/README.md b/Atlas/runtime/README.md new file mode 100644 index 0000000000000000000000000000000000000000..f169da51e70625b6ae0eb56759c4b8409d709f7c --- /dev/null +++ b/Atlas/runtime/README.md @@ -0,0 +1,93 @@ +[//]: # ( (c) Copyright 2016 Hewlett Packard Enterprise Development LP ) +[//]: # ( ) +[//]: # ( This program is free software: you can redistribute it and/or modify ) +[//]: # ( it under the terms of the GNU Lesser General Public License as ) +[//]: # ( published by the Free Software Foundation, either version 3 of the ) +[//]: # ( License, or (at your option) any later version. This program is ) +[//]: # ( distributed in the hope that it will be useful, but WITHOUT ANY ) +[//]: # ( WARRANTY; without even the implied warranty of MERCHANTABILITY or ) +[//]: # ( FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License ) +[//]: # ( for more details. You should have received a copy of the GNU Lesser ) +[//]: # ( General Public License along with this program. If not, see ) +[//]: # ( . ) + + +# Atlas Runtime APIs + +Atlas is a high-level programming environment for non-volatile +memory. In-memory objects can be persisted or made durable with +relatively minor changes to code. There are 2 classes of APIs: +persistent region APIs and consistency APIs. The first class is used +to create/find/delete containers that store persistent data and can be +found in include/atlas_alloc.h. The second class is used to convey +data-consistency information to the system. Currently, this includes a +durable section (demarcated by begin_durable and end_durable) and +classical lock-based critical sections. See `include/atlas_api.h` for +these interfaces. For examples of how to write a persistent program +using Atlas, see `runtime/tests/data_structures/README.md`. + +## Building + +Atlas "runtime" uses cmake. cmake 3.1 is the minimum required +version. The library build must be in a separate build +directory. Assume that the top-level Atlas runtime directory is +`ATLAS_RUNTIME` and the build directory is `ATLAS_BUILD`. First create +`ATLAS_BUILD`. It is recommended to name this directory with the atlas +build config, e.g. `build-all`, or `build-all-persist`. Invoke cmake +within `ATLAS_BUILD`, passing the path to `ATLAS_RUNTIME` and +any variables needed for the config. Example: + + $ cd + $ mkdir build-all + $ cd build-all + $ cmake .. + $ make + +There are a number of modes for building the runtime. See +`runtime/CMakeLists.txt` for the supported ones. For example, to turn on +Atlas statistics, the cmake config line above should be: + + $ cmake .. -DNVM_STATS=true + +To rebuild Atlas runtime when changes are made to the sources, +just invoke `make` again. + +# Testing + +Persistent memory is simulated using Linux tmpfs, so make sure +`/dev/shm` is available, has enough space, and has `rwx` +permissions. After making, invoke `/tests/run_quick_test` +to do some basic testing. For developers: make sure that +`/tools/run_tests` passes before checking in. + +# Organization + +`ATLAS_RUNTIME` has the following subdirectories: + +`include`: contains the headers with exported interfaces. These are +the only headers that should be included in applications. + +`src`: the source files + +`src/internal_includes`: internal header files + +`src/pregion_mgr`: persistent region support + +`src/pmalloc`: persistent allocator support + +`src/logger`: support for logging updates to persistent memory + +`src/consistency`: automatic computation of consistent states and log pruning + +`src/cache_flush`: optimized cache line flush support + +`src/recover`: support for recovery after a failure + +`src/util`: common routines + +`tools`: `/tools/run_tests` goes through a variety of +build targets and does some basic testing for each of them. + +`tests`: directory used for testing. Contains binaries, inputs, +outputs, reference files, etc. See the READMEs in the individual +subdirectories. diff --git a/Atlas/runtime/include/atlas_alloc.h b/Atlas/runtime/include/atlas_alloc.h new file mode 100644 index 0000000000000000000000000000000000000000..46ea81ce1472858602d0034800af5eee4bad9be0 --- /dev/null +++ b/Atlas/runtime/include/atlas_alloc.h @@ -0,0 +1,194 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_H +#define ATLAS_ALLOC_H + +#include +#include +#include + +// +// Persistent region API +// These are interfaces for creating and managing persistent regions, +// entities that contain persistent data. Once a persistent region is +// created, objects can be allocated out of the region, e.g. by using +// nvm_alloc. Any data not in a persistent region is considered +// transient. +// +#ifdef __cplusplus +extern "C" { +#endif + +/// +/// @brief Create a named persistent region. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region created +/// +/// This interface does not check for an existing entry with +/// the same name. If a region with the same name already exists, the +/// behavior of the program is undefined. +/// +uint32_t NVM_CreateRegion(const char *name, int flags); + +/// +/// @brief Create a persistent region with the provided name. +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @param is_created Indicator whether the region got created as a +/// result of the call +/// @return Id of the region found or created +/// +/// If the region already exists, the existing id of the region is returned. +/// Otherwise a region is created and its newly assigned id returned. +/// +uint32_t NVM_FindOrCreateRegion(const char *name, int flags, int *is_created); + +/// +/// @brief Find the id of a region when it is known to exist already +/// @param name Name of the persistent region +/// @param flags access flag (one of O_RDONLY, O_WRONLY, O_RDWR) +/// @return Id of the region found +/// +/// This interface should be used over NVM_FindOrCreateRegion for +/// efficiency reasons if the region is known to exist. If a region +/// with the provided name does not exist, an assertion failure will +/// occur. +/// +uint32_t NVM_FindRegion(const char *name, int flags); + +/// +/// @brief Delete the region with the provided name. +/// @param name Name of the persistent region +/// +/// Use this interface to completely destroy a region. If the region +/// does not exist, an assertion failure will occur. +/// +void NVM_DeleteRegion(const char *name); + +/// +/// @brief Close a persistent region +/// @param rid Region id +/// +/// After closing, it won't be available to the calling process +/// without calling NVM_FindOrCreateRegion. The region will stay in +/// NVM even after calling this interface. This interface allows +/// closing a region with normal bookkeeping. +/// +void NVM_CloseRegion(uint32_t rid); + +/// +/// @brief Get the root pointer of the persistent region +/// @param rid Region id +/// @return Root pointer of the region +/// +/// The region must have been created already. Currently, only one +/// root is implemented for a given region. The idea is that anything +/// within a region that is not reachable from the root after program +/// termination is assumed to be garbage and can be recycled. During +/// execution, anything within a region that is not reachable from the +/// root or from other _roots_ (in the GC sense) is assumed to be +/// garbage as well. +/// +void *NVM_GetRegionRoot(uint32_t rid); + +/// +/// @brief Set the root pointer of an existing persistent region +/// @param rid Region id +/// @param root The new root of the region +/// +void NVM_SetRegionRoot(uint32_t rid, void *root); + +/// +/// @brief Determines if a memory location is within a region +/// @param ptr Queried address +/// @param sz Size of the location in bytes +/// @return 1 if within the region, otherwise 0 +/// +int NVM_IsInRegion(void *ptr, size_t sz); + +/// +/// @brief Determines if the addresses are on different cache lines +/// +/// @param p1 First address +/// @param p2 Second address +/// @return Indicates whether the addresses are on different cache +/// lines +/// +/// The objects under consideration must not cross cache lines, +/// otherwise this interface is inadequate. +/// +int isOnDifferentCacheLine(void *p1, void *p2); + +/// +/// @brief Determines if a memory location is aligned to a cache line +/// +/// @param p Address of memory location under consideration +/// @return Indicates whether the memory location is cache line +/// aligned +/// +int isCacheLineAligned(void *p); + +/// +/// @brief Malloc style interface for allocation from a persistent +/// region +/// +/// @param sz Size of location to be allocated +/// @param rid Id of persistent region for allocation +/// @return Address of memory location allocated +/// +void *nvm_alloc(size_t sz, uint32_t rid); + +/// +/// @brief Calloc style interface for allocation from a persistent +/// region +/// +/// @param nmemb Number of elements in the array to be allocated +/// @param sz Size of each element +/// @param rid Id of persistent region for allocation +/// @return Pointer to allocated memory +/// +void *nvm_calloc(size_t nmemb, size_t sz, uint32_t rid); + +/// +/// @brief Realloc style interface for allocation from a persistent +/// region +/// +/// @param ptr Address of memory block provided +/// @param sz New size of allocation +/// @param rid Id of persistent region for allocation +/// @return Pointer to re-allocated memory +/// +void *nvm_realloc(void *ptr, size_t sz, uint32_t rid); + +/// +/// @brief Deallocation interface for persistent data +/// +/// @param ptr Address of memory location to be freed. +/// +/// Though the usual use case would be for the location to be in +/// persistent memory, this interface will also work for transient +/// data. The implementation is required to transparently handle +/// this case as well. +/// +void nvm_free(void *ptr); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/Atlas/runtime/include/atlas_alloc_cpp.hpp b/Atlas/runtime/include/atlas_alloc_cpp.hpp new file mode 100644 index 0000000000000000000000000000000000000000..9f201bb76c36d36ff9bc9c51c9f370e1e09324fb --- /dev/null +++ b/Atlas/runtime/include/atlas_alloc_cpp.hpp @@ -0,0 +1,120 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_ALLOC_CPP_H +#define ATLAS_ALLOC_CPP_H + +// Forward declarations +namespace Atlas +{ + class PRegion; +} + +/// +/// @brief Get a handle to a persistent region +/// @param rid Region identifier +/// @return Pointer to the corresponding persistent region +/// +/// Currently, this interface is to be used by a client only for the +/// placement new operations +/// +Atlas::PRegion *NVM_GetRegion(uint32_t rid); + +/// +/// @brief Object allocation for C++ +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the C++ placement new operator. The +/// corresponding delete operation is NVM_Destroy. +/// +void* operator new(size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Array form allocation for C++, type must have explicit +/// destructor +/// @param sz Allocation size +/// @param rgn Pointer to the region to serve the allocation from +/// @return Pointer to memory allocated +/// +/// This interface overloads the array form C++ placement new +/// operator. The type of the array elements must have an explicit +/// destructor. The corresponding delete operation is +/// NVM_Destroy_Array. +/// +void* operator new[](size_t sz, Atlas::PRegion *rgn) noexcept; + +/// +/// @brief Object destruction for C++ +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an object that was +/// created from a persistent region using the single-object new +/// operator. The implementation calls the destructor followed by +/// actual deallocation. This interface can also be called for +/// destroying an object that was created using the default +/// single-object new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default single-object delete operator. This interface must not be +/// called for deallocating an object created in any other way, e.g. a +/// placement new operator where the placement address is not within a +/// persistent region. +/// +template static inline void NVM_Destroy(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete ptr; + return; + } + ptr->~T(); + void nvm_delete(void*); + nvm_delete(ptr); +} + +/// +/// @brief Array form destruction for C++, type must have explicit +/// destructor +/// @param ptr Pointer to memory to be deallocated +/// +/// This interface should be called for destroying an array of objects +/// that was created from a persistent region using the array-form new +/// operator. The implementation calls the destructors for all objects +/// of the array followed by actual deallocation. Note that the type +/// of the array elements must have an explicit destructor for this +/// interface to work correctly. This interface can also be called for +/// destroying an array of objects that was created using the default +/// array-form new operator. If the latter is the case, the +/// implementation detects this situation and turns around to call the +/// default array-form delete operator. This interface must not be +/// called for deallocating an object created in any other way. +/// +template static inline void NVM_Destroy_Array(T *ptr) +{ + if (!ptr) return; + if (!NVM_IsInRegion(ptr, 1 /* dummy, since size unknown */)) { + delete [] ptr; + return; + } + char *delete_ptr = reinterpret_cast(ptr) - sizeof(size_t); + size_t count = *reinterpret_cast(delete_ptr); + for (int i=count-1; i>=0; --i) (ptr+i)->~T(); + void nvm_delete(void*); + nvm_delete(delete_ptr); +} + +#endif diff --git a/Atlas/runtime/include/atlas_api.h b/Atlas/runtime/include/atlas_api.h new file mode 100644 index 0000000000000000000000000000000000000000..29bfa200de78887690c75378543be976a8cd9768 --- /dev/null +++ b/Atlas/runtime/include/atlas_api.h @@ -0,0 +1,178 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef ATLAS_API_H +#define ATLAS_API_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// +// Here are the APIs for initializing/finalizing Atlas. Each of the +// following 2 interfaces must be called only once. + +/// +/// Initialize Atlas internal data structures. This should be +/// called before persistent memory access. +/// +void NVM_Initialize(); + +/// +/// Finalize Atlas internal data structures. This should be called +/// before normal program exit. If not called, the implementation +/// will assume that program exit was abnormal and will require +/// invocation of recovery before restart. +/// +void NVM_Finalize(); + +void NVM_UsrDone(); + + +// +// No special interfaces are required for lock-based critical +// sections if compiler support is available. Use the +// compiler-plugin to take advantage of automatic instrumentation +// of critical sections. +// + +/// +/// The following 2 interfaces demarcate a failure-atomic section +/// of code, i.e. code where persistent locations are updated and +/// all-or-nothing behavior of those updates is required. Note that +/// no isolation among threads is provided by these 2 interfaces. +/// +void nvm_begin_durable(); +void nvm_end_durable(); + +// +// The following interfaces are for low-level programming of +// persistent memory, where the high-level consistency support +// afforded by Atlas is not used. Instead, persistence is explicitly +// managed by the following interfaces. +// + +/// +/// Is the following address with associated size within an open +/// persistent region? +/// +int NVM_IsInOpenPR(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses +/// +void nvm_psync(void *addr, size_t sz /* in bytes */); + +/// +/// Persistent sync of a range of addresses without a trailing barrier +/// +void nvm_psync_acq(void *addr, size_t sz /* in bytes */); + +// This may be invoked by a user program to print out Atlas statistics +#ifdef NVM_STATS + void NVM_PrintStats(); +#endif + +#ifdef __cplusplus +} +#endif + +// End of Atlas APIs + +#ifdef NVM_STATS +extern __thread uint64_t num_flushes; +#endif + +// Useful macros +#define NVM_BEGIN_DURABLE() nvm_begin_durable() +#define NVM_END_DURABLE() nvm_end_durable() + +#define NVM_CLFLUSH(p) nvm_clflush((char*)(void*)(p)) + +#ifndef DISABLE_FLUSHES +#define NVM_FLUSH(p) \ + { full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } + +#define NVM_FLUSH_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH((p)); \ + full_fence(); \ + } \ + } + +#define NVM_FLUSH_ACQ(p) \ + { full_fence(); \ + NVM_CLFLUSH(p); \ + } + +#define NVM_FLUSH_ACQ_COND(p) \ + { if (NVM_IsInOpenPR(p, 1)) { \ + full_fence(); \ + NVM_CLFLUSH(p); \ + } \ + } + +#define NVM_PSYNC(p1,s) nvm_psync(p1,s) + +#define NVM_PSYNC_COND(p1,s) \ + { if (NVM_IsInOpenPR(p1, s)) nvm_psync(p1,s); } + +#define NVM_PSYNC_ACQ(p1,s) \ + { \ + nvm_psync_acq(p1,s); \ + } \ + +#define NVM_PSYNC_ACQ_COND(p1,s) \ + { \ + if (NVM_IsInOpenPR(p1, s)) nvm_psync_acq(p1, s); \ + } \ + +#else +#define NVM_FLUSH(p) +#define NVM_FLUSH_COND(p) +#define NVM_FLUSH_ACQ(p) +#define NVM_FLUSH_ACQ_COND(p) +#define NVM_PSYNC(p1,s) +#define NVM_PSYNC_COND(p1,s) +#define NVM_PSYNC_ACQ(p1,s) +#define NVM_PSYNC_ACQ_COND(p1,s) +#endif + +static __inline void nvm_clflush(const void *p) +{ +#ifndef DISABLE_FLUSHES +#ifdef NVM_STATS + ++num_flushes; +#endif + __asm__ __volatile__ ( + "clflush %0 \n" : "+m" (*(char*)(p)) + ); +#endif +} + +// Used in conjunction with clflush. +static __inline void full_fence() { + __asm__ __volatile__ ("mfence" ::: "memory"); + } + +#endif diff --git a/Atlas/runtime/scripts/run_all.sh b/Atlas/runtime/scripts/run_all.sh new file mode 100755 index 0000000000000000000000000000000000000000..def838097666430a7cc07d61bc06131a2277f442 --- /dev/null +++ b/Atlas/runtime/scripts/run_all.sh @@ -0,0 +1,37 @@ +rm exec.csv +rm util.csv +echo "Running CQ" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/cq_nvm +echo "Running SPS" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/sps_nvm +echo "Running PC" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/pc_nvm +echo "Running RB" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/rb_nvm +echo "Running TATP" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/tatp_nvm +echo "Running LL" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/linked_list_nvm +echo "Running TPCC" +echo "" +echo "" +./tools/clean_mem +./tests/data_structures/tpcc_nvm diff --git a/Atlas/runtime/src/CMakeLists.txt b/Atlas/runtime/src/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..1c208db77b73a19b0c053d515a2b79c3db95834f --- /dev/null +++ b/Atlas/runtime/src/CMakeLists.txt @@ -0,0 +1,23 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# src CMakeLists.txt + +add_subdirectory (cache_flush) +add_subdirectory (consistency) +add_subdirectory (logger) +add_subdirectory (util) +add_subdirectory (pmalloc) +add_subdirectory (pregion_mgr) +add_subdirectory (recover) diff --git a/Atlas/runtime/src/cache_flush/CMakeLists.txt b/Atlas/runtime/src/cache_flush/CMakeLists.txt new file mode 100644 index 0000000000000000000000000000000000000000..52ec63ff13f4861cc8bd3884ca7f8d53a9b38565 --- /dev/null +++ b/Atlas/runtime/src/cache_flush/CMakeLists.txt @@ -0,0 +1,20 @@ +# +# (c) Copyright 2016 Hewlett Packard Enterprise Development LP +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Lesser General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. This program is +# distributed in the hope that it will be useful, but WITHOUT ANY +# WARRANTY; without even the implied warranty of MERCHANTABILITY or +# FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +# for more details. You should have received a copy of the GNU Lesser +# General Public License along with this program. If not, see +# . +# +# cache_flush CMakeLists +set (CACHE_FLUSH_SRC + delayed.cpp + generic.cpp + table_based.cpp) +add_library (Cache_flush OBJECT ${CACHE_FLUSH_SRC}) diff --git a/Atlas/runtime/src/cache_flush/delayed.cpp b/Atlas/runtime/src/cache_flush/delayed.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bf7a14eb671835d7b5c6bc812497119094a0e44b --- /dev/null +++ b/Atlas/runtime/src/cache_flush/delayed.cpp @@ -0,0 +1,85 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +// TODO Cache flush functionality should be in its own class + +namespace Atlas { + +#if (defined(_FLUSH_LOCAL_COMMIT) || defined(_FLUSH_GLOBAL_COMMIT)) && \ + !(defined DISABLE_FLUSHES) + +void LogMgr::collectCacheLines(SetOfInts *cl_set, void *addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!sz) return; + + char *last_addr = (char*)addr + sz - 1; + char *line_addr = (char*)((uint64_t)addr & + PMallocUtil::get_cache_line_mask()); + char *last_line_addr = (char*)((uint64_t)last_addr & + PMallocUtil::get_cache_line_mask()); + do { + (*cl_set).insert((uint64_t)line_addr); + line_addr += PMallocUtil::get_cache_line_size(); + }while (line_addr < last_line_addr+1); +} + +void LogMgr::flushCacheLines(const SetOfInts & cl_set) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + full_fence(); + SetOfInts::const_iterator ci_end = cl_set.end(); + for (SetOfInts::const_iterator ci = cl_set.begin(); ci != ci_end; ++ ci) { + assert(*ci); + // We are assuming that a user persistent region is not closed + // within a critical or atomic section. +#ifdef _FLUSH_GLOBAL_COMMIT + // This is the only scenario today where the helper thread is + // flushing data (i.e. essentially writing) data into a user + // persistent region. But this region may have been closed by + // the user by this point. So need to check for this + // situation. This is still not full-proof since the region + // can be closed between the check and the actual flush. + // This will at least prevent a fault but more needs to be done + // to ensure consistency. + if (!NVM_IsInOpenPR((void*)*ci, 1 /*dummy*/)) + continue; +#endif + NVM_CLFLUSH((char*)*ci); + } + full_fence(); +} + +void LogMgr::flushCacheLinesUnconstrained(const SetOfInts & cl_set) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + SetOfInts::const_iterator ci_end = cl_set.end(); + for (SetOfInts::const_iterator ci = cl_set.begin(); ci != ci_end; ++ ci) { + assert(*ci); + NVM_CLFLUSH((char*)*ci); + } +} +#endif + +} // namespace Atlas diff --git a/Atlas/runtime/src/cache_flush/generic.cpp b/Atlas/runtime/src/cache_flush/generic.cpp new file mode 100644 index 0000000000000000000000000000000000000000..afa60d9e719a1bed779aabb92e0d4bb4b7cd2123 --- /dev/null +++ b/Atlas/runtime/src/cache_flush/generic.cpp @@ -0,0 +1,61 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +namespace Atlas { + +void LogMgr::psyncWithAcquireBarrier(void *start_addr, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (sz <= 0) return; + + char *last_addr = (char*)start_addr + sz - 1; + + char *cacheline_addr = + (char*)(((uint64_t)start_addr) & PMallocUtil::get_cache_line_mask()); + char *last_cacheline_addr = + (char*)(((uint64_t)last_addr) & PMallocUtil::get_cache_line_mask()); + + full_fence(); + do { + NVM_CLFLUSH(cacheline_addr); + cacheline_addr += PMallocUtil::get_cache_line_size(); + }while (cacheline_addr < last_cacheline_addr+1); +} + +void LogMgr::psync(void *start_addr, size_t sz) +{ + psyncWithAcquireBarrier(start_addr, sz); + full_fence(); +} + +void LogMgr::flushAtEndOfFase() +{ +#if defined(_FLUSH_LOCAL_COMMIT) && !defined(DISABLE_FLUSHES) + assert(TL_FaseFlushPtr_); + if (!TL_FaseFlushPtr_->empty()) { + flushCacheLines(*TL_FaseFlushPtr_); + TL_FaseFlushPtr_->clear(); + } +#elif defined(_USE_TABLE_FLUSH) && !defined(DISABLE_FLUSHES) + syncDataFlush(); +#endif +} + +} // namespace Atlas diff --git a/Atlas/runtime/src/cache_flush/table_based.cpp b/Atlas/runtime/src/cache_flush/table_based.cpp new file mode 100644 index 0000000000000000000000000000000000000000..a3229bfa8241c375dc056ce45a95a6d0f69c8a47 --- /dev/null +++ b/Atlas/runtime/src/cache_flush/table_based.cpp @@ -0,0 +1,125 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "log_mgr.hpp" + +void AsyncDataCacheFlush(void *p); +void AsyncMemOpDataCacheFlush(void *dst, size_t sz); +void SyncDataCacheFlush(); + +namespace Atlas { + +#if 0 // unused +void LogMgr::asyncLogFlush(void *p) +{ + // Since this is a log entry, we don't need to check whether it is + // persistent or not. It must be persistent. + intptr_t *entry = TL_LogFlushTab_ + + (((intptr_t)p >> kFlushShift) & kFlushTableMask); + intptr_t cache_line = (intptr_t)p & PMallocUtil::get_cache_line_mask(); + + if (*entry != cache_line) { + if (*entry) { + full_fence(); + NVM_CLFLUSH(*entry); + } + *entry = cache_line; + } +} + +void LogMgr::syncLogFlush() +{ + int i; + full_fence(); + for (i=0; i> kFlushShift) & kFlushTableMask); + intptr_t cache_line = (intptr_t)p & PMallocUtil::get_cache_line_mask(); + + if (*entry != cache_line) { + if (*entry) { + full_fence(); + NVM_CLFLUSH(*entry); + } + *entry = cache_line; + } +} + +void LogMgr::asyncMemOpDataFlush(void *dst, size_t sz) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!NVM_IsInOpenPR(dst, 1)) return; + + if (sz <= 0) return; + + char *last_addr = (char*)dst + sz - 1; + char *cacheline_addr = + (char*)(((uint64_t)dst) & PMallocUtil::get_cache_line_mask()); + char *last_cacheline_addr = + (char*)(((uint64_t)last_addr) & PMallocUtil::get_cache_line_mask()); + + intptr_t *entry; + full_fence(); + do { + entry = TL_DataFlushTab_ + + (((intptr_t)cacheline_addr >> kFlushShift) & kFlushTableMask); + if (*entry != (intptr_t)cacheline_addr) { + if (*entry) NVM_CLFLUSH(*entry); + *entry = (intptr_t)cacheline_addr; + } + cacheline_addr += PMallocUtil::get_cache_line_size(); + }while (cacheline_addr < last_cacheline_addr+1); +} + +void LogMgr::syncDataFlush() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + int i; + full_fence(); + for (i=0; i. +# +# consistency CMakeLists + +set (CONSISTENCY_SRC + consistency.cpp + consistency_mgr.cpp + durability_graph_builder.cpp + helper_driver.cpp + log_pruner.cpp) +add_library (Consistency OBJECT ${CONSISTENCY_SRC}) diff --git a/Atlas/runtime/src/consistency/consistency.cpp b/Atlas/runtime/src/consistency/consistency.cpp new file mode 100644 index 0000000000000000000000000000000000000000..df022ba96ef463706fba5ca5cf95487209a320c3 --- /dev/null +++ b/Atlas/runtime/src/consistency/consistency.cpp @@ -0,0 +1,362 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include + +#include "atlas_api.h" +#include "util.hpp" + +#include "pregion_mgr.hpp" +#include "log_mgr.hpp" +#include "consistency_mgr.hpp" +#include "circular_buffer.hpp" + +namespace Atlas { + +bool CSMgr::isFoundInExistingLog(LogEntry *le, uint64_t gen_num) const +{ + Helper::MapLog2Int::const_iterator ci = ExistingRelMap_->find(le); + if (ci != ExistingRelMap_->end() && ci->second == gen_num) return true; + return false; +} + +// Build a Failure Atomic Section (FASection) given the starting log +// entry for the FASE. This data structure is used by the helper +// thread alone. The builder starts with a provided log entry and +// traverses the thread-specific logs until it either runs out of them +// or comes across the end of an outermost critical section. If the +// former, a FASE is not built. If the latter, a FASE is built and +// returned. +FASection *CSMgr::buildFASection(LogEntry *le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uint32_t lock_count = 0; + LogEntry *first_le = le; + while (le) { + LogEntry *next_le = le->Next.load(std::memory_order_acquire); + if (!next_le) return nullptr; // always keep one non-null log entry + + if (le->isAcquire() || le->isRWLockRdLock() || le->isRWLockWrLock() + || le->isBeginDurable()) ++lock_count; + + if (le->isRelease() || le->isRWLockUnlock() || le->isEndDurable()) { + if (lock_count > 0) --lock_count; + if (!lock_count) + return new FASection(first_le, le); + } + le = next_le; + } + assert(0 && "FASE construction in an unexpected code path!"); + return nullptr; +} + +void CSMgr::destroyFASections() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + FaseVec::iterator ci_end = AllFases_.end(); + for (FaseVec::iterator ci = AllFases_.begin(); ci != ci_end; ++ci) + delete *ci; +} + +// +// Examine the pending list, trying to find the log entry that +// immediately happens before it, adding to the durability graph in +// the process. At the end of this function, the pending list is left +// with log entries that cannot be resolved in the current round. +void CSMgr::resolvePendingList() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (PendingList_.empty()) { + traceHelper("Pending list is empty: graph unchanged\n"); + return; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + // Track the resolved entries using a vector + typedef std::vector DelVec; + DelVec del_vec; + + PendingList::iterator ci_end = PendingList_.end(); + for (PendingList::iterator ci = PendingList_.begin(); ci != ci_end; ++ci) { + LogEntry *le = ci->first; + + assert(le); + assert(le->isAcquire()); + assert(le->ValueOrPtr); + + const DGraph::NodeInfo& node_info = + Graph_.getTargetNodeInfo( + reinterpret_cast(le->ValueOrPtr)); + + if (node_info.NodeType_ == DGraph::kAvail) { + Graph_.createEdge(ci->second, node_info.NodeId_); + // Now that this entry is resolved, tag it for deletion + del_vec.push_back(ci); + } + // Mark the corresponding node unstable only if target is absent. + else if (node_info.NodeType_ == DGraph::kAbsent) + if (le->ValueOrPtr) + set_is_stable(ci->second, false); + } + // Actual removal of tagged resolved entries + DelVec::const_iterator del_ci_end = del_vec.end(); + for (DelVec::const_iterator del_ci = del_vec.begin(); + del_ci != del_ci_end; ++ del_ci) + PendingList_.erase(*del_ci); + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in graph after pending list resolution\n"); + traceGraph(); +} + +// This routine removes nodes (from the durability graph) that cannot +// be resolved +void CSMgr::removeUnresolvedNodes() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (PendingList_.empty()) { + traceHelper("Pending list is empty: graph unchanged\n"); + return; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + MapNodes removed_nodes; + std::pair vp; + for (vp = vertices(Graph_.get_directed_graph()); + vp.first != vp.second; ++ vp.first) { + DGraph::VDesc nid = *(vp.first); + + // This node has been already processed + if (removed_nodes.find(nid) != removed_nodes.end()) { + assert(!is_stable(nid)); + continue; + } + + if (is_stable(nid)) continue; + handleUnresolved(nid, &removed_nodes); + } + + // Actually remove the nodes + MapNodes::const_iterator rm_ci_end = removed_nodes.end(); + MapNodes::const_iterator rm_ci = removed_nodes.begin(); + for (; rm_ci != rm_ci_end; ++ rm_ci) + { + Graph_.clear_vertex(rm_ci->first); + Graph_.remove_vertex(rm_ci->first); + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in resolved graph\n"); + traceGraph(); +} + +// +// Given an unstable node, mark other "happen-after" nodes unstable +// as well. +// +void CSMgr::handleUnresolved(DGraph::VDesc nid, MapNodes *removed_nodes) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // already handled + if (removed_nodes->find(nid) != removed_nodes->end()) return; + + (*removed_nodes)[nid] = true; + + // if nid is removed, examine all in-edges and for a given in-edge, + // remove the source node as well + std::pair iep; + for (iep = in_edges(nid, Graph_.get_directed_graph()); + iep.first != iep.second; ++iep.first) { + DGraph::EDesc eid = *iep.first; + DGraph::VDesc src = source(eid, Graph_.get_directed_graph()); + + if (removed_nodes->find(src) != removed_nodes->end()) { + assert(!is_stable(src)); + continue; + } + set_is_stable(src, false); + handleUnresolved(src, removed_nodes); + } +} + +// +// At this point, a node is in the graph if an only if it belongs to +// the corresponding consistent state. This routine creates a new +// version of the log structure and adds it to the list of such +// outstanding new versions. This new version has new thread-specific +// headers that point to log entries in a way that excludes the FASEs +// corresponding to the graph nodes that belong to this consistent state. +// +void CSMgr::createVersions(Helper::LogVersions *log_v) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + if (!get_num_graph_vertices()) return; + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_resolve = atlas_rdtsc(); +#endif + + // All nodes in the graph at this point are complete and have been + // resolved. So all of the corresponding FASEs are marked deletable. + std::pair vp; + for (vp = vertices(Graph_.get_directed_graph()); + vp.first != vp.second; ++ vp.first) { + FASection *fase = Graph_.get_fase(*vp.first); + assert(fase); + assert(!fase->IsDeleted); + fase->IsDeleted = true; + } + + // TODO cache these instances? + LogStructure *lsp = IsInRecovery_ ? + LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire) : + LogMgr::getInstance().getLogPointer(std::memory_order_acquire); + assert(lsp); + + LogStructure *new_header = 0; + LogStructure *last_ls = 0; + // We walk the log-structure-header, and for every entry in it, + // walk through that thread's FASEs and find the first undeleted + // one. + + Log2Bool deletable_logs; // log entries to be deleted in this version + while (lsp) { + FASection *fase = getFirstFase(lsp); + bool found_undeleted = false; + if (!fase) { + found_undeleted = true; + addLogStructure(lsp->Le, &new_header, &last_ls); + } + FASection *last_fase = nullptr; + while (fase) { + if (!found_undeleted && !fase->IsDeleted) { + found_undeleted = true; + addLogStructure(fase->First, &new_header, &last_ls); + last_fase = fase; + fase = fase->Next; + break; + } + else { + collectLogs(&deletable_logs, fase); + last_fase = fase; + fase = fase->Next; + } + } + // For a given thread, we always leave the last log entry around. + + // We may not have found an undeleted FASE if all created + // FASEs are in the consistent state + if (!found_undeleted) { + assert(last_fase); + assert(last_fase->Last); + assert(last_fase->Last->Next); + addLogStructure(last_fase->Last->Next, &new_header, &last_ls); + } + lsp = lsp->Next; + } + assert(new_header); + (*log_v).push_back(Helper::LogVer(new_header, deletable_logs)); + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_resolve = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphResolveTime( + stop_graph_resolve - start_graph_resolve); +#endif +} + +/// +/// @brief Add a new thread specific log header +/// @param le Log entry the new header points to +/// @param header A pointer to a future global header +/// @param last_header The last thread specific log header in sequence +/// +/// Create a new thread specific log header. If this is the first in +/// the sequence of thread specific log headers, set the future global +/// header, otherwise have the last thread specific header to point to +/// this newly created one. +void CSMgr::addLogStructure(LogEntry *le, LogStructure **header, + LogStructure **last_header) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(header); + assert(last_header); + // TODO ensure that new_ls is getting flushed + LogStructure *new_ls = LogMgr::getInstance().createLogStructure(le); + if (!*header) *header = new_ls; + else { + assert(*last_header); + (*last_header)->Next = new_ls; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(&(*last_header)->Next); +#endif + } + *last_header = new_ls; +} + +// Add all log entries of the provided FASE to the map +void CSMgr::collectLogs(Log2Bool *logs, FASection *fase) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(fase); + assert(fase->Last); + assert(fase->IsDeleted); + + LogEntry *curr = fase->First; + do { + assert(curr); + (*logs)[curr] = true; + if (curr == fase->Last) break; + curr = curr->Next; + }while (true); +} + +} // namespace Atlas diff --git a/Atlas/runtime/src/consistency/consistency_mgr.cpp b/Atlas/runtime/src/consistency/consistency_mgr.cpp new file mode 100644 index 0000000000000000000000000000000000000000..bc49833ee912b1e04e70092911f813e94c79b6dc --- /dev/null +++ b/Atlas/runtime/src/consistency/consistency_mgr.cpp @@ -0,0 +1,85 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "consistency_mgr.hpp" + +namespace Atlas { + +CSMgr *CSMgr::Instance_{nullptr}; + +/// +/// @brief Main entry point for a single round of consistent state gen +/// @param lsp Pointer to the first thread specific header +/// @param log_v Pointer to the versions of consistent states +/// @param is_in_recovery Whether invoked online or during recovery +/// +/// Build a graph of completed failure atomic sections (FASE) with +/// durability edges among them. All log entries of a FASE are in a +/// consistent state if all log entries they transitively happen-after +/// are also in the same consistent state. Failure-atomically removing +/// these log entries advances the persistent consistent state. +/// +void CSMgr::doConsistentUpdate(LogStructure *lsp, + Helper::LogVersions *log_v, + bool is_in_recovery) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + IsInRecovery_ = is_in_recovery; + + // TODO incorporate consistency analysis profiling if required + + buildInitialGraph(lsp); + + if (IsParentDone_) return; + + // If there is any pending entry from the initial graph created + // above, examine whether it can be resolved. + resolvePendingList(); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // If there is still any unresolved log entry, it cannot belong to + // a consistent state. + removeUnresolvedNodes(); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // TODO: If we are in recovery phase and the resolved graph is + // empty, we should increase the candidate log entries chosen and + // then try again. + if (IsInRecovery_ && !get_num_graph_vertices()) return; + + // Create versions of consistent states + createVersions(log_v); + if (areUserThreadsDone()) { + IsParentDone_ = true; + return; + } + + // Remove the log entries failure-atomically. + destroyLogs(log_v); + + // Clean up FASEs created for this round. + destroyFASections(); +} + +} // namespace Atlas diff --git a/Atlas/runtime/src/consistency/durability_graph_builder.cpp b/Atlas/runtime/src/consistency/durability_graph_builder.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ee73237efcba4df2893407789e95dbb1303c6352 --- /dev/null +++ b/Atlas/runtime/src/consistency/durability_graph_builder.cpp @@ -0,0 +1,474 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "consistency_configs.hpp" +#include "consistency_mgr.hpp" +#include "durability_graph.hpp" +#include "helper.hpp" + +namespace Atlas { + +static inline void addThreadNode( + CSMgr::MapNodes *thread_nodes, DGraph::VDesc nid) +{ + assert(thread_nodes->find(nid) == thread_nodes->end()); + thread_nodes->insert(std::make_pair(nid, true)); +} + +static inline bool hasThreadNode( + const CSMgr::MapNodes& thread_nodes, DGraph::VDesc nid) +{ + return thread_nodes.find(nid) != thread_nodes.end(); +} + +void CSMgr::buildInitialGraph(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_graph_build = atlas_rdtsc(); +#endif + + // This loop goes through the log entries of one thread at a time + while (lsp) { + LogEntry *current_le = lsp->Le; + assert(current_le); + + DGraph::VDesc prev_nid = 0; + FASection *prev_fase = nullptr; + bool is_first_node = true; + uint32_t fase_count = 0; + MapNodes thread_nodes; + // This loop goes through the FASEs + while (true) { + ++fase_count; + + // TODO: If a consistent state is not found, the number + // of FASEs examined should be increased. + + // There is a configurable maximum number of FASEs chosen + // from a given thread in a given analysis step + if (fase_count > kFaseAnalysisLimit) break; + + if (areUserThreadsDone()) { + IsParentDone_ = true; + break; + } + + // Build a FASE starting with this log entry + FASection *current_fase = buildFASection(current_le); + if (!current_fase) break; // this thread is done + else { + if (!isFirstFaseFound(lsp)) + addFirstFase(lsp, current_fase); + addFaseToVec(current_fase); + } + + if (prev_fase) prev_fase->Next = current_fase; + + DGraph::VDesc nid = Graph_.createNode(current_fase); + addThreadNode(&thread_nodes, nid); + + if (!is_first_node) { + assert(prev_nid); + Graph_.createEdge(nid, prev_nid); + } + + is_first_node = false; + prev_nid = nid; + + // This loop goes through the log entries of a FASE + do { + addSyncEdges(thread_nodes, current_le, nid); + + if (current_le == current_fase->Last) break; + + // No need for an atomic read, we are guaranteed + // at this point that the next ptr won't change. + current_le = current_le->Next; + + }while (true); + + prev_fase = current_fase; + current_le = current_le->Next.load(std::memory_order_acquire); + } + if (IsParentDone_) break; + lsp = lsp->Next; + } + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_graph_build = atlas_rdtsc(); + Helper::getInstance().incrementTotalGraphBuildTime( + stop_graph_build - start_graph_build); +#endif + + traceHelper(get_num_graph_vertices()); + traceHelper(" nodes found in initial graph\n"); + traceGraph(); +} + +// TODO Take care of reentrant locking. +// Keeping a thread-local map to filter out locks held at a certain point +// of time can help here. + +/// +/// @brief Add synchronizes-with edges between log entries +/// @param thread_nodes Nodes created till now by this thread +/// @param le Log entry to be processed +/// @param nid Node id of the FASE containing le +/// +/// An acquire log entry is examined to see whether a +/// synchronizes-with relation should be created. A number of +/// scenarios can arise: +/// (1) The acquire log entry does not synchronize-with anything. +/// (2) This is an online analysis phase and the acquire log entry "le" +/// synchronizes-with a release log entry "rle" but "rle" was deleted +/// earlier while computing a consistent state. In such a case, no +/// synchronizes-with relation needs to be added. +/// (3) If this is invoked during recovery and #2 does not hold and +/// the acquire log entry "le" synchronizes-with a release log entry +/// "rle" but "rle" is not found in the log entries left over at the +/// start of recovery, no synchronizes-with relation needs to be +/// added. +/// (4) If the above are not satisfied and the acquire log entry "le" +/// synchronizes-with a release log entry "rle" and "rle" belongs to an +/// existing node "tgt" of the graph, add a synchronizes-with edge +/// from nid to tgt. +/// (5) If the acquire log entry "le" synchronizes with a release log +/// entry "rle" and "rle" does not belong to an existing node of the +/// graph, "le" is added to a pending list to be examined again after +/// all the nodes of the graph are created. If it cannot be resolved +/// even then, this FASE cannot belong to the consistent state under +/// creation. +/// If "le" is of release type, track it for future synchronizes-with +/// relationship creation. +/// +// TODO: do other log types need handling? free and rw-type +void CSMgr::addSyncEdges( + const MapNodes& thread_nodes, LogEntry *le, DGraph::VDesc nid) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // First filter out the scenario where the target is already deleted + if (le->isAcquire() && le->ValueOrPtr) { + LogEntry *rel_le = (LogEntry*)(le->ValueOrPtr); + + // Note: the following call deletes the found entry. + // ValueOrPtr is currently not of atomic type. This + // is still ok as long as there is a single helper + // thread. + if (Helper::getInstance().isDeletedByHelperThread(rel_le, le->Size)) + le->ValueOrPtr = 0; + else if (IsInRecovery_ && !isFoundInExistingLog(rel_le, le->Size)) + le->ValueOrPtr = 0; + } + + if (le->isAcquire() && le->ValueOrPtr) { + const DGraph::NodeInfo& node_info = + Graph_.getTargetNodeInfo((LogEntry *)le->ValueOrPtr); + if (node_info.NodeType_ == DGraph::kAvail) { + if (!hasThreadNode(thread_nodes, node_info.NodeId_)) + Graph_.createEdge(nid, node_info.NodeId_); + } + else if (node_info.NodeType_ == DGraph::kAbsent) + addToPendingList(le, nid); + } + else if (le->isRelease()) + Graph_.addToNodeInfoMap(le, nid, DGraph::kAvail); +} + +DGraph::NodeInfo DGraph::getTargetNodeInfo(LogEntry *tgt_le) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + NodeInfoMap::const_iterator ci = NodeInfoMap_.find(tgt_le); + if (ci == NodeInfoMap_.end()) + return NodeInfo(static_cast(0) /* dummy */, kAbsent); + else return ci->second; +} + +void DGraph::addToNodeInfoMap(LogEntry *le, VDesc nid, NodeType node_type) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(node_type == kAvail); // currently + NodeInfoMap_.insert(std::make_pair(le, NodeInfo(nid, node_type))); +} + +void DGraph::trace() +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + std::pair vp; + for (vp = vertices(DirectedGraph_); vp.first != vp.second; ++ vp.first) + { + VDesc nid = *vp.first; + FASection *fase = DirectedGraph_[nid].Fase_; + + traceHelper("======================\n"); + traceHelper("\tNode id: "); + traceHelper(nid); + traceHelper("\tFASE: "); + traceHelper(fase); + traceHelper(" isStable: "); + traceHelper(DirectedGraph_[nid].isStable_); + + traceHelper("\n\tHere are the log records:\n"); + PrintLogs(fase); + + std::pair iep; + int count = 0; + traceHelper("\n\tHere are the sources:\n"); + for (iep = in_edges(nid, DirectedGraph_); + iep.first != iep.second; ++ iep.first) + { + EDesc eid = *iep.first; + VDesc src = source(eid, DirectedGraph_); + FASection *src_fase = DirectedGraph_[src].Fase_; + ++count; + traceHelper("\t\tNode id: "); + traceHelper(src); + traceHelper(" FASE: "); + traceHelper(src_fase); + } + traceHelper("\n\t# incoming edges: "); + traceHelper(count); + traceHelper('\n'); + } +} + +void DGraph::PrintLogs(FASection *fase) +{ + LogEntry *current_le = fase->First; + assert(current_le); + + LogEntry *last_le = fase->Last; + assert(last_le); + + do + { + switch(current_le->Type) + { + case LE_dummy: + PrintDummyLog(current_le); + break; + case LE_acquire: + PrintAcqLog(current_le); + break; + case LE_rwlock_rdlock: + PrintRdLockLog(current_le); + break; + case LE_rwlock_wrlock: + PrintWrLockLog(current_le); + break; + case LE_begin_durable: + PrintBeginDurableLog(current_le); + break; + case LE_release: + PrintRelLog(current_le); + break; + case LE_rwlock_unlock: + PrintRWUnlockLog(current_le); + break; + case LE_end_durable: + PrintEndDurableLog(current_le); + break; + case LE_str: + PrintStrLog(current_le); + break; + case LE_memset: + case LE_memcpy: + case LE_memmove: + PrintMemOpLog(current_le); + break; + case LE_strcpy: + case LE_strcat: + PrintStrOpLog(current_le); + break; + case LE_alloc: + PrintAllocLog(current_le); + break; + case LE_free: + PrintFreeLog(current_le); + break; + default: + assert(0); + } + if (current_le == last_le) break; + current_le = current_le->Next; + }while (true); +} + +// TODO The following should call a LogEntry interface with the +// appropriate stream +void DGraph::PrintDummyLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type dummy\n"); +} + +void DGraph::PrintAcqLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = acq next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintRdLockLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = rw_rd next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintWrLockLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" ha = "); + traceHelper((intptr_t*)(le->ValueOrPtr)); + traceHelper(" type = rw_wr next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintBeginDurableLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type = begin_durable next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintRelLog(LogEntry *le) +{ + assert(!le->ValueOrPtr); + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" type = rel next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintRWUnlockLog(LogEntry *le) +{ + assert(!le->ValueOrPtr); + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" lock = "); + traceHelper(le->Addr); + traceHelper(" type = rw_unlock next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintEndDurableLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" type = end_durable next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintStrLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper(le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = str next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintMemOpLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = memop next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +// TODO complete +void DGraph::PrintStrOpLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = strop next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintAllocLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper((void*)le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = alloc next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +void DGraph::PrintFreeLog(LogEntry *le) +{ + traceHelper("\t\tle = "); + traceHelper(le); + traceHelper(" addr = "); + traceHelper(le->Addr); + traceHelper(" val = "); + traceHelper((void*)le->ValueOrPtr); + traceHelper(" size = "); + traceHelper(le->Size); + traceHelper(" type = free next = "); + traceHelper(le->Next.load(std::memory_order_relaxed)); +} + +} // namespace Atlas diff --git a/Atlas/runtime/src/consistency/helper_driver.cpp b/Atlas/runtime/src/consistency/helper_driver.cpp new file mode 100644 index 0000000000000000000000000000000000000000..f34c8f2e58f54d8e8202ab1c2996dd3f2926438d --- /dev/null +++ b/Atlas/runtime/src/consistency/helper_driver.cpp @@ -0,0 +1,184 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include +#include +#include + +#include "atlas_api.h" + +#include "helper.hpp" +#include "log_mgr.hpp" +#include "consistency_mgr.hpp" + +namespace Atlas { + +uint64_t removed_log_count = 0; + +Helper *Helper::Instance_{nullptr}; + +void *helper(void *arg_lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif +#ifdef _DISABLE_HELPER + return nullptr; +#endif + + Helper::createInstance(); + Helper::getInstance().doConsistentUpdate(arg_lsp); + + if (!arg_lsp) Helper::getInstance().printStats(); + +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + std::cout << + "[Atlas-log-pruner] Traces written to /tmp/atlas_log_pruner.txt" << + std::endl; +#endif + + Helper::deleteInstance(); + + std::cout << "[Atlas-log-pruner] # log entries removed: " << + removed_log_count << std::endl; + return 0; +} + +void Helper::collectRelLogEntries(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + while (lsp) { + LogEntry *le = lsp->Le; + while (le) { + if (le->isRelease()) // TODO: how about free and other rel types? + ExistingRelMap_.insert(std::make_pair(le, (uint64_t)le->Size)); + le = le->Next; + } + lsp = lsp->Next; + } +} + +void Helper::doConsistentUpdate(void *arg_lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // During normal execution, the argument is NULL. + if (arg_lsp) + { + fprintf(stderr, + "[Atlas] Advancing consistent state before undoing ...\n"); + collectRelLogEntries((LogStructure*)arg_lsp); + } + +// Have the helper thread work in _small_ chunks. Given that an +// iteration of the helper thread can be quite expensive, we want to +// make sure that the helper thread can be joined as soon as the user +// thread is done. An alternative is for the user thread to send a signal +// to the helper thread. + + do { + + ++IterNum_; + + LogStructure *lsp = 0; + + if (!arg_lsp) { + LogMgr::getInstance().acquireLogReadyLock(); + // We don't want to check this condition within a loop since we + // need to do some work. If a spurious wakeup happens and that + // should be rare, the helper thread may go through a round of + // analysis that may or may not result in wasted work. + if (!areUserThreadsDone()) LogMgr::getInstance().waitLogReady(); + LogMgr::getInstance().releaseLogReadyLock(); + + if (areUserThreadsDone()) break; + + lsp = LogMgr::getInstance().getLogPointer( + std::memory_order_acquire); + } + else if (!LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire)) { + IsInRecovery_ = true; + lsp = (LogStructure*)arg_lsp; + LogMgr::getInstance().setRecoveryLogPointer( + lsp, std::memory_order_release); + } + else lsp = LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire); + + // Can't assert during normal execution since a spurious wakeup + // may have happened + if (!arg_lsp && !lsp) continue; + + CSMgr& cs_mgr = CSMgr::createInstance(); + if (IsInRecovery_) + cs_mgr.set_existing_rel_map(&ExistingRelMap_); + cs_mgr.doConsistentUpdate(lsp, &LogVersions_, IsInRecovery_); + + if (IsInRecovery_ && !cs_mgr.get_num_graph_vertices()) { + CSMgr::deleteInstance(); + break; + } + + CSMgr::deleteInstance(); + + }while (!areUserThreadsDone()); +} + +bool Helper::isDeletedByHelperThread(LogEntry *le, uint64_t gen_num) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + std::pair del_iter = DeletedRelLogs_.equal_range(le); + for (DelIter di = del_iter.first; di != del_iter.second; ++di) { + if (di->second == gen_num) { + DeletedRelLogs_.erase(di); + // Must return since the iterator is broken by the above erase. + // Any subsequent use of the iterator may fail. + return true; + } + } + return false; +} + +void Helper::printStats() +{ + // TODO The lock should be owned by Stats, not Logger +#if defined(NVM_STATS) + LogMgr::getInstance().acquireStatsLock(); + std::cout << "[Atlas-log-pruner] Thread " << pthread_self() << std::endl; +#ifdef _PROFILE_HT + std::cout << "[Atlas-log-pruner] " << "Total graph creation cycles: " << + TotalGraphBuildTime_ << std::endl; + std::cout << "[Atlas-log-pruner] " << "Total graph resolution cycles: " << + TotalGraphResolveTime_ << std::endl; + std::cout << "[Atlas-log-pruner] " << "Total log prune cycles: " << + TotalPruneTime_ << std::endl; +#endif + std::cout << "[Atlas-log-pruner] # iterations: " << + Helper::getInstance().get_iter_num() << std::endl; + std::cout << "[Atlas-log-pruner] # flushes from this thread: " << + num_flushes << std::endl; + LogMgr::getInstance().releaseStatsLock(); +#endif +} + +} // namespace Atlas + diff --git a/Atlas/runtime/src/consistency/log_pruner.cpp b/Atlas/runtime/src/consistency/log_pruner.cpp new file mode 100644 index 0000000000000000000000000000000000000000..523ffdcaafa8e1a526b9246fd897b448872e143e --- /dev/null +++ b/Atlas/runtime/src/consistency/log_pruner.cpp @@ -0,0 +1,482 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#include "atlas_alloc.h" + +#include "consistency_mgr.hpp" +#include "helper.hpp" + +namespace Atlas { + +extern uint64_t removed_log_count; + +bool CSMgr::areLogicallySame(LogStructure *gh, LogStructure *cand_gh) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + while (gh) { + if (gh == cand_gh) return true; + gh = gh->Next; + } + return false; +} + +uint32_t CSMgr::getNumNewEntries(LogStructure *new_e, LogStructure *old_e) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + uint32_t new_count = 0; + uint32_t old_count = 0; + while (new_e) { + ++new_count; + new_e = new_e->Next; + } + while (old_e) { + ++old_count; + old_e = old_e->Next; + } + assert(!(new_count < old_count)); + return new_count - old_count; +} + +void CSMgr::destroyLogs(Helper::LogVersions *log_v) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Nothing to do + if (!log_v->size()) return; + +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t start_log_prune = atlas_rdtsc(); +#endif + + LogIterVec deleted_lsp; + LogEntryVec deleted_log_entries; + + LogStructure *cand_gh = 0; + Helper::LogVersions::iterator logs_ci_end = log_v->end(); + Helper::LogVersions::iterator logs_ci = log_v->begin(); + Helper::LogVersions::iterator last_logs_ci = logs_ci_end; + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + bool did_cas_succeed = true; +#endif + + // Go through each version + while (logs_ci != logs_ci_end) { + // Get the current pointer to the log + LogStructure *gh = !CSMgr::getInstance().isInRecovery() ? + LogMgr::getInstance().getLogPointer(std::memory_order_acquire) : + LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire); + assert(gh); + + LogStructure *tmp_gh = gh; + + // This is the candidate pointer to the log representing the + // new consistent state. We would like to move the log pointer + // to this candidate in a single pointer switch + // (failure-atomically), essentially moving the program state + // to the next consistent state. + cand_gh = (*logs_ci).LS_; + assert(cand_gh); + LogStructure *tmp_cand_gh = cand_gh; + + const Log2Bool& deletable_logs = (*logs_ci).Del_; + + // Initially, gh is not part of log_v. But if a new gh is formed, + // gh may actually be the same as cand_gh. In such a case, we just + // need to skip to the next candidate. Additionally, we need to + // check for logical identity, meaning that if logs for a new thread + // were added in between "setting the GH last by the helper thread" + // and "setting the GH by an application thread because of a new + // thread creation", we need to identify that scenario as well. + if (areLogicallySame(gh, cand_gh)) { + last_logs_ci = logs_ci; + ++logs_ci; + continue; + } + + // Since the time of creation of cand_gh, entries may have been + // added at the head of gh. By comparing the number of + // *threads*, we can tell whether this has indeed happened. If + // yes, the new entries are always found at the head. + uint32_t num_new_entries = getNumNewEntries(tmp_gh, tmp_cand_gh); + + // We can't just use "deletable_logs" to collect logs for + // removal since the elements in "deletable_logs" may have + // been split into different versions. For removal purposes, + // we need to collect for only the versions that can be + // removed. + LogEntryVec tmp_deleted_log_entries; + LSVec new_entries; + while (tmp_gh) { + if (num_new_entries) { + new_entries.push_back(tmp_gh); + tmp_gh = tmp_gh->Next; + // Do not advance tmp_cand_gh + --num_new_entries; + continue; + } + + LogEntry *curr_le = tmp_gh->Le; + + assert(tmp_cand_gh); + LogEntry *end_le = tmp_cand_gh->Le; + assert(end_le); + + do + { + assert(curr_le); + + // Both creation/destruction of threads during log + // pruning are supported. + + // Check whether this log entry is scheduled to be + // deleted. The cumulative list of deletable + // log entries is found for every version and that is + // used to check here. + + if (deletable_logs.find(curr_le) == deletable_logs.end()) + break; + + // Add it tentatively to the list of logs to be + // deleted + tmp_deleted_log_entries.push_back(curr_le); + + // This Next ptr has been read before, so no atomic + // operation is required. + curr_le = curr_le->Next; + }while (curr_le != end_le); + + // We compare the number of headers in GH and cand_GH and + // if unequal, the difference at the head of GH are the + // new entries. For this to work, insertions must always + // be made at the head. + tmp_gh = tmp_gh->Next; + tmp_cand_gh = tmp_cand_gh->Next; + } + + // If new_entries have been found, we need to add those entries + // to this version before deleting it. + + if (new_entries.size()) { + fixupNewEntries(&cand_gh, new_entries); + (*logs_ci).LS_ = cand_gh; + } + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + if (did_cas_succeed) flushGlobalCommit(tmp_deleted_log_entries); +#endif + + // Atomically flip the global log structure header pointer + + // Note that cache line flushing for this CAS is tricky. The current + // ad-hoc solution is for user-threads to flush this + // location after reading it. Since reads of this location are + // rare enough, this should not hurt performance. + bool status = !CSMgr::getInstance().isInRecovery() ? + LogMgr::getInstance().cmpXchngWeakLogPointer( + gh, cand_gh, + std::memory_order_acq_rel, std::memory_order_relaxed) : + LogMgr::getInstance().cmpXchngWeakRecoveryLogPointer( + gh, cand_gh, + std::memory_order_acq_rel, std::memory_order_relaxed); + + if (status) + { +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + if (!CSMgr::getInstance().isInRecovery()) + LogMgr::getInstance().flushLogPointer(); + else LogMgr::getInstance().flushRecoveryLogPointer(); +#endif + +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + did_cas_succeed = true; +#endif + // During the first time through the top-level vector elements, + // gh is not in log_v. So this special handling must be done + // where we are destroying the old gh that is not in the vector. + if (logs_ci == log_v->begin()) destroyLS(gh); + else { + assert(last_logs_ci != logs_ci_end); + deleted_lsp.push_back(last_logs_ci); + } + + // This builds the list of log entries which *will* be + // deleted + copyDeletedLogEntries(&deleted_log_entries, + tmp_deleted_log_entries); + last_logs_ci = logs_ci; + ++logs_ci; + } +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + else did_cas_succeed = false; +#endif + // If the above CAS failed, we don't advance the version but + // instead try again. + } + + // Once the root GH pointer has been swung, it does not matter when + // the log entries are removed or the other stuff is removed. No one can + // reach these any more. + destroyLogEntries(deleted_log_entries); + + // No need for any cache flushes for any deletions. + + LogIterVec::iterator del_ci_end = deleted_lsp.end(); + LogIterVec::iterator del_ci = deleted_lsp.begin(); + LogIterVec::iterator last_valid_ci; + for (; del_ci != del_ci_end; ++ del_ci) + { + destroyLS((**del_ci).LS_); + last_valid_ci = del_ci; + } + + del_ci = deleted_lsp.begin(); + if (del_ci != del_ci_end) + { + Helper::LogVersions::iterator lvi = *last_valid_ci; + assert(lvi != log_v->end()); + ++lvi; + (*log_v).erase(*del_ci, lvi); + } +#if defined(NVM_STATS) && defined(_PROFILE_HT) + uint64_t stop_log_prune = atlas_rdtsc(); + Helper::getInstance().incrementTotalPruneTime( + stop_log_prune - start_log_prune); +#endif +} + +void CSMgr::destroyLS(LogStructure *lsp) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(lsp); + if (!CSMgr::getInstance().isInRecovery()) + assert(lsp != LogMgr::getInstance().getLogPointer( + std::memory_order_acquire)); + else assert(lsp != LogMgr::getInstance().getRecoveryLogPointer( + std::memory_order_acquire)); + + traceHelper("[Atlas] Destroying log header "); + + while (lsp) + { + LogStructure *del_lsp = lsp; + lsp = lsp->Next; + + traceHelper(del_lsp); + + // TODO freeMem should call destructor. Use NVM_Destroy + if (!CSMgr::getInstance().isInRecovery()) + PRegionMgr::getInstance().freeMem(del_lsp, true /* do not log */); + } + traceHelper('\n'); +} + +void CSMgr::destroyLogEntries(const LogEntryVec& le_vec) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + traceHelper("[Atlas] Destroying log entries "); + + LogEntryVec::const_iterator ci_end = le_vec.end(); + for (LogEntryVec::const_iterator ci = le_vec.begin(); ci != ci_end; ++ ci) + { + traceHelper(*ci); + + if ((*ci)->isRelease() || (*ci)->isRWLockUnlock() || (*ci)->isFree()) + { + // Add it to a helper map so that the helper elides any + // happens-after relation from a later-examined log entry + // to this one + Helper::getInstance().addEntryToDeletedMap(*ci, (*ci)->Size); + + // Update the logger table that tracks happens-after + // between log entries + if (!CSMgr::getInstance().isInRecovery()) LogMgr::getInstance().deleteOwnerInfo(*ci); + } + + if (!CSMgr::getInstance().isInRecovery()) + { +#if defined(_LOG_WITH_MALLOC) + if ((*ci)->isMemop() || (*ci)->isStrop()) + free((void*)(*ci)->ValueOrPtr); + free(*ci); +#elif defined(_LOG_WITH_NVM_ALLOC) + if ((*ci)->isMemop() || (*ci)->isStrop()) + PRegionMgr::getInstance().freeMem((void*)(*ci)->ValueOrPtr, true); + PRegionMgr::getInstance().freeMem(*ci, true /* do not log */); +#else + if ((*ci)->isMemop() || (*ci)->isStrop()) + PRegionMgr::getInstance().freeMem((void*)(*ci)->ValueOrPtr, true); + // TODO cache LogMgr instance + LogMgr::getInstance().deleteEntry(*ci); +#endif + } + ++removed_log_count; + } + + traceHelper('\n'); +} + +void CSMgr::copyDeletedLogEntries(LogEntryVec *deleted_les, + const LogEntryVec & tmp_deleted_les) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogEntryVec::const_iterator ci_end = tmp_deleted_les.end(); + for (LogEntryVec::const_iterator ci = tmp_deleted_les.begin(); + ci != ci_end; ++ ci) + (*deleted_les).push_back(*ci); +} + +void CSMgr::fixupNewEntries(LogStructure **cand, const LSVec & new_entries) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + LogStructure *new_header = 0; + LogStructure *last_ls = 0; + LSVec::const_iterator ci_end = new_entries.end(); + + traceHelper("[Atlas] Fixup: created header nodes: "); + for (LSVec::const_iterator ci = new_entries.begin(); ci != ci_end; ++ci) + { + LogStructure *ls = (LogStructure *) + nvm_alloc(sizeof(LogStructure), + LogMgr::getInstance().getRegionId()); + assert(ls); + + traceHelper(ls); + traceHelper(" "); + + ls->Le = (*ci)->Le; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(ls); +#endif + if (!new_header) new_header = ls; + else + { + assert(last_ls); + last_ls->Next = ls; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(&last_ls->Next); +#endif + } + last_ls = ls; + } + + traceHelper('\n'); + + last_ls->Next = *cand; +#if !defined(_DISABLE_LOG_FLUSH) && !defined(DISABLE_FLUSHES) + NVM_FLUSH_ACQ(last_ls); +#endif + (*cand) = new_header; +} + +// TODO: the region may have been closed by this point. One solution is +// to check whether the address belongs to an open region before every +// clflush operation. This would slow down the helper thread but probably +// does not matter. Additionally, more logic needs to be employed in the +// helper thread in the global-flush mode so that if an address in a closed +// region is seen, the helper thread has to stop since no new consistent +// state can be found. This is tied with the observation that in this +// global mode, the consistent state cannot be moved forward during the +// recovery phase. +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) +// This is not thread-safe. Currently, only the serial helper thread +// can call this interface. +void CSMgr::flushGlobalCommit(const LogEntryVec& logs) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(GlobalFlush_); + assert(GlobalFlush_->empty()); + LogEntryVec::const_iterator ci_end = logs.end(); + for (LogEntryVec::const_iterator ci = logs.begin(); ci != ci_end; ++ci) + if ((*ci)->isStr() || (*ci)->isMemop() || (*ci)->isStrop()) + LogMgr::getInstance().collectCacheLines( + GlobalFlush_, (*ci)->Addr, (*ci)->Size); + LogMgr::getInstance().flushCacheLines(*GlobalFlush_); + GlobalFlush_->clear(); +} + +#endif + +template +void LogMgr::deleteSlot(CbLog *cb, T *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + assert(!cb->isEmpty()); + assert(addr == &(cb->LogArray[cb->Start.load(std::memory_order_acquire)])); + cb->Start.store( + (cb->Start.load(std::memory_order_acquire)+1) % cb->Size, + std::memory_order_release); +} + +template +void LogMgr::deleteEntry(const std::atomic*> & cb_list, T *addr) +{ +#ifdef _FORCE_FAIL + fail_program(); +#endif + // Instead of searching every time, we keep track of the last Cb used. + static CbListNode *last_cb_used = 0; + if (last_cb_used && + ((uintptr_t)addr >= (uintptr_t)last_cb_used->StartAddr && + (uintptr_t)addr <= (uintptr_t)last_cb_used->EndAddr)) { + deleteSlot(last_cb_used->Cb, addr); + if (last_cb_used->Cb->isEmpty() && + last_cb_used->Cb->isFilled.load(std::memory_order_acquire)) + last_cb_used->isAvailable.store(true, std::memory_order_release); + return; + } + CbListNode *curr = cb_list.load(std::memory_order_acquire); + assert(curr); + while (curr) { + if ((uintptr_t)addr >= (uintptr_t)curr->StartAddr && + (uintptr_t)addr <= (uintptr_t)curr->EndAddr) { + last_cb_used = curr; + deleteSlot(curr->Cb, addr); + // A buffer that got filled and then emptied implies that + // the user thread moved on to a new buffer. Hence, mark it + // available so that it can be reused. + if (curr->Cb->isEmpty() && + curr->Cb->isFilled.load(std::memory_order_acquire)) + curr->isAvailable.store(true, std::memory_order_release); + break; + } + curr = curr->Next; + } +} + +} // namespace Atlas diff --git a/Atlas/runtime/src/internal_includes/cache_flush_configs.hpp b/Atlas/runtime/src/internal_includes/cache_flush_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..3b2c08f48563e9dc62a729c259c05dbee3e4031b --- /dev/null +++ b/Atlas/runtime/src/internal_includes/cache_flush_configs.hpp @@ -0,0 +1,29 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CACHE_FLUSH_CONFIGS_HPP +#define CACHE_FLUSH_CONFIGS_HPP + +namespace Atlas { + +const int32_t kFlushTableSize = 8; +const int32_t kFlushTableMask = kFlushTableSize - 1; +// TODO the following should be derived from cache line size +const uint32_t kFlushShift = 6; // log(cache line size) + +} // namespace Atlas + +#endif diff --git a/Atlas/runtime/src/internal_includes/circular_buffer.hpp b/Atlas/runtime/src/internal_includes/circular_buffer.hpp new file mode 100644 index 0000000000000000000000000000000000000000..088a038c3b1536a5ff4918e4085aa855844358b3 --- /dev/null +++ b/Atlas/runtime/src/internal_includes/circular_buffer.hpp @@ -0,0 +1,91 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef _LOG_ALLOC_H +#define _LOG_ALLOC_H + +#include + +namespace Atlas { + +template +struct CbLog +{ + explicit CbLog(uint32_t sz, uint32_t is_filled, + uint32_t start_cb, uint32_t end_cb) + : Size{sz}, + isFilled{is_filled}, + Start{start_cb}, + End{end_cb}, + LogArray{nullptr} {} + CbLog() = delete; + CbLog(const CbLog&) = delete; + CbLog(CbLog&&) = delete; + CbLog& operator=(const CbLog&) = delete; + CbLog& operator=(CbLog&&) = delete; + + uint32_t Size; + std::atomic isFilled; + std::atomic Start; + std::atomic End; + T *LogArray; + + bool isFull() { + return (End.load(std::memory_order_acquire)+1) % Size == + Start.load(std::memory_order_acquire); + } + + bool isEmpty() { + return Start.load(std::memory_order_acquire) == + End.load(std::memory_order_acquire); + } +}; + +template +struct CbListNode +{ + explicit CbListNode(CbLog *cb, char *start_addr, char *end_addr) + : Cb{cb}, + StartAddr{start_addr}, + EndAddr{end_addr}, + Next{nullptr}, + Tid{pthread_self()}, + isAvailable{false} {} + CbListNode() = delete; + CbListNode(const CbListNode&) = delete; + CbListNode(CbListNode&&) = delete; + CbListNode& operator=(const CbListNode&) = delete; + CbListNode& operator=(CbListNode&&) = delete; + + CbLog *Cb; + char *StartAddr; + char *EndAddr; + CbListNode *Next; + pthread_t Tid; + std::atomic isAvailable; +}; + +// CbList is a data structure shared among threads. When a new slot is +// requested, if the current buffer is found full, the current thread +// creates a new buffer, adds it to the CbList and +// return the first slot from this new buffer. If a buffer ever becomes +// empty, it can be reused. A partially empty buffer cannot be reused. + +// TODO eventual GC on cb_list + +} // namespace Atlas + +#endif diff --git a/Atlas/runtime/src/internal_includes/consistency_configs.hpp b/Atlas/runtime/src/internal_includes/consistency_configs.hpp new file mode 100644 index 0000000000000000000000000000000000000000..dbc0c0b5abb4eeb562a3c2461d7a5b8a62f3eb0b --- /dev/null +++ b/Atlas/runtime/src/internal_includes/consistency_configs.hpp @@ -0,0 +1,28 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CONSISTENCY_CONFIGS_HPP +#define CONSISTENCY_CONFIGS_HPP + +#include + +namespace Atlas { + +const uint32_t kFaseAnalysisLimit = 8; + +} // namespace Atlas + +#endif diff --git a/Atlas/runtime/src/internal_includes/consistency_mgr.hpp b/Atlas/runtime/src/internal_includes/consistency_mgr.hpp new file mode 100644 index 0000000000000000000000000000000000000000..28e1245bed87603edfeb440d32b18359f2228ac0 --- /dev/null +++ b/Atlas/runtime/src/internal_includes/consistency_mgr.hpp @@ -0,0 +1,196 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef CONSISTENCY_MGR_HPP +#define CONSISTENCY_MGR_HPP + +#include +#include +#include +#include +#include + +#include "helper.hpp" +#include "log_mgr.hpp" +#include "durability_graph.hpp" +#include "fase.hpp" + +namespace Atlas { + +// This class manages consistency of persistent data. It is either +// invoked by the helper thread during program execution or during +// recovery after a failure. Currently, there is at most one instance +// of this class. +class CSMgr { + static CSMgr *Instance_; +public: + typedef std::map MapNodes; + + // serial mode only + static CSMgr& createInstance() { + assert(!Instance_); + Instance_ = new CSMgr(); + return *Instance_; + } + + // serial mode only + static void deleteInstance() { + assert(Instance_); + delete Instance_; + Instance_ = nullptr; + } + + // serial mode only + static CSMgr& getInstance() { + assert(Instance_); + return *Instance_; + } + + void doConsistentUpdate(LogStructure*, + Helper::LogVersions*, bool is_in_recovery); + + void set_existing_rel_map(Helper::MapLog2Int *m) + { ExistingRelMap_ = m; } + + boost::graph_traits::vertices_size_type + get_num_graph_vertices() const { return Graph_.get_num_vertices(); } + + void set_is_stable(DGraph::VDesc vertex, bool b) + { Graph_.set_is_stable(vertex, b); } + bool is_stable(DGraph::VDesc vertex) const + { return Graph_.is_stable(vertex); } + +private: + + typedef std::pair PendingPair; + typedef std::vector PendingList; + + typedef std::vector LSVec; + typedef std::vector LogIterVec; + typedef std::map Addr2Bool; + typedef std::map FaseMap; + typedef std::vector FaseVec; + + bool IsParentDone_; // Is the parent user thread done? + bool IsInRecovery_; + DGraph Graph_; + + // A mapping from a release type log entry to its generation + // number. This is currently used only during recovery. Populated + // once and not changed later on at all. + Helper::MapLog2Int *ExistingRelMap_; + + // A list of acquire type log entries whose targets are not yet found + PendingList PendingList_; + + // Maps a log header to the first FASE in an analysis round + FaseMap FirstFaseOfHeader_; + + // Vector of all FASEs created in an analysis round + FaseVec AllFases_; + + SetOfInts *GlobalFlush_; + + explicit CSMgr() : + IsParentDone_{false}, + IsInRecovery_{false}, + Graph_{}, + ExistingRelMap_{nullptr}, + PendingList_{}, + FirstFaseOfHeader_{}, + AllFases_{}, +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + GlobalFlush_{new SetOfInts} +#else + GlobalFlush_{nullptr} +#endif + {} + + ~CSMgr() + { +#if defined(_FLUSH_GLOBAL_COMMIT) && !defined(DISABLE_FLUSHES) && \ + !defined(_DISABLE_DATA_FLUSH) + if (GlobalFlush_) { + delete GlobalFlush_; + GlobalFlush_ = nullptr; + } +#endif + } + CSMgr(const CSMgr&) = delete; + CSMgr(CSMgr&&) = delete; + CSMgr& operator=(const CSMgr&) = delete; + CSMgr& operator=(CSMgr&&) = delete; + + bool isFirstFaseFound(LogStructure *ls) const + { return FirstFaseOfHeader_.find(ls) != FirstFaseOfHeader_.end(); } + void addFirstFase(LogStructure *ls, FASection *fase) { + assert(FirstFaseOfHeader_.find(ls) == FirstFaseOfHeader_.end()); + FirstFaseOfHeader_.insert(std::make_pair(ls, fase)); + } + void addFaseToVec(FASection *fase) + { AllFases_.push_back(fase); } + void addToPendingList(LogEntry *le, DGraph::VDesc nid) { + PendingPair pp = std::make_pair(le, nid); + PendingList_.push_back(pp); + } + FASection *getFirstFase(LogStructure *ls) { + FaseMap::const_iterator ci = FirstFaseOfHeader_.find(ls); + if (ci != FirstFaseOfHeader_.end()) return ci->second; + else return NULL; + } + + void buildInitialGraph(LogStructure *lsp); + void addSyncEdges(const MapNodes&, LogEntry*, DGraph::VDesc); + bool isFoundInExistingLog(LogEntry *le, uint64_t gen_num) const; + void removeUnresolvedNodes(); + void createVersions(Helper::LogVersions *log_v); + void resolvePendingList(); + void handleUnresolved(DGraph::VDesc nid, MapNodes *rm); + void destroyLogs(Helper::LogVersions*); + void fixupNewEntries(LogStructure**, const LSVec&); + void copyDeletedLogEntries(LogEntryVec*, const LogEntryVec&); + void destroyLogEntries(const LogEntryVec&); + void destroyLS(LogStructure*); + FASection *buildFASection(LogEntry *le); + void addLogStructure(LogEntry *le, LogStructure **header, + LogStructure **last_header); + void collectLogs(Log2Bool *logs, FASection *fase); + bool areLogicallySame(LogStructure *gh, LogStructure *cand_gh); + uint32_t getNumNewEntries(LogStructure *new_e, LogStructure *old_e); + void destroyFASections(); + + void flushGlobalCommit(const LogEntryVec& logs); + + bool isInRecovery() const { return IsInRecovery_; } + bool areUserThreadsDone() const + { return LogMgr::getInstance().areUserThreadsDone(); } + void traceGraph() { +#if defined(_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + Graph_.trace(); +#endif + } + template void traceHelper(T s) { +#if defined (_NVM_TRACE) || defined(_NVM_VERBOSE_TRACE) + Helper::getInstance().trace(s); +#endif + } + +}; + +} // namespace Atlas + +#endif diff --git a/Atlas/runtime/src/internal_includes/durability_graph.hpp b/Atlas/runtime/src/internal_includes/durability_graph.hpp new file mode 100644 index 0000000000000000000000000000000000000000..61745b9f02a6573d48c6c485c8d39a23e351217a --- /dev/null +++ b/Atlas/runtime/src/internal_includes/durability_graph.hpp @@ -0,0 +1,148 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef DURABILITY_GRAPH_HPP +#define DURABILITY_GRAPH_HPP + +#include + +#include +#include +#include + +#include "helper.hpp" +#include "fase.hpp" + +namespace Atlas { + +// This is the durability graph built for consistency management of +// persistent data. A node denotes a failure-atomic section of code +// (FASE). An edge denotes a happens-after relationship. So if there +// is an edge from src to dest, src "happens-after" dest. +class DGraph { + +public: + + // Vertex properties. A vertex, corresponding to a FASE, is stable + // and is included in a consistent state if all FASEs that happen + // before it are also stable and are included in the consistent + // state. + struct VProp { + VProp(FASection *fase, bool is_stable) + : Fase_(fase), isStable_(is_stable) {} + VProp() = delete; + + FASection *Fase_; + bool isStable_; + }; + + typedef boost::adjacency_list< + boost::setS /* OutEdges: not allowing multi-graph */, + boost::listS /* Vertices: don't tolerate renumbered vertex indices */, + boost::bidirectionalS /* required for durability graph */, + VProp> DirectedGraph; + + typedef boost::graph_traits::vertex_descriptor VDesc; + typedef boost::graph_traits::edge_descriptor EDesc; + typedef boost::graph_traits::vertex_iterator VIter; + typedef boost::graph_traits::in_edge_iterator IEIter; + + // Status of a node in a given consistent state + enum NodeType {kAvail, kAbsent}; + + struct NodeInfo { + NodeInfo(VDesc nid, NodeType node_type) + : NodeId_(nid), NodeType_(node_type) {} + NodeInfo() = delete; + + VDesc NodeId_; + NodeType NodeType_; + }; + + typedef std::map NodeInfoMap; + + boost::graph_traits::vertices_size_type + get_num_vertices() const + { return boost::num_vertices(DirectedGraph_); } + + void set_is_stable(VDesc vertex, bool b) + { DirectedGraph_[vertex].isStable_ = b; } + bool is_stable(VDesc vertex) const + { return DirectedGraph_[vertex].isStable_; } + + void addToNodeInfoMap(LogEntry *le, VDesc nid, NodeType nt); + NodeInfo getTargetNodeInfo(LogEntry *tgt_le); + + VDesc createNode(FASection *fase); + EDesc createEdge(VDesc src, VDesc tgt); + + const DirectedGraph& get_directed_graph() const + { return DirectedGraph_; } + + void clear_vertex(VDesc vertex) + { boost::clear_vertex(vertex, DirectedGraph_); } + void remove_vertex(VDesc vertex) + { boost::remove_vertex(vertex, DirectedGraph_); } + + FASection *get_fase(VDesc vertex) const + { return DirectedGraph_[vertex].Fase_; } + + void trace(); + template void traceHelper(T tt) + { Helper::getInstance().trace(tt); } + +private: + + DirectedGraph DirectedGraph_; + NodeInfoMap NodeInfoMap_; + + void PrintLogs(FASection *fase); + void PrintDummyLog(LogEntry *le); + void PrintAcqLog(LogEntry *le); + void PrintRdLockLog(LogEntry *le); + void PrintWrLockLog(LogEntry *le); + void PrintBeginDurableLog(LogEntry *le); + void PrintRelLog(LogEntry *le); + void PrintRWUnlockLog(LogEntry *le); + void PrintEndDurableLog(LogEntry *le); + void PrintStrLog(LogEntry *le); + void PrintMemOpLog(LogEntry *le); + void PrintStrOpLog(LogEntry *le); + void PrintAllocLog(LogEntry *le); + void PrintFreeLog(LogEntry *le); +}; + +inline DGraph::VDesc DGraph::createNode(FASection *fase) +{ + // default attribute is stable. If any contained log entry is + // unresolved, the stable bit is flipped and the corresponding node + // removed from the graph + return boost::add_vertex(VProp(fase, true /* stable */), + DirectedGraph_); +} + +inline DGraph::EDesc DGraph::createEdge(VDesc src, VDesc tgt) +{ + // TODO: are we creating a multi-graph? Or does add_edge filter + // that out? + std::pair edge_pair = + boost::add_edge(src, tgt, DirectedGraph_); + return edge_pair.first; +} + +} // end namespace + +#endif diff --git a/Atlas/runtime/src/internal_includes/fail.hpp b/Atlas/runtime/src/internal_includes/fail.hpp new file mode 100644 index 0000000000000000000000000000000000000000..1dfeb0fd0d5c8d99d8999afdaaca76d73a458f9b --- /dev/null +++ b/Atlas/runtime/src/internal_includes/fail.hpp @@ -0,0 +1,44 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef FAIL +#define FAIL + +#include +#include +#include +#include +#define FAIL_MAX 100 +static std::atomic fail_chance(0); +inline void fail_program () { + if (rand() % FAIL_MAX <= fail_chance.load()){ + void *array[10]; + size_t size; + char **strings; + size_t i; + + size = backtrace (array, 10); + strings = backtrace_symbols (array, size); + + for (i = 0; i < size; i++) + std::cout << strings[i] << "\n"; + delete (strings); + std::exit(0); + } else { + ++fail_chance; + } +} +#endif diff --git a/Atlas/runtime/src/internal_includes/fase.hpp b/Atlas/runtime/src/internal_includes/fase.hpp new file mode 100644 index 0000000000000000000000000000000000000000..55acdc8b91df34a13fc88637aab45a1c5f1b2a50 --- /dev/null +++ b/Atlas/runtime/src/internal_includes/fase.hpp @@ -0,0 +1,45 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef FASE_HPP +#define FASE_HPP + +#include "log_mgr.hpp" + +namespace Atlas { + +// Represent a failure atomic section of code. +struct FASection { + explicit FASection(LogEntry *first, LogEntry *last) + : First{first}, + Last{last}, + Next{nullptr}, + IsDeleted{false} {} + FASection() = delete; + FASection(const FASection&) = delete; + FASection(FASection&&) = delete; + FASection& operator=(const FASection&) = delete; + FASection& operator=(FASection&&) = delete; + + LogEntry *First; + LogEntry *Last; + FASection *Next; + bool IsDeleted; +}; + +} // namespace Atlas + +#endif diff --git a/Atlas/runtime/src/internal_includes/fsync.hpp b/Atlas/runtime/src/internal_includes/fsync.hpp new file mode 100644 index 0000000000000000000000000000000000000000..bc9df7f436952bf15a0d52a42822180a9d73ff4d --- /dev/null +++ b/Atlas/runtime/src/internal_includes/fsync.hpp @@ -0,0 +1,74 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define FP (void)fprintf + +static void bail(char *msg, int line) { + FP(stderr, "%s:%d: %s: %s\n", __FILE__, line, msg, strerror(errno)); + exit(EXIT_FAILURE); +} +#define BAIL(msg) bail(msg, __LINE__) + +static void trim_rightmost_path_component(char *p) { + char *s = p + strlen(p) - 1; + if ('/' == *s) + *s-- = '\0'; + while (s > p && '/' != *s) + s--; + *++s = '\0'; +} + +static int fsync_paranoid(const char *name) { + char rp[1+PATH_MAX], *file = (char *) malloc(sizeof(char)*(strlen(name)+1)); + strcpy(file, name); + FP(stderr, "fsync to root '%s'\n", file); + if (NULL == realpath(file, rp)) BAIL("realpath failed"); + FP(stderr, " realpath '%s'\n", rp); + do { + int fd; + FP(stderr, " fsync-ing '%s'\n", rp); + if (-1 == (fd = open(rp, O_RDONLY))) BAIL("open failed"); + if (-1 == fsync(fd)) BAIL("fsync failed"); + if (-1 == close(fd)) BAIL("close failed"); + trim_rightmost_path_component(rp); + } while (*rp); + FP(stderr, " done\n"); + free(file); + return 0; +} + +static int fsync_dir(const char *name) +{ + char *file = (char*) malloc(sizeof(char)*(strlen(name)+1)); + strcpy(file, name); + trim_rightmost_path_component(file); + FP(stderr, " fsync-ing '%s'\n", file); + int fd; + if (-1 == (fd = open(file, O_RDONLY))) BAIL("open failed"); + if (-1 == fsync(fd)) BAIL("fsync failed"); + if (-1 == close(fd)) BAIL("close failed"); + free(file); + return 0; +} diff --git a/Atlas/runtime/src/internal_includes/happens_before.hpp b/Atlas/runtime/src/internal_includes/happens_before.hpp new file mode 100644 index 0000000000000000000000000000000000000000..dbfb76d2ca7814cb14ec1f110f3c15f11eaca223 --- /dev/null +++ b/Atlas/runtime/src/internal_includes/happens_before.hpp @@ -0,0 +1,85 @@ +/* + * (c) Copyright 2016 Hewlett Packard Enterprise Development LP + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. This program is + * distributed in the hope that it will be useful, but WITHOUT ANY + * WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * for more details. You should have received a copy of the GNU Lesser + * General Public License along with this program. If not, see + * . + */ + + +#ifndef HAPPENS_BEFORE_HPP +#define HAPPENS_BEFORE_HPP + +#include +#include + +#include "log_structure.hpp" + +namespace Atlas { + +typedef std::map MapOfLockInfo; + +// This structure is currently used in a write-once manner. It contains +// the core information within an entry in a hash table. If any of the +// components needs to be changed, the update is done in a copy-on-write +// manner. +struct ImmutableInfo +{ + explicit ImmutableInfo(LogEntry *le, MapOfLockInfo *linfo, bool is_del) + : LogAddr{le}, + LockInfoPtr{linfo}, + IsDeleted{is_del} {} + ImmutableInfo() = delete; + ImmutableInfo(const ImmutableInfo&) = delete; + ImmutableInfo(ImmutableInfo&&) = delete; + ImmutableInfo& operator=(const ImmutableInfo&) = delete; + ImmutableInfo& operator=(ImmutableInfo&&) = delete; + + // Here LogAddr_ is the address of the log entry of the last release + // operation of the corresponding synchronization object. + LogEntry *LogAddr; + + // The following map contains the set of locks (and their counts) + // that *this* lock *depends* on. This *dependence* relation is + // established at the point *this* lock is released. At any point + // of time, there can be at most one writer since only one thread + // can release *this* lock. But there can be multiple readers who + // may be examining this map (e.g. rw-locks). + MapOfLockInfo *LockInfoPtr; + + // The following field indicates whether this entry is obsolete + bool IsDeleted; +}; + +stru