synchronized boolean remove(long hash, K key) {
   int h = smallMap.startSearch(hash);
   boolean found = false;
   while (true) {
     int pos = smallMap.nextPos();
     if (pos < 0) {
       break;
     }
     bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize);
     K key2 = getKey();
     if (equals(key, key2)) {
       usedSet.clear(pos);
       smallMap.remove(h, pos);
       found = true;
       this.size--;
       break;
     }
   }
   K key2 = key instanceof CharSequence ? (K) key.toString() : key;
   DirectStore remove = map.remove(key2);
   if (remove == null) return found;
   offHeapUsed -= remove.size();
   remove.free();
   this.size--;
   return true;
 }
 synchronized V get(long hash, K key, V value) {
   smallMap.startSearch(hash);
   while (true) {
     int pos = smallMap.nextPos();
     if (pos < 0) {
       K key2 = key instanceof CharSequence ? (K) key.toString() : key;
       final DirectStore store = map.get(key2);
       if (store == null) return null;
       bytes.storePositionAndSize(store, 0, store.size());
       break;
     } else {
       bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize);
       K key2 = getKey();
       if (equals(key, key2)) break;
     }
   }
   if (bytesMarshallable) {
     try {
       V v = value == null ? (V) NativeBytes.UNSAFE.allocateInstance(vClass) : value;
       ((BytesMarshallable) v).readMarshallable(bytes);
       return v;
     } catch (InstantiationException e) {
       throw new AssertionError(e);
     }
   }
   return (V) bytes.readObject();
 }
  public int hashFunction(K dkey) {
    String hashstr = dkey.toString();
    int hashCode = 0;
    for (int i = 0; i < hashstr.length(); i++) {
      int code = (int) hashstr.charAt(i) * 32 ^ i;
      hashCode = hashCode + code;
    }

    hashCode = hashCode % size;
    // System.out.println(hashCode);
    return hashCode;
  }
Ejemplo n.º 4
0
  public String getStratsAndStatesStringForKey(final int key) {
    if (keyStrings.get(key) == null) {
      StringBuilder b = new StringBuilder();
      for (int i = 0; i < stratifiers.size(); i++) {
        final K strat = stratifiers.get(i);
        final Object stratValue = stratifierValuesByKey.get(key).get(i);
        b.append(strat.toString()).append(":").append(stratValue.toString());
      }
      keyStrings.set(key, b.toString());
    }

    return keyStrings.get(key);
  }
Ejemplo n.º 5
0
 /**
  * toString methode: creates a String representation of the object
  *
  * @return the String representation
  * @author info.vancauwenberge.tostring plugin
  */
 public String toString() {
   StringBuffer buffer = new StringBuffer();
   ArrayList keys = new ArrayList(hashtable.keySet());
   Collections.sort(keys);
   for (K key : (List<K>) keys) {
     ArrayList<O> vals = get(key);
     buffer.append(key.toString()).append("(").append(vals.size()).append(")").append(":\n");
     for (O val : vals) {
       buffer.append("\t").append(val.toString()).append("\n");
     }
   }
   return buffer.toString();
 }
 synchronized boolean containsKey(long hash, K key) {
   smallMap.startSearch(hash);
   while (true) {
     int pos = smallMap.nextPos();
     if (pos < 0) {
       K key2 = key instanceof CharSequence ? (K) key.toString() : key;
       return map.containsKey(key2);
     }
     bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize);
     K key2 = getKey();
     if (equals(key, key2)) {
       return true;
     }
   }
 }
    synchronized void put(long hash, K key, V value, boolean ifPresent, boolean ifAbsent) {
      // search for the previous entry
      int h = smallMap.startSearch(hash);
      boolean foundSmall = false, foundLarge = false;
      while (true) {
        int pos = smallMap.nextPos();
        if (pos < 0) {
          K key2 = key instanceof CharSequence ? (K) key.toString() : key;
          final DirectStore store = map.get(key2);
          if (store == null) {
            if (ifPresent && !ifAbsent) return;
            break;
          }
          if (ifAbsent) return;
          bytes.storePositionAndSize(store, 0, store.size());
          foundLarge = true;
          break;
        } else {
          bytes.storePositionAndSize(store, pos * smallEntrySize, smallEntrySize);
          K key2 = getKey();
          if (equals(key, key2)) {
            if (ifAbsent && !ifPresent) return;
            foundSmall = true;
            break;
          }
        }
      }

      tmpBytes.clear();
      if (csKey)
        //noinspection ConstantConditions
        tmpBytes.writeUTFΔ((CharSequence) key);
      else tmpBytes.writeObject(key);
      long startOfValuePos = tmpBytes.position();
      if (bytesMarshallable) ((BytesMarshallable) value).writeMarshallable(tmpBytes);
      else tmpBytes.writeObject(value);
      long size = tmpBytes.position();
      if (size <= smallEntrySize) {
        if (foundSmall) {
          bytes.position(0);
          bytes.write(tmpBytes, 0, size);
          return;
        } else if (foundLarge) {
          remove(hash, key);
        }
        // look for a free spot.
        int position = h & (entriesPerSegment - 1);
        int free = usedSet.nextClearBit(position);
        if (free >= entriesPerSegment) free = usedSet.nextClearBit(0);
        if (free < entriesPerSegment) {
          bytes.storePositionAndSize(store, free * smallEntrySize, smallEntrySize);
          bytes.write(tmpBytes, 0, size);
          smallMap.put(h, free);
          usedSet.set(free);
          this.size++;
          return;
        }
      }
      if (foundSmall) {
        remove(hash, key);
      } else if (foundLarge) {
        // can it be reused.
        if (bytes.capacity() <= size || bytes.capacity() - size < (size >> 3)) {
          bytes.write(tmpBytes, startOfValuePos, size);
          return;
        }
        remove(hash, key);
      }
      size = size - startOfValuePos;
      DirectStore store = new DirectStore(bmf, size);
      bytes.storePositionAndSize(store, 0, size);
      bytes.write(tmpBytes, startOfValuePos, size);
      K key2 = key instanceof CharSequence ? (K) key.toString() : key;
      map.put(key2, store);
      offHeapUsed += size;
      this.size++;
    }
Ejemplo n.º 8
0
    // O: 1-{4,5,6,7} 0-{0,1,2,3}
    // P: 1-{2,3,6,7} 0-{0,1,4,5}
    // S: 1-{1,3,5,7} 0-{0,2,4,6}
    public int getPartition(K key, V value, int numReduceTasks) {

      String line = key.toString();

      if (line.startsWith("O")) // order
      {
        String keyIdS = line.substring(1, line.length() - 1);
        String placeId = line.substring(line.length() - 1);
        Integer keyId = 0;

        try {
          keyId = Integer.parseInt(keyIdS);
        } catch (Exception ex) {
          return 0;
        }
        if (keyId % 2 == 1) {
          // 4,5,6,7
          if (placeId.equalsIgnoreCase("A")) {
            return 4;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 5;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 6;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 7;
          } else {
            return 0;
          }
        } else {
          // 0,1,2,3
          if (placeId.equalsIgnoreCase("A")) {
            return 0;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 1;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 2;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 3;
          } else {
            return 0;
          }
        }
      } else if (line.startsWith("P")) // part
      {
        String keyIdS = line.substring(1, line.length() - 1);
        String placeId = line.substring(line.length() - 1);
        Integer keyId = 0;

        try {
          keyId = Integer.parseInt(keyIdS);
        } catch (Exception ex) {
          return 0;
        }

        if (keyId % 2 == 1) {
          // 2,3,6,7
          if (placeId.equalsIgnoreCase("A")) {
            return 2;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 3;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 6;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 7;
          } else {
            return 0;
          }
        } else {
          // 0,1,4,5
          if (placeId.equalsIgnoreCase("A")) {
            return 0;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 1;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 4;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 5;
          } else {
            return 0;
          }
        }
      } else if (line.startsWith("S")) // supplier
      {
        String keyIdS = line.substring(1, line.length() - 1);
        String placeId = line.substring(line.length() - 1);
        Integer keyId = 0;

        try {
          keyId = Integer.parseInt(keyIdS);
        } catch (Exception ex) {
          return 0;
        }

        if (keyId % 2 == 1) {
          // 1,3,5,7
          if (placeId.equalsIgnoreCase("A")) {
            return 1;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 3;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 5;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 7;
          } else {
            return 0;
          }
        } else {
          // 0,2,4,6
          if (placeId.equalsIgnoreCase("A")) {
            return 0;
          } else if (placeId.equalsIgnoreCase("B")) {
            return 2;
          } else if (placeId.equalsIgnoreCase("C")) {
            return 4;
          } else if (placeId.equalsIgnoreCase("D")) {
            return 6;
          } else {
            return 0;
          }
        }
      } else if (line.startsWith("L")) // lineitem
      {
        String[] keyIdS = line.substring(1).split("[+]");

        Integer keyId0 = 0;
        Integer keyId1 = 0;
        Integer keyId2 = 0;

        try {
          keyId0 = Integer.parseInt(keyIdS[0].substring(1)) % 2; // Order
          keyId1 = Integer.parseInt(keyIdS[1].substring(1)) % 2; // Part
          keyId2 = Integer.parseInt(keyIdS[2].substring(1)) % 2; // Supplier
        } catch (Exception ex) {
          return 0;
        }
        return 4 * keyId0 + 2 * keyId1 + 1 * keyId2;

      } else {
        return 0;
      }
    }