}
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) {
-
#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);
}
#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 */
-
#include "orderencoder.h"
#include "structs.h"
#include "csolver.h"
#include "ordernode.h"
-NodeInfo* allocNodeInfo(){
+NodeInfo* allocNodeInfo() {
NodeInfo* This = (NodeInfo*) ourmalloc(sizeof(NodeInfo));
This->finishTime = 0;
This->status = NOTVISITED;
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);
enum NodeStatus {NOTVISITED, VISITED, FINISHED};
typedef enum NodeStatus NodeStatus;
-struct NodeInfo{
+struct NodeInfo {
NodeStatus status;
uint finishTime;
};
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);
#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:{
}
}
-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);
}
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 {
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);
}
}
deleteIterOrderEdge(eiterator);
ourfree(graph);
-}
\ No newline at end of file
+}
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);
#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;
deleteHashSetOrderEdge(node->inEdges);
deleteHashSetOrderEdge(node->outEdges);
ourfree(node);
-}
\ No newline at end of file
+}
#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);