예제 #1
0
void endstate(
        dict *d, lin_dict *ko_ld,
        node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes,
        state *s, node_value parent_v, int turn, int low_player
    ) {
    if (s->passes == 2) {
        if (turn) {
            stones_t temp = s->player;
            s->player = s->opponent;
            s->opponent = temp;
        }
        return;
    }
    state child_;
    state *child = &child_;
    for (int j = -1; j < STATE_SIZE; j++) {
        *child = *s;
        stones_t move;
        if (j == -1){
            move = 0;
        }
        else {
            move = 1UL << j;
        }
        node_value child_v;
        if (make_move(child, move)) {
            canonize(child);
            size_t child_key = to_key(child);
            if (child->passes == 2){
                value_t score = liberty_score(child);
                child_v = (node_value) {score, score, 0, 0};
            }
            else if (child->passes == 1) {
                child_v = pass_nodes[key_index(d, child_key)];
            }
            else if (child->ko) {
                child_key = child_key * STATE_SIZE + bitscan(child->ko);
                child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
            }
            else {
                child_v = base_nodes[key_index(d, child_key)];
            }
            int is_best_child = (-child_v.high == parent_v.low && child_v.high_distance + 1 == parent_v.low_distance);
            is_best_child = low_player ? is_best_child : (-child_v.low == parent_v.high && child_v.low_distance + 1 == parent_v.high_distance);
            if (is_best_child) {
                *s = *child;
                endstate(
                    d, ko_ld,
                    base_nodes, pass_nodes, ko_nodes,
                    s, child_v, !turn, !low_player
                );
            }
        }
    }
}
예제 #2
0
// scan services
void test_scan_services() {

  // setup
  hashdb_settings_t settings;
  rm_hashdb_dir(temp_dir1);
  commands_t::create(settings, temp_dir1);
  commands_t::import(temp_dir1, sample_dfxml4096, "repository1");

  // scan
  commands_t::scan(temp_dir1, sample_dfxml4096);
  hash_t k1;
  to_key(1, k1);
  commands_t::scan_hash(temp_dir1, k1.hexdigest());
}
예제 #3
0
int main(int argc, char *argv[]) {
    if (argc != 3) {
        printf("Usage: %s width height\n", argv[0]);
        return 0;
    }
    int width = atoi(argv[1]);
    int height = atoi(argv[2]);
    if (width <= 0) {
        printf("Width must be larger than 0.\n");
        return 0;
    }
    if (width >= 7) {
        printf("Width must be less than 7.\n");
        return 0;
    }
    if (height <= 0) {
        printf("Height must be larger than 0.\n");
        return 0;
    }
    if (height >= 6) {
        printf("Height must be less than 6.\n");
        return 0;
    }

    state s_ = (state) {rectangle(width, height), 0, 0, 0, 0};
    state *s = &s_;

    dict d_;
    dict *d = &d_;

    size_t max_k = max_key(s);
    init_dict(d, max_k);

    size_t key_min = ~0;
    size_t key_max = 0;

    size_t total_legal = 0;
    for (size_t k = 0; k < max_k; k++) {
        if (!from_key(s, k)){
            continue;
        }
        total_legal++;
        canonize(s);
        size_t key = to_key(s);
        add_key(d, key);
        if (key < key_min) {
            key_min = key;
        }
        if (key > key_max) {
            key_max = key;
        }
    }
    resize_dict(d, key_max);
    finalize_dict(d);
    size_t num_states = num_keys(d);

    printf("Total legal positions %zu\n", total_legal);
    printf("Total unique positions %zu\n", num_states);

    node_value *base_nodes = (node_value*) malloc(num_states * sizeof(node_value));
    node_value *pass_nodes = (node_value*) malloc(num_states * sizeof(node_value));
    value_t *leaf_nodes = (value_t*) malloc(num_states * sizeof(value_t));

    lin_dict ko_ld_ = (lin_dict) {0, 0, 0, NULL};
    lin_dict *ko_ld = &ko_ld_;

    state child_;
    state *child = &child_;
    size_t child_key;
    size_t key = key_min;
    for (size_t i = 0; i < num_states; i++) {
        assert(from_key(s, key));
        value_t score = liberty_score(s);
        leaf_nodes[i] = score;
        pass_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
        base_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
        for (int j = 0; j < STATE_SIZE; j++) {
            *child = *s;
            if (make_move(child, 1UL << j)) {
                if (child->ko) {
                    canonize(child);
                    child_key = to_key(child) * STATE_SIZE + bitscan(child->ko);
                    add_lin_key(ko_ld, child_key);
                }
            }
        }
        key = next_key(d, key);
    }

    finalize_lin_dict(ko_ld);

    node_value *ko_nodes = (node_value*) malloc(ko_ld->num_keys * sizeof(node_value));
    printf("Unique positions with ko %zu\n", ko_ld->num_keys);

    for (size_t i = 0; i < ko_ld->num_keys; i++) {
        ko_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
    }

    #ifndef PRELOAD
    printf("Negamax with Chinese rules.\n");
    iterate(
        d, ko_ld,
        base_nodes, pass_nodes, ko_nodes, leaf_nodes,
        s, key_min, 0
    );
    #endif

    char dir_name[16];
    sprintf(dir_name, "%dx%d", width, height);
    struct stat sb;
    if (stat(dir_name, &sb) == -1) {
        mkdir(dir_name, 0700);
    }
    assert(chdir(dir_name) == 0);
    FILE *f;

    #ifndef PRELOAD
    f = fopen("d_slots.dat", "wb");
    fwrite((void*) d->slots, sizeof(slot_t), d->num_slots, f);
    fclose(f);
    f = fopen("d_checkpoints.dat", "wb");
    fwrite((void*) d->checkpoints, sizeof(size_t), (d->num_slots >> 4) + 1, f);
    fclose(f);
    f = fopen("ko_ld_keys.dat", "wb");
    fwrite((void*) ko_ld->keys, sizeof(size_t), ko_ld->num_keys, f);
    fclose(f);

    f = fopen("base_nodes.dat", "wb");
    fwrite((void*) base_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("pass_nodes.dat", "wb");
    fwrite((void*) pass_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("leaf_nodes.dat", "wb");
    fwrite((void*) leaf_nodes, sizeof(value_t), num_states, f);
    fclose(f);
    f = fopen("ko_nodes.dat", "wb");
    fwrite((void*) ko_nodes, sizeof(node_value), ko_ld->num_keys, f);
    fclose(f);
    #endif

    #ifdef PRELOAD
    f = fopen("base_nodes.dat", "rb");
    fread((void*) base_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("pass_nodes.dat", "rb");
    fread((void*) pass_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("leaf_nodes.dat", "rb");
    fread((void*) leaf_nodes, sizeof(value_t), num_states, f);
    fclose(f);
    f = fopen("ko_nodes.dat", "rb");
    fread((void*) ko_nodes, sizeof(node_value), ko_ld->num_keys, f);
    fclose(f);
    #endif

    // Japanese leaf state calculation.
    state new_s_;
    state *new_s = &new_s_;
    key = key_min;
    for (size_t i = 0; i < num_states; i++) {
        assert(from_key(s, key));
        stones_t empty = s->playing_area & ~(s->player | s->opponent);

        *new_s = *s;
        endstate(
            d, ko_ld,
            base_nodes, pass_nodes, ko_nodes,
            new_s, base_nodes[i], 0, 1
        );

        stones_t player_controlled = new_s->player | liberties(new_s->player, new_s->playing_area & ~new_s->opponent);
        stones_t opponent_controlled = new_s->opponent | liberties(new_s->opponent, new_s->playing_area & ~new_s->player);
        value_t score = popcount(player_controlled & empty) - popcount(opponent_controlled & empty);
        score += 2 * (popcount(player_controlled & s->opponent) - popcount(opponent_controlled & s->player));
        leaf_nodes[i] = score;

        *new_s = *s;
        endstate(
            d, ko_ld,
            base_nodes, pass_nodes, ko_nodes,
            new_s, base_nodes[i], 0, 0
        );

        player_controlled = new_s->player | liberties(new_s->player, new_s->playing_area & ~new_s->opponent);
        opponent_controlled = new_s->opponent | liberties(new_s->opponent, new_s->playing_area & ~new_s->player);
        score = popcount(player_controlled & empty) - popcount(opponent_controlled & empty);
        score += 2 * (popcount(player_controlled & s->opponent) - popcount(opponent_controlled & s->player));
        leaf_nodes[i] += score;

        key = next_key(d, key);
    }

    // Clear the rest of the tree.
    for (size_t i = 0; i < num_states; i++) {
        pass_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
        base_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
    }
    for (size_t i = 0; i < ko_ld->num_keys; i++) {
        ko_nodes[i] = (node_value) {VALUE_MIN, VALUE_MAX, DISTANCE_MAX, DISTANCE_MAX};
    }

    printf("Negamax with Japanese rules.\n");
    iterate(
        d, ko_ld,
        base_nodes, pass_nodes, ko_nodes, leaf_nodes,
        s, key_min, 1
    );

    f = fopen("base_nodes_j.dat", "wb");
    fwrite((void*) base_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("pass_nodes_j.dat", "wb");
    fwrite((void*) pass_nodes, sizeof(node_value), num_states, f);
    fclose(f);
    f = fopen("leaf_nodes_j.dat", "wb");
    fwrite((void*) leaf_nodes, sizeof(value_t), num_states, f);
    fclose(f);
    f = fopen("ko_nodes_j.dat", "wb");
    fwrite((void*) ko_nodes, sizeof(node_value), ko_ld->num_keys, f);
    fclose(f);

    return 0;
}
예제 #4
0
void iterate(
        dict *d, lin_dict *ko_ld,
        node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes, value_t *leaf_nodes,
        state *s, size_t key_min, int japanese_rules
    ) {
    state child_;
    state *child = &child_;

    size_t num_states = num_keys(d);

    int changed = 1;
    while (changed) {
        changed = 0;
        size_t key = key_min;
        for (size_t i = 0; i < 2 * num_states + ko_ld->num_keys; i++) {
            if (i < 2 * num_states) {
                assert(from_key(s, key));
                if (i % 2 == 1) {
                    s->passes = 1;
                }
            }
            else {
                key = ko_ld->keys[i - 2 * num_states];
                size_t ko_pos = key % STATE_SIZE;
                key /= STATE_SIZE;
                assert(from_key(s, key));
                s->ko = 1UL << ko_pos;
            }
            node_value new_v = (node_value) {VALUE_MIN, VALUE_MIN, DISTANCE_MAX, 0};
            for (int j = -1; j < STATE_SIZE; j++) {
                size_t child_key;
                node_value child_v;
                *child = *s;
                stones_t move;
                if (j == -1){
                    move = 0;
                }
                else {
                    move = 1UL << j;
                }
                if (make_move(child, move)) {
                    canonize(child);
                    child_key = to_key(child);
                    if (child->passes == 2){
                        value_t score = leaf_nodes[key_index(d, child_key)];
                        child_v = (node_value) {score, score, 0, 0};
                    }
                    else if (child->passes == 1) {
                        child_v = pass_nodes[key_index(d, child_key)];
                    }
                    else if (child->ko) {
                        child_key = child_key * STATE_SIZE + bitscan(child->ko);
                        child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
                    }
                    else {
                        child_v = base_nodes[key_index(d, child_key)];
                    }
                    if (japanese_rules) {
                        int prisoners = (popcount(s->opponent) - popcount(child->player)) * PRISONER_VALUE;
                        if (child_v.low > VALUE_MIN) {
                            child_v.low = child_v.low - prisoners;
                        }
                        if (child_v.high < VALUE_MAX) {
                            child_v.high = child_v.high - prisoners;
                        }
                    }
                    new_v = negamax(new_v, child_v);
                }
            }
            assert(new_v.high_distance > 0);
            if (i < 2 * num_states) {
                if (i % 2 == 0) {
                    assert(new_v.low_distance > 1);
                    assert(new_v.high_distance > 1);
                    assert(new_v.low >= base_nodes[i / 2].low);
                    assert(new_v.high <= base_nodes[i / 2].high);
                    changed = changed || !equal(base_nodes[i / 2], new_v);
                    base_nodes[i / 2] = new_v;
                }
                else {
                    changed = changed || !equal(pass_nodes[i / 2], new_v);
                    pass_nodes[i / 2] = new_v;
                    key = next_key(d, key);
                }
            }
            else {
                changed = changed || !equal(ko_nodes[i - 2 * num_states], new_v);
                ko_nodes[i - 2 * num_states] = new_v;
            }
        }
        print_node(base_nodes[0]);
    }
    for (size_t i = 0; i < ko_ld->num_keys; i++) {
        assert(ko_nodes[i].low_distance > 2);
        assert(ko_nodes[i].high_distance > 2);
    }

    for (size_t i = 0; i < num_states; i++) {
        assert(base_nodes[i].low_distance > 1);
        assert(base_nodes[i].high_distance > 1);
        assert(pass_nodes[i].low_distance > 0);
        assert(pass_nodes[i].high_distance > 0);
    }
}
예제 #5
0
void rw_new_tests() {

  // valid hashdigest values
  hash_t k1;
  hash_t k2;
  to_key(1, k1);
  to_key(2, k2);

  hashdb_element_t element;

  // create working changes object
  hashdb_changes_t changes;

  // open new hashdb manager
  hashdb_manager_t manager(temp_dir, RW_NEW);

  // ************************************************************
  // initial state
  // ************************************************************
  // check initial size
  BOOST_TEST_EQ(manager.map_size(), 0);

  // check initial iterator
  BOOST_TEST_EQ((manager.begin() == manager.end()), true);

  // ************************************************************
  // insert, remove, and hashdb_changes variables
  // note: some of these tests additionally test failure ordering
  // ************************************************************
  // insert valid
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_inserted, 1);
  BOOST_TEST_EQ(manager.map_size(), 1);

  // insert, mismatched hash block size
  element = hashdb_element_t(k1, 5, "rep1", "file1", 0);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_inserted_mismatched_hash_block_size, 1);
  BOOST_TEST_EQ(manager.map_size(), 1);

  // insert, file offset not aligned
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 5);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_inserted_invalid_byte_alignment, 1);
  BOOST_TEST_EQ(manager.map_size(), 1);

  // insert, no exact duplicates
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 4096);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_inserted, 2);
  BOOST_TEST_EQ(manager.map_size(), 2);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_inserted_duplicate_element, 1);
  BOOST_TEST_EQ(manager.map_size(), 2);

  // max 4 elements of same hash
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);
  element = hashdb_element_t(k2, 4096, "rep1", "file2", 4096);
  manager.insert(element, changes);
  element = hashdb_element_t(k2, 4096, "rep2", "file1", 4096);
  manager.insert(element, changes);
  element = hashdb_element_t(k2, 4096, "rep3", "file1", 4096); // too many
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_inserted_exceeds_max_duplicates, 1);
  BOOST_TEST_EQ(manager.map_size(), 5);

  // delete elements of same hash
  element = hashdb_element_t(k2, 4096, "rep3", "file1", 4096); // not present
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_removed, 0);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_element, 1);
  BOOST_TEST_EQ(manager.map_size(), 5);
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 4096);
  manager.remove(element, changes);
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 0);
  manager.remove(element, changes);
  element = hashdb_element_t(k2, 4096, "rep1", "file2", 4096);
  manager.remove(element, changes);
  element = hashdb_element_t(k2, 4096, "rep2", "file1", 4096);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_removed, 4);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_element, 1);
  BOOST_TEST_EQ(manager.map_size(), 1);

  // remove, entry of single element
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 0);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_removed, 5);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_element, 1);
  BOOST_TEST_EQ(manager.map_size(), 0);

  // remove, no element
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 0);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_element, 2);
  BOOST_TEST_EQ(manager.map_size(), 0);

  // insert, valid, previously deleted
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);
  BOOST_TEST_EQ(changes.hashes_inserted, 6);

  // remove_key successfully
  manager.remove_key(k1, changes);
  BOOST_TEST_EQ(changes.hashes_removed, 6);

  // add two of same key then remove_key successfully
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);
  element = hashdb_element_t(k2, 4096, "rep1", "file2", 4096);
  manager.insert(element, changes);
  manager.remove_key(k2, changes);
  BOOST_TEST_EQ(changes.hashes_removed, 8);

  // remove_key no hash
  manager.remove_key(k1, changes);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_hash, 1);

  // remove, mismatched hash block size
  element = hashdb_element_t(k1, 5, "rep1", "file1", 0);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_removed_mismatched_hash_block_size, 1);

  // remove, file offset not aligned
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 5);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_removed_invalid_byte_alignment, 1);

  // remove, no element
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 0);
  manager.remove(element, changes);
  BOOST_TEST_EQ(changes.hashes_not_removed_no_element, 3);

  // ************************************************************
  // find, find_count, size, iterator
  // ************************************************************
  BOOST_TEST_EQ(manager.find_count(k1), 0);
  BOOST_TEST_EQ(manager.find_count(k1), 0);

  // setup with one element to make iterator simple
  element = hashdb_element_t(k1, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);
  BOOST_TEST_EQ(manager.map_size(), 1);
  hashdb_iterator_t it(manager.begin());
  BOOST_TEST_EQ(it->key, k1);
  BOOST_TEST_EQ(it->hash_block_size, 4096);
  BOOST_TEST_EQ(it->repository_name, "rep1");
  BOOST_TEST_EQ(it->filename, "file1");
  BOOST_TEST_EQ(it->file_offset, 0);
  BOOST_TEST_EQ((*it).file_offset, 0);
  ++it;
  BOOST_TEST_EQ((it == manager.end()), true);

  // setup with two elements under one key and one element under another key
  element = hashdb_element_t(k1, 4096, "second_rep1", "file1", 0);
  manager.insert(element, changes);
  element = hashdb_element_t(k2, 4096, "rep1", "file1", 0);
  manager.insert(element, changes);

  BOOST_TEST_EQ(manager.find_count(k1), 2);
  BOOST_TEST_EQ(manager.map_size(), 3);

  hashdb_iterator_t it2(manager.begin());
  ++it2;
  it2++;
  ++it2;

  BOOST_TEST_EQ((it2 == manager.end()), true);

  // check iterator pair from find
  std::pair<hashdb_iterator_t, hashdb_iterator_t> it_pair;
  it_pair = manager.find(k1);
  ++it_pair.first;
  ++it_pair.first;
  BOOST_TEST_EQ((it_pair.first == it_pair.second), true);
  it_pair = manager.find(k1);
  ++it_pair.first;
  ++it_pair.first;
  BOOST_TEST_EQ((it_pair.first == it_pair.second), true);

  // ************************************************************
  // install lots of data
  // ************************************************************
  // populate with 1,000,000 entries
  hash_t key;
  BOOST_TEST_EQ(manager.map_size(), 3);
  for (uint64_t n=0; n< 1000000; ++n) {
    to_key(n+1000000, key);
    element = hashdb_element_t(key, 4096, "rep1", "file1", 0);
    manager.insert(element, changes);
  }
  BOOST_TEST_EQ(manager.map_size(), 1000003);
}
예제 #6
0
int main(int argc, char *argv[]) {
    if (argc != 3 && argc != 4) {
        printf("Usage: %s width height high_path\n", argv[0]);
        return 0;
    }
    int width = atoi(argv[1]);
    int height = atoi(argv[2]);
    if (width <= 0) {
        printf("Width must be larger than 0.\n");
        return 0;
    }
    if (width >= 7) {
        printf("Width must be less than 7.\n");
        return 0;
    }
    if (height <= 0) {
        printf("Height must be larger than 0.\n");
        return 0;
    }
    if (height >= 6) {
        printf("Height must be less than 6.\n");
        return 0;
    }
    int player_low = 1;
    if (argc == 4) {
        player_low = 0;
    }

    state s_ = (state) {rectangle(width, height), 0, 0, 0, 0};
    state *s = &s_;

    char dir_name[16];
    sprintf(dir_name, "%dx%d", width, height);
    assert(chdir(dir_name) == 0);

    dict d_;
    dict *d = &d_;
    d->num_slots = load_dat("d_slots.dat", (void**) &(d->slots), sizeof(slot_t));
    load_dat("d_checkpoints.dat", (void**) &(d->checkpoints), sizeof(size_t));

    lin_dict ko_ld_;
    lin_dict *ko_ld = &ko_ld_;

    ko_ld->num_keys = load_dat("ko_ld_keys.dat", (void**) &(ko_ld->keys), sizeof(size_t));

    node_value *base_nodes;
    load_dat("base_nodes_j.dat", (void**) &base_nodes, sizeof(node_value));
    node_value *pass_nodes;
    load_dat("pass_nodes_j.dat", (void**) &pass_nodes, sizeof(node_value));
    node_value *ko_nodes;
    load_dat("ko_nodes_j.dat", (void**) &ko_nodes, sizeof(node_value));
    value_t *leaf_nodes;
    load_dat("leaf_nodes_j.dat", (void**) &leaf_nodes, sizeof(value_t));

    canonize(s);
    inspect(
        d, ko_ld,
        base_nodes, pass_nodes, ko_nodes, leaf_nodes,
        s, base_nodes[key_index(d, to_key(s))], player_low, 1
    );

    /*
    FILE *f;

    f = fopen("d_slots.dat", "wb");
    fwrite((void*) d->slots, sizeof(slot_t), d->num_slots, f);
    fclose(f);
    f = fopen("d_checkpoints.dat", "wb");
    fwrite((void*) d->checkpoints, sizeof(size_t), (d->num_slots >> 4) + 1, f);
    fclose(f);
    f = fopen("ko_ld_keys.dat", "wb");
    fwrite((void*) ko_ld->keys, sizeof(size_t), ko_ld->num_keys, f);
    fclose(f);
    */
}
예제 #7
0
void inspect(
        dict *d, lin_dict *ko_ld,
        node_value *base_nodes, node_value *pass_nodes, node_value *ko_nodes, value_t *leaf_nodes,
        state *s, node_value parent_v, int low_player, int japanese_rules
    ) {
    print_state(s);
    print_node(parent_v);
    if (s->passes == 2){
        return;
    }
    state child_;
    state *child = &child_;
    for (int j = -1; j < STATE_SIZE; j++) {
        *child = *s;
        stones_t move;
        if (j == -1){
            move = 0;
        }
        else {
            move = 1UL << j;
        }
        node_value child_v;
        if (make_move(child, move)) {
            canonize(child);
            size_t child_key = to_key(child);
            if (child->passes == 2){
                value_t score = leaf_nodes[key_index(d, child_key)];
                child_v = (node_value) {score, score, 0, 0};
            }
            else if (child->passes == 1) {
                child_v = pass_nodes[key_index(d, child_key)];
            }
            else if (child->ko) {
                child_key = child_key * STATE_SIZE + bitscan(child->ko);
                child_v = ko_nodes[lin_key_index(ko_ld, child_key)];
            }
            else {
                child_v = base_nodes[key_index(d, child_key)];
            }

            node_value child_tree_v = child_v;
            if (japanese_rules) {
                int prisoners = (popcount(s->opponent) - popcount(child->player)) * PRISONER_VALUE;
                if (child_v.low > VALUE_MIN) {
                    child_v.low = child_v.low - prisoners;
                }
                if (child_v.high < VALUE_MAX) {
                    child_v.high = child_v.high - prisoners;
                }
            }

            int is_best_child = (-child_v.high == parent_v.low && child_v.high_distance + 1 == parent_v.low_distance);
            is_best_child = low_player ? is_best_child : (-child_v.low == parent_v.high && child_v.low_distance + 1 == parent_v.high_distance);
            if (is_best_child) {
                *s = *child;
                inspect(
                    d, ko_ld,
                    base_nodes, pass_nodes, ko_nodes, leaf_nodes,
                    s, child_tree_v, !low_player, japanese_rules
                );
                return;
            }
        }
    }
    assert(0);
}
예제 #8
0
int flashnode_build_config(struct list_head *params,
			   struct flashnode_rec *fnode, struct iovec *iovs)
{
	struct user_param *param;
	struct iovec *iov = NULL;
	int count = 0;
	int port = 3260;

	/* start at 2, because 0 is for nlmsghdr and 1 for event */
	iov = iovs + 2;

	list_for_each_entry(param, params, list) {
		if (!strcmp(param->name, FLASHNODE_SESS_AUTO_SND_TGT_DISABLE)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_AUTO_SND_TGT_DISABLE,
			    fnode->sess.auto_snd_tgt_disable))
				count++;
		} else if (!strcmp(param->name,
				   FLASHNODE_SESS_DISCOVERY_SESS)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_DISCOVERY_SESS,
			    fnode->sess.discovery_session))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_ENTRY_EN)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_ENTRY_EN,
			    fnode->sess.entry_enable))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_IMM_DATA_EN)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_IMM_DATA_EN,
			    fnode->sess.immediate_data))
				count++;
		} else if (!strcmp(param->name,
				   FLASHNODE_SESS_INITIAL_R2T_EN)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_INITIAL_R2T_EN,
			    fnode->sess.initial_r2t))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DATASEQ_INORDER)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_DATASEQ_INORDER,
			    fnode->sess.data_seq_in_order))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_PDU_INORDER)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_PDU_INORDER,
			    fnode->sess.data_pdu_in_order))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_CHAP_AUTH_EN)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_CHAP_AUTH_EN,
			    fnode->sess.chap_auth_en))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DISCOVERY_LOGOUT_EN)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_DISCOVERY_LOGOUT_EN,
			    fnode->sess.discovery_logout_en))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_BIDI_CHAP_EN )) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_BIDI_CHAP_EN,
			    fnode->sess.bidi_chap_en))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DISCOVERY_AUTH_OPTIONAL)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_DISCOVERY_AUTH_OPTIONAL,
			    fnode->sess.discovery_auth_optional))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_ERL)) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_ERL,
			    fnode->sess.erl))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DEF_TIME2WAIT)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_DEF_TIME2WAIT,
			    fnode->sess.def_time2wait))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DEF_TIME2RETAIN)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_DEF_TIME2RETAIN,
			    fnode->sess.def_time2retain))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_MAX_R2T)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_MAX_R2T,
			    fnode->sess.max_outstanding_r2t))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_TSID)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_TSID,
			    fnode->sess.tsid))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_MAX_BURST)) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_MAX_BURST,
			    fnode->sess.max_burst_len))
				count++;
		} else if (!strcmp(param->name,
				  FLASHNODE_SESS_DEF_TASKMGMT_TMO)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_DEF_TASKMGMT_TMO,
			    fnode->sess.def_taskmgmt_tmo))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_NAME)) {
			if (!flashnode_fill_str(fnode, &iov[count],
			    ISCSI_FLASHNODE_NAME,
			    fnode->sess.targetname,
			    sizeof(fnode->sess.targetname)))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_FIRST_BURST)) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_FIRST_BURST,
			    fnode->sess.first_burst_len))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_ISID)) {
			if (!flashnode_fill_isid(fnode, &iov[count]))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_ALIAS)) {
			if (!flashnode_fill_str(fnode, &iov[count],
			    ISCSI_FLASHNODE_ALIAS,
			    fnode->sess.targetalias,
			    sizeof(fnode->sess.targetalias)))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_TPGT)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_TPGT,
			    fnode->sess.tpgt))
				count++;
		} else if (!strcmp(param->name,
			  FLASHNODE_SESS_DISCOVERY_PARENT_IDX)) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_DISCOVERY_PARENT_IDX,
			    fnode->sess.discovery_parent_idx))
				count++;
		} else if (!strcmp(param->name,
			  FLASHNODE_SESS_DISCOVERY_PARENT_TYPE)) {
			if (!flashnode_fill_str(fnode, &iov[count],
			    ISCSI_FLASHNODE_DISCOVERY_PARENT_TYPE,
			    fnode->sess.discovery_parent_type,
			    sizeof(fnode->sess.discovery_parent_type)))
				count++;
		} else if (!strcmp(param->name, FLASHNODE_SESS_PORTAL_TYPE)) {
			if (!flashnode_fill_str(fnode, &iov[count],
			    ISCSI_FLASHNODE_PORTAL_TYPE,
			    fnode->sess.portal_type,
			    sizeof(fnode->sess.portal_type)))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_SESS_CHAP_OUT_IDX))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_CHAP_OUT_IDX,
			    fnode->sess.chap_out_idx))
				count++;
		} else if (!strcmp(param->name, to_key(FLASHNODE_CONN_PORT))) {
			if (fnode->conn[0].port)
				port = fnode->conn[0].port;
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_PORT, port))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IPADDR))) {
			if (!flashnode_fill_ipaddr(fnode, &iov[count],
						   ISCSI_FLASHNODE_IPADDR))
					count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_MAX_RECV_DLENGTH))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_MAX_RECV_DLENGTH,
			    fnode->conn[0].max_recv_dlength))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IS_FW_ASSIGNED_IPV6))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_IS_FW_ASSIGNED_IPV6,
			    fnode->conn[0].is_fw_assigned_ipv6))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_HDR_DGST_EN))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_HDR_DGST_EN,
			    fnode->conn[0].header_digest_en))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_DATA_DGST_EN))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_DATA_DGST_EN,
			    fnode->conn[0].data_digest_en))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_SNACK_REQ_EN))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_SNACK_REQ_EN,
			    fnode->conn[0].snack_req_en))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_TIMESTAMP_STAT))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_TIMESTAMP_STAT,
			    fnode->conn[0].tcp_timestamp_stat))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_NAGLE_DISABLE))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_NAGLE_DISABLE,
			    fnode->conn[0].tcp_nagle_disable))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_WSF_DISABLE))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_WSF_DISABLE,
			    fnode->conn[0].tcp_wsf_disable))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_TIMER_SCALE))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_TIMER_SCALE,
			    fnode->conn[0].tcp_timer_scale))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_TIMESTAMP_EN))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_TIMESTAMP_EN,
			    fnode->conn[0].tcp_timestamp_en))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IP_FRAG_DISABLE))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_IP_FRAG_DISABLE,
			    fnode->conn[0].fragment_disable))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_MAX_XMIT_DLENGTH))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_MAX_XMIT_DLENGTH,
			    fnode->conn[0].max_xmit_dlength))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_KEEPALIVE_TMO))) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_KEEPALIVE_TMO,
			    fnode->conn[0].keepalive_tmo))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_REDIRECT_IPADDR))) {
			if (!flashnode_fill_ipaddr(fnode, &iov[count],
					ISCSI_FLASHNODE_REDIRECT_IPADDR))
					count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_MAX_SEGMENT_SIZE))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_MAX_SEGMENT_SIZE,
			    fnode->conn[0].max_segment_size))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_LOCAL_PORT))) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_LOCAL_PORT,
			    fnode->conn[0].local_port))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IPV4_TOS))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_IPV4_TOS,
			    fnode->conn[0].ipv4_tos))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IPV6_TC))) {
			if (!flashnode_fill_uint8(fnode, &iov[count],
			    ISCSI_FLASHNODE_IPV6_TC,
			    fnode->conn[0].ipv6_traffic_class))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_IPV6_FLOW_LABEL))) {
			if (!flashnode_fill_uint16(fnode, &iov[count],
			    ISCSI_FLASHNODE_IPV6_FLOW_LABEL,
			    fnode->conn[0].ipv6_flow_lbl))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_LINK_LOCAL_IPV6))) {
			if (!flashnode_fill_ipv6_addr(fnode, &iov[count],
					ISCSI_FLASHNODE_LINK_LOCAL_IPV6))
					count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_XMIT_WSF))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_XMIT_WSF,
			    fnode->conn[0].tcp_xmit_wsf))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_TCP_RECV_WSF))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_TCP_RECV_WSF,
			    fnode->conn[0].tcp_recv_wsf))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_STATSN))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_STATSN,
			    fnode->conn[0].stat_sn))
				count++;
		} else if (!strcmp(param->name,
			  to_key(FLASHNODE_CONN_EXP_STATSN))) {
			if (!flashnode_fill_uint32(fnode, &iov[count],
			    ISCSI_FLASHNODE_EXP_STATSN,
			    fnode->conn[0].exp_stat_sn))
				count++;
		}
	}

	return count;
}