Finish clone
authorbdemsky <bdemsky@uci.edu>
Sun, 27 Aug 2017 07:59:13 +0000 (00:59 -0700)
committerbdemsky <bdemsky@uci.edu>
Sun, 27 Aug 2017 07:59:13 +0000 (00:59 -0700)
19 files changed:
src/AST/boolean.cc
src/AST/boolean.h
src/AST/element.cc
src/AST/element.h
src/AST/function.cc
src/AST/function.h
src/AST/mutableset.cc
src/AST/mutableset.h
src/AST/order.cc
src/AST/order.h
src/AST/predicate.cc
src/AST/predicate.h
src/AST/set.cc
src/AST/set.h
src/AST/table.cc
src/AST/table.h
src/Collections/structs.h
src/csolver.cc
src/csolver.h

index 1eb2f00..77709b6 100644 (file)
@@ -43,36 +43,36 @@ BooleanLogic::BooleanLogic(CSolver *solver, LogicOp _op, Boolean **array, uint a
        inputs(array, asize) {
 }
 
-Boolean * BooleanVar::clone(CSolver *solver, CloneMap *map) {
-       if (map->boolean.contains(this)) {
-               return map->boolean.get(this);
-       } else {
-               Boolean * bvar=solver->getBooleanVar(type);
-               map->boolean.put(this, bvar);
-               return bvar;
-       }
+Boolean *BooleanVar::clone(CSolver *solver, CloneMap *map) {
+       Boolean *b = (Boolean *) map->get(this);
+       if (b != NULL)
+               return b;
+       Boolean *bvar = solver->getBooleanVar(type);
+       map->put(this, bvar);
+       return bvar;
+
 }
 
-Boolean * BooleanOrder::clone(CSolver * solver, CloneMap *map) {
-       Order * ordercopy=order->clone(map);
+Boolean *BooleanOrder::clone(CSolver *solver, CloneMap *map) {
+       Order *ordercopy = order->clone(solver, map);
        return solver->orderConstraint(ordercopy, first, second);
 }
 
-Boolean * BooleanLogic::clone(CSolver * solver, CloneMap *map) {
-       Boolean * array[inputs.getSize()];
-       for(uint i=0;i<inputs.getSize();i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Boolean *BooleanLogic::clone(CSolver *solver, CloneMap *map) {
+       Boolean *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);
        }
        return solver->applyLogicalOperation(op, array, inputs.getSize());
 }
 
-Boolean * BooleanPredicate::clone(CSolver * solver, CloneMap *map) {
-       Element * array[inputs.getSize()];
-       for(uint i=0;i<inputs.getSize();i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Boolean *BooleanPredicate::clone(CSolver *solver, CloneMap *map) {
+       Element *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);
        }
-       Predicate * pred=predicate->clone(map);
-       Boolean * defstatus=(undefStatus != NULL) ? undefStatus->clone(solver, map) : NULL;
-       
+       Predicate *pred = predicate->clone(solver, map);
+       Boolean *defstatus = (undefStatus != NULL) ? undefStatus->clone(solver, map) : NULL;
+
        return solver->applyPredicateTable(pred, array, inputs.getSize(), defstatus);
 }
index 2341fcf..bc247c2 100644 (file)
@@ -21,7 +21,7 @@ class Boolean : public ASTNode {
 public:
        Boolean(ASTNodeType _type);
        virtual ~Boolean() {}
-       virtual Boolean * clone(CSolver * solver, CloneMap *map);
+       virtual Boolean *clone(CSolver *solver, CloneMap *map);
        Polarity polarity;
        BooleanValue boolVal;
        Vector<Boolean *> parents;
@@ -31,8 +31,8 @@ public:
 class BooleanVar : public Boolean {
 public:
        BooleanVar(VarType t);
-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+
        VarType vtype;
        Edge var;
        MEMALLOC;
@@ -41,8 +41,8 @@ public:
 class BooleanOrder : public Boolean {
 public:
        BooleanOrder(Order *_order, uint64_t _first, uint64_t _second);
-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+
        Order *order;
        uint64_t first;
        uint64_t second;
@@ -52,8 +52,8 @@ public:
 class BooleanPredicate : public Boolean {
 public:
        BooleanPredicate(Predicate *_predicate, Element **_inputs, uint _numInputs, Boolean *_undefinedStatus);
-       Boolean * clone(CSolver * solver, CloneMap *map);
-       
+       Boolean *clone(CSolver *solver, CloneMap *map);
+
        Predicate *predicate;
        FunctionEncoding encoding;
        Array<Element *> inputs;
@@ -65,7 +65,7 @@ public:
 class BooleanLogic : public Boolean {
 public:
        BooleanLogic(CSolver *solver, LogicOp _op, Boolean **array, uint asize);
-       Boolean * clone(CSolver * solver, CloneMap *map);
+       Boolean *clone(CSolver *solver, CloneMap *map);
 
        LogicOp op;
        Array<Boolean *> inputs;
index d6832f9..20cddf3 100644 (file)
@@ -26,7 +26,7 @@ ElementFunction::ElementFunction(Function *_function, Element **array, uint numA
                GETELEMENTPARENTS(array[i])->push(this);
 }
 
-ElementConst::ElementConst(uint64_t _value, VarType _type, Set * _set) :
+ElementConst::ElementConst(uint64_t _value, VarType _type, Set *_set) :
        Element(ELEMCONST),
        set(_set),
        value(_value) {
@@ -56,24 +56,24 @@ Set *getElementSet(Element *This) {
        return NULL;
 }
 
-Element * ElementConst::clone(CSolver *solver, CloneMap * map) {
+Element *ElementConst::clone(CSolver *solver, CloneMap *map) {
        return solver->getElementConst(type, value);
 }
-               
-Element * ElementSet::clone(CSolver *solver, CloneMap * map) {
-       Element * e = map->element.get(this);
+
+Element *ElementSet::clone(CSolver *solver, CloneMap *map) {
+       Element *e = (Element *) map->get(this);
        if (e != NULL)
                return e;
        e = solver->getElementVar(set->clone(solver, map));
-       map->element.put(e, e);
+       map->put(e, e);
        return e;
 }
 
-Element * ElementFunction::clone(CSolver *solver, CloneMap * map) {
-       Element * array[inputs.getSize()];
-       for(uint i=0; i<inputs.getSize(); i++) {
-               array[i]=inputs.get(i)->clone(solver, map);
+Element *ElementFunction::clone(CSolver *solver, CloneMap *map) {
+       Element *array[inputs.getSize()];
+       for (uint i = 0; i < inputs.getSize(); i++) {
+               array[i] = inputs.get(i)->clone(solver, map);
        }
-       Element * e = solver->applyFunction(function->clone(solver, map), array, inputs.getSize(), overflowstatus->clone(solver, map));
+       Element *e = solver->applyFunction(function->clone(solver, map), array, inputs.getSize(), overflowstatus->clone(solver, map));
        return e;
 }
index a230055..267f133 100644 (file)
@@ -16,7 +16,7 @@ public:
        virtual ~Element() {}
        Vector<ASTNode *> parents;
        ElementEncoding encoding;
-       virtual Element * clone(CSolver * solver, CloneMap * map);
+       virtual Element *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
@@ -25,7 +25,7 @@ public:
        ElementConst(uint64_t value, VarType type, Set *_set);
        Set *set;
        uint64_t value;
-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
@@ -33,7 +33,7 @@ class ElementSet : public Element {
 public:
        ElementSet(Set *s);
        Set *set;
-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
@@ -44,7 +44,7 @@ public:
        Array<Element *> inputs;
        Boolean *overflowstatus;
        FunctionEncoding functionencoding;
-       Element * clone(CSolver * solver, CloneMap * map);
+       Element *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
index 50f8715..1d910e4 100644 (file)
@@ -1,7 +1,7 @@
 #include "function.h"
 #include "table.h"
 #include "set.h"
-
+#include "csolver.h"
 
 FunctionOperator::FunctionOperator(ArithOp _op, Set **domain, uint numDomain, Set *_range, OverFlowBehavior _overflowbehavior) : Function(OPERATORFUNC), op(_op), domains(domain, numDomain), range(_range), overflowbehavior(_overflowbehavior) {
 }
@@ -27,3 +27,28 @@ bool FunctionOperator::isInRangeFunction(uint64_t val) {
        return range->exists(val);
 }
 
+Function *FunctionOperator::clone(CSolver *solver, CloneMap *map) {
+       Function *f = (Function *) map->get(this);
+       if (f != NULL)
+               return f;
+
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++) {
+               array[i] = domains.get(i)->clone(solver, map);
+       }
+       Set *rcopy = range->clone(solver, map);
+       f = solver->createFunctionOperator(op, array, domains.getSize(), rcopy, overflowbehavior);
+       map->put(this, f);
+       return f;
+}
+
+Function *FunctionTable::clone(CSolver *solver, CloneMap *map) {
+       Function *f = (Function *) map->get(this);
+       if (f != NULL)
+               return f;
+
+       Table *tcopy = table->clone(solver, map);
+       f = solver->completeTable(tcopy, undefBehavior);
+       map->put(this, f);
+       return f;
+}
index e00afd3..6b0cd13 100644 (file)
@@ -12,7 +12,7 @@ public:
        Function(FunctionType _type) : type(_type) {}
        FunctionType type;
        virtual ~Function() {}
-       virtual Function * clone(CSolver * solver, CloneMap *map);
+       virtual Function *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
@@ -25,7 +25,7 @@ public:
        FunctionOperator(ArithOp op, Set **domain, uint numDomain, Set *range, OverFlowBehavior overflowbehavior);
        uint64_t applyFunctionOperator(uint numVals, uint64_t *values);
        bool isInRangeFunction(uint64_t val);
-       Function * clone(CSolver * solver, CloneMap *map);
+       Function *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
@@ -34,7 +34,7 @@ public:
        Table *table;
        UndefinedBehavior undefBehavior;
        FunctionTable (Table *table, UndefinedBehavior behavior);
-       Function * clone(CSolver * solver, CloneMap *map);
+       Function *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 
index d029f82..6b3f953 100644 (file)
@@ -8,14 +8,14 @@ void MutableSet::addElementMSet(uint64_t element) {
        members->push(element);
 }
 
-Set * MutableSet::clone(CSolver * solver, CloneMap *map) {
-       Set * s=map->set.get(this);
+Set *MutableSet::clone(CSolver *solver, CloneMap *map) {
+       Set *s = (Set *) map->get(this);
        if (s != NULL)
                return s;
-       s=solver->createMutableSet(type);
-       for(uint i=0; i<members->getSize();i++) {
+       s = solver->createMutableSet(type);
+       for (uint i = 0; i < members->getSize(); i++) {
                solver->addItem((MutableSet *) s, members->get(i));
        }
-       map->set.put(this, s);
+       map->put(this, s);
        return s;
 }
index 36ce011..080db14 100644 (file)
@@ -6,7 +6,7 @@ class MutableSet : public Set {
 public:
        MutableSet(VarType t);
        void addElementMSet(uint64_t element);
-       Set * clone(CSolver * solver, CloneMap *map);
+       Set *clone(CSolver *solver, CloneMap *map);
        MEMALLOC;
 };
 #endif
index debd37c..c9b0a79 100644 (file)
@@ -3,6 +3,7 @@
 #include "set.h"
 #include "boolean.h"
 #include "ordergraph.h"
+#include "csolver.h"
 
 Order::Order(OrderType _type, Set *_set) :
        type(_type),
@@ -30,6 +31,15 @@ void Order::setOrderEncodingType(OrderEncodingType type) {
        order.type = type;
 }
 
+Order *Order::clone(CSolver *solver, CloneMap *map) {
+       Order *o = (Order *)map->get(this);
+       if (o != NULL)
+               return o;
+       o = solver->createOrder(type, set->clone(solver, map));
+       map->put(this, o);
+       return o;
+}
+
 Order::~Order() {
        if (orderPairTable != NULL) {
                orderPairTable->resetanddelete();
index b4abd07..e5f5983 100644 (file)
@@ -17,7 +17,7 @@ public:
        HashTableOrderPair *orderPairTable;
        HashSetOrderElement *elementTable;
        OrderGraph *graph;
-       Order * clone(CloneMap *map);
+       Order *clone(CSolver *solver, CloneMap *map);
        Vector<BooleanOrder *> constraints;
        OrderEncoding order;
        void initializeOrderHashTable();
index 0e04668..99cd311 100644 (file)
@@ -2,6 +2,7 @@
 #include "boolean.h"
 #include "set.h"
 #include "table.h"
+#include "csolver.h"
 
 PredicateOperator::PredicateOperator(CompOp _op, Set **domain, uint numDomain) : Predicate(OPERATORPRED), op(_op), domains(domain, numDomain) {
 }
@@ -25,3 +26,27 @@ bool PredicateOperator::evalPredicateOperator(uint64_t *inputs) {
        ASSERT(0);
        return false;
 }
+
+Predicate *PredicateOperator::clone(CSolver *solver, CloneMap *map) {
+       Predicate *p = (Predicate *) map->get(this);
+       if (p != NULL)
+               return p;
+
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++)
+               array[i] = domains.get(i)->clone(solver, map);
+
+       p = solver->createPredicateOperator(op, array, domains.getSize());
+       map->put(this, p);
+       return p;
+}
+
+Predicate *PredicateTable::clone(CSolver *solver, CloneMap *map) {
+       Predicate *p = (Predicate *) map->get(this);
+       if (p != NULL)
+               return p;
+
+       p = solver->createPredicateTable(table->clone(solver, map), undefinedbehavior);
+       map->put(this, p);
+       return p;
+}
index c86c6c2..047ef13 100644 (file)
@@ -11,7 +11,7 @@ class Predicate {
 public:
        Predicate(PredicateType _type) : type(_type) {}
        virtual ~Predicate() {}
-       virtual Predicate * clone(CloneMap *map);
+       virtual Predicate *clone(CSolver *solver, CloneMap *map);
        PredicateType type;
        MEMALLOC;
 };
@@ -20,7 +20,7 @@ class PredicateOperator : public Predicate {
 public:
        PredicateOperator(CompOp op, Set **domain, uint numDomain);
        bool evalPredicateOperator(uint64_t *inputs);
-       Predicate * clone(CloneMap *map);
+       Predicate *clone(CSolver *solver, CloneMap *map);
        CompOp op;
        Array<Set *> domains;
        MEMALLOC;
@@ -29,7 +29,7 @@ public:
 class PredicateTable : public Predicate {
 public:
        PredicateTable(Table *table, UndefinedBehavior undefBehavior);
-       Predicate * clone(CloneMap *map);
+       Predicate *clone(CSolver *solver, CloneMap *map);
        Table *table;
        UndefinedBehavior undefinedbehavior;
        MEMALLOC;
index d5b9c34..b0e1d8a 100644 (file)
@@ -46,15 +46,15 @@ Set::~Set() {
                delete members;
 }
 
-Set * Set::clone(CSolver * solver, CloneMap *map) {
-       Set * s=map->set.get(this);
+Set *Set::clone(CSolver *solver, CloneMap *map) {
+       Set *s = (Set *) map->get(this);
        if (s != NULL)
                return s;
        if (isRange) {
-               s=solver->createRangeSet(type, low, high);
+               s = solver->createRangeSet(type, low, high);
        } else {
-               s=solver->createSet(type, members->expose(), members->getSize());
+               s = solver->createSet(type, members->expose(), members->getSize());
        }
-       map->set.put(this, s);
+       map->put(this, s);
        return s;
 }
index 3ff404a..938027b 100644 (file)
@@ -21,8 +21,8 @@ public:
        bool exists(uint64_t element);
        uint getSize();
        uint64_t getElement(uint index);
-       virtual Set * clone(CSolver * solver, CloneMap *map);
-       
+       virtual Set *clone(CSolver *solver, CloneMap *map);
+
        VarType type;
        bool isRange;
        uint64_t low;//also used to count unique items
index d54aefb..c4e9594 100644 (file)
@@ -4,6 +4,7 @@
 #include "tableentry.h"
 #include "set.h"
 #include "mutableset.h"
+#include "csolver.h"
 
 Table::Table(Set **_domains, uint numDomain, Set *_range) :
        domains(_domains, numDomain),
@@ -28,6 +29,26 @@ TableEntry *Table::getTableEntry(uint64_t *inputs, uint inputSize) {
        return result;
 }
 
+Table *Table::clone(CSolver *solver, CloneMap *map) {
+       Table *t = (Table *) map->get(this);
+       if (t != NULL)
+               return t;
+       Set *array[domains.getSize()];
+       for (uint i = 0; i < domains.getSize(); i++) {
+               array[i] = domains.get(i)->clone(solver, map);
+       }
+       Set *rcopy = range != NULL ? range->clone(solver, map) : NULL;
+       t = solver->createTable(array, domains.getSize(), rcopy);
+       HSIteratorTableEntry *entryit = entries->iterator();
+       while (entryit->hasNext()) {
+               TableEntry *te = entryit->next();
+               solver->addTableEntry(t, &te->inputs[0], te->inputSize, te->output);
+       }
+       delete entryit;
+       map->put(this, t);
+       return t;
+}
+
 Table::~Table() {
        HSIteratorTableEntry *iterator = entries->iterator();
        while (iterator->hasNext()) {
index 28b13e4..346da47 100644 (file)
@@ -9,6 +9,7 @@ public:
        Table(Set **domains, uint numDomain, Set *range);
        void addNewTableEntry(uint64_t *inputs, uint inputSize, uint64_t result);
        TableEntry *getTableEntry(uint64_t *inputs, uint inputSize);
+       Table *clone(CSolver *solver, CloneMap *map);
        ~Table();
        Array<Set *> domains;
        Set *range;
index 73f5bf5..43efbc5 100644 (file)
@@ -24,17 +24,7 @@ typedef HashSet<OrderEdge *, uintptr_t, 4, order_edge_hash_function, order_edge_
 typedef HashSet<OrderElement *, uintptr_t, 4, order_element_hash_function, order_element_equals> HashSetOrderElement;
 typedef HashTable<OrderNode *, HashSetOrderNode *, uintptr_t, 4> HashTableNodeToNodeSet;
 typedef HashTable<OrderPair *, OrderPair *, uintptr_t, 4, order_pair_hash_function, order_pair_equals> HashTableOrderPair;
-typedef HashTable<Order *, Order *, uintptr_t, 4> OrderMap;
-typedef HashTable<Boolean *, Boolean *, uintptr_t, 4> BooleanMap;
-typedef HashTable<Element *, Element *, uintptr_t, 4> ElementMap;
-typedef HashTable<Set *, Set *, uintptr_t, 4> SetMap;
-
-typedef struct CloneMap {
-       OrderMap order;
-       BooleanMap boolean;
-       ElementMap element;
-       SetMap set;
-} CloneMap;
+typedef HashTable<void *, void *, uintptr_t, 4> CloneMap;
 
 typedef HSIterator<TableEntry *, uintptr_t, 4, table_entry_hash_function, table_entry_equals> HSIteratorTableEntry;
 typedef HSIterator<Boolean *, uintptr_t, 4> HSIteratorBoolean;
index dec85e0..221f562 100644 (file)
@@ -60,12 +60,12 @@ CSolver::~CSolver() {
        delete tuner;
 }
 
-CSolver * CSolver::clone() {
-       CSolver * copy=new CSolver();
+CSolver *CSolver::clone() {
+       CSolver *copy = new CSolver();
        CloneMap map;
-       HSIteratorBoolean * it=getConstraints();
-       while(it->hasNext()) {
-               Boolean *b=it->next();
+       HSIteratorBoolean *it = getConstraints();
+       while (it->hasNext()) {
+               Boolean *b = it->next();
                b->clone(copy, &map);
        }
        delete it;
@@ -108,7 +108,7 @@ Element *CSolver::getElementVar(Set *set) {
 
 Element *CSolver::getElementConst(VarType type, uint64_t value) {
        uint64_t array[] = {value};
-       Set * set = new Set(type, array, 1);
+       Set *set = new Set(type, array, 1);
        allSets.push(set);
        Element *element = new ElementConst(value, type, set);
        allElements.push(element);
index 115006f..1f77993 100644 (file)
@@ -116,7 +116,7 @@ public:
        void replaceBooleanWithTrue(Boolean *bexpr);
        void replaceBooleanWithFalse(Boolean *bexpr);
        void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb);
-       CSolver * clone();
+       CSolver *clone();
 
        MEMALLOC;