CookieCat's pawn structure code

[sje]

CookieCat currently recognizes seven pawn structure attributes. A sample:
[d]2qrr1n1/3b1kp1/2pBpn1p/1p2PP2/p2P4/1BP5/P3Q1PP/4RRK1 w - - 0 1[/d]

Code: Select all

[] sfen 2qrr1n1/3b1kp1/2pBpn1p/1p2PP2/p2P4/1BP5/P3Q1PP/4RRK1 w - - 0 1
[] dps 
Backward  (white): [c3]
Backward  (black): [c6 e6 g7]
Connected (white): [g2 h2 c3 d4 e5 f5]
Connected (black): [a4 b5 c6 h6 g7]
Isolated  (white): [a2]
Isolated  (black): [e6]
Location  (white): [a2 g2 h2 c3 d4 e5 f5]
Location  (black): [a4 b5 c6 e6 h6 g7]
Majority  (white): [g2 d4 e5 f5]
Majority  (black): [a4 b5]
Multiple  (white): []
Multiple  (black): []
Passed    (white): []
Passed    (black): []

At present, only the location attribute is scored. Its values come from [color, sq] table look-ups.

Attribute recognition:

Code: Select all

    { Bitboard }

    bbtype =
      record
        case Boolean of
          False: (wvec: array [bbwtype] of bbwspantype); { Array of bitboard words }
          True:  (bv64: ui64type)                        { Unsigned 64 bit value }
      end;

    { Bitboard color indexed vector }

    bbcivtype = array [colorrtype] of bbtype;

    { Pawn structure }

    pawnstructtype =
      record
        backward:  bbcivtype; { Backward pawns by color }
        connected: bbcivtype; { Connected pawns by color }
        isolated:  bbcivtype; { Isolated pawns by color }
        location:  bbcivtype; { Locus of pawns by color }
        majority:  bbcivtype; { Three file majority pawns by color }
        multiple:  bbcivtype; { Doubled (and worse) multiple pawns by color }
        passed:    bbcivtype  { Passed pawns by color }
      end;

  procedure PawnStructReset(var pawnstruct: pawnstructtype);
    var
      color: colorrtype;
  begin
    with pawnstruct do
      for color := colorrmin to colorrmax do
        begin
          BbReset(backward[color]);
          BbReset(connected[color]);
          BbReset(isolated[color]);
          BbReset(location[color]);
          BbReset(majority[color]);
          BbReset(multiple[color]);
          BbReset(passed[color])
        end
  end; { PawnStructReset }

  procedure PawnStructLoadFromPos(var pawnstruct: pawnstructtype; var pos: postype);
    var
      color: colorrtype;
      c0bb, c1bb: bbtype;
      m0bb, m1bb: bbtype;
      bb: bbtype;
      sq: sqxtype;
      advdir: dirtype;
      advsq: sqxtype;
      countbb: bbtype;
  begin
    with pawnstruct, pos, bbdb do
      begin
        PawnStructReset(pawnstruct);
        for color := colorrmin to colorrmax do
          begin

            { Setup }

            c0bb := locbm[synthpawn[color]];
            c1bb := locbm[synthpawn[othercolor[color]]];
            advdir := pawnadvdir[color];

            { Scan }

            bb := c0bb;
            repeat
              sq := BbNextSq(bb);
              if sq <> sqnil then
                begin

                  &#123; Backward &#125;
                  
                  if BbNI2&#40;c0bb, guardedbbvec&#91;color, sq&#93;) then
                    begin
                      advsq &#58;= advance&#91;sq, advdir&#93;;
                      if advsq <> sqnil then
                        if not BbNI2&#40;c1bb, pawnatkbbvec&#91;color, advsq&#93;) then
                          BbSetSq&#40;backward&#91;color&#93;, sq&#41;
                    end;

                  &#123; Connected &#125;

                  if not BbNI2&#40;c0bb, connectbbvec&#91;sq&#93;) then
                    BbSetSq&#40;connected&#91;color&#93;, sq&#41;;

                  &#123; Isolated &#125;

                  if BbNI2&#40;c0bb, adjfilebbvec&#91;sq&#93;) then
                    BbSetSq&#40;isolated&#91;color&#93;, sq&#41;;

                  &#123; Location &#125;

                  location&#91;color&#93; &#58;= c0bb;

                  &#123; Majority &#125;

                  BbAnd2&#40;m0bb, c0bb, majfilebbvec&#91;sq&#93;);
                  BbAnd2&#40;m1bb, c1bb, majfilebbvec&#91;sq&#93;);
                  if BbCount&#40;m0bb&#41; > BbCount&#40;m1bb&#41; then
                    BbSetSq&#40;majority&#91;color&#93;, sq&#41;;

                  &#123; Multiple &#125;

                  BbAnd2&#40;countbb, c0bb, bfilebbvec&#91;MapSqToBfile&#40;sq&#41;&#93;);
                  if BbCount&#40;countbb&#41; > 1 then
                    BbSetSq&#40;multiple&#91;color&#93;, sq&#41;;

                  &#123; Passed &#125;

                  if BbNI2&#40;c1bb, passerbbvec&#91;color, sq&#93;) then
                    BbSetSq&#40;passed&#91;color&#93;, sq&#41;

                end
            until sq = sqnil;
          end
      end
  end; &#123; PawnStructLoadFromPos &#125;

[sje]

CookieCat also has a pawn structure transposition table. Each entry contains a 64 bit pawn structure hash, a copy of the pawn structure bitboards, a score, and some flag data.

Storing all the pawn structure bitboards makes for a jumbo size table entry, but this is necessary to avoid recalculation of the structure when the structure data is needed for pawn/non-pawn score factor calculation. Fortunately, the hit rate for a pawn transposition table is very high, even for a modestly size table.

Note that the pawn location bitboard pair, a part of the pawn structure, is also stored in the transposition table. This appears to be slightly redundant, but these bitboards are checked at probe time to completely eliminate any possibility of a false positive match.

Code: Select all

    { Pawn transposition table entry: flag data }

    { Bits 0 - 0: 0/Free, 1/In use }
    { Bits 1 - 1: 0/WTM, 1/BTM }
    { Bits 7 - 2: Unused }

    { Pawn transposition table items }

    ttpawnentrytype =
      record
        hash:       hashtype;       { Entry signature (from position pshc hash) }
        pawnstruct: pawnstructtype; { Pawn structure }
        score:      svtype;         { Associated score }
        flagdata:   ui8type         { Packed flag data }
      end;

    ttpawnindextype = 0..ttpawnmask;                               { Pawn TT storage index }
    ttpawnptrtype   = ^ttpawntype;                                 { Pointer to pawn TT storage }
    ttpawntype      = array [ttpawnindextype] of ttpawnentrytype;  { Pawn TT storage }

  { ***** Pawn transposition table routines ***** }

  procedure TTPawnReset(var ttpawn: ttpawntype);
    var
      ttpawnindex: ttpawnindextype;
  begin
    for ttpawnindex := 0 to ttpawnmask do
      with ttpawn[ttpawnindex] do
        begin
          HashReset(hash);
          PawnStructReset(pawnstruct);
          score := svbroken;
          flagdata := 0
        end
  end; { TTPawnReset }

  function TTPawnNew: ttpawnptrtype;
    var
      myresult: ttpawnptrtype;
  begin
    New(myresult);
    TTPawnReset(myresult^);
    TTPawnNew := myresult
  end; { TTPawnNew }

  procedure TTPawnDispose(ttpawnptr: ttpawnptrtype);
  begin
    Dispose(ttpawnptr)
  end; { TTPawnDispose }

  procedure TTPawnFetchEntry(
      var ttpawn: ttpawntype; var pos: postype; var sv: svtype; var mypawnstruct: pawnstructtype);
    var
      ttpawnindex: ttpawnindextype;
  begin
    ttpawnindex := pos.pshc.bits and ttpawnmask;
    with ttpawn[ttpawnindex] do
      if (hash.bits = pos.pshc.bits) and
          BbEqual(pawnstruct.location[colorw], pos.bbdb.locbm[manwp]) and
          BbEqual(pawnstruct.location[colorb], pos.bbdb.locbm[manbp]) and
          Odd(flagdata) and (((flagdata shr 1) and 1) = pos.good) then
        begin
          sv := score;
          mypawnstruct := pawnstruct
        end
      else
        sv := svbroken
  end; { TTPawnFetchEntry }

  procedure TTPawnStashEntry(
      var ttpawn: ttpawntype; var pos: postype; sv: svtype; var mypawnstruct: pawnstructtype);
    var
      ttpawnindex: ttpawnindextype;
  begin
    ttpawnindex := pos.pshc.bits and ttpawnmask;
    with ttpawn[ttpawnindex] do
      begin
        hash := pos.pshc;
        pawnstruct := mypawnstruct;
        score := sv;
        flagdata := 1 or (pos.good shl 1)
      end
  end; { TTPawnStashEntry }