Get rid of refs to order in graph

diff --git a/src/Collections/structs.c b/src/Collections/structs.c
index e88c09615d261aa8b5d6c0ff6231acf3b78bdecb..e528f64b8bfff81db9a70c289fc44331a0c4adfe 100644 (file)
--- a/src/Collections/structs.c
+++ b/src/Collections/structs.c
@@ -54,24 +54,24 @@ static inline bool table_entry_equals(TableEntry* key1, TableEntry* key2){
 }
 
 static inline unsigned int order_node_hash_Function(OrderNode* This){
-       return (uint) ((int64)This->order << 2) ^ This->id;
+       return (uint) This->id;
        
 }
 
 static inline bool order_node_equals(OrderNode* key1, OrderNode* key2){
-       return key1->id == key2->id && key1->order == key2->order;
+       return key1->id == key2->id;
 }
 
 static inline unsigned int order_edge_hash_Function(OrderEdge* This){
-       return (uint) (( (int64)This->sink << 2)^((int64)This->source << 6) ) ^ (int64)This->order;
+       return (uint) (( (uintptr_t)This->sink)^((uintptr_t)This->source << 4) );
 }
 
 static inline bool order_edge_equals(OrderEdge* key1, OrderEdge* key2){
-       return key1->sink == key2->sink && key1->source == key2->source && key1->order == key2->order;
+       return key1->sink == key2->sink && key1->source == key2->source;
 }
 
 static inline unsigned int node_info_hash_function(OrderNode * hash) {
-       return (uint)((int64)hash >> 4);
+       return (uint)((intptr_t)hash >> 4);
 }
 
 static inline bool node_info_equals(OrderNode * key1, OrderNode * key2) {

diff --git a/src/Encoders/orderedge.c b/src/Encoders/orderedge.c
index 6774cce6fb2770be1a060ba2eca98438063b87bf..d8466afabc7b000367cd312b31f2ae48210f26c9 100644 (file)
--- a/src/Encoders/orderedge.c
+++ b/src/Encoders/orderedge.c
@@ -1,14 +1,12 @@
-
 #include "orderedge.h"
 
-OrderEdge* allocOrderEdge(Boolean* order, OrderNode* source, OrderNode* sink){
+OrderEdge* allocOrderEdge(OrderNode* source, OrderNode* sink) {
        OrderEdge* This = (OrderEdge*) ourmalloc(sizeof(OrderEdge));
        This->source = source;
        This->sink = sink;
-       This->order = order;
        return This;
 }
 
-void deleteOrderEdge(OrderEdge* This){
+void deleteOrderEdge(OrderEdge* This) {
        ourfree(This);
 }

diff --git a/src/Encoders/orderedge.h b/src/Encoders/orderedge.h
index 64157289a7e0d9ecda2ccb4d3faafb17046ed274..52501af51a07ddbda54cb2ffb73dd5718c2be62e 100644 (file)
--- a/src/Encoders/orderedge.h
+++ b/src/Encoders/orderedge.h
@@ -11,13 +11,13 @@
 #include "mymemory.h"
 #include "ordernode.h"
 
-struct OrderEdge{
-       Boolean* order;
+struct OrderEdge {
        OrderNode* source;
        OrderNode* sink;
 };
 
-OrderEdge* allocOrderEdge(Boolean* order, OrderNode* begin, OrderNode* end);
+OrderEdge* allocOrderEdge(OrderNode* begin, OrderNode* end);
 void deleteOrderEdge(OrderEdge* This);
+
 #endif /* ORDEREDGE_H */
 

diff --git a/src/Encoders/orderencoder.c b/src/Encoders/orderencoder.c
index 5e1edf6e4d2234e5d265aad9bf6619c3a95ad19b..8ac2649f801dcfb39f6d955d6d65d2eee1be7a0f 100644 (file)
--- a/src/Encoders/orderencoder.c
+++ b/src/Encoders/orderencoder.c
@@ -1,4 +1,3 @@
-
 #include "orderencoder.h"
 #include "structs.h"
 #include "csolver.h"
@@ -8,7 +7,7 @@
 #include "ordernode.h"
 
 
-NodeInfo* allocNodeInfo(){
+NodeInfo* allocNodeInfo() {
        NodeInfo* This = (NodeInfo*) ourmalloc(sizeof(NodeInfo));
        This->finishTime = 0;
        This->status = NOTVISITED;
@@ -33,21 +32,26 @@ void deleteOrderEncoder(OrderEncoder* This){
        ourfree(This);
 }
 
-OrderEncoder* buildOrderGraphs(CSolver* This){
+OrderEncoder* buildOrderGraphs(CSolver* This) {
        uint size = getSizeVectorOrder(This->allOrders);
        OrderEncoder* oEncoder = allocOrderEncoder();
        for(uint i=0; i<size; i++){
-               OrderGraph* orderGraph = allocOrderGraph();
                Order* order = getVectorOrder(This->allOrders, i);
-               uint constrSize = getSizeVectorBoolean(&order->constraints);
-               for(uint j=0; j<constrSize; j++){
-                       addOrderConstraintToOrderGraph(orderGraph, getVectorBoolean(&order->constraints, j));
-               }
+               OrderGraph *orderGraph=buildOrderGraph(order);
                pushVectorOrderGraph(&oEncoder->graphs, orderGraph);
        }
        return oEncoder;
 }
 
+OrderGraph* buildOrderGraph(Order *order) {
+       OrderGraph* orderGraph = allocOrderGraph();
+       uint constrSize = getSizeVectorBoolean(&order->constraints);
+       for(uint j=0; j<constrSize; j++){
+               addOrderConstraintToOrderGraph(orderGraph, getVectorBoolean(&order->constraints, j));
+       }
+       return orderGraph;
+}
+
 void DFS(OrderGraph* graph, VectorOrderNode* finishNodes, HashTableNodeInfo* nodeToInfo){
        uint timer=0;
        HSIteratorOrderNode* iterator = iteratorOrderNode(graph->nodes);

diff --git a/src/Encoders/orderencoder.h b/src/Encoders/orderencoder.h
index 58ea3d8f2703fc44b7243cab3b0d7cd7ae6234f4..b9d9c77c027e3bc53a23219126c8514b446c3ff4 100644 (file)
--- a/src/Encoders/orderencoder.h
+++ b/src/Encoders/orderencoder.h
@@ -14,7 +14,7 @@
 enum NodeStatus {NOTVISITED, VISITED, FINISHED};
 typedef enum NodeStatus NodeStatus;
 
-struct NodeInfo{
+struct NodeInfo {
        NodeStatus status;
        uint finishTime;
 };
@@ -29,6 +29,7 @@ OrderEncoder* allocOrderEncoder();
 void deleteOrderEncoder(OrderEncoder* This);
 
 OrderEncoder* buildOrderGraphs(CSolver* This);
+OrderGraph* buildOrderGraph(Order *order);
 void computeStronglyConnectedComponentGraph(OrderGraph* graph);
 void orderAnalysis(CSolver* solver);
 void initializeNodeInfoSCC(OrderGraph* graph, HashTableNodeInfo* nodeToInfo);

diff --git a/src/Encoders/ordergraph.c b/src/Encoders/ordergraph.c
index 8de7eb0d2a9ea69bb8b0e6dd29c41370cde72e54..01e5f028a1f782f93f15333e3b3189456ef9482b 100644 (file)
--- a/src/Encoders/ordergraph.c
+++ b/src/Encoders/ordergraph.c
@@ -3,14 +3,14 @@
 #include "boolean.h"
 #include "orderedge.h"
 
-OrderGraph* allocOrderGraph(){
+OrderGraph* allocOrderGraph() {
        OrderGraph* This = (OrderGraph*) ourmalloc(sizeof(OrderGraph));
        This->nodes = allocHashSetOrderNode(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
        initDefVectorOrderNode(&This->scc);
        return This;
 }
 
-void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean* constr){
+void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean* constr) {
        switch(constr->polarity){
                case P_BOTHTRUEFALSE:
                case P_TRUE:{
@@ -32,8 +32,8 @@ void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean
        }
 }
 
-OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id, Order* order){
-       OrderNode* node = allocOrderNode(id, order);
+OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id) {
+       OrderNode* node = allocOrderNode(id);
        OrderNode* tmp = getHashSetOrderNode(graph->nodes, node);
        if( tmp!= NULL){
                deleteOrderNode(node);
@@ -45,9 +45,9 @@ OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id, Order* ord
 }
 
 OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, Boolean* order, OrderNode* begin, OrderNode* end){
-       OrderEdge* edge = allocOrderEdge(order, begin, end);
+       OrderEdge* edge = allocOrderEdge(begin, end);
        OrderEdge* tmp = getHashSetOrderEdge(graph->edges, edge);
-       if(tmp!= NULL){
+       if ( tmp!= NULL ) {
                deleteOrderEdge(edge);
                edge = tmp;
        } else {
@@ -56,10 +56,10 @@ OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, Boolean* order, OrderNo
        return edge;
 }
 
-void addOrderConstraintToOrderGraph(OrderGraph* graph, Boolean* constr){
+void addOrderConstraintToOrderGraph(OrderGraph* graph, Boolean* constr) {
        BooleanOrder* bOrder = (BooleanOrder*) constr;
-       OrderNode* from = getOrderNodeFromOrderGraph(graph, bOrder->first, bOrder->order);
-       OrderNode* to = getOrderNodeFromOrderGraph(graph, bOrder->second, bOrder->order);
+       OrderNode* from = getOrderNodeFromOrderGraph(graph, bOrder->first);
+       OrderNode* to = getOrderNodeFromOrderGraph(graph, bOrder->second);
        addOrderEdge(graph, from, to, constr);
 }
 
@@ -78,4 +78,4 @@ void deleteOrderGraph(OrderGraph* graph){
        }
        deleteIterOrderEdge(eiterator);
        ourfree(graph);
-}
\ No newline at end of file
+}

diff --git a/src/Encoders/ordergraph.h b/src/Encoders/ordergraph.h
index 3427b7a97999ab9719574502902a3931e90f073d..145d751288b0b60928c7cf095ef4703c49f929a0 100644 (file)
--- a/src/Encoders/ordergraph.h
+++ b/src/Encoders/ordergraph.h
@@ -19,7 +19,7 @@ struct OrderGraph{
 
 OrderGraph* allocOrderGraph();
 void addOrderConstraintToOrderGraph(OrderGraph* graph, Boolean* constr);
-OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id, Order* order);
+OrderNode* getOrderNodeFromOrderGraph(OrderGraph* graph, uint64_t id);
 OrderEdge* getOrderEdgeFromOrderGraph(OrderGraph* graph, Boolean* order, OrderNode* begin, OrderNode* end);
 void addOrderEdge(OrderGraph* graph, OrderNode* node1, OrderNode* node2, Boolean* constr);
 void deleteOrderGraph(OrderGraph* graph);

diff --git a/src/Encoders/ordernode.c b/src/Encoders/ordernode.c
index d441a074673acc2a5e4f19c8bb2a1aabe4643eda..0093648829fda5d39665ad9de2e0438b1a96beef 100644 (file)
--- a/src/Encoders/ordernode.c
+++ b/src/Encoders/ordernode.c
@@ -1,10 +1,9 @@
 #include "ordernode.h"
 #include "orderedge.h"
 
-OrderNode* allocOrderNode(uint64_t id, Order* order){
+OrderNode* allocOrderNode(uint64_t id) {
        OrderNode* This = (OrderNode*) ourmalloc(sizeof(OrderNode));
        This->id = id;
-       This->order = order;
        This->inEdges = allocHashSetOrderEdge(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
        This->outEdges = allocHashSetOrderEdge(HT_INITIAL_CAPACITY, HT_DEFAULT_FACTOR);
        return This;
@@ -24,4 +23,4 @@ void deleteOrderNode(OrderNode* node){
        deleteHashSetOrderEdge(node->inEdges);
        deleteHashSetOrderEdge(node->outEdges);
        ourfree(node);
-}
\ No newline at end of file
+}

diff --git a/src/Encoders/ordernode.h b/src/Encoders/ordernode.h
index 9abecf3fc8e87f884e164f63714397ebe8f199e2..60a261da1fdc7baccc3a316f559bb22cd4d391ee 100644 (file)
--- a/src/Encoders/ordernode.h
+++ b/src/Encoders/ordernode.h
@@ -15,12 +15,11 @@
 #include "orderedge.h"
 struct OrderNode{
        uint64_t id;
-       Order* order;
        HashSetOrderEdge* inEdges;
        HashSetOrderEdge* outEdges;
 };
 
-OrderNode* allocOrderNode(uint64_t id, Order* order);
+OrderNode* allocOrderNode(uint64_t id);
 void addNewIncomingEdge(OrderNode* node, OrderEdge* edge);
 void addNewOutgoingEdge(OrderNode* node, OrderEdge* edge);
 void deleteOrderNode(OrderNode* node);