voroskoi/pistike - Change GPBZ2C3DIF64ADOS2NKXYTS6U5DYTARO6RFCZNYZBDCBC2XA4LKAC

Add option to set hash table size

Created by voroskoi on February 2, 2023

GPBZ2C3DIF64ADOS2NKXYTS6U5DYTARO6RFCZNYZBDCBC2XA4LKAC

Dependencies

In channels

main

Change contents

Insertion in src/uci.zig at line 12 [4.32]

[3.85]

[4.270]


const MIN_HASH_SIZE = 4;
const MAX_HASH_SIZE = 256;
pub const EngineOptions = struct {
    hash_size: usize = 128,
};

Replacement in src/uci.zig at line 36 [4.32]

B:BD[3.398] → [3.398:415]

    try hello();

[3.398]

[4.309]

    std.log.info("UCI engine started...", .{});
    var engine_options = EngineOptions{};

Replacement in src/uci.zig at line 46 [4.32]

B:BD[3.649] → [3.649:710]

        }
        if (std.mem.eql(u8, input, "debug on")) {

[3.649]

[3.710]

        } else if (std.mem.eql(u8, input, "debug on")) {

Replacement in src/uci.zig at line 51 [4.32]

B:BD[3.918] → [3.918:975]

        }
        if (std.mem.eql(u8, input, "stop")) {

[3.918]

[3.975]

        } else if (std.mem.eql(u8, input, "stop")) {

Replacement in src/uci.zig at line 55 [4.32]

B:BD[3.1176] → [3.1176:1187]

B:BD[3.1187] → [5.123:172]

        }
        if (std.mem.eql(u8, input, "isready")) {

[3.1176]

[5.172]

        } else if (std.mem.eql(u8, input, "isready")) {

Replacement in src/uci.zig at line 57 [4.32]

B:BD[5.206] → [5.206:256]

                search = Search.init(&gs) catch {

[5.206]

[5.256]

                search = Search.init(&gs, engine_options) catch {

Replacement in src/uci.zig at line 63 [4.32]

B:BD[5.464] → [5.464:474]

[5.464]

[3.1269]

        } else {
            if (input.len >= 9) {
                if (std.mem.eql(u8, input[0..9], "setoption")) {
                    // setoption name Hash value <val>
                    if (std.mem.containsAtLeast(u8, input, 1, "Hash")) {
                        const start = std.mem.lastIndexOfLinear(u8, input, " ") orelse continue;
                        engine_options.hash_size =
                            std.fmt.parseUnsigned(usize, input[start + 1 ..], 10) catch {
                            std.log.debug("unable to parse Hash size: `{s}`", .{input[start..]});
                            continue;
                        };
                        if (engine_options.hash_size < MIN_HASH_SIZE) {
                            engine_options.hash_size = MIN_HASH_SIZE;
                        } else if (engine_options.hash_size > MAX_HASH_SIZE) {
                            engine_options.hash_size = MAX_HASH_SIZE;
                        }
                        std.log.debug("Hash size set to {d}", .{engine_options.hash_size});
                    }
                }
            }

Replacement in src/uci.zig at line 84 [4.32]

B:BD[3.1270] → [3.1270:1407]

B:BD[3.1407] → [6.86:231]

∅:D[7.139] → [3.1407:1434]

∅:D[6.231] → [3.1407:1434]

B:BD[3.1407] → [3.1407:1434]

        if (input.len >= 8) {
            if (std.mem.eql(u8, input[0..8], "position")) {
                try parsePosition(&gs, input);
                // std.log.debug("clearing transposition table", .{});
                // search.?.tt.clear(); // XXX: is this really necessary?
                gs.show();

[3.1270]

[3.1434]

            if (input.len >= 8) {
                if (std.mem.eql(u8, input[0..8], "position")) {
                    try parsePosition(&gs, input);
                    gs.show();
                }

Deletion in src/uci.zig at line 90 [4.32]
B:BD[3.1448] → [3.1448:1458]
```
        }
```

Replacement in src/uci.zig at line 91 [4.32]

B:BD[3.1459] → [3.1459:1604]

B:BD[3.1604] → [8.90:159]

B:BD[8.159] → [2.0:163]

        if (input.len >= 3) {
            if (std.mem.eql(u8, input[0..3], "uci")) {
                if (std.mem.eql(u8, input, "ucinewgame")) {
                    std.log.debug("initializing new uci game", .{});
                    if (search != null) {
                        std.log.debug("clearing transposition table", .{});
                        search.?.tt.clear();

[3.1459]

[2.163]

            if (input.len >= 3) {
                if (std.mem.eql(u8, input[0..3], "uci")) {
                    if (std.mem.eql(u8, input, "ucinewgame")) {
                        std.log.debug("initializing new uci game", .{});
                        if (search != null) {
                            std.log.debug("clearing transposition table", .{});
                            search.?.tt.clear();
                        }
                        std.log.debug("empty moves history", .{});
                        gs.history.clearRetainingCapacity();
                        try parsePosition(&gs, "position startpos");
                        std.log.debug("new uci game initialized", .{});
                    } else {
                        try hello();

Deletion in src/uci.zig at line 106 [4.32]

∅:D[2.185] → [6.232:352]

B:BD[8.272] → [6.232:352]

∅:D[8.272] → [3.1604:1795]

∅:D[6.352] → [3.1604:1795]

B:BD[3.1604] → [3.1604:1795]

                    std.log.debug("empty moves history", .{});
                    gs.history.clearRetainingCapacity();
                    try parsePosition(&gs, "position startpos");
                    std.log.debug("new uci game initialized", .{});
                } else {
                    try hello();

Deletion in src/uci.zig at line 108 [4.32]
B:BD[3.1827] → [3.1827:1837]
```
        }
```

Replacement in src/uci.zig at line 109 [4.32]

B:BD[3.1838] → [3.1838:1922]

B:BD[3.1922] → [5.475:631]

        if (input.len >= 2) {
            if (std.mem.eql(u8, input[0..2], "go")) {
                if (search == null) {
                    std.log.err("search is not initialized, call isready first!", .{});
                    continue;

[3.1838]

[5.631]

            if (input.len >= 2) {
                if (std.mem.eql(u8, input[0..2], "go")) {
                    if (search == null) {
                        std.log.err("search is not initialized, call isready first!", .{});
                        continue;
                    }
                    const srch = try std.Thread.spawn(
                        std.Thread.SpawnConfig{},
                        parseGo,
                        .{ &search.?, input },
                    );
                    srch.detach();

Deletion in src/uci.zig at line 122 [4.32]

∅:D[5.649] → [3.1922:2048]

B:BD[3.1922] → [3.1922:2048]

B:BD[3.2048] → [5.650:693]

∅:D[5.693] → [3.2089:2139]

B:BD[3.2089] → [3.2089:2139]

                const srch = try std.Thread.spawn(
                    std.Thread.SpawnConfig{},
                    parseGo,
                    .{ &search.?, input },
                );
                srch.detach();

Insertion in src/uci.zig at line 131 [4.32]

[3.2327]

    try std.fmt.format(
        stdout.writer(),
        "option name Hash type spin default 64 min {d} max {d}\n",
        .{ MIN_HASH_SIZE, MAX_HASH_SIZE },
    );

Replacement in src/main.zig at line 27 [9.50]

B:BD[3.3181] → [5.1608:1651]

        var search = try Search.init(&gs);

[3.3181]

[10.1530]

        var search = try Search.init(&gs, uci.EngineOptions{});

Insertion in src/Search.zig at line 21 [13.35]
[11.36]
[12.0]
```
const uci = @import("uci.zig");
```

Replacement in src/Search.zig at line 69 [13.35]

B:BD[13.629] → [5.1692:1735]

    pub fn init(gs: *GameState) !@This() {

[13.629]

[5.1735]

    pub fn init(gs: *GameState, options: uci.EngineOptions) !@This() {

Insertion in src/Search.zig at line 73 [13.35]

[5.1808]

[8.2415]

        std.log.debug("Initializin Search, options: {any}", .{options});

Replacement in src/Search.zig at line 76 [13.35]

B:BD[8.2463] → [8.2463:2541]

            .tt = try Transposition.Table.init(gs.allocator, 16 * (1 << 20)),

[8.2463]

[8.2541]

            .tt = try Transposition.Table.init(gs.allocator, options.hash_size * (1 << 20)),