コード例 #1
0
static void
reduce_using_and(IntMap &map, std::vector<std::unique_ptr<Step>> &steps)
{
    IntPairs map_entries(begin(map), end(map));
    IntMap tmp;
    tmp.reserve(map_entries.size());
    std::bitset<32> mask;
    for (int bit = 31; bit >= 0; bit--) {
        auto candidate_mask = mask;
        candidate_mask.set(bit);
        auto bitmask = ~static_cast<uint32_t>(candidate_mask.to_ulong());
        auto hash = [=](uint32_t x) {
            return x & bitmask;
        };
        if (apply_hash_to_map(map_entries, hash, tmp) &&
                tmp.size() < map_entries.size()) {
            std::swap(map, tmp);
            mask = candidate_mask;
        }
    }
    if (mask.any()) {
        steps.push_back(std::unique_ptr<Step>(new AndNotStep(mask.to_ulong())));
    }
}
コード例 #2
0
static bool
reduce_using_crc(IntMap &map,
                 bool allow_conflicts,
                 std::vector<std::unique_ptr<Step>> &steps)
{
    IntPairs map_entries(begin(map), end(map));
    std::vector<uint32_t> unique_values;
    unique_values.reserve(map_entries.size());
    for (const auto &entry : map_entries) {
        unique_values.push_back(entry.second);
    }
    std::sort(unique_values.begin(), unique_values.end());
    unique_values.erase(std::unique(unique_values.begin(), unique_values.end()),
                        unique_values.end());
    unsigned num_unique_values = unique_values.size();
    uint32_t collision_sentinal;
    if (allow_conflicts) {
        collision_sentinal = find_unused_value(unique_values);
        ++num_unique_values;
    }
    uint32_t best = 0;
    HashCost best_cost = HashCost::max();
    if (allow_conflicts) {
        best_cost.num_collisions = map_entries.size() / 4;
    } else {
        best_cost.num_collisions = 0;
        best_cost.table_size = get_lookup_table_size(map_entries);
        if (best_cost.table_size <= 4)
            return true;
        best_cost.table_size -= 4;
    }
    IntMap tmp;
    tmp.reserve(map_entries.size());
    unsigned min_width = log2_ceil(num_unique_values) - 1;
    for (unsigned width = min_width; width < 32; width++) {
        // Don't check polynomials of higher widths - we are unlikely to get any
        // further improvement.
        if (best != 0 || (1 << width) > best_cost.table_size)
            break;
        for (uint32_t poly = 1 << width; poly < (1 << (width + 1));
                poly++) {
            auto hash = [=](uint32_t x) {
                return crc32(x, poly, poly);
            };
            HashCost cost;
            if (apply_hash_to_map(map_entries, hash, best_cost, collision_sentinal,
                                  tmp, cost)) {
                best = poly;
                best_cost = cost;
            }
        }
    }
    if (best == 0)
        return true;
    auto hash = [=](uint32_t x) {
        return crc32(x, best, best);
    };
    if (best_cost.num_collisions != 0) {
        HashCost dummy;
        apply_hash_to_map(map_entries, hash, HashCost::max(), collision_sentinal,
                          tmp, dummy);
        DataType data_type = pick_datatype(tmp);
        steps.push_back(
            std::unique_ptr<Step>(
                new CrcLookupAndReturnStep(best, std::move(tmp), data_type,
                                           collision_sentinal)
            )
        );
        // Build map containing only conflicting keys.
        IntMap remaining;
        for (const auto &entry : map) {
            uint32_t x = entry.first;
            if (steps.back()->apply(x) != Step::DONE) {
                remaining.insert(entry);
            }
        }
        std::swap(map, remaining);
        return false;
    } else {
        apply_hash_to_map(map_entries, hash, map);
        steps.push_back(std::unique_ptr<Step>(new CrcStep(best)));
        return true;
    }
}