src/Serialize/deserializer.cc

   1
   2 /*
   3  * File:   deserializer.cc
   4  * Author: hamed
   5  *
   6  * Created on September 7, 2017, 6:08 PM
   7  */
   8
   9 #include "deserializer.h"
  10 #include "csolver.h"
  11 #include "unistd.h"
  12 #include "fcntl.h"
  13 #include "predicate.h"
  14 #include "table.h"
  15 #include "element.h"
  16 #include "mutableset.h"
  17
  18 Deserializer::Deserializer(const char* file):
  19         solver(new CSolver())
  20 {
  21         filedesc = open(file, O_RDONLY);
  22
  23         if (filedesc < 0) {
  24                 exit(-1);
  25         }
  26 }
  27
  28 Deserializer::~Deserializer() {
  29         delete solver;
  30
  31         if (-1 == close(filedesc)){
  32                 exit(-1);
  33         }
  34 }
  35
  36 ssize_t Deserializer::myread(void* __buf, size_t __nbytes){
  37         return read (filedesc, __buf, __nbytes);
  38 }
  39
  40 CSolver * Deserializer::deserialize(){
  41         ASTNodeType nodeType;
  42         while(myread(&nodeType, sizeof(ASTNodeType) ) >0){
  43                 switch(nodeType){
  44                         case BOOLEANEDGE:
  45                                 deserializeBooleanEdge();
  46                                 break;
  47                         case BOOLEANVAR:
  48                                 deserializeBooleanVar();
  49                                 break;
  50                         case ORDERCONST:
  51                                 deserializeBooleanOrder();
  52                                 break;
  53                         case ORDERTYPE:
  54                                 deserializeOrder();
  55                                 break;
  56                         case SETTYPE:
  57                                 deserializeSet();
  58                                 break;
  59                         case LOGICOP:
  60                                 deserializeBooleanLogic();
  61                                 break;
  62                         case PREDICATEOP:
  63                                 deserializeBooleanPredicate();
  64                                 break;
  65                         case PREDTABLETYPE:
  66                                 deserializePredicateTable();
  67                                 break;
  68                         case PREDOPERTYPE:
  69                                 deserializePredicateOperator();
  70                                 break;
  71                         case TABLETYPE:
  72                                 deserializeTable();
  73                                 break;
  74                         case ELEMSET:
  75                                 deserializeElementSet();
  76                                 break;
  77                         case ELEMCONST:
  78                                 deserializeElementConst();
  79                                 break;
  80                         case ELEMFUNCRETURN:
  81                                 deserializeElementFunction();
  82                                 break;
  83                         case FUNCOPTYPE:
  84                                 deserializeFunctionOperator();
  85                                 break;
  86                         case FUNCTABLETYPE:
  87                                 deserializeFunctionTable();
  88                                 break;
  89                         default:
  90                                 ASSERT(0);
  91                 }
  92         }
  93         return solver;
  94 }
  95
  96 void Deserializer::deserializeBooleanEdge(){
  97         Boolean *b;
  98         myread(&b, sizeof(Boolean*));
  99         BooleanEdge tmp(b);
 100         bool isNegated = tmp.isNegated();
 101         ASSERT(map.contains(tmp.getBoolean()));
 102         b = (Boolean*) map.get(tmp.getBoolean());
 103         BooleanEdge res(b);
 104         solver->addConstraint(isNegated?res.negate():res);
 105 }
 106
 107 void Deserializer::deserializeBooleanVar(){
 108         BooleanVar *b;
 109         myread(&b, sizeof(BooleanVar*));
 110         VarType vtype;
 111         myread(&vtype, sizeof(VarType));
 112         map.put(b, solver->getBooleanVar(vtype).getBoolean());
 113 }
 114
 115 void Deserializer::deserializeBooleanOrder(){
 116         BooleanOrder* bo_ptr;
 117         myread(&bo_ptr, sizeof(BooleanOrder*));
 118         Order* order;
 119         myread(&order, sizeof(Order*));
 120         ASSERT(map.contains(order));
 121         order  = (Order*) map.get(order);
 122         uint64_t first;
 123         myread(&first, sizeof(uint64_t));
 124         uint64_t second;
 125         myread(&second, sizeof(uint64_t));
 126         map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
 127 }
 128
 129 void Deserializer::deserializeOrder(){
 130         Order* o_ptr;
 131         myread(&o_ptr, sizeof(Order*));
 132         OrderType type;
 133         myread(&type, sizeof(OrderType));
 134         Set * set_ptr;
 135         myread(&set_ptr, sizeof(Set *));
 136         ASSERT(map.contains(set_ptr));
 137         Set* set  = (Set*) map.get(set_ptr);
 138         map.put(o_ptr, solver->createOrder(type, set));
 139 }
 140
 141 void Deserializer::deserializeSet(){
 142         Set *s_ptr;
 143         myread(&s_ptr, sizeof(Set*));
 144         VarType type;
 145         myread(&type, sizeof(VarType));
 146         bool isRange;
 147         myread(&isRange, sizeof(bool));
 148         uint64_t low;
 149         myread(&low, sizeof(uint64_t));
 150         uint64_t high;
 151         myread(&high, sizeof(uint64_t));
 152         bool isMutable;
 153         myread(&isMutable, sizeof(bool));
 154         Set *set;
 155         if(isMutable){
 156                 set = new MutableSet(type);
 157         }
 158         uint size;
 159         myread(&size, sizeof(uint));
 160         Vector<uint64_t> members;
 161         for(uint i=0; i<size; i++){
 162                 uint64_t mem;
 163                 myread(&mem, sizeof(uint64_t));
 164                 if(isMutable) {
 165                         ((MutableSet*) set)->addElementMSet(mem);
 166                 }else {
 167                         members.push(mem);
 168                 }
 169         }
 170         if(!isMutable){
 171                 set = isRange? solver->createRangeSet(type, low, high):
 172                         solver->createSet(type, members.expose(), size);
 173         }
 174         map.put(s_ptr, set);
 175 }
 176
 177 void Deserializer::deserializeBooleanLogic(){
 178         BooleanLogic *bl_ptr;
 179         myread(&bl_ptr, sizeof(BooleanLogic *));
 180         LogicOp op;
 181         myread(&op, sizeof(LogicOp));
 182         uint size;
 183         myread(&size, sizeof(uint));
 184         Vector<BooleanEdge> members;
 185         for(uint i=0; i<size; i++){
 186                 Boolean* member;
 187                 myread(&member, sizeof(Boolean *));
 188                 BooleanEdge tmp(member);
 189                 bool isNegated = tmp.isNegated();
 190                 ASSERT(map.contains(tmp.getBoolean()));
 191                 member = (Boolean*) map.get(tmp.getBoolean());
 192                 BooleanEdge res(member);
 193                 members.push( isNegated?res.negate():res );
 194         }
 195         map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
 196 }
 197
 198 void Deserializer::deserializeBooleanPredicate(){
 199         BooleanPredicate *bp_ptr;
 200         myread(&bp_ptr, sizeof(BooleanPredicate *));
 201         Predicate* predicate;
 202         myread(&predicate, sizeof(Predicate*));
 203         ASSERT(map.contains(predicate));
 204         predicate = (Predicate*) map.get(predicate);
 205         uint size;
 206         myread(&size, sizeof(uint));
 207         Vector<Element*> members;
 208         for(uint i=0; i<size; i++){
 209                 Element* input;
 210                 myread(&input, sizeof(Element *));
 211                 ASSERT(map.contains(input));
 212                 input = (Element*) map.get(input);
 213                 members.push(input);
 214         }
 215
 216         Boolean* stat_ptr;
 217         myread(&stat_ptr, sizeof(Boolean *));
 218         BooleanEdge undefStatus;
 219         if(stat_ptr != NULL){
 220                 BooleanEdge tmp(stat_ptr);
 221                 bool isNegated = tmp.isNegated();
 222                 ASSERT(map.contains(tmp.getBoolean()));
 223                 stat_ptr = (Boolean*) map.get(tmp.getBoolean());
 224                 BooleanEdge res(stat_ptr);
 225                 undefStatus = isNegated?res.negate():res;
 226         } else {
 227                 undefStatus = NULL;
 228         }
 229         map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 230 }
 231
 232 void Deserializer::deserializePredicateTable(){
 233         PredicateTable *pt_ptr;
 234         myread(&pt_ptr, sizeof(PredicateTable *));
 235         Table* table;
 236         myread(&table, sizeof(Table*));
 237         ASSERT(map.contains(table));
 238         table = (Table*) map.get(table);
 239         UndefinedBehavior undefinedbehavior;
 240         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 241
 242         map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
 243 }
 244
 245 void Deserializer::deserializePredicateOperator(){
 246         PredicateOperator *po_ptr;
 247         myread(&po_ptr, sizeof(PredicateOperator *));
 248         CompOp op;
 249         myread(&op, sizeof(CompOp));
 250         uint size;
 251         myread(&size, sizeof(uint));
 252         Vector<Set*> domains;
 253         for(uint i=0; i<size; i++){
 254                 Set* domain;
 255                 myread(&domain, sizeof(Set*));
 256                 ASSERT(map.contains(domain));
 257                 domain = (Set*) map.get(domain);
 258                 domains.push(domain);
 259         }
 260
 261         map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
 262 }
 263
 264 void Deserializer::deserializeTable(){
 265         Table *t_ptr;
 266         myread(&t_ptr, sizeof(Table *));
 267         uint size;
 268         myread(&size, sizeof(uint));
 269         Vector<Set*> domains;
 270         for(uint i=0; i<size; i++){
 271                 Set* domain;
 272                 myread(&domain, sizeof(Set*));
 273                 ASSERT(map.contains(domain));
 274                 domain = (Set*) map.get(domain);
 275                 domains.push(domain);
 276         }
 277         Set* range;
 278         myread(&range, sizeof(Set*));
 279         if(range != NULL){
 280                 ASSERT(map.contains(range));
 281                 range = (Set*) map.get(range);
 282         }
 283         Table* table = solver->createTable(domains.expose(), size, range);
 284         myread(&size, sizeof(uint));
 285         for(uint i=0; i<size; i++){
 286                 uint64_t output;
 287                 myread(&output, sizeof(uint64_t));
 288                 uint inputSize;
 289                 myread(&inputSize, sizeof(uint));
 290                 Vector<uint64_t> inputs;
 291                 inputs.setSize(inputSize);
 292                 myread(inputs.expose(), sizeof(uint64_t)*inputSize);
 293                 table->addNewTableEntry(inputs.expose(), inputSize, output);
 294         }
 295
 296         map.put(t_ptr, table);
 297 }
 298
 299
 300 void Deserializer::deserializeElementSet(){
 301         ElementSet* es_ptr;
 302         myread(&es_ptr, sizeof(ElementSet*));
 303         Set * set;
 304         myread(&set, sizeof(Set *));
 305         ASSERT(map.contains(set));
 306         set  = (Set*) map.get(set);
 307         map.put(es_ptr, solver->getElementVar(set));
 308 }
 309
 310 void Deserializer::deserializeElementConst(){
 311         ElementSet* es_ptr;
 312         myread(&es_ptr, sizeof(ElementSet*));
 313         VarType type;
 314         myread(&type, sizeof(VarType));
 315         uint64_t value;
 316         myread(&value, sizeof(uint64_t));
 317         map.put(es_ptr, solver->getElementConst(type, value));
 318 }
 319
 320 void Deserializer::deserializeElementFunction(){
 321         ElementFunction *ef_ptr;
 322         myread(&ef_ptr, sizeof(ElementFunction *));
 323         Function *function;
 324         myread(&function, sizeof(Function*));
 325         ASSERT(map.contains(function));
 326         function = (Function*) map.get(function);
 327         uint size;
 328         myread(&size, sizeof(uint));
 329         Vector<Element*> members;
 330         for(uint i=0; i<size; i++){
 331                 Element* input;
 332                 myread(&input, sizeof(Element *));
 333                 ASSERT(map.contains(input));
 334                 input = (Element*) map.get(input);
 335                 members.push(input);
 336         }
 337
 338         Boolean* overflowstatus;
 339         myread(&overflowstatus, sizeof(Boolean *));
 340         BooleanEdge tmp(overflowstatus);
 341         bool isNegated = tmp.isNegated();
 342         ASSERT(map.contains(tmp.getBoolean()));
 343         overflowstatus = (Boolean*) map.get(tmp.getBoolean());
 344         BooleanEdge res(overflowstatus);
 345         BooleanEdge undefStatus = isNegated?res.negate():res;
 346
 347         map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
 348 }
 349
 350
 351 void Deserializer::deserializeFunctionOperator(){
 352         FunctionOperator *fo_ptr;
 353         myread(&fo_ptr, sizeof(FunctionOperator *));
 354         ArithOp op;
 355         myread(&op, sizeof(ArithOp));
 356         uint size;
 357         myread(&size, sizeof(uint));
 358         Vector<Set*> domains;
 359         for(uint i=0; i<size; i++){
 360                 Set* domain;
 361                 myread(&domain, sizeof(Set*));
 362                 ASSERT(map.contains(domain));
 363                 domain = (Set*) map.get(domain);
 364                 domains.push(domain);
 365         }
 366         Set* range;
 367         myread(&range, sizeof(Set*));
 368         ASSERT(map.contains(range));
 369         range = (Set*) map.get(range);
 370         OverFlowBehavior overflowbehavior;
 371         myread(&overflowbehavior, sizeof(OverFlowBehavior));
 372         map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
 373 }
 374
 375 void Deserializer::deserializeFunctionTable(){
 376         FunctionTable *ft_ptr;
 377         myread(&ft_ptr, sizeof(FunctionTable *));
 378         Table* table;
 379         myread(&table, sizeof(Table*));
 380         ASSERT(map.contains(table));
 381         table = (Table*) map.get(table);
 382         UndefinedBehavior undefinedbehavior;
 383         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 384
 385         map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
 386 }