Merge pull request #193 from ROSS-org/develop

New ROSS version 8.1.0 !

Author: helq

.gitignore

@@ -1,4 +1,6 @@
 # ignore models that aren't already in tree
 # (must manually add models to override this)
-models/*
+build/
+models/*/
+!models/phold
 *.swp

README.md

@@ -65,6 +65,11 @@ ROSS developers typically do out-of-tree builds.  See the [Installation page](ht
   cd ROSS-build
   ccmake ~/path-to/ROSS
   ```
+We reccomend the following CMake parameters:
+  ```
+  cmake .. -DROSS_BUILD_MODELS=ON -DCMAKE_INSTALL_PREFIX="$(realpath ./bin)" \
+      -DCMAKE_C_COMPILER=mpicc -DCMAKE_BUILD_TYPE=Debug -DCMAKE_C_FLAGS="-g -Wall"
+  ```
 
 5. Make your model(s) with one of the following commands
   ```
@@ -80,5 +85,22 @@ See [this blog post](https://ross-org.github.io/setup/running-sim.html) for deta
   ./your-model --synch=1               // sequential mode
   mpirun -np 2 ./your-model --synch=2  // conservative mode
   mpirun -np 2 ./your-model --synch=3  // optimistic mode
-  ./your-model --synch=4               // optimistic debug mode (note: not a parallel execution!)
+  mpirun -np 1 ./your-model --synch=4  // optimistic debug mode (note: not a parallel execution!)
+  mpirun -np 2 ./your-model --synch=5  // optimistic realtime mode
+  mpirun -np 1 ./your-model --synch=6  // reverse handler check mode
+  ```
+
+You can pass arguments to your model from the command line as shown above. However, for better readability, it is also possible to pass command line arguments through a text file.
+
+A sample text file sample.txt is included below.
+  ```
+  # Synchonization protocol
+  --synch=4
+  # AVL Tree contains 2^avl-size nodes (default 18)
+  --avl-size=18
+  ```
+
+The text file is then parsed by ROSS through the args-file command line argument.
+  ```
+  ./your-model --args-file=sample.txt
   ```

core/CMakeLists.txt

@@ -7,17 +7,20 @@ queue/tw-queue.h
 queue/${QUEUE}.c
 
 ross-random.h
-ross-random.c
+ross-random-internal.h
+ross-random-internal.c
 rand-${RAND}.h
 rand-${RAND}.c
 
 clock/${CLOCK}.h
 clock/${CLOCK}.c
 
 ross-gvt.h
+ross-gvt-internal.h
 gvt/${GVT}.h
 gvt/${GVT}.c
 
+ross-network.h
 network-${NETWORK}.h
 network-${NETWORK}.c
 
@@ -33,10 +36,12 @@ tw-state.c
 ross-extern.h
 ross-global.c
 
+ross-base.h
 ross-inline.h
 ross-kernel-inline.h
 ross.h
 ross-types.h
+ross-clock.h
 
 tw-eventq.h
 tw-event.c
@@ -64,7 +69,11 @@ instrumentation/st-event-trace.c
 instrumentation/st-model-data.c
 instrumentation/ross-lps/analysis-lp.h
 instrumentation/ross-lps/analysis-lp.c
-instrumentation/ross-lps/specialized-lps.c)
+instrumentation/ross-lps/specialized-lps.c
+
+check-revent/crv-state.h
+check-revent/crv-state.c
+)
 
 # ROSS VERSION INFORMATION
 ## Print Date and Time at top of ROSS output
@@ -167,6 +176,7 @@ SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_BINARY_DIR}/config.h PROPERTIES GENE
 # CODES config bin
 SET(ROSS_CC $ENV{CC})
 SET(ROSS_CXX $ENV{CXX})
+STRING(REPLACE " " "\\ " CMAKE_INSTALL_PREFIX_ESCAPED "\"${CMAKE_INSTALL_PREFIX}\"")
 CONFIGURE_FILE(ross-config.in ross-config @ONLY)
 CONFIGURE_FILE(ross.pc.in ross.pc @ONLY)
 SET_SOURCE_FILES_PROPERTIES(${CMAKE_CURRENT_SOURCE_DIR}/ross.pc.in PROPERTIES GENERATED FALSE)

core/avl_tree.c

@@ -1,11 +1,10 @@
-#include <stdio.h>
-#include <stdlib.h>
+#include "avl_tree.h"
+#include <math.h>
 #include <assert.h>
+#include "ross-kernel-inline.h"
 
 /* Copied and modified from http://pine.cs.yale.edu/pinewiki/C/AvlTree google cache */
 
-#include "avl_tree.h"
-
 /* implementation of an AVL tree with explicit heights */
 
 tw_pe *pe;

core/avl_tree.h

@@ -1,4 +1,7 @@
-#include <ross.h>
+#ifndef INC_avl_tree_h
+#define INC_avl_tree_h
+
+#include "ross-types.h"
 
 /* Copied and modified from http://pine.cs.yale.edu/pinewiki/C/AvlTree google cache */
 
@@ -43,3 +46,5 @@ tw_event * avlDelete(AvlTree *t, tw_event *key);
 AvlTree avl_alloc(void);
 
 void avl_free(AvlTree t);
+
+#endif /* INC_avl_tree_h */

core/buddy.h

@@ -1,6 +1,7 @@
 #ifndef BUDDY_H
 #define BUDDY_H
 
+#include <stdint.h>
 #include <sys/queue.h>
 
 /**

core/check-revent/crv-state.c

@@ -0,0 +1,195 @@
+#include "ross.h"
+
+// Defining simple linked list because we don't care about speed at
+// initialization for SEQUENTIAL_ROLLBACK_CHECK
+struct llist_chptr {
+    crv_checkpointer * val;
+    struct llist_chptr * next;
+};
+struct llist_chptr * head_linked_list = NULL;
+struct llist_chptr * tail_linked_list = NULL;
+
+struct crv_checkpointer ** checkpointer_for_lps = NULL;
+
+void crv_add_custom_state_checkpoint(crv_checkpointer * state_checkpoint) {
+    struct llist_chptr * next = malloc(sizeof(struct llist_chptr));
+    if (next == NULL) {
+        tw_error(TW_LOC, "Could not allocate memory");
+    }
+    next->val = state_checkpoint;
+    next->next = NULL;
+
+    if (head_linked_list == NULL) {
+        tail_linked_list = head_linked_list = next;
+    } else {
+        tail_linked_list->next = next;
+        tail_linked_list = next;
+    }
+}
+
+static void crv_clean_linkedlist(void) {
+    if (head_linked_list == NULL) {
+        return;
+    }
+
+    struct llist_chptr * prev = head_linked_list;
+    struct llist_chptr * iter = prev->next;
+    while (iter != NULL) {
+        free(prev);
+        prev = iter;
+        iter = iter->next;
+    }
+    free(tail_linked_list);
+    head_linked_list = NULL;
+    tail_linked_list = NULL;
+}
+
+size_t crv_init_checkpoints(void) {
+    // No need to construct array with crv_checkpointer's if there isn't any
+    if (head_linked_list == NULL) {
+        return 0;
+    }
+
+    checkpointer_for_lps = malloc(g_tw_nlp * sizeof(struct crv_checkpointer *));
+
+    size_t largest_lp_checkpoint = 0;
+    for (size_t i = 0; i < g_tw_nlp; i++) {
+        tw_lp * lp = g_tw_lp[i];
+        struct crv_checkpointer * state_checkpointer = NULL;
+
+        // Finding crv_checkpointer, if it exists, for current lp
+        for (struct llist_chptr * iter = head_linked_list; iter != NULL; iter = iter->next) {
+            if (lp->type == iter->val->lptype) {
+                state_checkpointer = iter->val;
+                break;
+            }
+        }
+
+        checkpointer_for_lps[i] = state_checkpointer;
+
+        if (state_checkpointer != NULL && state_checkpointer->sz_storage > largest_lp_checkpoint) {
+            largest_lp_checkpoint = state_checkpointer->sz_storage;
+        }
+
+    }
+
+    crv_clean_linkedlist();
+
+    return largest_lp_checkpoint;
+}
+
+static crv_checkpointer * get_chkpntr(tw_lpid id) {
+    if (checkpointer_for_lps == NULL) {
+        return NULL;
+    }
+    return checkpointer_for_lps[id];
+}
+
+static void print_event(crv_checkpointer const * chkptr, tw_lp * clp, tw_event * cev) {
+    fprintf(stderr, "\n  Event:\n  ---------\n");
+    fprintf(stderr, "  Bit field contents\n");
+    tw_bf b = cev->cv;
+    fprintf(stderr, "  c0  c1  c2  c3  c4  c5  c6  c7  c8  c9  c10 c11 c12 c13 c14 c15\n");
+    fprintf(stderr, "  %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d \n", b.c0, b.c1, b.c2, b.c3, b.c4, b.c5, b.c6, b.c7, b.c8, b.c9, b.c10, b.c11, b.c12, b.c13, b.c14, b.c15);
+    fprintf(stderr, "  c16 c17 c18 c19 c20 c21 c22 c23 c24 c25 c26 c27 c28 c29 c30 c31\n");
+    fprintf(stderr, "  %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d   %d \n", b.c16, b.c17, b.c18, b.c19, b.c20, b.c21, b.c22, b.c23, b.c24, b.c25, b.c26, b.c27, b.c28, b.c29, b.c30, b.c31);
+    fprintf(stderr, "  ---------\n  Event contents\n");
+    tw_fprint_binary_array(stderr, "", tw_event_data(cev), g_tw_msg_sz);
+    if (chkptr && chkptr->print_event) {
+        fprintf(stderr, "---------------------------------\n");
+        chkptr->print_event(stderr, "", clp->cur_state, tw_event_data(cev));
+    }
+    fprintf(stderr, "---------------------------------\n");
+}
+
+void crv_check_lpstates(
+         tw_lp * clp,
+         tw_event * cev,
+         crv_lpstate_checkpoint_internal const * before_state,
+         char const * before_msg,
+         char const * after_msg
+) {
+    crv_checkpointer const * chkptr = get_chkpntr(clp->id);
+
+    bool state_equal;
+    if (chkptr && chkptr->check_lps) {
+        state_equal = chkptr->check_lps(before_state->state, clp->cur_state);
+    } else {
+        state_equal = !memcmp(before_state->state, clp->cur_state, clp->type->state_sz);
+    }
+
+    if (!state_equal) {
+        fprintf(stderr, "Error found by a rollback of an event\n");
+        fprintf(stderr, "  The state of the LP is not consistent when rollbacking!\n");
+        fprintf(stderr, "  LPID = %lu\n", clp->gid);
+        fprintf(stderr, "\n  LP contents (%s):\n", before_msg);
+        tw_fprint_binary_array(stderr, "", before_state->state, clp->type->state_sz);
+        if (chkptr && chkptr->print_checkpoint) {
+            fprintf(stderr, "---------------------------------\n");
+            chkptr->print_checkpoint(stderr, "", before_state->state);
+            fprintf(stderr, "---------------------------------\n");
+        }
+        fprintf(stderr, "\n  LP contents (%s):\n", after_msg);
+        tw_fprint_binary_array(stderr, "", clp->cur_state, clp->type->state_sz);
+        if (chkptr && chkptr->print_lp) {
+            fprintf(stderr, "---------------------------------\n");
+            chkptr->print_lp(stderr, "", clp->cur_state);
+            fprintf(stderr, "---------------------------------\n");
+        }
+        print_event(chkptr, clp, cev);
+	    tw_net_abort();
+    }
+    if (memcmp(&before_state->rng, clp->rng, sizeof(struct tw_rng_stream))) {
+        fprintf(stderr, "Error found by rollback of an event\n");
+        fprintf(stderr, "  Random number generation `rng` did not rollback properly!\n");
+        fprintf(stderr, "  This often happens if the random number generation was not properly rollbacked by the reverse handler!\n");
+        fprintf(stderr, "  LPID = %lu\n", clp->gid);
+        fprintf(stderr, "\n  rng contents (%s):\n", before_msg);
+        tw_fprint_binary_array(stderr, "", &before_state->rng, sizeof(struct tw_rng_stream));
+        fprintf(stderr, "\n  rng contents (%s):\n", after_msg);
+        tw_fprint_binary_array(stderr, "", clp->rng, sizeof(struct tw_rng_stream));
+        print_event(chkptr, clp, cev);
+	    tw_net_abort();
+    }
+    if (memcmp(&before_state->core_rng, clp->core_rng, sizeof(struct tw_rng_stream))) {
+        fprintf(stderr, "Error found by rollback of an event\n");
+        fprintf(stderr, "  Random number generation `core_rng` did not rollback properly!\n");
+        fprintf(stderr, "  LPID = %lu\n", clp->gid);
+        fprintf(stderr, "\n  core_rng contents (%s):\n", before_msg);
+        tw_fprint_binary_array(stderr, "", &before_state->core_rng, sizeof(struct tw_rng_stream));
+        fprintf(stderr, "\n  core_rng contents (%s):\n", after_msg);
+        tw_fprint_binary_array(stderr, "", clp->core_rng, sizeof(struct tw_rng_stream));
+        print_event(chkptr, clp, cev);
+	    tw_net_abort();
+    }
+    if (before_state->triggered_gvt_hook != clp->triggered_gvt_hook) {
+        fprintf(stderr, "Error found by rollback of an event\n");
+        fprintf(stderr, "  triggered_gvt_hook incogruent value, this is most likely the result of not calling tw_trigger_gvt_hook_now_rev when rollbacking tw_trigger_gvt_hook_now!\n");
+        fprintf(stderr, "  LPID = %lu\n", clp->gid);
+        fprintf(stderr, "\n  lp->triggered_gvt_hook (%s) = %d\n", before_msg, before_state->triggered_gvt_hook);
+        fprintf(stderr, "\n  lp->triggered_gvt_hook contents (%s) = %d\n", after_msg, clp->triggered_gvt_hook);
+        print_event(chkptr, clp, cev);
+	    tw_net_abort();
+    }
+}
+
+void crv_copy_lpstate(crv_lpstate_checkpoint_internal * into, tw_lp const * clp) {
+    crv_checkpointer const * chkptr = get_chkpntr(clp->id);
+
+    if (chkptr && chkptr->save_lp) {
+        chkptr->save_lp(into->state, clp->cur_state);
+    } else {
+        memcpy(into->state, clp->cur_state, clp->type->state_sz);
+    }
+    memcpy(&into->rng, clp->rng, sizeof(struct tw_rng_stream));
+    memcpy(&into->core_rng, clp->core_rng, sizeof(struct tw_rng_stream));
+    into->triggered_gvt_hook = clp->triggered_gvt_hook;
+}
+
+void crv_clean_lpstate(crv_lpstate_checkpoint_internal * state, tw_lp const * clp) {
+    crv_checkpointer const * chkptr = get_chkpntr(clp->id);
+
+    if (chkptr && chkptr->clean_lp) {
+        chkptr->clean_lp(state->state);
+    }
+}