|
|
@@ -0,0 +1,947 @@
|
|
|
+/*
|
|
|
+ * mp2.h
|
|
|
+ *
|
|
|
+ * Created by Mike Auguston on 2/2/15.
|
|
|
+ * recursive descent trace generation
|
|
|
+ * common declarations and globals
|
|
|
+ *
|
|
|
+ * last update: 03/26/15
|
|
|
+ */
|
|
|
+#include <iostream>
|
|
|
+#include <fstream>
|
|
|
+#include <cstdlib>
|
|
|
+#include <ctime>
|
|
|
+#include <vector>
|
|
|
+#include <map>
|
|
|
+#include <set>
|
|
|
+//#include <algorithm>
|
|
|
+
|
|
|
+using namespace std;
|
|
|
+
|
|
|
+//************************
|
|
|
+//***** Statistics
|
|
|
+//************************
|
|
|
+double storage = 0; // memory for composite segments
|
|
|
+int total_events = 0; // total events stored
|
|
|
+
|
|
|
+clock_t gen_start,gen_end; // for time measurement
|
|
|
+double dif; // for time interval
|
|
|
+
|
|
|
+//************************
|
|
|
+//***** Globals
|
|
|
+//************************
|
|
|
+ofstream JSON; // text file for trace visualization
|
|
|
+class Event_producer;
|
|
|
+class Composite_producer;
|
|
|
+
|
|
|
+typedef Event_producer * Event_producer_ref;
|
|
|
+typedef Composite_producer * Composite_producer_ref;
|
|
|
+typedef vector <Event_producer_ref> trace_segment;
|
|
|
+
|
|
|
+//***************************************
|
|
|
+//*** these are used for traverse() work
|
|
|
+//***************************************
|
|
|
+trace_segment Stack;
|
|
|
+ // Stack used by producers for trace segment construction via traverse()
|
|
|
+
|
|
|
+// to maintain relations lists
|
|
|
+typedef multimap <int, int> pair_list;
|
|
|
+ // for storing basic relations IN, FOLLOWS, EQUAL for the segment,
|
|
|
+ // matricies for segments are build from these when needed
|
|
|
+pair_list Follows; // to store FOLLOWS
|
|
|
+pair_list Inside; // to store IN
|
|
|
+pair_list Equals; // to store Equals (result of MAP or SHARE ALL)
|
|
|
+
|
|
|
+// stack accompanying the Stack
|
|
|
+vector <int> predecessor; // to track PRECEDES relation during traverse()
|
|
|
+ // push/pop performed in Composite_producer
|
|
|
+
|
|
|
+//===========================
|
|
|
+// for SET_node traverse()
|
|
|
+//--------------------------------------------------
|
|
|
+// initialized in Composite_producer, similar to predecessor.back()
|
|
|
+// used in SET_node_producer_container
|
|
|
+// replace predecessor when traversing Sets
|
|
|
+
|
|
|
+// heads and tails store for each Set a list
|
|
|
+// (branch_begin FOLLOWS node) for heads
|
|
|
+// (forthcoming_node FOLLOWS end-of-branch-event) for tails
|
|
|
+// each is a permanent list for Set traverse()
|
|
|
+vector<pair_list> heads;
|
|
|
+vector<pair_list> tails;
|
|
|
+
|
|
|
+void find_and_copy_heads(int branch_start, int my_index);
|
|
|
+void find_and_copy_tails(int first_branch_start, pair_list &destination);
|
|
|
+void copy_from_to(int anchor, pair_list &from_list, pair_list &to_list);
|
|
|
+void copy_and_adjust_from_to(int anchor, int adjusted_node,
|
|
|
+ pair_list &from_list, pair_list &to_list);
|
|
|
+bool find_in_heads(int node);
|
|
|
+
|
|
|
+//===================================
|
|
|
+// composite producers infrastructure
|
|
|
+//===================================
|
|
|
+void add_relations_for_leader(); // the subroutine for adding relations for
|
|
|
+ //the leading event in Atomic_producer or Composite_secondary_producer
|
|
|
+
|
|
|
+//********** main list of composite event, root, and schema producers ******
|
|
|
+//==========================================================================
|
|
|
+map <int, Composite_producer_ref> Composite_address_book;
|
|
|
+// for each composite event/root/schema name contains a plain pointer to the
|
|
|
+// producer object with the segment list
|
|
|
+
|
|
|
+void show_map(pair_list &x);// for debugging printouts
|
|
|
+
|
|
|
+//****************************
|
|
|
+// event producer types
|
|
|
+//****************************
|
|
|
+enum Event_type {Atom, Composite_producer_node, Composite_event_instance_node,
|
|
|
+ Composite_secondary_producer_node,
|
|
|
+ ROOT_node, Schema_node, OR_node, AND_node, SET_node, Empty_node,
|
|
|
+ Coordinate_op, ShareAll_op };
|
|
|
+
|
|
|
+string event_type_string[] = { "Atom", "Composite_producer_node",
|
|
|
+ "Composite_event_instance_node",
|
|
|
+ "Composite_secondary_producer_node",
|
|
|
+ "ROOT_node", "Schema_node",
|
|
|
+ "OR_node", "AND_node", "SET_node",
|
|
|
+ "Empty_node", "Coordinate_op", "ShareAll_op" };
|
|
|
+
|
|
|
+//======= traversal results
|
|
|
+enum Traversal_result {failed, success_and_completed, success_and_ready_for_next};
|
|
|
+string Traversal_result_string[] = {"failed", "success_and_completed",
|
|
|
+ "success_and_ready_for_next"};
|
|
|
+
|
|
|
+//**************************************
|
|
|
+//========= generic classes ============
|
|
|
+//**************************************
|
|
|
+
|
|
|
+//********** Event producers ************
|
|
|
+//***************************************
|
|
|
+class Event_producer{
|
|
|
+public:
|
|
|
+
|
|
|
+ int name; // event name
|
|
|
+ Event_type type;
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ Event_producer(int n){
|
|
|
+ name = n;
|
|
|
+ type = Atom; // default
|
|
|
+ }
|
|
|
+
|
|
|
+ virtual Traversal_result traverse()=0; // will be overloaded
|
|
|
+
|
|
|
+ virtual void hold(){} // redefined for OR_nodes
|
|
|
+
|
|
|
+ virtual void print_event();
|
|
|
+};
|
|
|
+//--------------------------------------
|
|
|
+class Atomic_producer: public Event_producer {
|
|
|
+public:
|
|
|
+ // constructor
|
|
|
+ Atomic_producer(int n): Event_producer(n){}
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+ // add relations for new event
|
|
|
+ add_relations_for_leader();
|
|
|
+ Stack.push_back(this);
|
|
|
+
|
|
|
+ return success_and_completed;
|
|
|
+ }
|
|
|
+
|
|
|
+};// end class Atomic_producer
|
|
|
+
|
|
|
+//-----------------------------------------
|
|
|
+// for empty alternatives in Alt and Optional containers
|
|
|
+// does not leave anything on the trace
|
|
|
+class Empty_producer: public Event_producer {
|
|
|
+public:
|
|
|
+ // constructor
|
|
|
+ Empty_producer(int n): Event_producer(n){
|
|
|
+ type = Empty_node;
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+ return success_and_completed;
|
|
|
+ }
|
|
|
+
|
|
|
+};// end class Empty_producer
|
|
|
+
|
|
|
+//-----------------------------------------
|
|
|
+class OR_node_producer_container: public Event_producer{
|
|
|
+public:
|
|
|
+ Event_producer_ref * element; // dynamic array of producer elements
|
|
|
+ int element_count; // length of the element array
|
|
|
+ int current_alternative; // the alternative to try, when there is one
|
|
|
+ int previous_alternative; // to hold on the alternative waiting until successors complete
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ OR_node_producer_container(int n): Event_producer(n){
|
|
|
+ type = OR_node;
|
|
|
+ current_alternative = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+
|
|
|
+ previous_alternative = current_alternative;
|
|
|
+ Traversal_result result;
|
|
|
+ bool done = false; // to interrupt the for loop when success is reached
|
|
|
+ // try to find a valid alternative
|
|
|
+ for(int i = current_alternative; (i< element_count) && !done; i++){
|
|
|
+ switch(result = (element[i] -> traverse()) ){
|
|
|
+ case failed: continue; // try next alternative
|
|
|
+
|
|
|
+ case success_and_completed: current_alternative++;
|
|
|
+ done = true;
|
|
|
+ break;
|
|
|
+
|
|
|
+ case success_and_ready_for_next: done = true;
|
|
|
+ // retain the current_alternative
|
|
|
+ };
|
|
|
+ }
|
|
|
+ if(result == failed) return failed;
|
|
|
+
|
|
|
+ return (current_alternative >= element_count)?
|
|
|
+ (current_alternative = 0, success_and_completed):
|
|
|
+ success_and_ready_for_next;
|
|
|
+ }
|
|
|
+
|
|
|
+ void hold(){ //follower in an AND_node may hold advance to the next alternative
|
|
|
+ // because the follower has not yet completed
|
|
|
+
|
|
|
+ current_alternative = previous_alternative;
|
|
|
+ // freez producers in the alternative that will be executed next
|
|
|
+ element[current_alternative]->hold();
|
|
|
+ }
|
|
|
+
|
|
|
+}; // end OR_node_producer_container class
|
|
|
+
|
|
|
+//-----------------------------------------------------------
|
|
|
+class AND_node_producer_container: public Event_producer{
|
|
|
+ // serves sequence producers
|
|
|
+public:
|
|
|
+ Event_producer_ref * element; // array of producer elements
|
|
|
+ int element_count; // length of the element array
|
|
|
+ Event_type target_event;// set in the generated subclass constructor
|
|
|
+ int completeness_count; // for harvest() to detect when no more options remain
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ AND_node_producer_container(int n): Event_producer(n){
|
|
|
+ type = target_event = AND_node;
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+
|
|
|
+ completeness_count = 0;
|
|
|
+ for(int i =0; i< element_count; i++){
|
|
|
+
|
|
|
+ if(target_event == Schema_node) {
|
|
|
+ // before element[i] -> traverse()
|
|
|
+ predecessor.back() = -1; // block regular ordering
|
|
|
+ }
|
|
|
+ switch(element[i] -> traverse()){
|
|
|
+ case failed: if(completeness_count == i)
|
|
|
+ // there are no more options to try
|
|
|
+ // let harvest() to stop calling this traverse() again
|
|
|
+ completeness_count = element_count;
|
|
|
+ return failed;
|
|
|
+ case success_and_completed: completeness_count++;
|
|
|
+ break;
|
|
|
+ case success_and_ready_for_next:
|
|
|
+ // hold all previous OR_nodes until element[i] completes
|
|
|
+ for(int j = 0; j<i; j++)
|
|
|
+ element[j]->hold();
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return (completeness_count == element_count)? success_and_completed:
|
|
|
+ success_and_ready_for_next;
|
|
|
+ }
|
|
|
+
|
|
|
+ void hold(){
|
|
|
+ // hold all nodes until next element completes
|
|
|
+ for(int j = 0; j < element_count; j++){
|
|
|
+ element[j]->hold();
|
|
|
+ }
|
|
|
+ }
|
|
|
+}; // end AND_node_producer_container class
|
|
|
+
|
|
|
+//----------------------------------------------------------------------
|
|
|
+class SET_node_producer_container: public Event_producer{
|
|
|
+ // serves set producers
|
|
|
+public:
|
|
|
+ Event_producer_ref * element; // array of producer elements
|
|
|
+ // set branches
|
|
|
+ int element_count; // length of the element array
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ SET_node_producer_container(int n): Event_producer(n){
|
|
|
+ type = SET_node;
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+ int completeness_count = 0;
|
|
|
+
|
|
|
+ //========= begin Set traversal ================
|
|
|
+ // prepare heads for set branch traversal
|
|
|
+ //==============================================
|
|
|
+ int last = predecessor.back(); // current predecessor, value stored on the top of stack
|
|
|
+ int first_branch_start = Stack.size();
|
|
|
+ pair_list temp_list; // needed to push empty map to heads,
|
|
|
+ // and to store this Set's tails before moving them to global tails
|
|
|
+ set<int> my_tails; // will use in this traverse() and store in tails at the very end
|
|
|
+
|
|
|
+
|
|
|
+ int my_index = heads.size(); // position in heads vector
|
|
|
+ heads.push_back(temp_list); // start heads[my_index] with empty, will update in situ
|
|
|
+
|
|
|
+ // prepare heads for the first branch
|
|
|
+ if(last >= 0){
|
|
|
+ // this Set is not at any branch begin in a parent Set
|
|
|
+ heads[my_index].insert(pair<int, int>(first_branch_start, last) );
|
|
|
+ }
|
|
|
+ // find the earliest parent and copy to heads[my_index] for this branch
|
|
|
+ // this Set is at some branch beginning with a parent Set
|
|
|
+ find_and_copy_heads(first_branch_start, my_index);
|
|
|
+ // if first_branch_start is found in any previous Set tails, copy it to heads[my_index]
|
|
|
+ find_and_copy_tails(first_branch_start, heads[my_index]);
|
|
|
+
|
|
|
+ //============================
|
|
|
+ // main loop starts here
|
|
|
+ //============================
|
|
|
+ for(int i =0; i< element_count; i++){
|
|
|
+
|
|
|
+ //=================================
|
|
|
+ // before element[i] -> traverse()
|
|
|
+ //=================================
|
|
|
+ predecessor.back() = -1; // block regular ordering
|
|
|
+ int forthcoming_event = Stack.size();
|
|
|
+
|
|
|
+ if(forthcoming_event > first_branch_start){
|
|
|
+ // not the first branch beginning, copy and adjust
|
|
|
+ copy_and_adjust_from_to(first_branch_start, forthcoming_event,
|
|
|
+ heads[my_index], heads[my_index]);
|
|
|
+ }
|
|
|
+
|
|
|
+ // copy tails from children Set and delete them, to prevent siblings from using it
|
|
|
+ for(int k = 0; k < tails.size(); k++){
|
|
|
+ multimap<int, int>:: iterator p = tails[k].find(forthcoming_event);
|
|
|
+ multimap<int, int>:: iterator q = tails[k].upper_bound(forthcoming_event);
|
|
|
+ if(p != tails[k].end()){ // found a tail that should be added to my_tails
|
|
|
+ while(p != q) {
|
|
|
+ my_tails.insert(p->second);
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ tails[k].clear();// done with this Set
|
|
|
+ }
|
|
|
+ }
|
|
|
+ //===============
|
|
|
+ // traverse()
|
|
|
+ //===============
|
|
|
+ switch(element[i] -> traverse()){
|
|
|
+ case failed: return failed;
|
|
|
+ case success_and_completed: completeness_count++;
|
|
|
+ break;
|
|
|
+ case success_and_ready_for_next:
|
|
|
+ // hold all previous OR_nodes until element[i] completes
|
|
|
+ for(int j = 0; j<i; j++)
|
|
|
+ element[j]->hold();
|
|
|
+ }
|
|
|
+ //===============================
|
|
|
+ // after element[i] -> traverse()
|
|
|
+ //===============================
|
|
|
+ int next_event = Stack.size();
|
|
|
+ if( next_event > forthcoming_event ){
|
|
|
+ // there was a non-empty contribution by traverse()
|
|
|
+
|
|
|
+ // forthcoming_event exists, now can forward heads[my_index]
|
|
|
+ // for forthcoming_event to Follows
|
|
|
+ // and perform this delayed action
|
|
|
+ copy_from_to(forthcoming_event, heads[my_index], Follows);
|
|
|
+
|
|
|
+ if(predecessor.back() >= 0){
|
|
|
+ my_tails.insert(predecessor.back());
|
|
|
+ }
|
|
|
+
|
|
|
+ if(i == element_count - 1){// if the last element, do it now
|
|
|
+ // copy tails from children Set
|
|
|
+ for(int k = 0; k < tails.size(); k++){
|
|
|
+ multimap<int, int>:: iterator p = tails[k].find(next_event);
|
|
|
+ multimap<int, int>:: iterator q = tails[k].upper_bound(next_event);
|
|
|
+ if(p != tails[k].end()){ // found a tail that should be added to my_tails
|
|
|
+ while(p != q) {
|
|
|
+ my_tails.insert(p->second);
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ tails[k].clear();// done with this Set
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // else continue element[i+1] -> traverse() with the same heads and tails
|
|
|
+ } // end main loop
|
|
|
+
|
|
|
+ //============================
|
|
|
+ // end of Set generation
|
|
|
+ //============================
|
|
|
+
|
|
|
+ // store tails accumulated in my_tails
|
|
|
+ int next = Stack.size();
|
|
|
+ for(set<int>:: iterator tt = my_tails.begin(); tt != my_tails.end(); tt++){
|
|
|
+ temp_list.insert(pair<int, int>(next, *tt) );
|
|
|
+ }
|
|
|
+ // finally add to the global tails
|
|
|
+ tails.push_back(temp_list);
|
|
|
+
|
|
|
+ predecessor.back() = -1; // block regular ordering
|
|
|
+
|
|
|
+ return (completeness_count == element_count)? success_and_completed:
|
|
|
+ success_and_ready_for_next;
|
|
|
+ }
|
|
|
+
|
|
|
+ void hold(){
|
|
|
+ // hold all nodes until next element completes
|
|
|
+ for(int j = 0; j < element_count; j++){
|
|
|
+ element[j]->hold();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+}; // end SET_node_producer_container class
|
|
|
+
|
|
|
+//--------------------------------------------------
|
|
|
+// this element sits on the generated event trace, along with Atomic_producers
|
|
|
+// generated in the Composite_secondary_producer,
|
|
|
+// added at the beginning of each segment,
|
|
|
+// brought from the Composite_producer segments storage
|
|
|
+class Composite_event_instance: public Event_producer{
|
|
|
+public:
|
|
|
+ int index; // fetched segment's index in the segment_storage (version of this composite event)
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ Composite_event_instance(int n, int indx): Event_producer(n){
|
|
|
+ type = Composite_event_instance_node;
|
|
|
+ index = indx;
|
|
|
+ }
|
|
|
+
|
|
|
+ void print_event(); // defined in the generated part,
|
|
|
+ // because it needs event type and name strings
|
|
|
+
|
|
|
+ // to prevent this class from being abstract, as Event_producer
|
|
|
+ Traversal_result traverse(){return success_and_completed;}
|
|
|
+
|
|
|
+}; // end Composite_event_instance class
|
|
|
+
|
|
|
+//---------------------------------------------------------------
|
|
|
+// is a subclass of generated Composite classes
|
|
|
+// this object creates and stores list of composite event instances
|
|
|
+// traverse() is called from its harvest() only
|
|
|
+class Composite_producer: public AND_node_producer_container {
|
|
|
+public:
|
|
|
+ // storage for secondary producers
|
|
|
+ //===================================
|
|
|
+ vector <trace_segment> segments;// composite event trace instance list
|
|
|
+ // to store relation lists for the segments
|
|
|
+ vector <pair_list> follows_lists; // to store FOLLOWS
|
|
|
+ vector <pair_list> inside_lists; // to store IN
|
|
|
+ vector <pair_list> equals_lists; // to store Equals (results of MAP or SHARE ALL)
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ Composite_producer(int n): AND_node_producer_container(n){
|
|
|
+ type = Composite_producer_node;
|
|
|
+ // posts a reference to itself on the Composite_address_book
|
|
|
+ Composite_address_book.insert(pair<int, Composite_producer_ref>(name, this));
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+ // creates a single trace on the Stack
|
|
|
+ return this -> AND_node_producer_container::traverse();
|
|
|
+ }
|
|
|
+
|
|
|
+ // calls traverse to fill the segments list
|
|
|
+ void harvest(); // defined in mp2_print_etc.h
|
|
|
+
|
|
|
+ void show_traces(); // defined in mp2_print_etc.h
|
|
|
+
|
|
|
+ void output_JSON(); // defined in mp2_print_etc.h
|
|
|
+
|
|
|
+}; // end Composite_producer class
|
|
|
+
|
|
|
+//-------------------------------------------------------
|
|
|
+// sits in the recursive descent graph
|
|
|
+// used during the recursive descent to traverse composite storage
|
|
|
+// and to fetch the next composite segment
|
|
|
+// previous_index shows the position of segment added to the trace
|
|
|
+class Composite_secondary_producer: public Event_producer{
|
|
|
+public:
|
|
|
+ Composite_producer_ref segment_storage;// ptr to segment info stored in Composite_producer
|
|
|
+ int index; // segment info index in the segment_storage to fetch now
|
|
|
+ int previous_index; // for hold() implementation
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ Composite_secondary_producer(int n): Event_producer(n){
|
|
|
+ type = Composite_secondary_producer_node;
|
|
|
+
|
|
|
+ // find segment list storage
|
|
|
+ map <int, Composite_producer_ref> :: iterator p;
|
|
|
+ p = Composite_address_book.find(name);
|
|
|
+ if(p == Composite_address_book.end()){
|
|
|
+ cout<< "Composite_secondary_producer constructor cannot find segment storage for the\n";
|
|
|
+ print_event();
|
|
|
+ segment_storage = NULL;
|
|
|
+ }
|
|
|
+ else segment_storage = p-> second;
|
|
|
+ index = 0;
|
|
|
+ previous_index = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ Traversal_result traverse(){
|
|
|
+ if(!segment_storage) {
|
|
|
+ // add relations for new event and add it
|
|
|
+ add_relations_for_leader();
|
|
|
+ Stack.push_back(new Composite_event_instance(name, 0));
|
|
|
+ return success_and_completed;
|
|
|
+ }
|
|
|
+
|
|
|
+ // we are going to fetch this segment from the storage
|
|
|
+ trace_segment * my_segment_ptr = & ((segment_storage->segments)[index]);
|
|
|
+
|
|
|
+ // prepare for added segement scanning for relation update
|
|
|
+ int base = Stack.size(); //master Composite_event_instance event's position in the trace
|
|
|
+ // base is the position of composite event inside which the segment belongs
|
|
|
+
|
|
|
+ // fetch a valid alternative and adjust relation list
|
|
|
+ add_relations_for_leader();// add IN/PRECEDES for the composite event at the beginning of segment
|
|
|
+ Stack.insert(Stack.end(), my_segment_ptr->begin(), my_segment_ptr->end() );
|
|
|
+
|
|
|
+ // get the relation lists from the storage, adjust them with base,
|
|
|
+ // and add to Follows, Inside and Equals
|
|
|
+ multimap <int, int>:: iterator p;
|
|
|
+ pair_list * my_rel_list_ptr = & ((segment_storage->follows_lists)[index]);
|
|
|
+
|
|
|
+ for(p = my_rel_list_ptr-> begin(); p != my_rel_list_ptr-> end(); p++){
|
|
|
+ // scan the list of pairs and add them to Follows adjusted with base
|
|
|
+ Follows.insert(pair<int, int>( (p->first) + base,
|
|
|
+ (p->second) + base ) );
|
|
|
+ }
|
|
|
+
|
|
|
+ my_rel_list_ptr = & ((segment_storage->inside_lists)[index]);
|
|
|
+ for(p = my_rel_list_ptr-> begin(); p != my_rel_list_ptr-> end(); p++){
|
|
|
+ // scan the list of pairs and add them to Follows adjusted with base
|
|
|
+ Inside.insert(pair<int, int>( (p->first) + base,
|
|
|
+ (p->second) + base ) );
|
|
|
+ }
|
|
|
+
|
|
|
+ my_rel_list_ptr = & ((segment_storage->equals_lists)[index]);
|
|
|
+ for(p = my_rel_list_ptr-> begin(); p != my_rel_list_ptr-> end(); p++){
|
|
|
+ // scan the list of pairs and add them to Follows adjusted with base
|
|
|
+ Equals.insert(pair<int, int>( (p->first) + base,
|
|
|
+ (p->second) + base ) );
|
|
|
+ }
|
|
|
+ previous_index = index;
|
|
|
+ index++;
|
|
|
+
|
|
|
+ return (index >= (segment_storage->segments).size() )?
|
|
|
+ (index = 0, success_and_completed):
|
|
|
+ success_and_ready_for_next;
|
|
|
+ }
|
|
|
+
|
|
|
+ void hold(){
|
|
|
+ //follower in an AND_node may hold advance to the next alternative
|
|
|
+ // because the follower has not yet completed
|
|
|
+ index = previous_index;
|
|
|
+ }
|
|
|
+
|
|
|
+}; // end Composite_secondary_producer class
|
|
|
+//---------------------------------------------------------------------------
|
|
|
+
|
|
|
+class Coordinate: public Event_producer {
|
|
|
+public:
|
|
|
+ // these arrays are 2-dimensional,
|
|
|
+ // and are allocated/deleted in generated traverse()
|
|
|
+ // by create_matrices() as Stack.size() * Stack.size()
|
|
|
+ char * eq_matrix;
|
|
|
+ char * in_matrix;
|
|
|
+ char * follows_matrix;
|
|
|
+ int len; // matrix dimension
|
|
|
+ int matrix_len; // len * len
|
|
|
+
|
|
|
+ // constructor
|
|
|
+ Coordinate(int n): Event_producer(n){
|
|
|
+ type = Coordinate_op;
|
|
|
+ eq_matrix = in_matrix = follows_matrix = 0;
|
|
|
+ len = matrix_len = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ // transitive closures are based on Floyd-Warshall algorithm
|
|
|
+ // [Cormen et al. 3rd Edition, pp.699]
|
|
|
+ //--------------------------------------------------------------
|
|
|
+ void eq_transitive_closure(char * m){
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ m[i * len + j] =
|
|
|
+ m[i * len + j] || (m[i * len + k] && m[k * len + j]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } // end eq_transitive_closure(char * m)
|
|
|
+
|
|
|
+ void in_transitive_closure(char * m){
|
|
|
+ // merge equal event rows
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ if(eq_matrix[i * len + j] && (i != j)){
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ m[i * len + k] =
|
|
|
+ m[j * len + k] =
|
|
|
+ m[i * len + k] || m[j * len + k];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // do the closure
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ m[i * len + j] =
|
|
|
+ m[i * len + j] || (m[i * len + k] && m[k * len + j]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // check for loops: axioms 5-6
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ if(m[i * len + i]) throw failed;
|
|
|
+ }
|
|
|
+ } // end in_transitive_closure(char * m)
|
|
|
+
|
|
|
+ void fw_transitive_closure(char * m){
|
|
|
+ // merge equal event rows
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ if(eq_matrix[i * len + j] && (i != j)){
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ m[i * len + k] =
|
|
|
+ m[j * len + k] =
|
|
|
+ m[i * len + k] || m[j * len + k];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // propagate FOLLOWS to the inner events
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ // distributivity axioms 9-10
|
|
|
+ if(in_matrix[i * len + j]){
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ m[k * len + i] =
|
|
|
+ m[k * len + i] || m[k * len + j];
|
|
|
+ }
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ m[i * len + k] =
|
|
|
+ m[i * len + k] || m[j * len + k];
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // do the closure
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ for(int j = 0; j < len; j++){
|
|
|
+ m[i * len + j] =
|
|
|
+ m[i * len + j] || (m[i * len + k] && m[k * len + j]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // check for loops: axioms 5-6
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ if(m[i * len + i]) throw failed;
|
|
|
+ }
|
|
|
+ // check for mutual exclusion: axioms 1-4
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ for(int i = 0; i < len; i++){
|
|
|
+ if(in_matrix[k * len + i] &&
|
|
|
+ follows_matrix[k * len + i]) throw failed;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ } // end fw_transitive_closure(char * m)
|
|
|
+
|
|
|
+ void delete_matrices(){
|
|
|
+ if(in_matrix){
|
|
|
+ delete [] eq_matrix;
|
|
|
+ delete [] in_matrix;
|
|
|
+ delete [] follows_matrix;
|
|
|
+ eq_matrix = in_matrix = follows_matrix = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void create_matrices(){
|
|
|
+ len = Stack.size();
|
|
|
+ matrix_len = len * len;
|
|
|
+
|
|
|
+ // allocate and initialize with 0
|
|
|
+ eq_matrix = new char [matrix_len];
|
|
|
+ in_matrix = new char [matrix_len];
|
|
|
+ follows_matrix = new char [matrix_len];
|
|
|
+ for(int i = 0; i < matrix_len; i++){
|
|
|
+ eq_matrix[i] =
|
|
|
+ in_matrix[i] =
|
|
|
+ follows_matrix[i] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ multimap <int, int>:: iterator p;
|
|
|
+
|
|
|
+ // fill eq matrix
|
|
|
+ for(p = Equals.begin(); p != Equals.end(); p++){
|
|
|
+ eq_matrix[p->first * len + p->second ] =
|
|
|
+ eq_matrix[p->second * len + p->first ] = 1;
|
|
|
+ }
|
|
|
+ eq_transitive_closure(eq_matrix);
|
|
|
+
|
|
|
+ // fill in matrix
|
|
|
+ for(p = Inside.begin(); p != Inside.end(); p++){
|
|
|
+ in_matrix[p->first * len + p->second ] = 1;
|
|
|
+ }
|
|
|
+ in_transitive_closure(in_matrix);
|
|
|
+
|
|
|
+ // fill follows matrix
|
|
|
+ for(p = Follows.begin(); p != Follows.end(); p++){
|
|
|
+ follows_matrix[p->first * len + p->second ] = 1;
|
|
|
+ }
|
|
|
+ fw_transitive_closure(follows_matrix);
|
|
|
+
|
|
|
+ } // end create_matrices()
|
|
|
+
|
|
|
+ void sort_events(vector<int> &L){
|
|
|
+ // sorts vector of events by FOLLOWS
|
|
|
+ // Selection Sort, Levitin p.99 (OK for small lists)
|
|
|
+ // since FOLLOWS is partial order, the sort is topological
|
|
|
+ // although selection sort is not stable
|
|
|
+ if(L.size() < 2) return;
|
|
|
+ int min, temp;
|
|
|
+
|
|
|
+ for(int i = 0; i < L.size() - 1; i++){
|
|
|
+ min = i;
|
|
|
+ for(int j = i + 1; j < L.size(); j++){
|
|
|
+ if(follows_matrix[L[min] * len + L[j]]){
|
|
|
+ min = j;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ temp = L[i];
|
|
|
+ L[i] = L[min];
|
|
|
+ L[min] = temp;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void sort_and_check_coordinated_events(vector<int> &L){
|
|
|
+ // for synchronous COORDINATE
|
|
|
+ // sorts vector of events by FOLLOWS
|
|
|
+ // then checks for total ordering
|
|
|
+ if(L.size() < 2) return;
|
|
|
+ sort_events(L);
|
|
|
+
|
|
|
+ // check total ordering
|
|
|
+ for(int i = 0; i < L.size() - 1; i++){
|
|
|
+ if(!follows_matrix[L[i + 1] * len + L[i]]) throw failed;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void make_equality_complete(int a, int b){
|
|
|
+ // add to Equals, but earlier position in Stack is more equal :-)
|
|
|
+ // copies all Follows and Inside from b to a
|
|
|
+ // and do the same for all inner events
|
|
|
+ if(a == b) return;
|
|
|
+ if(Stack[a]->name != Stack[b]->name) throw failed;
|
|
|
+ if(Stack[a]->type == Composite_event_instance_node &&
|
|
|
+ Stack[b]->type == Composite_event_instance_node &&
|
|
|
+ ( ((Composite_event_instance *)Stack[a])->index !=
|
|
|
+ ((Composite_event_instance *)Stack[b])->index ) )throw failed;
|
|
|
+
|
|
|
+ // earlier position in Stack is more equal :-)
|
|
|
+ if(a > b) {int t = a; a = b; b = t;}
|
|
|
+ Equals.insert(pair<int, int>(a, b));
|
|
|
+ // copy all Follows and Inside from b to a
|
|
|
+ multimap<int, int>:: iterator p;
|
|
|
+
|
|
|
+ for(p = Follows.begin(); p != Follows.end(); p++) {
|
|
|
+ if(p->second == b)
|
|
|
+ Follows.insert(pair<int, int>(p->first, a));
|
|
|
+ if(p->first == b)
|
|
|
+ Follows.insert(pair<int, int>(a, p->second));
|
|
|
+ }
|
|
|
+
|
|
|
+ for(p = Inside.begin(); p != Inside.end(); p++) {
|
|
|
+ if(p->first == b)
|
|
|
+ Inside.insert(pair<int, int>(a, p->second));
|
|
|
+ }
|
|
|
+
|
|
|
+ if(Stack[a]->type == Atom) return;
|
|
|
+
|
|
|
+ // if composite event, do the same for all inner events
|
|
|
+ vector<int> a_list, b_list;
|
|
|
+
|
|
|
+ p = Inside.begin();
|
|
|
+ while(p != Inside.end()) {
|
|
|
+ if(p->second == a) a_list.push_back(p->first);
|
|
|
+ if(p->second == b) b_list.push_back(p->first);
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ if(a_list.size() != b_list.size()) throw failed;
|
|
|
+ sort_events(a_list);
|
|
|
+ sort_events(b_list);
|
|
|
+ for(int i = 0; i < a_list.size() && i < b_list.size(); i++){
|
|
|
+ make_equality_complete(a_list[i], b_list[i]);
|
|
|
+ }
|
|
|
+ }// end make_equality_complete()
|
|
|
+
|
|
|
+ void print_matrix(char * m){
|
|
|
+ cout<<" size: "<<len<< " * "<<len<<endl;
|
|
|
+ cout<< " \t";
|
|
|
+ for(int k = 0; k < len; k++){
|
|
|
+ cout<<k<<" \t";
|
|
|
+ }
|
|
|
+ for(int i= 0; i < len; i++){
|
|
|
+ cout<<"\n"<<i<<": \t";
|
|
|
+ for(int j = 0; j <len; j++){
|
|
|
+ cout<<(int)m[i * len + j]<<" \t";
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ void print_matrices(){
|
|
|
+ cout<<"\n\neq_matrix ";
|
|
|
+ print_matrix(eq_matrix);
|
|
|
+ cout<<"\n\nin_matrix ";
|
|
|
+ print_matrix(in_matrix);
|
|
|
+ cout<<"\n\nfollows_matrix ";
|
|
|
+ print_matrix(follows_matrix);
|
|
|
+ }
|
|
|
+
|
|
|
+ // traverse() is defined in the generated subclasses
|
|
|
+
|
|
|
+}; // end Coordinate class
|
|
|
+
|
|
|
+//========== auxiliary subroutines and declarations =========================
|
|
|
+
|
|
|
+inline void add_relations_for_leader(){
|
|
|
+// add relations for the event which will be in a moment pushed on the top of Stack
|
|
|
+// called from Atomic_producer or Composite_secondary_producer
|
|
|
+// when they add to the trace
|
|
|
+
|
|
|
+ int myindex = Stack.size(); // index of this event in the segment,
|
|
|
+ // before the event is actually pushed on the stack
|
|
|
+
|
|
|
+ // always inside the master composite of the segment
|
|
|
+ // will be further adjusted in Composite_secondary_producer traverse()
|
|
|
+ Inside.insert(pair<int, int>(myindex, 0));
|
|
|
+
|
|
|
+ // add PRECEDES according to the position in AND_node_producer_container where it belongs
|
|
|
+ int last = predecessor.back(); // value stored on the top of stack
|
|
|
+ if(last >= 0) { // if predecessor is defined
|
|
|
+ Follows.insert(pair<int, int>(myindex, last) );
|
|
|
+ }
|
|
|
+ else{// happens seldom, only inside Set, or at the beginning of Composite
|
|
|
+ // if heads have this node, do nothing, it will be taken care in Set,
|
|
|
+ // otherwise, if tails have this node, add it to Follows
|
|
|
+ if( !find_in_heads(myindex)) find_and_copy_tails(myindex, Follows);
|
|
|
+ }
|
|
|
+ predecessor.back() = myindex; // place this event as a previous
|
|
|
+}
|
|
|
+
|
|
|
+//---------------------------------------------------------------------------
|
|
|
+inline void copy_from_to(int anchor, pair_list &from_list, pair_list &to_list){
|
|
|
+ // called from SET_node_producer_container.traverse()
|
|
|
+ multimap<int, int>:: iterator q = from_list.find(anchor);
|
|
|
+ if(q != from_list.end()){
|
|
|
+ do {
|
|
|
+ to_list.insert(pair<int, int>(anchor, q->second) );
|
|
|
+ q++;
|
|
|
+ } while ( q != from_list.upper_bound(anchor));
|
|
|
+ }
|
|
|
+}
|
|
|
+//----------------------------------------------------------------------------
|
|
|
+inline void copy_and_adjust_from_to(int anchor, int adjusted_node,
|
|
|
+ pair_list &from_list, pair_list &to_list){
|
|
|
+ // called from SET_node_producer_container.traverse()
|
|
|
+
|
|
|
+ multimap<int, int>:: iterator p = from_list.find(anchor);
|
|
|
+ multimap<int, int>:: iterator q = from_list.upper_bound(anchor);
|
|
|
+ if(p != from_list.end()) {
|
|
|
+ set<int> temp;
|
|
|
+ // collect all predecessors of anchor in from_list
|
|
|
+ do {
|
|
|
+ temp.insert( p->second);
|
|
|
+ p++;
|
|
|
+ } while ( p != q );
|
|
|
+ // put them into to_list for adjusted_node
|
|
|
+ for(set<int>:: iterator tt = temp.begin(); tt != temp.end(); tt++){
|
|
|
+ to_list.insert(pair<int, int>(adjusted_node, *tt) );
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+//-----------------------------------------------------------------------------
|
|
|
+void find_and_copy_heads(int branch_start, int my_index){
|
|
|
+ // called from SET_node_producer_container.traverse()
|
|
|
+ // find the first parent Set that contains branch_start
|
|
|
+ // and copy all branch_start -> N to heads[my_index]
|
|
|
+ for(int i = 0; i < my_index; i++){
|
|
|
+ multimap<int, int>:: iterator p = heads[i].find(branch_start);
|
|
|
+ multimap<int, int>:: iterator q = heads[i].upper_bound(branch_start);
|
|
|
+ if(p != heads[i].end()){ // found a parent Set
|
|
|
+ while(p != q) {
|
|
|
+ heads[my_index].insert(pair<int, int>(branch_start, p->second) );
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+}
|
|
|
+//-------------------------------------------------------------------------------
|
|
|
+void find_and_copy_tails(int node, pair_list &destination){
|
|
|
+ // called from SET_node_producer_container.traverse() and add_relations_for_leader()
|
|
|
+ // if node is found in any previous Set tails, copy it to destination
|
|
|
+ for(int i = 0; i < tails.size(); i++){
|
|
|
+ multimap<int, int>:: iterator p = tails[i].find(node);
|
|
|
+ multimap<int, int>:: iterator q = tails[i].upper_bound(node);
|
|
|
+ if(p != tails[i].end()){ // found a match
|
|
|
+ while(p != q) {
|
|
|
+ destination.insert(pair<int, int>(node, p->second) );
|
|
|
+ p++;
|
|
|
+ }
|
|
|
+ // now can discard it
|
|
|
+ tails[i].clear();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return;
|
|
|
+}
|
|
|
+//--------------------------------------------------------------------------------
|
|
|
+bool find_in_heads(int node){
|
|
|
+ // called from add_relations_for_leader()
|
|
|
+ for(int i = 0; i < heads.size(); i++){
|
|
|
+ multimap<int, int>:: iterator p = heads[i].find(node);
|
|
|
+ if(p != heads[i].end()) return true;// found a match
|
|
|
+ }
|
|
|
+ return false;
|
|
|
+}
|
|
|
+//=======================================================================================
|
|
|
+void show_statistics(){
|
|
|
+ /*
|
|
|
+ cout<<"\n*** Statistics **************************************\n";
|
|
|
+ cout<<"size of Event_producer = "<< sizeof(Event_producer)<<endl;
|
|
|
+ cout<<"size of OR_node_producer_container = "<< sizeof(OR_node_producer_container)<<endl;
|
|
|
+ cout<<"size of AND_node_producer_container = "<< sizeof(AND_node_producer_container)<<endl;
|
|
|
+ cout<<"size of SET_node_producer_container = "<< sizeof(SET_node_producer_container)<<endl;
|
|
|
+ cout<<"size of Composite_producer = "<< sizeof(Composite_producer)<<endl;
|
|
|
+ cout<<"size of Composite_secondary_producer = "<< sizeof(Composite_secondary_producer)<<endl;
|
|
|
+ cout<<"size of Coordinate = "<< sizeof(Coordinate)<<endl;
|
|
|
+ cout<<" *** These are stored on the trace\n";
|
|
|
+ cout<<"size of Atomic_producer = "<< sizeof(Atomic_producer)<<endl;
|
|
|
+ cout<<"size of Composite_event_instance = "<< sizeof(Composite_event_instance)<<endl;
|
|
|
+ */
|
|
|
+ cout<<"\ntotal number of stored events= "<< total_events;
|
|
|
+ cout<< "\nmemory of composite storage= "<< storage << " bytes/ "<<
|
|
|
+ (double)storage /1024<< "KB/ "<< (double)storage /1024/1024<< "MB (JEDEC binary definition)"<<endl;
|
|
|
+
|
|
|
+ //gen_end = clock();
|
|
|
+ dif = double(gen_end - gen_start) / CLOCKS_PER_SEC;
|
|
|
+ cout<<"Elapsed time "<< dif<<" sec, Speed: "<< total_events/dif <<" events/sec\n"<<endl;
|
|
|
+
|
|
|
+}
|
mikau2
10 years ago