case ELEMFUNCRETURN: {
ElementEncoding *encoding=e->getElementEncoding();
if (encoding->getElementEncodingType() == ELEM_UNASSIGNED) {
- //Do assignment...
+ EncodingNode *n = getNode(e);
+ ASSERT(n != NULL);
+ ElementEncodingType encodetype=n->getEncoding();
+ encoding->setElementEncodingType(encodetype);
+ if (encodetype == UNARY || encodetype == ONEHOT) {
+ encoding->encodingArrayInitialization();
+ } else if (encodetype == BINARYINDEX) {
+ EncodingSubGraph * subgraph = graphMap.get(n);
+ uint encodingSize = subgraph->getEncodingSize(n);
+ uint paddedSize = encoding->getSizeEncodingArray(encodingSize);
+ encoding->allocInUseArrayElement(paddedSize);
+ encoding->allocEncodingArrayElement(paddedSize);
+ Set * s=e->getRange();
+ for(uint i=0;i<s->getSize();i++) {
+ uint64_t value=s->getElement(i);
+ uint encodingIndex=subgraph->getEncoding(n, value);
+ encoding->setInUseElement(encodingIndex);
+ encoding->encodingArray[encodingIndex] = value;
+ }
+ }
}
break;
}
default:
break;
}
+ encodeParent(e);
+ }
+}
+
+void EncodingGraph::encodeParent(Element *e) {
+ uint size=e->parents.getSize();
+ for(uint i=0;i<size;i++) {
+ ASTNode * n = e->parents.get(i);
+ if (n->type==PREDICATEOP) {
+ BooleanPredicate *b=(BooleanPredicate *)n;
+ FunctionEncoding *fenc=b->getFunctionEncoding();
+ if (fenc->getFunctionEncodingType() != FUNC_UNASSIGNED)
+ continue;
+ Predicate *p=b->getPredicate();
+ if (p->type==OPERATORPRED) {
+ PredicateOperator *po=(PredicateOperator *)p;
+ ASSERT(b->inputs.getSize()==2);
+ EncodingNode *left=createNode(b->inputs.get(0));
+ EncodingNode *right=createNode(b->inputs.get(1));
+ if (left == NULL || right == NULL)
+ return;
+ EncodingEdge *edge=getEdge(left, right, NULL);
+ if (edge != NULL && edge->getEncoding() == EDGE_MATCH) {
+ fenc->setFunctionEncodingType(CIRCUIT);
+ }
+ }
+ }
}
-
}
void EncodingGraph::mergeNodes(EncodingNode *first, EncodingNode *second) {
if (left == NULL && right == NULL)
return;
EncodingNode *dst=createNode(ef);
- EncodingEdge *edge=getEdge(left, right, dst);
+ EncodingEdge *edge=createEdge(left, right, dst);
edge->numArithOps++;
}
}
EncodingNode *right=createNode(b->inputs.get(1));
if (left == NULL || right == NULL)
return;
- EncodingEdge *edge=getEdge(left, right, NULL);
+ EncodingEdge *edge=createEdge(left, right, NULL);
CompOp op=po->getOp();
switch(op) {
case SATC_EQUALS:
static TunableDesc EdgeEncodingDesc(EDGE_UNASSIGNED, EDGE_MATCH, EDGE_UNASSIGNED);
EncodingEdge * EncodingGraph::getEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst) {
+ EncodingEdge e(left, right, dst);
+ EncodingEdge *result = edgeMap.get(&e);
+ return result;
+}
+
+EncodingEdge * EncodingGraph::createEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst) {
EncodingEdge e(left, right, dst);
EncodingEdge *result = edgeMap.get(&e);
if (result == NULL) {
return n;
}
+EncodingNode * EncodingGraph::getNode(Element *e) {
+ if (e->type == ELEMCONST)
+ return NULL;
+ Set *s = e->getRange();
+ EncodingNode *n = encodingMap.get(s);
+ return n;
+}
+
void EncodingNode::addElement(Element *e) {
elements.add(e);
}
HashtableNodeToSubGraph graphMap;
HashsetEncodingSubGraph subgraphs;
+ void encodeParent(Element *e);
void decideEdges();
void mergeNodes(EncodingNode *first, EncodingNode *second);
void processElement(Element *e);
void processFunction(ElementFunction *f);
void processPredicate(BooleanPredicate *b);
EncodingNode * createNode(Element *e);
+ EncodingNode * getNode(Element *e);
EncodingEdge * getEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst);
+ EncodingEdge * createEdge(EncodingNode *left, EncodingNode *right, EncodingNode *dst);
};
class EncodingNode {
uint getSize() const;
VarType getType() const;
void setEncoding(ElementEncodingType e) {encoding=e;}
-
+ ElementEncodingType getEncoding() {return encoding;}
CMEMALLOC;
private:
Set *s;
EncodingEdge(EncodingNode *_l, EncodingNode *_r, EncodingNode *_d);
void setEncoding(EdgeEncodingType e) {encoding=e;}
uint64_t getValue() const;
+ EdgeEncodingType getEncoding() {return encoding;}
+
CMEMALLOC;
private: