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