From 4646025e50b9fd4a754cb6b036c3166072e95d90 Mon Sep 17 00:00:00 2001 From: bdemsky Date: Sun, 27 Aug 2017 00:59:13 -0700 Subject: [PATCH] Finish clone --- src/AST/boolean.cc | 42 +++++++++++++++++++-------------------- src/AST/boolean.h | 16 +++++++-------- src/AST/element.cc | 22 ++++++++++---------- src/AST/element.h | 8 ++++---- src/AST/function.cc | 27 ++++++++++++++++++++++++- src/AST/function.h | 6 +++--- src/AST/mutableset.cc | 10 +++++----- src/AST/mutableset.h | 2 +- src/AST/order.cc | 10 ++++++++++ src/AST/order.h | 2 +- src/AST/predicate.cc | 25 +++++++++++++++++++++++ src/AST/predicate.h | 6 +++--- src/AST/set.cc | 10 +++++----- src/AST/set.h | 4 ++-- src/AST/table.cc | 21 ++++++++++++++++++++ src/AST/table.h | 1 + src/Collections/structs.h | 12 +---------- src/csolver.cc | 12 +++++------ src/csolver.h | 2 +- 19 files changed, 155 insertions(+), 83 deletions(-) diff --git a/src/AST/boolean.cc b/src/AST/boolean.cc index 1eb2f00..77709b6 100644 --- a/src/AST/boolean.cc +++ b/src/AST/boolean.cc @@ -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;iclone(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;iclone(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); } diff --git a/src/AST/boolean.h b/src/AST/boolean.h index 2341fcf..bc247c2 100644 --- a/src/AST/boolean.h +++ b/src/AST/boolean.h @@ -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 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 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 inputs; diff --git a/src/AST/element.cc b/src/AST/element.cc index d6832f9..20cddf3 100644 --- a/src/AST/element.cc +++ b/src/AST/element.cc @@ -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; iclone(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; } diff --git a/src/AST/element.h b/src/AST/element.h index a230055..267f133 100644 --- a/src/AST/element.h +++ b/src/AST/element.h @@ -16,7 +16,7 @@ public: virtual ~Element() {} Vector 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 inputs; Boolean *overflowstatus; FunctionEncoding functionencoding; - Element * clone(CSolver * solver, CloneMap * map); + Element *clone(CSolver *solver, CloneMap *map); MEMALLOC; }; diff --git a/src/AST/function.cc b/src/AST/function.cc index 50f8715..1d910e4 100644 --- a/src/AST/function.cc +++ b/src/AST/function.cc @@ -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; +} diff --git a/src/AST/function.h b/src/AST/function.h index e00afd3..6b0cd13 100644 --- a/src/AST/function.h +++ b/src/AST/function.h @@ -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; }; diff --git a/src/AST/mutableset.cc b/src/AST/mutableset.cc index d029f82..6b3f953 100644 --- a/src/AST/mutableset.cc +++ b/src/AST/mutableset.cc @@ -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; igetSize();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; } diff --git a/src/AST/mutableset.h b/src/AST/mutableset.h index 36ce011..080db14 100644 --- a/src/AST/mutableset.h +++ b/src/AST/mutableset.h @@ -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 diff --git a/src/AST/order.cc b/src/AST/order.cc index debd37c..c9b0a79 100644 --- a/src/AST/order.cc +++ b/src/AST/order.cc @@ -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(); diff --git a/src/AST/order.h b/src/AST/order.h index b4abd07..e5f5983 100644 --- a/src/AST/order.h +++ b/src/AST/order.h @@ -17,7 +17,7 @@ public: HashTableOrderPair *orderPairTable; HashSetOrderElement *elementTable; OrderGraph *graph; - Order * clone(CloneMap *map); + Order *clone(CSolver *solver, CloneMap *map); Vector constraints; OrderEncoding order; void initializeOrderHashTable(); diff --git a/src/AST/predicate.cc b/src/AST/predicate.cc index 0e04668..99cd311 100644 --- a/src/AST/predicate.cc +++ b/src/AST/predicate.cc @@ -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; +} diff --git a/src/AST/predicate.h b/src/AST/predicate.h index c86c6c2..047ef13 100644 --- a/src/AST/predicate.h +++ b/src/AST/predicate.h @@ -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 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; diff --git a/src/AST/set.cc b/src/AST/set.cc index d5b9c34..b0e1d8a 100644 --- a/src/AST/set.cc +++ b/src/AST/set.cc @@ -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; } diff --git a/src/AST/set.h b/src/AST/set.h index 3ff404a..938027b 100644 --- a/src/AST/set.h +++ b/src/AST/set.h @@ -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 diff --git a/src/AST/table.cc b/src/AST/table.cc index d54aefb..c4e9594 100644 --- a/src/AST/table.cc +++ b/src/AST/table.cc @@ -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()) { diff --git a/src/AST/table.h b/src/AST/table.h index 28b13e4..346da47 100644 --- a/src/AST/table.h +++ b/src/AST/table.h @@ -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 domains; Set *range; diff --git a/src/Collections/structs.h b/src/Collections/structs.h index 73f5bf5..43efbc5 100644 --- a/src/Collections/structs.h +++ b/src/Collections/structs.h @@ -24,17 +24,7 @@ typedef HashSet HashSetOrderElement; typedef HashTable HashTableNodeToNodeSet; typedef HashTable HashTableOrderPair; -typedef HashTable OrderMap; -typedef HashTable BooleanMap; -typedef HashTable ElementMap; -typedef HashTable SetMap; - -typedef struct CloneMap { - OrderMap order; - BooleanMap boolean; - ElementMap element; - SetMap set; -} CloneMap; +typedef HashTable CloneMap; typedef HSIterator HSIteratorTableEntry; typedef HSIterator HSIteratorBoolean; diff --git a/src/csolver.cc b/src/csolver.cc index dec85e0..221f562 100644 --- a/src/csolver.cc +++ b/src/csolver.cc @@ -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); diff --git a/src/csolver.h b/src/csolver.h index 115006f..1f77993 100644 --- a/src/csolver.h +++ b/src/csolver.h @@ -116,7 +116,7 @@ public: void replaceBooleanWithTrue(Boolean *bexpr); void replaceBooleanWithFalse(Boolean *bexpr); void replaceBooleanWithBoolean(Boolean *oldb, Boolean *newb); - CSolver * clone(); + CSolver *clone(); MEMALLOC; -- 2.34.1