Fix some of the memory leaks

diff --git a/src/AST/order.c b/src/AST/order.c
index b943392f81daba49e02539c46a4e2823f505e08a..b1b52e3e82df9fc52b4e5099a5f646a041eecec3 100644 (file)
--- a/src/AST/order.c
+++ b/src/AST/order.c
@@ -29,7 +29,9 @@ void setOrderEncodingType(Order* order, OrderEncodingType type){
 void deleteOrder(Order* order){
        deleteVectorArrayBoolean(& order->constraints);
        deleteOrderEncoding(& order->order);
-       if(order->boolsToConstraints!= NULL)
+       if(order->boolsToConstraints!= NULL) {
+               resetAndDeleteHashTableBoolConst(order->boolsToConstraints);
                deleteHashTableBoolConst(order->boolsToConstraints);
+       }
        ourfree(order);
 }

diff --git a/src/Backend/constraint.c b/src/Backend/constraint.c
index ef607099abf8c995c02424242c2d7390b17b658c..46c8c5effcd43c8ff1adc87b5fe294bd7dac69ce 100644 (file)
--- a/src/Backend/constraint.c
+++ b/src/Backend/constraint.c
@@ -63,6 +63,7 @@ Constraint * allocVarConstraint(CType t, uint v) {
 void deleteConstraint(Constraint *This) {
        if (This->operands!=NULL)
                ourfree(This->operands);
+       ourfree(This);
 }
 
 void dumpConstraint(Constraint * This, IncrementalSolver *solver) {
@@ -97,7 +98,7 @@ void internalfreeConstraint(Constraint * This) {
                ASSERT(0);
        default:
                This->type=BOGUS;
-               ourfree(This);
+               deleteConstraint(This);
        }
 }
 

diff --git a/src/Backend/orderpair.c b/src/Backend/orderpair.c
index 2290b36dd6bd47fb34b828c0351ff6d1cca141fd..109fc536afe87ad9d161bd9818b8db90ffdb0770 100644 (file)
--- a/src/Backend/orderpair.c
+++ b/src/Backend/orderpair.c
@@ -1,12 +1,14 @@
 #include "orderpair.h"
 
 
-OrderPair* allocOrderPair(uint64_t first, uint64_t second){
+OrderPair* allocOrderPair(uint64_t first, uint64_t second, Constraint * constraint){
        OrderPair* pair = (OrderPair*) ourmalloc(sizeof(OrderPair));
        pair->first = first;
        pair->second = second;
+       pair->constraint = constraint;
        return pair;
 }
+
 void deleteOrderPair(OrderPair* pair){
        ourfree(pair);
-}
\ No newline at end of file
+}

diff --git a/src/Backend/orderpair.h b/src/Backend/orderpair.h
index 21bddd794dcbc6906af73f58ec3aba2d06786fc2..bdffb15442a7f5e529cb9642a5e5089624e4d5c7 100644 (file)
--- a/src/Backend/orderpair.h
+++ b/src/Backend/orderpair.h
@@ -14,9 +14,10 @@
 struct OrderPair{
        uint64_t first;
        uint64_t second;
+       Constraint *constraint;
 }; 
 
-OrderPair* allocOrderPair(uint64_t first, uint64_t second);
+OrderPair* allocOrderPair(uint64_t first, uint64_t second, Constraint * constraint);
 void deleteOrderPair(OrderPair* pair);
 
 #endif /* ORDERPAIR_H */

diff --git a/src/Backend/satencoder.c b/src/Backend/satencoder.c
index 3c2d3e1eb6fae92802393a8596596262ea6a0de9..fa1d5133f5126001fe83fdb864800724123c4fb7 100644 (file)
--- a/src/Backend/satencoder.c
+++ b/src/Backend/satencoder.c
@@ -72,6 +72,7 @@ void addConstraintToSATSolver(Constraint *c, IncrementalSolver* satSolver) {
                        continue;
                ASSERT(simp->type!=FALSE);
                dumpConstraint(simp, satSolver);
+               freerecConstraint(simp);
        }
        deleteVectorConstraint(simplified);
 }
@@ -181,10 +182,10 @@ Constraint * getPairConstraint(SATEncoder *This, HashTableBoolConst * table, Ord
        Constraint * constraint;
        if (!containsBoolConst(table, pair)) {
                constraint = getNewVarSATEncoder(This);
-               OrderPair * paircopy = allocOrderPair(pair->first, pair->second);
-               putBoolConst(table, paircopy, constraint);
+               OrderPair * paircopy = allocOrderPair(pair->first, pair->second, constraint);
+               putBoolConst(table, paircopy, paircopy);
        } else
-               constraint = getBoolConst(table, pair);
+               constraint = getBoolConst(table, pair)->constraint;
        if (negate)
                return negateConstraint(constraint);
        else
@@ -199,9 +200,8 @@ Constraint * encodeTotalOrderSATEncoder(SATEncoder *This, BooleanOrder * boolOrd
                return createAllTotalOrderConstraintsSATEncoder(This, boolOrder->order);
        }
        HashTableBoolConst* boolToConsts = boolOrder->order->boolsToConstraints;
-       OrderPair pair={boolOrder->first, boolOrder->second};
-       Constraint* constraint = getPairConstraint(This, boolToConsts, & pair);
-       ASSERT(constraint != NULL);
+       OrderPair pair={boolOrder->first, boolOrder->second, NULL};
+       Constraint *constraint = getPairConstraint(This, boolToConsts, & pair);
        return constraint;
 }
 
@@ -234,8 +234,7 @@ Constraint* createAllTotalOrderConstraintsSATEncoder(SATEncoder* This, Order* or
 
 Constraint* getOrderConstraint(HashTableBoolConst *table, OrderPair *pair){
        ASSERT(pair->first!= pair->second);
-       Constraint* constraint= getBoolConst(table, pair);
-       ASSERT(constraint!= NULL);
+       Constraint* constraint= getBoolConst(table, pair)->constraint;
        if(pair->first > pair->second)
                return constraint;
        else

diff --git a/src/Collections/hashtable.h b/src/Collections/hashtable.h
index b7c78d94bb6142b60c180bf7c65a8532a59c7b8d..dbf61f91110a4ade864d02c89cf4c902cdf0460e 100644 (file)
--- a/src/Collections/hashtable.h
+++ b/src/Collections/hashtable.h
@@ -62,9 +62,10 @@
        bool contains ## Name(const HashTable ## Name * tab, _Key key);       \
        void resize ## Name(HashTable ## Name * tab, unsigned int newsize);   \
        double getLoadFactor ## Name(HashTable ## Name * tab);                \
-       unsigned int getCapacity ## Name(HashTable ## Name * tab);
+       unsigned int getCapacity ## Name(HashTable ## Name * tab);                                              \
+       void resetAndDeleteHashTable ## Name(HashTable ## Name * tab);
 
-#define HashTableImpl(Name, _Key, _Val, hash_function, equals) \
+#define HashTableImpl(Name, _Key, _Val, hash_function, equals, freefunction) \
        HashTable ## Name * allocHashTable ## Name(unsigned int initialcapacity, double factor) { \
                HashTable ## Name * tab = (HashTable ## Name *)ourmalloc(sizeof(HashTable ## Name)); \
                tab->table = (struct hashlistnode ## Name *)ourcalloc(initialcapacity, sizeof(struct hashlistnode ## Name)); \
@@ -77,14 +78,34 @@
                tab->size = 0;                                                      \
                return tab;                                                         \
        }                                                                     \
-                                                                        \
-       void deleteHashTable ## Name(HashTable ## Name * tab) {                 \
+                                                                                                                                                                                                                                                                                               \
+       void deleteHashTable ## Name(HashTable ## Name * tab) {                                                         \
                ourfree(tab->table);                                                \
                if (tab->zero)                                                      \
                        ourfree(tab->zero);                                               \
                ourfree(tab);                                                       \
        }                                                                     \
-                                                                        \
+                                                                                                                                                                                                                                                                                               \
+       void resetAndDeleteHashTable ## Name(HashTable ## Name * tab) {                         \
+               for(uint i=0;i<tab->capacity;i++) {                                                                                                                                     \
+                       struct hashlistnode ## Name * bin=&tab->table[i];                                                                       \
+                       if (bin->key!=NULL) {                                                                                                                                                                                   \
+                               bin->key=NULL;                                                                                                                                                                                                  \
+                               if (bin->val!=NULL) {                                                                                                                                                                           \
+                                       freefunction(bin->val);                                                                                                                                                         \
+                                       bin->val=NULL;                                                                                                                                                                                          \
+                               }                                                                                                                                                                                                                                                               \
+                       }                                                                                                                                                                                                                                                                       \
+               }                                                                                                                                                                                                                                                                               \
+               if (tab->zero)  {                                                                                                                                                                                                               \
+                       if (tab->zero->val != NULL)                                                                                                                                                             \
+                               freefunction(tab->zero->val);                                                                                                                                           \
+                       ourfree(tab->zero);                                                                                                                                                                                             \
+                       tab->zero=NULL;                                                                                                                                                                                                         \
+               }                                                                                                                                                                                                                                                                               \
+               tab->size=0;                                                                                                                                                                                                                            \
+       }                                                                                                                                                                                                                                                                                       \
+                                                                                                                                                                                                                                                                                               \
        void reset ## Name(HashTable ## Name * tab) {                         \
                memset(tab->table, 0, tab->capacity * sizeof(struct hashlistnode ## Name)); \
                if (tab->zero) {                                                    \

diff --git a/src/Collections/structs.c b/src/Collections/structs.c
index f5f8f68e323aac242344fdc216eb68995e27a00d..045323143c9402ba9533a42b9903efab38e8b60f 100644 (file)
--- a/src/Collections/structs.c
+++ b/src/Collections/structs.c
@@ -30,4 +30,4 @@ static inline unsigned int order_pair_equals(OrderPair* key1, OrderPair* key2){
        return key1->first== key2->first && key1->second == key2->second;
 }
 
-HashTableImpl(BoolConst, OrderPair *, Constraint *, order_pair_hash_Function, order_pair_equals);
+HashTableImpl(BoolConst, OrderPair *, OrderPair *, order_pair_hash_Function, order_pair_equals, ourfree);

diff --git a/src/Collections/structs.h b/src/Collections/structs.h
index 6b274cec11d7ccdbed208480fc45d10753c9fe5d..8700459863d84dd8aa8256672045fd8a50a2faf4 100644 (file)
--- a/src/Collections/structs.h
+++ b/src/Collections/structs.h
@@ -23,7 +23,7 @@ VectorDef(ASTNode, ASTNode *);
 VectorDef(Int, uint64_t);
 
 HashTableDef(Void, void *, void *);
-HashTableDef(BoolConst, OrderPair *, Constraint *);
+HashTableDef(BoolConst, OrderPair *, OrderPair *);
 
 HashSetDef(Void, void *);
 

diff --git a/src/csolver.c b/src/csolver.c
index e3850d15a8782cf90ae812dccddf411e7af49245..1d31e42558a70bcf1ca3af8be314d0d3ec342762 100644 (file)
--- a/src/csolver.c
+++ b/src/csolver.c
@@ -174,7 +174,6 @@ Boolean * orderConstraint(CSolver *solver, Order * order, uint64_t first, uint64
 void startEncoding(CSolver* solver){
        naiveEncodingDecision(solver);
        SATEncoder* satEncoder = allocSATEncoder();
-       satEncoder->satSolver =allocIncrementalSolver();
        encodeAllSATEncoder(solver, satEncoder);
        finishedClauses(satEncoder->satSolver);
        int result= solve(satEncoder->satSolver);
@@ -182,4 +181,4 @@ void startEncoding(CSolver* solver){
        //For now, let's just delete it, and in future for doing queries 
        //we may need it.
        deleteSATEncoder(satEncoder);
-}
\ No newline at end of file
+}