src/Collections/structs.cc

   1 #include "mymemory.h"
   2 #include "orderpair.h"
   3 #include "tableentry.h"
   4 #include "ordernode.h"
   5 #include "orderedge.h"
   6 #include "ordergraph.h"
   7 #include "orderelement.h"
   8 #include "structs.h"
   9 #include "decomposeorderresolver.h"
  10 #include "searchtuner.h"
  11
  12 #define HASHNEXT(hash, newval) {hash += newval; hash += hash << 10; hash ^= hash >> 6;}
  13 #define HASHFINAL(hash) {hash += hash << 3; hash ^= hash >> 11; hash += hash << 15;}
  14
  15 unsigned int table_entry_hash_function(TableEntry *This) {
  16         unsigned int h = 0;
  17         for (uint i = 0; i < This->inputSize; i++) {
  18                 HASHNEXT(h, This->inputs[i]);
  19         }
  20         HASHFINAL(h);
  21         return h;
  22 }
  23
  24 bool table_entry_equals(TableEntry *key1, TableEntry *key2) {
  25         if (key1->inputSize != key2->inputSize)
  26                 return false;
  27         for (uint i = 0; i < key1->inputSize; i++)
  28                 if (key1->inputs[i] != key2->inputs[i])
  29                         return false;
  30         return true;
  31 }
  32
  33 unsigned int order_node_hash_function(OrderNodeKey *This) {
  34         return (uint) This->id;
  35 }
  36
  37 bool order_node_equals(OrderNodeKey *key1, OrderNodeKey *key2) {
  38         return key1->id == key2->id;
  39 }
  40
  41 unsigned int order_edge_hash_function(OrderEdge *This) {
  42         uint hash = 0;
  43         HASHNEXT(hash, (uint)(uintptr_t) This->sink);
  44         HASHNEXT(hash, (uint)(uintptr_t) This->source);
  45         HASHFINAL(hash);
  46         return hash;
  47 }
  48
  49 bool order_edge_equals(OrderEdge *key1, OrderEdge *key2) {
  50         return key1->sink == key2->sink && key1->source == key2->source;
  51 }
  52
  53 unsigned int order_element_hash_function(OrderElement *This) {
  54         return This->getHash();
  55 }
  56
  57 bool order_element_equals(OrderElement *key1, OrderElement *key2) {
  58         return key1->equals(key2);
  59 }
  60
  61 unsigned int order_pair_hash_function(OrderPair *This) {
  62         uint hash = 0;
  63         HASHNEXT(hash, This->first);
  64         HASHNEXT(hash, This->second);
  65         HASHFINAL(hash);
  66         return hash;
  67 }
  68
  69 bool order_pair_equals(OrderPair *key1, OrderPair *key2) {
  70         return key1->first == key2->first && key1->second == key2->second;
  71 }
  72
  73 unsigned int doredge_hash_function(DOREdge *key) {
  74         uint hash = 0;
  75         HASHNEXT(hash, (uint) key->newfirst);
  76         HASHNEXT(hash, (uint) key->newsecond);
  77         HASHFINAL(hash);
  78         return hash;
  79 }
  80
  81 bool doredge_equals(DOREdge *key1, DOREdge *key2) {
  82         return key1->newfirst == key2->newfirst &&
  83                                  key1->newsecond == key2->newsecond;
  84 }
  85
  86 unsigned int tunableSettingHash(TunableSetting *setting) {
  87         return setting->hasVar ^ setting->type1 ^ setting->type2 ^ setting->param;
  88 }
  89
  90 bool tunableSettingEquals(TunableSetting *setting1, TunableSetting *setting2) {
  91         return setting1->hasVar == setting2->hasVar &&
  92                                  setting1->type1 == setting2->type1 &&
  93                                  setting1->type2 == setting2->type2 &&
  94                                  setting1->param == setting2->param;
  95 }