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 ORDERCONST:
  80                         deserializeBooleanOrder();
  81                         break;
  82                 case ORDERTYPE:
  83                         deserializeOrder();
  84                         break;
  85                 case SETTYPE:
  86                         deserializeSet();
  87                         break;
  88                 case LOGICOP:
  89                         deserializeBooleanLogic();
  90                         break;
  91                 case PREDICATEOP:
  92                         deserializeBooleanPredicate();
  93                         break;
  94                 case PREDTABLETYPE:
  95                         deserializePredicateTable();
  96                         break;
  97                 case PREDOPERTYPE:
  98                         deserializePredicateOperator();
  99                         break;
 100                 case TABLETYPE:
 101                         deserializeTable();
 102                         break;
 103                 case ELEMSET:
 104                         deserializeElementSet();
 105                         break;
 106                 case ELEMCONST:
 107                         deserializeElementConst();
 108                         break;
 109                 case ELEMFUNCRETURN:
 110                         deserializeElementFunction();
 111                         break;
 112                 case FUNCOPTYPE:
 113                         deserializeFunctionOperator();
 114                         break;
 115                 case FUNCTABLETYPE:
 116                         deserializeFunctionTable();
 117                         break;
 118                 default:
 119                         ASSERT(0);
 120                 }
 121         }
 122         return solver;
 123 }
 124
 125 void Deserializer::deserializeBooleanEdge() {
 126         Boolean *b_ptr;
 127         myread(&b_ptr, sizeof(Boolean *));
 128         BooleanEdge tmp(b_ptr);
 129         bool isNegated = tmp.isNegated();
 130         ASSERT(map.contains(tmp.getBoolean()));
 131         b_ptr = (Boolean *) map.get(tmp.getBoolean());
 132         BooleanEdge res(b_ptr);
 133         bool isTopLevel;
 134         myread(&isTopLevel, sizeof(bool));
 135         if (isTopLevel) {
 136                 solver->addConstraint(isNegated ? res.negate() : res);
 137         }
 138 }
 139
 140 void Deserializer::deserializeBooleanVar() {
 141         BooleanVar *b;
 142         myread(&b, sizeof(BooleanVar *));
 143         VarType vtype;
 144         myread(&vtype, sizeof(VarType));
 145         map.put(b, solver->getBooleanVar(vtype).getBoolean());
 146 }
 147
 148 void Deserializer::deserializeBooleanOrder() {
 149         BooleanOrder *bo_ptr;
 150         myread(&bo_ptr, sizeof(BooleanOrder *));
 151         Order *order;
 152         myread(&order, sizeof(Order *));
 153         ASSERT(map.contains(order));
 154         order  = (Order *) map.get(order);
 155         uint64_t first;
 156         myread(&first, sizeof(uint64_t));
 157         uint64_t second;
 158         myread(&second, sizeof(uint64_t));
 159         map.put(bo_ptr, solver->orderConstraint(order, first, second).getBoolean());
 160 }
 161
 162 void Deserializer::deserializeOrder() {
 163         Order *o_ptr;
 164         myread(&o_ptr, sizeof(Order *));
 165         OrderType type;
 166         myread(&type, sizeof(OrderType));
 167         Set *set_ptr;
 168         myread(&set_ptr, sizeof(Set *));
 169         ASSERT(map.contains(set_ptr));
 170         Set *set  = (Set *) map.get(set_ptr);
 171         map.put(o_ptr, solver->createOrder(type, set));
 172 }
 173
 174 void Deserializer::deserializeSet() {
 175         Set *s_ptr;
 176         myread(&s_ptr, sizeof(Set *));
 177         VarType type;
 178         myread(&type, sizeof(VarType));
 179         bool isRange;
 180         myread(&isRange, sizeof(bool));
 181         bool isMutable;
 182         myread(&isMutable, sizeof(bool));
 183         if (isRange) {
 184                 uint64_t low;
 185                 myread(&low, sizeof(uint64_t));
 186                 uint64_t high;
 187                 myread(&high, sizeof(uint64_t));
 188                 map.put(s_ptr, new Set(type, low, high));
 189         } else {
 190                 Set *set = NULL;
 191                 if (isMutable) {
 192                         set = new MutableSet(type);
 193                 }
 194                 uint size;
 195                 myread(&size, sizeof(uint));
 196                 Vector<uint64_t> members;
 197                 for (uint i = 0; i < size; i++) {
 198                         uint64_t mem;
 199                         myread(&mem, sizeof(uint64_t));
 200                         if (isMutable) {
 201                                 ((MutableSet *) set)->addElementMSet(mem);
 202                         } else {
 203                                 members.push(mem);
 204                         }
 205                 }
 206                 if (!isMutable) {
 207                         set = solver->createSet(type, members.expose(), size);
 208                 }
 209                 map.put(s_ptr, set);
 210         }
 211 }
 212
 213 void Deserializer::deserializeBooleanLogic() {
 214         BooleanLogic *bl_ptr;
 215         myread(&bl_ptr, sizeof(BooleanLogic *));
 216         LogicOp op;
 217         myread(&op, sizeof(LogicOp));
 218         uint size;
 219         myread(&size, sizeof(uint));
 220         Vector<BooleanEdge> members;
 221         for (uint i = 0; i < size; i++) {
 222                 Boolean *member;
 223                 myread(&member, sizeof(Boolean *));
 224                 BooleanEdge tmp(member);
 225                 bool isNegated = tmp.isNegated();
 226                 ASSERT(map.contains(tmp.getBoolean()));
 227                 member = (Boolean *) map.get(tmp.getBoolean());
 228                 BooleanEdge res(member);
 229                 members.push( isNegated ? res.negate() : res );
 230         }
 231         map.put(bl_ptr, solver->applyLogicalOperation(op, members.expose(), size).getBoolean());
 232 }
 233
 234 void Deserializer::deserializeBooleanPredicate() {
 235         BooleanPredicate *bp_ptr;
 236         myread(&bp_ptr, sizeof(BooleanPredicate *));
 237         Predicate *predicate;
 238         myread(&predicate, sizeof(Predicate *));
 239         ASSERT(map.contains(predicate));
 240         predicate = (Predicate *) map.get(predicate);
 241         uint size;
 242         myread(&size, sizeof(uint));
 243         Vector<Element *> members;
 244         for (uint i = 0; i < size; i++) {
 245                 Element *input;
 246                 myread(&input, sizeof(Element *));
 247                 ASSERT(map.contains(input));
 248                 input = (Element *) map.get(input);
 249                 members.push(input);
 250         }
 251
 252         Boolean *stat_ptr;
 253         myread(&stat_ptr, sizeof(Boolean *));
 254         BooleanEdge undefStatus;
 255         if (stat_ptr != NULL) {
 256                 BooleanEdge tmp(stat_ptr);
 257                 bool isNegated = tmp.isNegated();
 258                 ASSERT(map.contains(tmp.getBoolean()));
 259                 stat_ptr = (Boolean *) map.get(tmp.getBoolean());
 260                 BooleanEdge res(stat_ptr);
 261                 undefStatus = isNegated ? res.negate() : res;
 262         } else {
 263                 undefStatus = NULL;
 264         }
 265         map.put(bp_ptr, solver->applyPredicateTable(predicate, members.expose(), size, undefStatus).getBoolean());
 266 }
 267
 268 void Deserializer::deserializePredicateTable() {
 269         PredicateTable *pt_ptr;
 270         myread(&pt_ptr, sizeof(PredicateTable *));
 271         Table *table;
 272         myread(&table, sizeof(Table *));
 273         ASSERT(map.contains(table));
 274         table = (Table *) map.get(table);
 275         UndefinedBehavior undefinedbehavior;
 276         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 277
 278         map.put(pt_ptr, solver->createPredicateTable(table, undefinedbehavior));
 279 }
 280
 281 void Deserializer::deserializePredicateOperator() {
 282         PredicateOperator *po_ptr;
 283         myread(&po_ptr, sizeof(PredicateOperator *));
 284         CompOp op;
 285         myread(&op, sizeof(CompOp));
 286
 287         map.put(po_ptr, solver->createPredicateOperator(op));
 288 }
 289
 290 void Deserializer::deserializeTable() {
 291         Table *t_ptr;
 292         myread(&t_ptr, sizeof(Table *));
 293         Set *range;
 294         myread(&range, sizeof(Set *));
 295         if (range != NULL) {
 296                 ASSERT(map.contains(range));
 297                 range = (Set *) map.get(range);
 298         }
 299         Table *table = solver->createTable(range);
 300         uint size;
 301         myread(&size, sizeof(uint));
 302         for (uint i = 0; i < size; i++) {
 303                 uint64_t output;
 304                 myread(&output, sizeof(uint64_t));
 305                 uint inputSize;
 306                 myread(&inputSize, sizeof(uint));
 307                 Vector<uint64_t> inputs;
 308                 inputs.setSize(inputSize);
 309                 myread(inputs.expose(), sizeof(uint64_t) * inputSize);
 310                 table->addNewTableEntry(inputs.expose(), inputSize, output);
 311         }
 312
 313         map.put(t_ptr, table);
 314 }
 315
 316
 317 void Deserializer::deserializeElementSet() {
 318         ElementSet *es_ptr;
 319         myread(&es_ptr, sizeof(ElementSet *));
 320         Set *set;
 321         myread(&set, sizeof(Set *));
 322         ASSERT(map.contains(set));
 323         set  = (Set *) map.get(set);
 324         map.put(es_ptr, solver->getElementVar(set));
 325 }
 326
 327 void Deserializer::deserializeElementConst() {
 328         ElementSet *es_ptr;
 329         myread(&es_ptr, sizeof(ElementSet *));
 330         VarType type;
 331         myread(&type, sizeof(VarType));
 332         uint64_t value;
 333         myread(&value, sizeof(uint64_t));
 334         map.put(es_ptr, solver->getElementConst(type, value));
 335 }
 336
 337 void Deserializer::deserializeElementFunction() {
 338         ElementFunction *ef_ptr;
 339         myread(&ef_ptr, sizeof(ElementFunction *));
 340         Function *function;
 341         myread(&function, sizeof(Function *));
 342         ASSERT(map.contains(function));
 343         function = (Function *) map.get(function);
 344         uint size;
 345         myread(&size, sizeof(uint));
 346         Vector<Element *> members;
 347         for (uint i = 0; i < size; i++) {
 348                 Element *input;
 349                 myread(&input, sizeof(Element *));
 350                 ASSERT(map.contains(input));
 351                 input = (Element *) map.get(input);
 352                 members.push(input);
 353         }
 354
 355         Boolean *overflowstatus;
 356         myread(&overflowstatus, sizeof(Boolean *));
 357         BooleanEdge tmp(overflowstatus);
 358         bool isNegated = tmp.isNegated();
 359         ASSERT(map.contains(tmp.getBoolean()));
 360         overflowstatus = (Boolean *) map.get(tmp.getBoolean());
 361         BooleanEdge res(overflowstatus);
 362         BooleanEdge undefStatus = isNegated ? res.negate() : res;
 363         map.put(ef_ptr, solver->applyFunction(function, members.expose(), size, undefStatus));
 364 }
 365
 366
 367 void Deserializer::deserializeFunctionOperator() {
 368         FunctionOperator *fo_ptr;
 369         myread(&fo_ptr, sizeof(FunctionOperator *));
 370         ArithOp op;
 371         myread(&op, sizeof(ArithOp));
 372         Set *range;
 373         myread(&range, sizeof(Set *));
 374         ASSERT(map.contains(range));
 375         range = (Set *) map.get(range);
 376         OverFlowBehavior overflowbehavior;
 377         myread(&overflowbehavior, sizeof(OverFlowBehavior));
 378         map.put(fo_ptr, solver->createFunctionOperator(op, range, overflowbehavior));
 379 }
 380
 381 void Deserializer::deserializeFunctionTable() {
 382         FunctionTable *ft_ptr;
 383         myread(&ft_ptr, sizeof(FunctionTable *));
 384         Table *table;
 385         myread(&table, sizeof(Table *));
 386         ASSERT(map.contains(table));
 387         table = (Table *) map.get(table);
 388         UndefinedBehavior undefinedbehavior;
 389         myread(&undefinedbehavior, sizeof(UndefinedBehavior));
 390
 391         map.put(ft_ptr, solver->completeTable(table, undefinedbehavior));
 392 }