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         bool isMutable;
 149         myread(&isMutable, sizeof(bool));
 150         if(isRange){
 151                 uint64_t low;
 152                 myread(&low, sizeof(uint64_t));
 153                 uint64_t high;
 154                 myread(&high, sizeof(uint64_t));
 155                 map.put(s_ptr, new Set(type, low, high));
 156         } else{
 157                 Set *set;
 158                 if(isMutable){
 159                         set = new MutableSet(type);
 160                 }
 161                 uint size;
 162                 myread(&size, sizeof(uint));
 163                 Vector<uint64_t> members;
 164                 for(uint i=0; i<size; i++){
 165                         uint64_t mem;
 166                         myread(&mem, sizeof(uint64_t));
 167                         if(isMutable) {
 168                                 ((MutableSet*) set)->addElementMSet(mem);
 169                         }else {
 170                                 members.push(mem);
 171                         }
 172                 }
 173                 if(!isMutable){
 174                         set = solver->createSet(type, members.expose(), size);
 175                 }
 176                 map.put(s_ptr, set);
 177         }
 178
 179 }
 180
 181 void Deserializer::deserializeBooleanLogic(){
 182         BooleanLogic *bl_ptr;
 183         myread(&bl_ptr, sizeof(BooleanLogic *));
 184         LogicOp op;
 185         myread(&op, sizeof(LogicOp));
 186         uint size;
 187         myread(&size, sizeof(uint));
 188         Vector<BooleanEdge> members;
 189         for(uint i=0; i<size; i++){
 190                 Boolean* member;
 191                 myread(&member, sizeof(Boolean *));
 192                 BooleanEdge tmp(member);
 193                 bool isNegated = tmp.isNegated();
 194                 ASSERT(map.contains(tmp.getBoolean()));
 195                 member = (Boolean*) map.get(tmp.getBoolean());
 196                 BooleanEdge res(member);
 197                 members.push( isNegated?res.negate():res );
 198         }
 199         map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
 200 }
 201
 202 void Deserializer::deserializeBooleanPredicate(){
 203         BooleanPredicate *bp_ptr;
 204         myread(&bp_ptr, sizeof(BooleanPredicate *));
 205         Predicate* predicate;
 206         myread(&predicate, sizeof(Predicate*));
 207         ASSERT(map.contains(predicate));
 208         predicate = (Predicate*) map.get(predicate);
 209         uint size;
 210         myread(&size, sizeof(uint));
 211         Vector<Element*> members;
 212         for(uint i=0; i<size; i++){
 213                 Element* input;
 214                 myread(&input, sizeof(Element *));
 215                 ASSERT(map.contains(input));
 216                 input = (Element*) map.get(input);
 217                 members.push(input);
 218         }
 219
 220         Boolean* stat_ptr;
 221         myread(&stat_ptr, sizeof(Boolean *));
 222         BooleanEdge undefStatus;
 223         if(stat_ptr != NULL){
 224                 BooleanEdge tmp(stat_ptr);
 225                 bool isNegated = tmp.isNegated();
 226                 ASSERT(map.contains(tmp.getBoolean()));
 227                 stat_ptr = (Boolean*) map.get(tmp.getBoolean());
 228                 BooleanEdge res(stat_ptr);
 229                 undefStatus = isNegated?res.negate():res;
 230         } else {
 231                 undefStatus = NULL;
 232         }
 233         map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 234 }
 235
 236 void Deserializer::deserializePredicateTable(){
 237         PredicateTable *pt_ptr;
 238         myread(&pt_ptr, sizeof(PredicateTable *));
 239         Table* table;
 240         myread(&table, sizeof(Table*));
 241         ASSERT(map.contains(table));
 242         table = (Table*) map.get(table);
 243         UndefinedBehavior undefinedbehavior;
 244         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 245
 246         map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
 247 }
 248
 249 void Deserializer::deserializePredicateOperator(){
 250         PredicateOperator *po_ptr;
 251         myread(&po_ptr, sizeof(PredicateOperator *));
 252         CompOp op;
 253         myread(&op, sizeof(CompOp));
 254         uint size;
 255         myread(&size, sizeof(uint));
 256         Vector<Set*> domains;
 257         for(uint i=0; i<size; i++){
 258                 Set* domain;
 259                 myread(&domain, sizeof(Set*));
 260                 ASSERT(map.contains(domain));
 261                 domain = (Set*) map.get(domain);
 262                 domains.push(domain);
 263         }
 264
 265         map.put(po_ptr, solver->createPredicateOperator(op, domains.expose(), size));
 266 }
 267
 268 void Deserializer::deserializeTable(){
 269         Table *t_ptr;
 270         myread(&t_ptr, sizeof(Table *));
 271         uint size;
 272         myread(&size, sizeof(uint));
 273         Vector<Set*> domains;
 274         for(uint i=0; i<size; i++){
 275                 Set* domain;
 276                 myread(&domain, sizeof(Set*));
 277                 ASSERT(map.contains(domain));
 278                 domain = (Set*) map.get(domain);
 279                 domains.push(domain);
 280         }
 281         Set* range;
 282         myread(&range, sizeof(Set*));
 283         if(range != NULL){
 284                 ASSERT(map.contains(range));
 285                 range = (Set*) map.get(range);
 286         }
 287         Table* table = solver->createTable(domains.expose(), size, range);
 288         myread(&size, sizeof(uint));
 289         for(uint i=0; i<size; i++){
 290                 uint64_t output;
 291                 myread(&output, sizeof(uint64_t));
 292                 uint inputSize;
 293                 myread(&inputSize, sizeof(uint));
 294                 Vector<uint64_t> inputs;
 295                 inputs.setSize(inputSize);
 296                 myread(inputs.expose(), sizeof(uint64_t)*inputSize);
 297                 table->addNewTableEntry(inputs.expose(), inputSize, output);
 298         }
 299
 300         map.put(t_ptr, table);
 301 }
 302
 303
 304 void Deserializer::deserializeElementSet(){
 305         ElementSet* es_ptr;
 306         myread(&es_ptr, sizeof(ElementSet*));
 307         Set * set;
 308         myread(&set, sizeof(Set *));
 309         ASSERT(map.contains(set));
 310         set  = (Set*) map.get(set);
 311         map.put(es_ptr, solver->getElementVar(set));
 312 }
 313
 314 void Deserializer::deserializeElementConst(){
 315         ElementSet* es_ptr;
 316         myread(&es_ptr, sizeof(ElementSet*));
 317         VarType type;
 318         myread(&type, sizeof(VarType));
 319         uint64_t value;
 320         myread(&value, sizeof(uint64_t));
 321         map.put(es_ptr, solver->getElementConst(type, value));
 322 }
 323
 324 void Deserializer::deserializeElementFunction(){
 325         ElementFunction *ef_ptr;
 326         myread(&ef_ptr, sizeof(ElementFunction *));
 327         Function *function;
 328         myread(&function, sizeof(Function*));
 329         ASSERT(map.contains(function));
 330         function = (Function*) map.get(function);
 331         uint size;
 332         myread(&size, sizeof(uint));
 333         Vector<Element*> members;
 334         for(uint i=0; i<size; i++){
 335                 Element* input;
 336                 myread(&input, sizeof(Element *));
 337                 ASSERT(map.contains(input));
 338                 input = (Element*) map.get(input);
 339                 members.push(input);
 340         }
 341
 342         Boolean* overflowstatus;
 343         myread(&overflowstatus, sizeof(Boolean *));
 344         BooleanEdge tmp(overflowstatus);
 345         bool isNegated = tmp.isNegated();
 346         ASSERT(map.contains(tmp.getBoolean()));
 347         overflowstatus = (Boolean*) map.get(tmp.getBoolean());
 348         BooleanEdge res(overflowstatus);
 349         BooleanEdge undefStatus = isNegated?res.negate():res;
 350
 351         map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
 352 }
 353
 354
 355 void Deserializer::deserializeFunctionOperator(){
 356         FunctionOperator *fo_ptr;
 357         myread(&fo_ptr, sizeof(FunctionOperator *));
 358         ArithOp op;
 359         myread(&op, sizeof(ArithOp));
 360         uint size;
 361         myread(&size, sizeof(uint));
 362         Vector<Set*> domains;
 363         for(uint i=0; i<size; i++){
 364                 Set* domain;
 365                 myread(&domain, sizeof(Set*));
 366                 ASSERT(map.contains(domain));
 367                 domain = (Set*) map.get(domain);
 368                 domains.push(domain);
 369         }
 370         Set* range;
 371         myread(&range, sizeof(Set*));
 372         ASSERT(map.contains(range));
 373         range = (Set*) map.get(range);
 374         OverFlowBehavior overflowbehavior;
 375         myread(&overflowbehavior, sizeof(OverFlowBehavior));
 376         map.put(fo_ptr, solver->createFunctionOperator(op, domains.expose(), size, range, overflowbehavior));
 377 }
 378
 379 void Deserializer::deserializeFunctionTable(){
 380         FunctionTable *ft_ptr;
 381         myread(&ft_ptr, sizeof(FunctionTable *));
 382         Table* table;
 383         myread(&table, sizeof(Table*));
 384         ASSERT(map.contains(table));
 385         table = (Table*) map.get(table);
 386         UndefinedBehavior undefinedbehavior;
 387         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 388
 389         map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
 390 }