├── src
    ├── .gitignore
    ├── timer.cpp
    ├── pgn.cpp
    ├── task_component.cpp
    ├── log_board.cpp
    ├── CMakeLists.txt
    ├── chess_move.cpp
    ├── hpx_task.cpp
    ├── xboard.cpp
    ├── minimax.cpp
    ├── alphabeta.cpp
    ├── eval.cpp
    ├── data.cpp
    └── search.cpp
├── .gitignore
├── tests
    ├── ts_alltests.rb
    ├── tc_enpassant.rb
    ├── tc_castling.rb
    └── time_test.rb
├── inputs
    ├── board1
    ├── board2
    ├── board3
    └── board4
├── ChessViewer
    ├── ic_launcher-web.png
    ├── libs
    │   └── android-support-v4.jar
    ├── res
    │   ├── drawable
    │   │   ├── black_king.png
    │   │   ├── black_pawn.png
    │   │   ├── black_queen.png
    │   │   ├── black_rook.png
    │   │   ├── white_king.png
    │   │   ├── white_pawn.png
    │   │   ├── white_queen.png
    │   │   ├── white_rook.png
    │   │   ├── black_bishop.png
    │   │   ├── black_knight.png
    │   │   ├── white_bishop.png
    │   │   └── white_knight.png
    │   ├── values
    │   │   ├── styles.xml
    │   │   └── strings.xml
    │   ├── values-v11
    │   │   └── styles.xml
    │   ├── drawable-hdpi
    │   │   ├── ic_launcher.png
    │   │   └── ic_action_search.png
    │   ├── drawable-ldpi
    │   │   └── ic_launcher.png
    │   ├── drawable-mdpi
    │   │   ├── ic_launcher.png
    │   │   └── ic_action_search.png
    │   ├── drawable-xhdpi
    │   │   ├── ic_launcher.png
    │   │   └── ic_action_search.png
    │   ├── values-v14
    │   │   └── styles.xml
    │   ├── menu
    │   │   ├── activity_chess.xml
    │   │   └── mainmenu.xml
    │   └── layout
    │   │   └── activity_chess.xml
    ├── chessviewer.properties
    ├── .classpath
    ├── src
    │   └── edu
    │   │   └── lsu
    │   │       └── cct
    │   │           └── chess
    │   │               ├── Piece.java
    │   │               └── Board.java
    ├── project.properties
    ├── proguard-project.txt
    ├── .project
    ├── AndroidManifest.xml
    ├── module_chessviewer.xml
    └── chessviewer.xml
├── headers
    ├── timer.hpp
    ├── task_component_impl.hpp
    ├── pgn.hpp
    ├── log_board.hpp
    ├── hash.hpp
    ├── here.hpp
    ├── parallel.hpp
    ├── zkey.hpp
    ├── hpx_support.hpp
    ├── main.hpp
    ├── board.hpp
    ├── eval.hpp
    ├── defs.hpp
    ├── node.hpp
    ├── FixedVec.hpp
    ├── data.hpp
    ├── task_component.hpp
    ├── search.hpp
    ├── chess_move.hpp
    ├── score.hpp
    ├── combine.hpp
    ├── parallel_support.hpp
    └── database.hpp
├── docs
    ├── algorithms
    │   ├── README.txt
    │   └── src
    │   │   └── edu
    │   │       └── lsu
    │   │           └── cct
    │   │               └── minimax
    │   │                   ├── Counter.java
    │   │                   ├── Out.java
    │   │                   ├── Game.java
    │   │                   └── Node.java
    └── answers.txt
├── TODO.rst
├── LogParser
    └── log_parser.py
├── cmake
    ├── FindReadline.cmake
    └── FindSQLite3.cmake
├── CMakeLists.txt
├── README.rst
├── harness_memcheck.pl
├── harness_helgrind.pl
└── harness_plain.pl


/src/.gitignore:
--------------------------------------------------------------------------------
1 | CMakeFiles
2 | Makefile
3 | chx
4 | cmake_install.make
5 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .bench
2 | CMakeCache.txt
3 | CMakeFiles
4 | Makefile
5 | cmake_install.cmake
6 | test.db*
7 | 


--------------------------------------------------------------------------------
/tests/ts_alltests.rb:
--------------------------------------------------------------------------------
1 | require "test/unit"
2 | require "./tc_enpassant.rb"
3 | require "./tc_castling.rb"
4 | 


--------------------------------------------------------------------------------
/inputs/board1:
--------------------------------------------------------------------------------
1 | rnbqkbnr
2 | pppppppp
3 | ........
4 | ........
5 | ........
6 | ........
7 | PPPPPPPP
8 | RNBQKBNR
9 | 


--------------------------------------------------------------------------------
/ChessViewer/ic_launcher-web.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/ic_launcher-web.png


--------------------------------------------------------------------------------
/src/timer.cpp:
--------------------------------------------------------------------------------
1 | #ifdef HPX_SUPPORT
2 | #include "timer.hpp"
3 | 
4 | hpx::util::high_resolution_timer timer;
5 | #endif
6 | 


--------------------------------------------------------------------------------
/ChessViewer/libs/android-support-v4.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/libs/android-support-v4.jar


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_king.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_king.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_pawn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_pawn.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_queen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_queen.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_rook.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_rook.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_king.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_king.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_pawn.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_pawn.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_queen.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_queen.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_rook.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_rook.png


--------------------------------------------------------------------------------
/ChessViewer/res/values/styles.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <style name="AppTheme" parent="android:Theme.Light" />
4 | 
5 | </resources>


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_bishop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_bishop.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/black_knight.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/black_knight.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_bishop.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_bishop.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable/white_knight.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable/white_knight.png


--------------------------------------------------------------------------------
/ChessViewer/res/values-v11/styles.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <style name="AppTheme" parent="android:Theme.Holo.Light" />
4 | 
5 | </resources>


--------------------------------------------------------------------------------
/headers/timer.hpp:
--------------------------------------------------------------------------------
1 | #ifdef HPX_SUPPORT
2 | #include <hpx/include/util.hpp>
3 | 
4 | extern hpx::util::high_resolution_timer timer;
5 | #endif
6 | 


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-ldpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-ldpi/ic_launcher.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-hdpi/ic_action_search.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-hdpi/ic_action_search.png


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-mdpi/ic_action_search.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-mdpi/ic_action_search.png


--------------------------------------------------------------------------------
/ChessViewer/res/values-v14/styles.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <style name="AppTheme" parent="android:Theme.Holo.Light.DarkActionBar" />
4 | 
5 | </resources>


--------------------------------------------------------------------------------
/ChessViewer/res/drawable-xhdpi/ic_action_search.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/stevenrbrandt/chess/master/ChessViewer/res/drawable-xhdpi/ic_action_search.png


--------------------------------------------------------------------------------
/docs/algorithms/README.txt:
--------------------------------------------------------------------------------
1 | Just some simple java files to play with the various chess
2 | algorithms. It does this by searching a game tree that
3 | with random values.
4 | 


--------------------------------------------------------------------------------
/inputs/board2:
--------------------------------------------------------------------------------
1 | r n b q k . . r
2 | p . p p . p p p
3 | . p . . p n . .
4 | . . . . . . . .
5 | . b P P . . . .
6 | . . N . . N . .
7 | P P . . P P P P
8 | R . B Q K B . R
9 | 


--------------------------------------------------------------------------------
/ChessViewer/chessviewer.properties:
--------------------------------------------------------------------------------
1 | path.variable.maven_repository=/home/sbrandt/.m2/repository
2 | jdk.home.android_4.0.3_platform=/home/sbrandt/Download/android-sdk-linux
3 | javac2.instrumentation.includeJavaRuntime=false


--------------------------------------------------------------------------------
/headers/task_component_impl.hpp:
--------------------------------------------------------------------------------
1 | #include "task_component.hpp"
2 | 
3 | void task_component::server::cancel() {
4 | }
5 | 
6 | score_t task_component::server::search(search_info inf) {
7 |     return bad_min_score;
8 | }
9 | 


--------------------------------------------------------------------------------
/docs/algorithms/src/edu/lsu/cct/minimax/Counter.java:
--------------------------------------------------------------------------------
1 | package edu.lsu.cct.minimax;
2 | 
3 | public class Counter {
4 | 	int c=0;
5 | 	void inc() { c++; }
6 | 	public String toString() { return Integer.toString(c); }
7 | }
8 | 


--------------------------------------------------------------------------------
/headers/pgn.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CHESS_MOVE_H
 2 | 
 3 | #include "chess_move.hpp"
 4 | #include "node.hpp"
 5 | #include "data.hpp"
 6 | 
 7 | const void pgn_output(const node_t &board, const chess_move &move);
 8 | 
 9 | #endif
10 | 


--------------------------------------------------------------------------------
/docs/algorithms/src/edu/lsu/cct/minimax/Out.java:
--------------------------------------------------------------------------------
 1 | package edu.lsu.cct.minimax;
 2 | 
 3 | public class Out {
 4 | 	int indent = 0;
 5 | 	void println(String s) {
 6 | 		for(int i=0;i<indent;i++)
 7 | 			System.out.print(' ');
 8 | 		System.out.println(s);
 9 | 	}
10 | }
11 | 


--------------------------------------------------------------------------------
/inputs/board3:
--------------------------------------------------------------------------------
 1 | # From Massively Parallel Chess
 2 | # Christopher F. Joerg, Bradley C. Kuszmaul
 3 | # 1994, board (a)
 4 | r q . . r . k .
 5 | . . . . . p p .
 6 | p . . . . . . .
 7 | . . . . b N P .
 8 | . p . . P . . P
 9 | . . . . . Q . .
10 | P P . . . . K .
11 | . . . . . R . R 
12 | 


--------------------------------------------------------------------------------
/inputs/board4:
--------------------------------------------------------------------------------
 1 | # From Massively Parallel Chess
 2 | # Christopher F. Joerg, Bradley C. Kuszmaul
 3 | # 1994, board (b)
 4 | . . . . . r . k
 5 | p . q . . p p .
 6 | . p b . . . . p
 7 | n . . . R . N Q
 8 | . . . . . . . P
 9 | . . . B . P . .
10 | . . P . . . P .
11 | . . . . . . . K
12 | 


--------------------------------------------------------------------------------
/headers/log_board.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef LOG_BOARD_HPP
 2 | #define LOG_BOARD_HPP
 3 | 
 4 | #include <ostream>
 5 | #include "parallel.hpp"
 6 | #include "defs.hpp"
 7 | #include "node.hpp"
 8 | #include "board.hpp"
 9 | 
10 | void log_board(const node_t& board,std::ostream& out);
11 | 
12 | #endif
13 | 


--------------------------------------------------------------------------------
/ChessViewer/res/menu/activity_chess.xml:
--------------------------------------------------------------------------------
1 | <menu xmlns:android="http://schemas.android.com/apk/res/android">
2 |     <item android:id="@+id/menu_settings"
3 |         android:title="@string/menu_settings"
4 |         android:orderInCategory="100"
5 |         android:showAsAction="never" />
6 | </menu>
7 | 


--------------------------------------------------------------------------------
/ChessViewer/res/values/strings.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 | 
3 |     <string name="app_name">ChessViewer</string>
4 |     <string name="hello_world">Hello world!</string>
5 |     <string name="menu_settings">Settings</string>
6 |     <string name="title_activity_chess">ChessActivity</string>
7 | 
8 | </resources>


--------------------------------------------------------------------------------
/ChessViewer/res/menu/mainmenu.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="utf-8"?>
2 | <menu xmlns:android="http://schemas.android.com/apk/res/android" >
3 |     <item android:id="@+id/ChangeUrl" android:title="Change URL"></item>
4 |     <item android:id="@+id/Stop" android:title="Stop"></item>
5 |     
6 | 
7 | </menu>


--------------------------------------------------------------------------------
/TODO.rst:
--------------------------------------------------------------------------------
 1 | TODO list. Place to check off progress.
 2 | 
 3 | 1) Full benchmark (run for 2 hours)
 4 | 2) MPI
 5 |     a) need chx_abort() to work over MPI
 6 |     b) need to send history over wire
 7 |     c) communicate transposition table?
 8 | 3) Sinch evaluator
 9 | 4) Modifiy harness to accept a command line parameter that accepts the number of processors and the number of threads per processor
10 | 


--------------------------------------------------------------------------------
/ChessViewer/.classpath:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <classpath>
3 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
4 | 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
5 | 	<classpathentry kind="src" path="src"/>
6 | 	<classpathentry kind="src" path="gen"/>
7 | 	<classpathentry kind="output" path="bin/classes"/>
8 | </classpath>
9 | 


--------------------------------------------------------------------------------
/src/pgn.cpp:
--------------------------------------------------------------------------------
 1 | #include "pgn.hpp"
 2 | #include <iostream>
 3 | //#include <string>
 4 | 
 5 | using namespace std;
 6 | 
 7 | const void pgn_output(const node_t &board, const chess_move &move)
 8 | {
 9 |     string piece;
10 |     piece = piece_char[(size_t)board.piece[move.getTo()]];
11 |     if (piece == "p")
12 |         piece = "";
13 |     cout << "pgn " << piece << (move.getCapture()?"x":"") << move.pgn() << endl;
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/ChessViewer/src/edu/lsu/cct/chess/Piece.java:
--------------------------------------------------------------------------------
 1 | package edu.lsu.cct.chess;
 2 | 
 3 | public class Piece {
 4 | 	public final int boardnum;
 5 | 	final int x;
 6 | 	final int y;
 7 | 	final int p;
 8 | 	public final int time;
 9 | 	Piece(int t,int b,int x,int y,int p) {
10 | 		this.time = t;
11 | 		this.boardnum = b;
12 | 		this.x = x;
13 | 		this.y = y;
14 | 		this.p = p;
15 | 	}
16 | 	public String toString() {
17 | 		return ((char)p) + "("+time+","+boardnum+","+x+","+y+")";
18 | 	}
19 | }


--------------------------------------------------------------------------------
/ChessViewer/res/layout/activity_chess.xml:
--------------------------------------------------------------------------------
 1 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     xmlns:tools="http://schemas.android.com/tools"
 3 |     android:layout_width="match_parent"
 4 |     android:layout_height="match_parent" >
 5 | 
 6 |     <edu.lsu.cct.chess.Board
 7 |         android:id="@+id/board1"
 8 |         android:layout_width="wrap_content"
 9 |         android:layout_height="wrap_content"
10 |         android:layout_centerInParent="true" />
11 | 
12 | </RelativeLayout>
13 | 


--------------------------------------------------------------------------------
/headers/hash.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef HASH_HPP
 8 | #define HASH_HPP
 9 | #include <stdint.h>
10 | #include "parallel.hpp"
11 | #include <stdio.h>
12 | 
13 | typedef uint32_t hash_t;
14 | 
15 | #endif
16 | 


--------------------------------------------------------------------------------
/headers/here.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef HERE_HPP
 8 | #define HERE_HPP 1
 9 | #define HERE std::cout << "HERE " << __FILE__ << ", " << __LINE__ << std::flush << std::endl;
10 | #define VAR(X) #X << "=" << (X) << " "
11 | #endif
12 | 


--------------------------------------------------------------------------------
/ChessViewer/project.properties:
--------------------------------------------------------------------------------
 1 | # This file is automatically generated by Android Tools.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must be checked in Version Control Systems.
 5 | #
 6 | # To customize properties used by the Ant build system edit
 7 | # "ant.properties", and override values to adapt the script to your
 8 | # project structure.
 9 | #
10 | # To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
11 | #proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
12 | 
13 | # Project target.
14 | target=android-15
15 | 


--------------------------------------------------------------------------------
/docs/answers.txt:
--------------------------------------------------------------------------------
 1 | Answer key:
 2 | 
 3 | board1
 4 | ply | answer
 5 | ====+=======
 6 |   7 |   e2e4
 7 |   6 |   b1c3
 8 |   5 |   b2b4
 9 |   4 |   g1f3
10 |   3 |   g1f3
11 |   2 |   d2d4
12 | 
13 | board2
14 | ply | answer
15 | ====+=======
16 |   7 |   d1b3
17 |   6 |   c1d2
18 |   5 |   c1g5
19 |   4 |   c1g5
20 |   3 |   c1d2
21 |   2 |   e2e4
22 | 
23 | board3
24 | ply | answer
25 | ====+=======
26 |   7 |   f5h7
27 |   6 |   f5g7
28 |   5 |   f5h6
29 |   4 |   f5g7
30 |   3 |   f3b3
31 |   2 |   b2b3
32 | 
33 | board4
34 | ply | answer
35 | ====+=======
36 |   7 |   e5f5
37 |   6 |   e5e3
38 |   5 |   h5h6
39 |   4 |   e5e3
40 |   3 |   e5b5
41 |   2 |   e5e3
42 | 


--------------------------------------------------------------------------------
/LogParser/log_parser.py:
--------------------------------------------------------------------------------
 1 | #! /usr/bin/python
 2 | 
 3 | num_files=input("Number of log files? ")
 4 | input_files=[]
 5 | times=[]
 6 | for number in range(num_files):
 7 |     input_files.append(open("chess_out"+str(number)+".txt"))
 8 |     times.append(float(input_files[number].readline()))
 9 | output=open("log.txt","w")
10 | while len(input_files)>0:
11 |     min_i=times.index(min(times))
12 |     output.write(str(min_i)+"\n")
13 |     for line in range(8):
14 |         output.write(input_files[min_i].readline())
15 |     next_time=input_files[min_i].readline()
16 |     if next_time=="":
17 |         input_files.pop(min_i)
18 |         times.pop(min_i)
19 |     else:
20 |         times[min_i]=float(next_time)
21 | 


--------------------------------------------------------------------------------
/src/task_component.cpp:
--------------------------------------------------------------------------------
 1 | #include "task_component.hpp"
 2 | #include <hpx/hpx.hpp>
 3 | #include <hpx/include/components.hpp>
 4 | #include <hpx/include/serialization.hpp>
 5 | 
 6 | #include "task_component_impl.hpp"
 7 | HPX_REGISTER_COMPONENT_MODULE();
 8 | 
 9 | typedef hpx::components::managed_component<task_component::server> task_component_type;
10 | 
11 | 
12 | 
13 | 
14 | typedef task_component::server task_component_server;
15 | 
16 | HPX_REGISTER_MINIMAL_COMPONENT_FACTORY(task_component_type, task_component_server);
17 | HPX_REGISTER_ACTION_EX(task_component_type::wrapped_type::cancel_action,action_cancel);
18 | HPX_REGISTER_ACTION_EX(task_component_type::wrapped_type::search_action,action_search);
19 | 
20 | 
21 | 


--------------------------------------------------------------------------------
/tests/tc_enpassant.rb:
--------------------------------------------------------------------------------
 1 | require "test/unit"
 2 | require "fileutils"
 3 | include FileUtils
 4 | 
 5 | 
 6 | class TestEnPassant < Test::Unit::TestCase
 7 | 
 8 | 
 9 | 	def setup
10 |   @chx_exe = "../../build_chx/src/chx"
11 |   @success = "8  r n b q k b n r\n7  p p p . p p p .\n6  . . . P . . . p\n5  . . . . . . . .\n4  . . . . . . . .\n3  . . . . . . . .\n2  P P P P . P P P\n1  R N B Q K B N R"
12 | 		if Dir[@chx_exe].empty?
13 | 			puts "Please specify the path to the chx executable in $chx_exe"
14 | 			exit
15 | 		end
16 | 		f = open(".test","w+")
17 |     f.write "e2e4\nh7h6\ne4e5\nd7d5\ne5d6\nd\nquit\n"
18 |     f.close
19 | 	end
20 | 
21 | 	def test_enpassant
22 | 		val = `#{@chx_exe} < .test`
23 | 		assert( val =~ /#{@success}/o )
24 | 	end
25 | end
26 | 


--------------------------------------------------------------------------------
/cmake/FindReadline.cmake:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2012 Steve Brandt and Philip LeBlanc
 2 | #
 3 | # Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | find_path(READLINE_INCLUDE_DIR readline/readline.h)
 7 | find_library(READLINE_LIBRARY NAMES readline) 
 8 | 
 9 | if(READLINE_INCLUDE_DIR AND READLINE_LIBRARY)
10 |    set(READLINE_FOUND TRUE)
11 | endif(READLINE_INCLUDE_DIR AND READLINE_LIBRARY)
12 | 
13 | if(READLINE_FOUND)
14 |    if(NOT Readline_FIND_QUIETLY)
15 |       message(STATUS "Found GNU readline: ${READLINE_LIBRARY}")
16 |    endif(NOT Readline_FIND_QUIETLY)
17 | else()
18 |    if(Readline_FIND_REQUIRED)
19 |       message(FATAL_ERROR "Could not find GNU readline")
20 |    endif()
21 | endif()
22 | 
23 | 


--------------------------------------------------------------------------------
/src/log_board.cpp:
--------------------------------------------------------------------------------
 1 | #include <ostream>
 2 | #include <iostream>
 3 | #include "log_board.hpp"
 4 | #include "timer.hpp"
 5 | #include "defs.hpp"
 6 | 
 7 | void log_board(const node_t& board,std::ostream& out)
 8 | {
 9 | #ifdef HPX_SUPPORT
10 |   int i;
11 | 
12 |   out<<timer.elapsed()<<std::endl;
13 | 
14 |   for (i = 0; i < 64; ++i) {
15 |     switch (board.color[i]) {
16 |       case EMPTY:
17 |         out << " .";
18 |         break;
19 |       case LIGHT:
20 |         out << " " << piece_char[(size_t)board.piece[i]];
21 |         break;
22 |       case DARK:
23 |         char ch = (piece_char[(size_t)board.piece[i]] + ('a' - 'A'));
24 |         out << " " << ch;
25 |         break;
26 |     }
27 |     if ((i + 1) % 8 == 0 && i != 63)
28 |         out<<std::endl;
29 |   }
30 |   out<<std::endl;
31 | #endif
32 | }
33 | 


--------------------------------------------------------------------------------
/ChessViewer/proguard-project.txt:
--------------------------------------------------------------------------------
 1 | # To enable ProGuard in your project, edit project.properties
 2 | # to define the proguard.config property as described in that file.
 3 | #
 4 | # Add project specific ProGuard rules here.
 5 | # By default, the flags in this file are appended to flags specified
 6 | # in ${sdk.dir}/tools/proguard/proguard-android.txt
 7 | # You can edit the include path and order by changing the ProGuard
 8 | # include property in project.properties.
 9 | #
10 | # For more details, see
11 | #   http://developer.android.com/guide/developing/tools/proguard.html
12 | 
13 | # Add any project specific keep options here:
14 | 
15 | # If your project uses WebView with JS, uncomment the following
16 | # and specify the fully qualified class name to the JavaScript interface
17 | # class:
18 | #-keepclassmembers class fqcn.of.javascript.interface.for.webview {
19 | #   public *;
20 | #}
21 | 


--------------------------------------------------------------------------------
/src/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2012 Steve Brandt and Philip LeBlanc
 2 | #
 3 | # Distributed under the Boost Software License, Version 1.0. (See accompanying
 4 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 5 | 
 6 | set(sources
 7 |     main.cpp
 8 |     board.cpp 
 9 |     data.cpp
10 |     eval.cpp
11 |     search.cpp
12 |     minimax.cpp
13 |     log_board.cpp
14 |     timer.cpp
15 |     alphabeta.cpp
16 |     chess_move.cpp
17 |     pgn.cpp)
18 | 
19 | if(HPX_FOUND)
20 |   set(sources ${sources}
21 |       #task_component.cpp Not used
22 |       hpx_task.cpp)
23 |  
24 |   add_hpx_executable(chx
25 |     ESSENTIAL
26 |     COMPONENT_DEPENDENCIES iostreams
27 |     SOURCES ${sources})
28 | elseif(MPI_FOUND)
29 | 
30 |   add_executable(chx ${sources})
31 |   target_link_libraries(chx ${EXTRA_LIBS})
32 | else()
33 |   add_executable(chx ${sources})
34 |   target_link_libraries(chx ${EXTRA_LIBS})
35 | endif()
36 | 
37 | 


--------------------------------------------------------------------------------
/ChessViewer/.project:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <projectDescription>
 3 | 	<name>Alex_Demo</name>
 4 | 	<comment></comment>
 5 | 	<projects>
 6 | 	</projects>
 7 | 	<buildSpec>
 8 | 		<buildCommand>
 9 | 			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
10 | 			<arguments>
11 | 			</arguments>
12 | 		</buildCommand>
13 | 		<buildCommand>
14 | 			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
15 | 			<arguments>
16 | 			</arguments>
17 | 		</buildCommand>
18 | 		<buildCommand>
19 | 			<name>org.eclipse.jdt.core.javabuilder</name>
20 | 			<arguments>
21 | 			</arguments>
22 | 		</buildCommand>
23 | 		<buildCommand>
24 | 			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
25 | 			<arguments>
26 | 			</arguments>
27 | 		</buildCommand>
28 | 	</buildSpec>
29 | 	<natures>
30 | 		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
31 | 		<nature>org.eclipse.jdt.core.javanature</nature>
32 | 	</natures>
33 | </projectDescription>
34 | 


--------------------------------------------------------------------------------
/headers/parallel.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef PARALLEL_HPP
 2 | #define PARALLEL_HPP
 3 | 
 4 | /*
 5 |  * By wrapping the HPX mutex and the thread mutex in the Mutex and
 6 |  * ScopedLock classes we make it possible to support both without a
 7 |  * lot of ifdefs.
 8 |  */
 9 | 
10 | #include <assert.h>
11 | 
12 | #ifdef HPX_SUPPORT
13 | #include <hpx/include/lcos.hpp>
14 | struct Mutex {
15 |     hpx::lcos::local::mutex mut;
16 |     Mutex() : mut() {}
17 |     ~Mutex() {}
18 | };
19 | struct ScopedLock {
20 |     hpx::lcos::local::mutex::scoped_lock l;
21 |     ScopedLock(Mutex& m) : l(m.mut) {}
22 |     ~ScopedLock() {}
23 | };
24 | #else
25 | #include <mutex>
26 | struct Mutex {
27 |     std::mutex mut;
28 |     Mutex() {}
29 | };
30 | struct ScopedLock {
31 |     Mutex *m;
32 |     ScopedLock(Mutex& m_) {
33 |         m = &m_;
34 |         m->mut.lock();
35 |     }
36 |     ~ScopedLock() {
37 |         m->mut.unlock();
38 |     }
39 | };
40 | #endif
41 | 
42 | #endif
43 | //extern Mutex mutex;
44 | 


--------------------------------------------------------------------------------
/tests/tc_castling.rb:
--------------------------------------------------------------------------------
 1 | require "test/unit"
 2 | require "fileutils"
 3 | include FileUtils
 4 | 
 5 | 
 6 | class TestCastling < Test::Unit::TestCase
 7 | 
 8 | 
 9 | 	def setup
10 | @chx_exe = "../../build_chx/src/chx"
11 | @input =
12 | """
13 | a2a3
14 | a7a6
15 | b1c3
16 | b8c6
17 | b2b3
18 | b7b6
19 | c1b2
20 | c8b7
21 | d2d3
22 | d7d6
23 | d1d2
24 | d8d7
25 | e1c1
26 | e8c8
27 | d
28 | quit
29 | 
30 | """
31 | @success = 
32 | """
33 | 8  . . k r . b n r
34 | 7  . b p q p p p p
35 | 6  p p n p . . . .
36 | 5  . . . . . . . .
37 | 4  . . . . . . . .
38 | 3  P P N P . . . .
39 | 2  . B P Q P P P P
40 | 1  . . K R . B N R
41 | 
42 |    a b c d e f g h
43 | """
44 | 		if Dir[@chx_exe].empty?
45 | 			puts "Please specify the path to the chx executable in $chx_exe"
46 | 			exit
47 | 		end
48 | 		f = open(".test","w+")
49 |     f.write @input
50 |     f.close
51 | 	end
52 | 
53 | 	def test_castling
54 | 		val = `#{@chx_exe} < .test`
55 | 		assert( val =~ /#{@success}/o )
56 | 	end
57 | end
58 | 


--------------------------------------------------------------------------------
/docs/algorithms/src/edu/lsu/cct/minimax/Game.java:
--------------------------------------------------------------------------------
 1 | package edu.lsu.cct.minimax;
 2 | 
 3 | import java.util.Random;
 4 | 
 5 | public class Game {
 6 | 	final static Random rand = getRandom();
 7 | 	
 8 | 	private static Random getRandom() {
 9 | 		Random rand = new Random();
10 | 		long seed = rand.nextLong();
11 | 		System.out.println("seed="+seed);
12 | 		rand.setSeed(seed);
13 | 		return rand;
14 | 	}
15 | 	
16 | 	int depth = 6;
17 | 	int branching = 6;
18 | 	int count = 0;
19 | 	Node root = new Node(rand,depth,branching,1-2*(depth%2));
20 | 	
21 | 	public static void main(String[] args) {
22 | 		Game g = new Game();
23 | 		g.root.minimax();
24 | 		int ans = g.root.score;
25 | 		
26 | 		Out out = new Out();
27 | 		//g.root.print(out);
28 | 		g.root.alphabeta(ans);
29 | 		g.root.alphabetamem(ans);
30 | 		g.root.negascout(ans);
31 | 		int del = 20;
32 | 		int off = rand.nextInt(2*del)-del;
33 | 		g.root.mtdf(ans,ans+off);
34 | 		g.root.mtdf2(ans,ans+off);
35 | 		g.root.srb(ans,ans+off-del,ans+off+del);
36 | 	}
37 | }
38 | 


--------------------------------------------------------------------------------
/headers/zkey.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef ZKEY_HPP
 8 | #define ZKEY_HPP
 9 | #include "hash.hpp"
10 | #include "score.hpp"
11 | #include "node.hpp"
12 | #include <math.h>
13 | #include "parallel.hpp"
14 | 
15 | const int table_size = 4*16*4096;
16 | 
17 | struct zkey_t {
18 |   score_t lower, upper;
19 |   Mutex mut;
20 |   node_t board;
21 |   int depth;
22 |   zkey_t() : depth(-1) {
23 |   }
24 | };
25 | 
26 | extern zkey_t transposition_table[table_size];
27 | 
28 | bool get_transposition_value(const node_t& board,score_t& lower,score_t& upper);
29 | 
30 | void set_transposition_value(const node_t& board,score_t lower,score_t upper);
31 | 
32 | #endif
33 | 


--------------------------------------------------------------------------------
/ChessViewer/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 2 |     package="edu.lsu.cct.chessviewer.chessviewer"
 3 |     android:versionCode="1"
 4 |     android:versionName="1.0" >
 5 | 
 6 |     <uses-sdk
 7 |         android:minSdkVersion="8"
 8 |         android:targetSdkVersion="15" />
 9 | 	<uses-permission android:name="android.permission.INTERNET"/>
10 | 	
11 |     <application
12 |         android:icon="@drawable/ic_launcher"
13 |         android:label="@string/app_name"
14 |         android:theme="@style/AppTheme" >
15 |         <activity
16 |             android:name="edu.lsu.cct.chessviewer.ChessActivity"
17 |             android:screenOrientation="portrait"
18 |             android:label="@string/title_activity_chess" >
19 |             <intent-filter>
20 |                 <action android:name="android.intent.action.MAIN" />
21 | 
22 |                 <category android:name="android.intent.category.LAUNCHER" />
23 |             </intent-filter>
24 |         </activity>
25 |     </application>
26 | 
27 | </manifest>


--------------------------------------------------------------------------------
/headers/hpx_support.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef CHX_HPX_HPP_367926FF_8920_423F_8FCA_E8_CHESS34E8_CHESS5C6_CHESS101
 2 | #define CHX_HPX_HPP_367926FF_8920_423F_8FCA_E8_CHESS34E8_CHESS5C6_CHESS101
 3 | 
 4 | #include <hpx/hpx.hpp>
 5 | #include <hpx/hpx_init.hpp>
 6 | #include <hpx/runtime/actions/plain_action.hpp>
 7 | #include "node.hpp"
 8 | #include "defs.hpp"
 9 |     
10 | namespace boost { namespace serialization
11 | {
12 | template <typename Archive>
13 | void serialize(Archive &ar, search_info& info, const unsigned int)
14 | {
15 |     ar & info.board;
16 |     ar & info.mv;
17 |     ar & info.result;
18 |     ar & info.depth;
19 |     ar & info.incr;
20 |     ar & info.alpha;
21 |     ar & info.beta;
22 | }
23 | template <typename Archive>
24 | void serialize(Archive &ar, node_t& board, const unsigned int)
25 | {
26 |     ar & board.hash;
27 |     ar & board.color;
28 |     ar & board.piece;
29 |     ar & board.depth;
30 |     ar & board.side;
31 |     ar & board.castle;
32 |     ar & board.ep;
33 |     ar & board.fifty;
34 |     ar & board.ply;
35 |     ar & board.hist_dat;
36 | }
37 | template <typename Archive>
38 | void serialize(Archive &ar, FixedVec<unsigned int, 50> vec, const unsigned int)
39 | {
40 |     ar & vec.data;
41 |     ar & vec._size;
42 | }
43 | }}
44 | 
45 | #endif
46 | 


--------------------------------------------------------------------------------
/headers/main.hpp:
--------------------------------------------------------------------------------
 1 | ///////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Phillip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef MAIN_H
 8 | #define MAIN_H
 9 | #include <iostream>
10 | #include <string>
11 | 
12 | #include <sys/timeb.h>
13 | #include "node.hpp"
14 | #include "defs.hpp"
15 | #include "data.hpp"
16 | #include "search.hpp"
17 | #include "chess_move.hpp"
18 | 
19 | int main(int argc, char *argv[]);
20 | int parse_move(std::vector<chess_move>& workq, const char *s, const node_t& board);
21 | char *move_str(chess_move& m);
22 | //void print_board(const node_t& board, std::ostream& out,bool trimmed=false);
23 | int print_result(std::vector<chess_move>& workq, node_t& board);
24 | void start_benchmark(std::string filename, int ply_level, int num_runs,bool parallel,node_t& n);
25 | int get_ms();
26 | std::string get_log_name();
27 | int chx_main();
28 | #ifdef HPX_SUPPORT
29 | extern database dbase;
30 | extern std::ofstream **streams;
31 | extern bool file_output_enabled;
32 | #endif
33 | 
34 | #endif
35 | 


--------------------------------------------------------------------------------
/headers/board.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef BOARD_H
 8 | #define BOARD_H
 9 | #include <iostream>
10 | #include "node.hpp"
11 | #include "defs.hpp"
12 | #include "data.hpp"
13 | #include "hash.hpp"
14 | #include "chess_move.hpp"
15 | 
16 | void init_board(node_t& board);
17 | void init_hash();
18 | hash_t hash_rand();
19 | hash_t set_hash(node_t& board);
20 | hash_t update_hash(node_t& board, chess_move& m);
21 | bool in_check(const node_t& board, int s);
22 | bool attack(const node_t& board, int sq, int s);
23 | void gen(std::vector<chess_move>& workq, const node_t& board);
24 | void gen_caps(std::vector<chess_move>& workq, const node_t& board);
25 | void gen_push(std::vector<chess_move>& workq, const node_t& board, int from, int to, int bits);
26 | void gen_promote(std::vector<chess_move>& workq, int from, int to, int bits);
27 | bool makemove(node_t& board, chess_move& m);
28 | void takeback(node_t& board);
29 | bool board_equals(const node_t& b1,const node_t& b2);
30 | #endif
31 | 


--------------------------------------------------------------------------------
/headers/eval.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef EVAL_H
 8 | #define EVAL_H
 9 | 
10 | 
11 | #include "node.hpp"
12 | #include "defs.hpp"
13 | #include "data.hpp"
14 | #include "chess_move.hpp"
15 | 
16 | 
17 | #define DOUBLED_PAWN_PENALTY        10
18 | #define ISOLATED_PAWN_PENALTY       20
19 | #define BACKWARDS_PAWN_PENALTY       8
20 | #define PASSED_PAWN_BONUS           20
21 | #define ROOK_SEMI_OPEN_FILE_BONUS   10
22 | #define ROOK_OPEN_FILE_BONUS        15
23 | #define ROOK_ON_SEVENTH_BONUS       20
24 | 
25 | struct evaluator {
26 |     int pawn_rank[2][10];
27 |     int piece_mat[2];  // the value of a side's pieces
28 |     int pawn_mat[2];  // the value of a side's pawns
29 | 
30 |     int eval(const node_t& board, int evaluator);
31 |     int eval_simple(const node_t& board);
32 |     int eval_orig(const node_t& board);
33 |     int eval_light_pawn(int sq);
34 |     int eval_dark_pawn(int sq);
35 |     int eval_light_king(int sq);
36 |     int eval_lkp(int f);
37 |     int eval_dark_king(int sq);
38 |     int eval_dkp(int f);
39 | };
40 | 
41 | #endif
42 | 


--------------------------------------------------------------------------------
/src/chess_move.cpp:
--------------------------------------------------------------------------------
 1 | #include <sstream>
 2 | #include "defs.hpp"
 3 | #include "data.hpp"
 4 | #include "chess_move.hpp"
 5 | 
 6 | using namespace std;
 7 | 
 8 | string chess_move::str() const
 9 | {
10 |     ostringstream ostr;
11 |     ostr << (char)('a' + COL(getFrom())) << 8 - ROW(getFrom()) <<
12 |             (char)('a' + COL(getTo()))   << 8 - ROW(getTo());
13 |     if (getBits() & 32)
14 |         switch (getPromote())
15 |         { 
16 |           case KNIGHT:
17 |             ostr << "n";
18 |             break;
19 |           case BISHOP:
20 |             ostr << "b";
21 |             break;
22 |           case ROOK:
23 |             ostr << "r";
24 |             break;
25 |           default: 
26 |             ostr << "q";
27 |             break;
28 |         }
29 |     return ostr.str();
30 | }
31 | string chess_move::pgn() const
32 | {
33 |     ostringstream ostr;
34 |     ostr << piece_char[getFrom()];
35 |     ostr << (char)('a' + COL(getFrom())) << 8 - ROW(getFrom()) <<
36 |             (char)('a' + COL(getTo()))   << 8 - ROW(getTo());
37 |     if (getBits() & 32)
38 |         switch (getPromote())
39 |         { 
40 |           case KNIGHT:
41 |             ostr << "=N";
42 |             break;
43 |           case BISHOP:
44 |             ostr << "=B";
45 |             break;
46 |           case ROOK:
47 |             ostr << "=R";
48 |             break;
49 |           default: 
50 |             ostr << "=Q";
51 |             break;
52 |         }
53 |     return ostr.str();
54 | }
55 | 
56 | 


--------------------------------------------------------------------------------
/src/hpx_task.cpp:
--------------------------------------------------------------------------------
 1 | #include "parallel_support.hpp"
 2 | #include <hpx/include/iostreams.hpp>
 3 | #include "search.hpp"
 4 | 
 5 | #ifdef HPX_SUPPORT
 6 |     
 7 | HPX_PLAIN_ACTION(search_ab_pt,alphabeta_action);
 8 | HPX_PLAIN_ACTION(search_pt,minimax_action);
 9 | HPX_PLAIN_ACTION(qeval_pt,qeval_action);
10 | 
11 | using namespace hpx;
12 | 
13 | // Figure out why actions perform badly
14 | #define USE_ACTIONS 1
15 | #if USE_ACTIONS
16 | void hpx_task::start() {
17 |     assert(info.valid());
18 |     static std::vector<hpx::naming::id_type> all_localities = hpx::find_all_localities();
19 |     static hpx::naming::id_type const locality_id = all_localities[0];
20 | 
21 |     if (pfunc == search_f)
22 |     {
23 |         result = async<minimax_action>(locality_id, info);
24 |     }
25 |     else if (pfunc == search_ab_f)
26 |     {
27 |         result = async<alphabeta_action>(locality_id, info);
28 |     }
29 |     else if (pfunc == qeval_f)
30 |     {
31 |         result = async<qeval_action>(locality_id, info);
32 |     }
33 |     else
34 |         assert(false); // should never get here
35 |         
36 | }
37 | #else
38 | void hpx_task::start() {
39 |     if (pfunc == search_f)
40 |     {
41 |         result = async(search_pt, info.ptr());
42 |     }
43 |     else if (pfunc == search_ab_f)
44 |     {
45 |         result = async(search_ab_pt, info.ptr());
46 |     }
47 |     else if (pfunc == qeval_f)
48 |     {
49 |         result = async(qeval_pt, info.ptr());
50 |     }
51 |     else
52 |         assert(false); // should never get here
53 |         
54 | }
55 | #endif
56 | #endif
57 | 


--------------------------------------------------------------------------------
/headers/defs.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Phillip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | /*
 8 |  *  DEFS.H
 9 |  */
10 | #ifndef DEFS_H
11 | #define DEFS_H
12 | 
13 | #define LIGHT           0
14 | #define DARK            1
15 | 
16 | #define PAWN            0
17 | #define KNIGHT          1
18 | #define BISHOP          2
19 | #define ROOK            3
20 | #define QUEEN           4
21 | #define KING            5
22 | 
23 | #define EMPTY           6
24 | 
25 | // Evaluator Defs
26 | #define ORIGINAL        0
27 | #define SIMPLE          1
28 | 
29 | // Search method Defs
30 | #define MINIMAX         0
31 | #define ALPHABETA       1
32 | #define MTDF            2
33 | 
34 | /* useful squares */
35 | #define A1_CHESS              56
36 | #define B1_CHESS              57
37 | #define C1_CHESS              58
38 | #define D1_CHESS              59
39 | #define E1_CHESS              60
40 | #define F1_CHESS              61
41 | #define G1_CHESS              62
42 | #define H1_CHESS              63
43 | #define A8_CHESS              0
44 | #define B8_CHESS              1
45 | #define C8_CHESS              2
46 | #define D8_CHESS              3
47 | #define E8_CHESS              4
48 | #define F8_CHESS              5
49 | #define G8_CHESS              6
50 | #define H8_CHESS              7
51 | 
52 | #define ROW(x)          (x >> 3)
53 | #define COL(x)          (x & 7)
54 | 
55 | 
56 | #endif
57 | 


--------------------------------------------------------------------------------
/headers/node.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef NODE_H
 8 | #define NODE_H
 9 | #include <iostream>
10 | #include <vector>
11 | #include <stdlib.h>
12 | #include <stdio.h>
13 | #include "score.hpp"
14 | #include "defs.hpp"
15 | #include "hash.hpp"
16 | 
17 | /**
18 |  * IMPORTANT NOTE:
19 |  * The board_equal() method compares the base_node_t
20 |  * data bitwise to determine whether two boards are
21 |  * equal. Don't put pointers here, and don't add anything
22 |  * that would violate the needs of board_equal().
23 |  */
24 | struct base_node_t { 
25 |     hash_t hash=0;
26 |     char color[64];
27 |     char piece[64];
28 |     int depth=0;
29 |     int excess_depth = 0;
30 |     int side=-1;
31 |     int castle=0;
32 |     int ep=0;
33 | };
34 | struct node_t : public base_node_t {
35 |     
36 |     /* the number of moves since a capture or pawn chess_move, used to handle the fifty-chess_move-draw rule */
37 |     int fifty=0;
38 |     int move_num=0;
39 |     score_t p_board;
40 |     int ply=0;
41 |     bool follow_capt = false;
42 |     bool root_side=-1;
43 |     score_t follow_score;
44 |     int follow_depth = 2;
45 |     int search_depth = 0;
46 |     std::vector<hash_t> hist_dat;
47 | 
48 |     void clear() {
49 |       hist_dat.clear();
50 |       fifty = 0;
51 |       follow_capt = false;
52 |       ply = 0;
53 |       move_num = 0;
54 |     }
55 |     node_t() {}
56 |     // Make it possible to construct a board from
57 |     // a string representation.
58 |     node_t(std::string s);
59 | };
60 | 
61 | #endif
62 | 


--------------------------------------------------------------------------------
/headers/FixedVec.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef FIXED_VEC_HPP
 8 | #define FIXED_VEC_HPP 1
 9 | #include <assert.h>
10 | template<class T,int N>
11 | struct FixedVec {
12 |     T data[N];
13 |     int _size;
14 |     FixedVec() : _size(0) {}
15 |     FixedVec(const FixedVec<T,N>& fvec) {
16 |         _size = fvec._size;
17 |         for(int i=0;i < _size;i++)
18 |             data[i] = fvec.data[i];
19 |     }
20 |     T& operator[](int n) {
21 |         assert(n >= 0 && n < _size);
22 |         return data[n];
23 |     }
24 |     const T& operator[](int n) const {
25 |         assert(n >= 0 && n < _size);
26 |         return data[n];
27 |     }
28 |     void operator=(const FixedVec<T,N>& fvec) {
29 |         _size = fvec._size;
30 |         for(int i=0;i < _size;i++)
31 |             data[i] = fvec.data[i];
32 |     }
33 |     T *ptr() { return data; }
34 |     void push_back(T t) {
35 |         if(_size == N) {
36 |             // We're only using this for
37 |             // chess_move history, and only the
38 |             // last N moves matter.
39 |             for(int i=1;i<N;i++)
40 |                 data[i-1] = data[i];
41 |             data[_size-1] = t;
42 |         } else {
43 |             data[_size++] = t;
44 |         }
45 |     }
46 |     int size() const {
47 |         return _size;
48 |     }
49 |     void resize(int n) {
50 |         assert(n >= 0 && n < N);
51 |         // Keep Valgrind happy
52 |         while(_size < n) {
53 |             push_back(0);
54 |         }
55 |         if(_size > n) {
56 |             int d = _size-n;
57 |             for(int i=0;i<n;i++) {
58 |                 data[i] = data[i+d];
59 |             }
60 |         }
61 |         _size = n;
62 |     }
63 | };
64 | #endif
65 | 


--------------------------------------------------------------------------------
/headers/data.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef DATA_HPP
 8 | #define DATA_HPP
 9 | #include "hash.hpp"
10 | #include <assert.h>
11 | #include "here.hpp"
12 | #include <iostream>
13 | #include <stdlib.h>
14 | #include "chess_move.hpp"
15 | /*
16 |  *  data.hpp
17 |  */
18 | 
19 | /* this is basically a copy of data.cpp that's included by most
20 |    of the source files so they can use the data.cpp variables */
21 | 
22 | 
23 | /////////////////////////////////////////////////////////////////////////
24 | // Static Global Variables                                             //
25 | /////////////////////////////////////////////////////////////////////////
26 | extern hash_t hash_piece[2][6][64];
27 | extern hash_t hash_side;
28 | extern hash_t hash_ep[64];
29 | extern int mailbox[120];
30 | extern int mailbox64[64];
31 | extern bool slide[6];
32 | extern int offsets[6];
33 | extern int offset[6][8];
34 | extern int castle_mask[64];
35 | extern char piece_char[6];
36 | extern int init_color[64];
37 | extern int init_piece[64];
38 | extern int depth[2];
39 | extern int output;
40 | extern int chosen_evaluator;
41 | extern int search_method;
42 | extern int light_search_method;
43 | extern int dark_search_method;
44 | extern int iter_depth;
45 | extern int rnum[];
46 | extern bool bench_mode;
47 | extern bool logging_enabled;
48 | extern int mpi_depth;
49 | 
50 | ////////////////////////////////////////////////////////////////////////////
51 | //State Information -- The global variables this program uses and modifies//
52 | //                     in order to work properly.                         //
53 | ////////////////////////////////////////////////////////////////////////////
54 | 
55 | extern chess_move move_to_make;
56 | 
57 | void do_data();
58 | #endif
59 | 


--------------------------------------------------------------------------------
/headers/task_component.hpp:
--------------------------------------------------------------------------------
 1 | #ifndef TASK_COMPONENT_H
 2 | #define TASK_COMPONENT_H 1
 3 | #include <hpx/hpx_fwd.hpp>
 4 | #include <hpx/include/components.hpp>
 5 | #include <hpx/include/actions.hpp>
 6 | #include <hpx/include/async.hpp>
 7 | #include "parallel_support.hpp"
 8 | 
 9 | 
10 | namespace task_component { 
11 | class HPX_COMPONENT_EXPORT server : public hpx::components::managed_component_base<server>  {
12 | 
13 | public:
14 |    server()  {}
15 |    enum {
16 | 	  cancel_func_code,
17 | 	  search_func_code,
18 | 
19 |    } func_codes;
20 | 
21 |    void cancel();
22 |    typedef hpx::actions::action0<
23 | 	  server, cancel_func_code , &server::cancel
24 |    > cancel_action;
25 | 
26 |    score_t search(search_info inf);
27 |    typedef hpx::actions::result_action1<
28 | 	  server, score_t, search_func_code , search_info, &server::search
29 |    > search_action;
30 | 
31 | };
32 | }
33 | HPX_REGISTER_ACTION_DECLARATION_EX(task_component::server::cancel_action,action_cancel);
34 | HPX_REGISTER_ACTION_DECLARATION_EX(task_component::server::search_action,action_search);
35 | 
36 | namespace task_component { 
37 | 
38 | class stub : public hpx::components::stubs::stub_base<server> {
39 | public:
40 | 
41 |    static void cancel(
42 |    	hpx::naming::id_type gid)
43 |    {
44 | 	  hpx::async<server::cancel_action>(gid).get();
45 |    }
46 | 
47 |    static hpx::lcos::future<score_t> search_async(
48 | 	  hpx::naming::id_type gid, search_info arg0)
49 |    {
50 | 	  return hpx::async<server::search_action>(gid, arg0);
51 |    }
52 |    static score_t search(
53 | 	  hpx::naming::id_type gid, search_info arg0)
54 |    {
55 | 	  return search_async(gid, arg0).get();
56 |    }
57 | 
58 | };
59 | 
60 | class client : public hpx::components::client_base<client, stub> {
61 |    typedef hpx::components::client_base<client, task_component::stub> base_type;
62 | public:
63 |    client(hpx::naming::id_type gid) : base_type(gid) {}
64 |    client() : base_type() {}
65 | 
66 |    void cancel() {
67 | 	  BOOST_ASSERT(gid_);
68 | 	  this->base_type::cancel(gid_);
69 |    }
70 | 
71 |    score_t search(search_info arg0) {
72 | 	  BOOST_ASSERT(gid_);
73 | 	  return this->base_type::search(gid_, arg0);
74 |    }
75 | 
76 | };
77 | }
78 | #endif
79 | 


--------------------------------------------------------------------------------
/headers/search.hpp:
--------------------------------------------------------------------------------
 1 | ////////////////////////////////////////////////////////////////////////////////
 2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
 3 | //
 4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | ////////////////////////////////////////////////////////////////////////////////
 7 | #ifndef SEARCH_H
 8 | #define SEARCH_H
 9 | 
10 | #include <stdio.h>
11 | #include <string.h>
12 | #include "node.hpp"
13 | #include "defs.hpp"
14 | #include "data.hpp"
15 | #include "main.hpp"
16 | #include "board.hpp"
17 | #include "eval.hpp"
18 | #include "parallel.hpp"
19 | #include <list>
20 | #include <map>
21 | #include "hash.hpp"
22 | #include "score.hpp"
23 | #include "parallel_support.hpp"
24 | #include "chess_move.hpp"
25 | #include <boost/shared_ptr.hpp>
26 | 
27 | int think(node_t& board,bool parallel);
28 | score_t search(boost::shared_ptr<search_info>);
29 | score_t search_ab(boost::shared_ptr<search_info>);
30 | score_t mtdf(node_t& board,score_t f,int depth,const score_t target_score,score_t moving);
31 | score_t qeval(boost::shared_ptr<search_info>);
32 | int reps(const node_t& board);
33 | bool compare_moves(chess_move a, chess_move b);
34 | void sort_pv(std::vector<chess_move>& workq, int ply);
35 | bool capture(const node_t& board,chess_move& g);
36 | boost::shared_ptr<task> parallel_task(int depth, bool *parallel);
37 | int min(int a,int b);
38 | int max(int a,int b);
39 | void xboard();
40 | 
41 | extern Mutex cmutex;
42 | extern const int num_proc;
43 | 
44 | struct safe_move {
45 |     Mutex mut;
46 |     chess_move mv;
47 |     safe_move() : mut(), mv() {}
48 |     safe_move(const safe_move& sm) : mut(), mv(sm.mv) {}
49 |     void set(chess_move mv_) {
50 |         ScopedLock s(mut);
51 |         mv = mv_;
52 |     }
53 |     chess_move get() {
54 |         ScopedLock s(mut);
55 |         chess_move m = mv;
56 |         return m;
57 |     }
58 | private:
59 | };
60 | extern std::vector<safe_move> pv;  // Principle Variation, used in iterative deepening
61 | 
62 | // Note that testing alphabeta disables iterative deepening
63 | const bool test_alphabeta = false;
64 | 
65 | #define PV_ON 1
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # Copyright (c) 2012 Steve Brandt and Philip LeBlanc
 2 | # Copyright (c) 2012 Bryce Adelstein-Lelbach
 3 | #
 4 | # Distributed under the Boost Software License, Version 1.0. (See accompanying
 5 | # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 6 | 
 7 | # TODO: Add install code.
 8 | 
 9 | cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
10 | 
11 | project(chess CXX)
12 | 
13 | # Project version.
14 | set(CHX_MAJOR_VERSION 0)
15 | set(CHX_MINOR_VERSION 1)
16 | set(CHX_PATCH_LEVEL   0)
17 | set(CHX_SOVERSION     ${CHX_MAJOR_VERSION})
18 | set(CHX_VERSION       "${CHX_MAJOR_VERSION}.${CHX_MINOR_VERSION}.${CHX_PATCH_LEVEL}")
19 | 
20 | if(NOT CMAKE_BUILD_TYPE)
21 |   set(CMAKE_BUILD_TYPE Debug)
22 | endif()
23 | 
24 | set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake)
25 | set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
26 | #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-inline")
27 | #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -pg -fPIC")
28 | 
29 | #find_package(HPX)
30 | if(HPX_FOUND)
31 |   message("HPX was found.")
32 | 
33 |   include_directories(${HPX_INCLUDE_DIR})
34 |   link_directories(${HPX_LIBRARY_DIR})
35 | 
36 |   add_definitions(-DHPX_SUPPORT)
37 | else()
38 |   message("Could not find HPX. Configuring without HPX support.")
39 | endif()
40 | 
41 | set(EXTRA_LIBS pthread)
42 | 
43 | find_package(Readline)
44 | find_package(SQLite3)
45 | 
46 | if(SQLITE3_FOUND)
47 |   message("Sqlite3 was found")
48 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSQLITE3_SUPPORT")
49 |   set(EXTRA_LIBS ${EXTRA_LIBS} sqlite3)
50 | else()
51 |   message("Sqlite3 was *NOT* found")
52 | endif()
53 | 
54 | if(READLINE_FOUND)
55 |   message("Readline was found.")
56 | 
57 |   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DREADLINE_SUPPORT")
58 |   set(EXTRA_LIBS ${EXTRA_LIBS} readline)
59 | else()
60 |   message("Could not find Readline. Configuring without Readline support.")
61 | endif()
62 | 
63 | if(NOT HPX_FOUND)
64 |   find_package(Boost)
65 | 
66 |   if(Boost_FOUND)
67 |     message("Boost was found.")
68 | 
69 |     include_directories(${BOOST_INCLUDE_DIR})
70 |     link_directories(${BOOST_LIBRARY_DIR})
71 | 
72 |     add_definitions(-DBOOST_SUPPORT)
73 |   else()
74 |     message("Could not find Boost. Configuring without Boost support.")
75 |   endif()
76 | else()
77 |   message("Boost was found.")
78 |   add_definitions(-DBOOST_SUPPORT)
79 | endif()
80 | 
81 | include_directories("${PROJECT_SOURCE_DIR}/headers")
82 | 
83 | add_subdirectory(src)
84 | 
85 | 


--------------------------------------------------------------------------------
/cmake/FindSQLite3.cmake:
--------------------------------------------------------------------------------
 1 | # - Try to find Sqlite3
 2 | # Once done this will define
 3 | #
 4 | #  SQLITE3_FOUND - system has Sqlite3
 5 | #  SQLITE3_INCLUDE_DIRS - the Sqlite3 include directory
 6 | #  SQLITE3_LIBRARIES - Link these to use Sqlite3
 7 | #  SQLITE3_DEFINITIONS - Compiler switches required for using Sqlite3
 8 | #
 9 | #  Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
10 | #
11 | #  Redistribution and use is allowed according to the terms of the New
12 | #  BSD license.
13 | #  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
14 | #
15 | 
16 | 
17 | if (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
18 |   # in cache already
19 |   set(SQLITE3_FOUND TRUE)
20 | else (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
21 |   # use pkg-config to get the directories and then use these values
22 |   # in the FIND_PATH() and FIND_LIBRARY() calls
23 |   if (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
24 |     include(UsePkgConfig)
25 |     pkgconfig(sqlite3 _SQLITE3_INCLUDEDIR _SQLITE3_LIBDIR _SQLITE3_LDFLAGS _SQLITE3_CFLAGS)
26 |   else (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
27 |     find_package(PkgConfig)
28 |     if (PKG_CONFIG_FOUND)
29 |       pkg_check_modules(_SQLITE3 sqlite3)
30 |     endif (PKG_CONFIG_FOUND)
31 |   endif (${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} EQUAL 4)
32 |   find_path(SQLITE3_INCLUDE_DIR
33 |     NAMES
34 |       sqlite3.h
35 |     PATHS
36 |       ${_SQLITE3_INCLUDEDIR}
37 |       /usr/include
38 |       /usr/local/include
39 |       /opt/local/include
40 |       /sw/include
41 |   )
42 | 
43 |   find_library(SQLITE3_LIBRARY
44 |     NAMES
45 |       sqlite3
46 |     PATHS
47 |       ${_SQLITE3_LIBDIR}
48 |       /usr/lib
49 |       /usr/local/lib
50 |       /opt/local/lib
51 |       /sw/lib
52 |   )
53 | 
54 |   if (SQLITE3_LIBRARY)
55 |     set(SQLITE3_FOUND TRUE)
56 |   endif (SQLITE3_LIBRARY)
57 | 
58 |   set(SQLITE3_INCLUDE_DIRS
59 |     ${SQLITE3_INCLUDE_DIR}
60 |   )
61 | 
62 |   if (SQLITE3_FOUND)
63 |     set(SQLITE3_LIBRARIES
64 |       ${SQLITE3_LIBRARIES}
65 |       ${SQLITE3_LIBRARY}
66 |     )
67 |   endif (SQLITE3_FOUND)
68 | 
69 |   if (SQLITE3_INCLUDE_DIRS AND SQLITE3_LIBRARIES)
70 |      set(SQLITE3_FOUND TRUE)
71 |   endif (SQLITE3_INCLUDE_DIRS AND SQLITE3_LIBRARIES)
72 | 
73 |   if (SQLITE3_FOUND)
74 |     if (NOT Sqlite3_FIND_QUIETLY)
75 |       message(STATUS "Found Sqlite3: ${SQLITE3_LIBRARIES}")
76 |     endif (NOT Sqlite3_FIND_QUIETLY)
77 |   else (SQLITE3_FOUND)
78 |     if (Sqlite3_FIND_REQUIRED)
79 |       message(FATAL_ERROR "Could not find Sqlite3")
80 |     endif (Sqlite3_FIND_REQUIRED)
81 |   endif (SQLITE3_FOUND)
82 | 
83 |   # show the SQLITE3_INCLUDE_DIRS and SQLITE3_LIBRARIES variables only in the advanced view
84 |   mark_as_advanced(SQLITE3_INCLUDE_DIRS SQLITE3_LIBRARIES)
85 | 
86 | endif (SQLITE3_LIBRARIES AND SQLITE3_INCLUDE_DIRS)
87 | 
88 | 


--------------------------------------------------------------------------------
/src/xboard.cpp:
--------------------------------------------------------------------------------
  1 | /* xboard() is a substitute for chx_main() that is XBoard
  2 |    and WinBoard compatible. See the following page for details:
  3 | http://home.hccnet.nl/h.g.muller/engine-intf.html */
  4 | 
  5 | #include "search.hpp"
  6 | #include <signal.h>
  7 | 
  8 | void xboard()
  9 | {
 10 |     int computer_side;
 11 |     std::string command;
 12 |     int m;
 13 |     //int post = 0;
 14 |     std::vector<chess_move> workq;
 15 | 
 16 |     signal(SIGINT, SIG_IGN);
 17 |     
 18 |     
 19 |     std::cout << std::endl;
 20 |     std::cout.flush();
 21 | 
 22 |     node_t board;
 23 |     init_hash();
 24 |     init_board(board);
 25 |     computer_side = EMPTY;
 26 | 
 27 |     gen(workq, board);
 28 | 
 29 |     for (;;) {
 30 |         command.clear();
 31 |         if (board.side == computer_side) {
 32 |             think(board, false);
 33 |             if (move_to_make.u == 0) {
 34 |                 computer_side = EMPTY;
 35 |                 continue;
 36 |             }
 37 |             std::cout << "chess_move " << move_to_make.b.str() << std::endl;
 38 |             std::cout.flush();
 39 |             makemove(board, move_to_make.b);
 40 |             board.ply = 0;
 41 |             workq.clear();
 42 |             gen(workq, board);
 43 |             print_result(workq, board);
 44 | 
 45 |             move_to_make.u = 0;
 46 |             continue;
 47 |         }
 48 |         std::cin >> command;
 49 | 
 50 |         if (command.empty())
 51 |             continue;
 52 | 
 53 |         if (command == "xboard")
 54 |             continue;
 55 | 
 56 |         if (command == "new") {
 57 |             computer_side = EMPTY;
 58 |             init_board(board);
 59 |             workq.clear();
 60 |             gen(workq, board);
 61 |             continue;
 62 |         }
 63 |         if (command == "quit")
 64 |             return;
 65 |         if (command == "force") {
 66 |             computer_side = EMPTY;
 67 |             continue;
 68 |         }
 69 |         if (command == "white") {
 70 |             board.side = LIGHT;
 71 |             workq.clear();
 72 |             gen(workq, board);
 73 |             computer_side = DARK;
 74 |             continue;
 75 |         }
 76 |         if (command == "black") {
 77 |             board.side = DARK;
 78 |             workq.clear();
 79 |             gen(workq, board);
 80 |             computer_side = LIGHT;
 81 |             continue;
 82 |         }
 83 |         if (command == "otim") {
 84 |             continue;
 85 |         }
 86 |         if (command == "go") {
 87 |             computer_side = board.side;
 88 |             continue;
 89 |         }
 90 |         if (command == "hint") {
 91 |             think(board, false);
 92 |             if (move_to_make.u == 0)
 93 |                 continue;
 94 |             std::cout << "Hint: " << move_to_make.b.str() << std::endl;
 95 |             continue;
 96 |         }
 97 | 
 98 |         m = parse_move(workq, command.c_str());
 99 |         chess_move mov;
100 |         mov.u = m;
101 |         node_t newboard = board;
102 |         if (m == -1 || !makemove(newboard, mov.b))
103 |             std::cerr << "Error (unknown command): " << command << std::endl;
104 |         else {
105 |             makemove(board, mov.b);
106 |             board.ply = 0;
107 |             workq.clear();
108 |             gen(workq, board);
109 |             print_result(workq, board);
110 |         }
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/tests/time_test.rb:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env ruby
  2 | require "open3"
  3 | require "fileutils"
  4 | include FileUtils
  5 | 
  6 | # number of tests
  7 | num_tests = 1
  8 | 
  9 | # maps revision number to input type (ini or unified) for each 
 10 | # svn revision we want to test
 11 | svn_revs = Hash[5433 => :ini, 5953 => :unified, 6723 => :unified]
 12 | 
 13 | # because I do an out of source build, my executable is in a non standard place
 14 | # so put the path to the current chx executable in here (relative to the testing folder)
 15 | $chx_exe = "../../build_chx/src/chx"
 16 | 
 17 | search_ms = ["minimax","alphabeta","mtdf"]
 18 | plies = [2,3,4,5]
 19 | boards = [:board1,:board2,:board3,:board4]
 20 | 
 21 | #This script assumes that it lives inside of the testing folder
 22 | # and that your working directory is already built
 23 | 
 24 | def make_sure_dir_exists(svn_rev)
 25 |   list = Dir["chx_#{svn_rev}"]
 26 |   if list.empty?
 27 |     puts "Checking out revision #{svn_rev}"
 28 |     `svn checkout https://svn.cct.lsu.edu/repos/projects/parallex/branches/chess/openmp@#{svn_rev} chx_#{svn_rev}`
 29 |   end
 30 | end
 31 | 
 32 | def make(svn_rev)
 33 |   make_sure_dir_exists svn_rev
 34 |   cd "chx_#{svn_rev}"
 35 |   if Dir["Makefile"].empty?
 36 |     puts "Running cmake on revision #{svn_rev}"
 37 |     puts `cmake .`
 38 |   end
 39 |   if Dir["src/chx"].empty?
 40 |     puts "making revision #{svn_rev}"
 41 |     puts `make`
 42 |   end
 43 |   cd ".."
 44 | end
 45 | 
 46 | def check_usage
 47 |   if Dir[$chx_exe].empty?
 48 |     if ARGV.length = 0
 49 |       puts "Please specify the current chx executable path either in the script or the command line"
 50 |       puts "Usage: #{$0} /path/to/chx"
 51 |       exit
 52 |     end
 53 |     $chx_exe = ARGV[0]
 54 |   end
 55 | end
 56 | 
 57 | def run_test(search_m, board_n, ply, svn_revs)
 58 |   svn_revs.each do | svn_rev, input |
 59 |     f = open(".test_unified","w")
 60 |     f.write "search #{search_m}\neval original\nbench ../inputs/#{board_n} #{ply} 1\n"
 61 |     f.close
 62 |     t1 = Time.now
 63 |     if input == :ini
 64 |       f = open(".test","w")
 65 |       if search_m == "mtdf" then
 66 |         search_m = "mtd-f"
 67 |       end
 68 |       f.write "[CHX Main]
 69 |                 search_method = #{search_m}
 70 |                 eval_method = original
 71 | 
 72 |                 [Benchmark]
 73 |                 mode=true
 74 |                 file=../inputs/#{board_n}
 75 |                 max_ply=#{ply}
 76 |                 num_runs=1"
 77 |       f.close
 78 |       `chx_#{svn_rev}/src/chx -s .test`
 79 |       if search_m == "mtd-f" then
 80 |         search_m = "mtdf"
 81 |       end
 82 |     else
 83 |       `chx_#{svn_rev}/src/chx < .test_unified`
 84 |     end
 85 |     t2 = Time.now
 86 |     puts "%10s\t%5s\t%3d\t%8s\t%5.3f" % [search_m, board_n, ply, svn_rev, t2-t1]
 87 |   end
 88 | 
 89 |   t1 = Time.now
 90 |   `#{$chx_exe} < .test_unified`
 91 |   t2 = Time.now
 92 |   puts "%10s\t%5s\t%3d\t%8s\t%5.3f\n\n" % [search_m, board_n, ply, "current", t2-t1]
 93 | end
 94 | 
 95 | if $0 == __FILE__
 96 |   check_usage
 97 |   svn_revs.each do | svn_rev, input |
 98 |     make(svn_rev)
 99 |   end
100 |   puts "    search\t board\tply\trevision\ttime (seconds)"
101 |   puts "-" * 62
102 |   search_ms.each do | search_m |
103 |     boards.each do | board_n |
104 |       plies.each do | ply |
105 |         unless search_m == "minimax" && ply == 5 then
106 |           run_test(search_m, board_n, ply, svn_revs)
107 |         end
108 |       end
109 |     end
110 |   end
111 | end
112 | 


--------------------------------------------------------------------------------
/headers/chess_move.hpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Phillip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | 
  8 | #ifndef  CHESS_MOVE_HPP_C1BEDE43_B47B_4694_ACF4_F41143D72B97
  9 | #define CHESS_MOVE_HPP_C1BEDE43_B47B_4694_ACF4_F41143D72B97
 10 | 
 11 | #include <stdint.h>
 12 | #include <string>
 13 | #include <iostream>
 14 | 
 15 | /* This is the basic description of a chess_move. promote is what
 16 |    piece to promote the pawn to, if the chess_move is a pawn
 17 |    promotion. bits is a bitfield that describes the chess_move,
 18 |    with the following bits:
 19 | 
 20 |    1    capture
 21 |    2    castle
 22 |    4    en passant capture
 23 |    8    pushing a pawn 2 squares
 24 |    16   pawn chess_move
 25 |    32   promote
 26 | 
 27 | */
 28 | const int INVALID_MOVE = 0xFFFFFFFF;
 29 | 
 30 | class chess_move {
 31 |     uint32_t u;
 32 |     uint8_t from; // MSB
 33 |     uint8_t to;
 34 |     uint8_t promote;
 35 |     uint8_t bits; // LSB
 36 | public:
 37 |     uint8_t score;
 38 | 
 39 |     chess_move() : u(0), from(0), to(0), promote(0), bits(0), score(0) {}
 40 |     uint32_t get32BitMove() {
 41 |         return u;
 42 |     }
 43 |     void set32BitMove(int32_t mv)
 44 |     {
 45 |         u = mv;
 46 |         from = ((mv >> 24) & 0xFF);
 47 |         to = ((mv >> 16) & 0xFF);
 48 |         promote = ((mv >> 8) & 0xFF);
 49 |         bits = ((mv >> 0) & 0xFF);
 50 |     }
 51 |     void setBytes(int8_t from, int8_t to, int8_t promote, int8_t bits)
 52 |     {
 53 |         this->from = from;
 54 |         this->to = to;
 55 |         this->promote = promote;
 56 |         this->bits = bits;
 57 |         u = ((from & 0xFF) << 24) + ((to & 0xFF) << 16) + ((promote & 0xFF) << 8)
 58 |             + ((bits & 0xFF) << 0);
 59 |     }
 60 |     uint8_t getFrom()    const { return from; }
 61 |     uint8_t getTo()      const { return to; }
 62 |     uint8_t getPromote() const { return promote; }
 63 |     uint8_t getBits()    const { return bits; }
 64 |     uint8_t getCapture() const {
 65 |         return (bits & 1) != 0;
 66 |     }
 67 |     void operator=(const uint32_t mv)
 68 |     {
 69 |         set32BitMove(mv);
 70 |     }
 71 |     void operator=(const chess_move& mv)
 72 |     {
 73 |         u = mv.u;
 74 |         from = mv.from;
 75 |         to = mv.to;
 76 |         promote = mv.promote;
 77 |         bits = mv.bits;
 78 |         score = mv.score;
 79 |     }
 80 |     bool operator==(const chess_move& mv) const
 81 |     {
 82 |         return (mv.u == u);
 83 |     }
 84 |     bool operator!=(const chess_move& mv) const
 85 |     {
 86 |         return (mv.u != u);
 87 |     }
 88 |     bool operator==(const uint32_t mv) const
 89 |     {
 90 |         return (mv == u);
 91 |     }
 92 |     bool operator!=(const uint32_t mv) const
 93 |     {
 94 |         return (mv != u);
 95 |     }
 96 |     template <class Archive>
 97 |     void serialize(Archive &ar, const unsigned int)
 98 |     {
 99 |         ar & this->u;
100 |         ar & this->from;
101 |         ar & this->to;
102 |         ar & this->promote;
103 |         ar & this->bits;
104 |     }
105 |     std::string str() const;
106 |     std::string pgn() const;
107 | };
108 | 
109 | inline std::ostream& operator<<(std::ostream& o,const chess_move& mv) {
110 |   return o << mv.str();
111 | }
112 | 
113 | #endif
114 | 


--------------------------------------------------------------------------------
/headers/score.hpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | #ifndef SCORE_HPP
  8 | #define SCORE_HPP
  9 | #include "hash.hpp"
 10 | #include <ostream>
 11 | 
 12 | #define LONG_SCORE 1
 13 | #define SHORT_SCORE 2
 14 | #define CLASS_SCORE 3
 15 | 
 16 | #define SCORE_TYPE SHORT_SCORE
 17 | 
 18 | #if SCORE_TYPE == CLASS_SCORE
 19 | /**
 20 |  * This doesn't work exactly the same as the
 21 |  * official version, LONG_SCORE, but it
 22 |  * is close.
 23 |  **/
 24 | const uint32_t BITS = 16L;
 25 | const uint32_t MASK = (1L<<(BITS+1))-1L;
 26 | struct score_t {
 27 |     signed long base;
 28 |     signed long hash;
 29 |     score_t(int b,hash_t h) : base(b), hash(h) {
 30 |         hash &= MASK;
 31 |     }
 32 |     score_t(const score_t& sc) : base(sc.base), hash(sc.hash) {
 33 |         hash &= MASK;
 34 |     }
 35 |     inline void operator=(const score_t& s) {
 36 |         base = s.base;
 37 |         hash = s.hash;
 38 |     }
 39 |     score_t() : base(0), hash(0) {}
 40 | };
 41 | inline std::ostream& operator<<(std::ostream& o,const score_t& s) {
 42 |     return o << s.base;
 43 | }
 44 | inline bool operator<(const score_t& a,const score_t& b) {
 45 |     if(a.base == b.base) return a.hash < b.hash;
 46 |     return a.base < b.base;
 47 | }
 48 | inline bool operator>(const score_t& a,const score_t& b) {
 49 |     if(a.base == b.base) return a.hash > b.hash;
 50 |     return a.base > b.base;
 51 | }
 52 | inline bool operator>=(const score_t& a,const score_t& b) {
 53 |     if(a.base == b.base) return a.hash >= b.hash;
 54 |     return a.base >= b.base;
 55 | }
 56 | inline bool operator<=(const score_t& a,const score_t& b) {
 57 |     if(a.base == b.base) return a.hash <= b.hash;
 58 |     return a.base <= b.base;
 59 | }
 60 | inline bool operator==(const score_t& a,const score_t& b) {
 61 |     return a.base == b.base && a.hash == b.hash;
 62 | }
 63 | inline bool operator!=(const score_t& a,const score_t& b) {
 64 |     return a.base != b.base || a.hash != b.hash;
 65 | }
 66 | inline score_t operator-(const score_t& a,int b) {
 67 |     score_t s(a.base-b,a.hash);
 68 |     return s;
 69 | }
 70 | inline score_t operator-(const score_t& a) {
 71 |     score_t s(a);
 72 |     s.base *= -1;
 73 |     s.hash *= -1;
 74 |     return s;
 75 | }
 76 | inline score_t operator+(const score_t& a,int b) {
 77 |     score_t s(a.base+b,a.hash);
 78 |     return s;
 79 | }
 80 | inline const score_t& max(const score_t& a,const score_t& b) {
 81 |     if(a >= b)
 82 |         return a;
 83 |     else
 84 |         return b;
 85 | }
 86 | inline const score_t& min(const score_t& a,const score_t& b) {
 87 |     if(a < b)
 88 |         return a;
 89 |     else
 90 |         return b;
 91 | }
 92 | #define DECL_SCORE(name,val,hcode) score_t name(val,hcode);
 93 | #define ADD_SCORE(var,val) var+val
 94 | #endif
 95 | 
 96 | #if SCORE_TYPE == LONG_SCORE
 97 | typedef signed long score_t;
 98 | const uint32_t BITS = 16L;
 99 | const uint32_t MASK = (1L<<(BITS+1))-1L;
100 | #define DECL_SCORE(name,val,hcode) score_t name = (score_t(val)<<BITS) | (hcode & MASK);
101 | #define ADD_SCORE(var,val) var + (score_t(val)<<BITS)
102 | #endif
103 | 
104 | #if SCORE_TYPE == SHORT_SCORE
105 | typedef signed int score_t;
106 | #define DECL_SCORE(name,val,hcode) score_t name = val;
107 | #define ADD_SCORE(var,val) var + val
108 | #endif
109 | 
110 | const DECL_SCORE(bad_min_score,-11000,0);
111 | const DECL_SCORE(bad_max_score, 11000,0);
112 | const DECL_SCORE(max_score,10000,0);
113 | 
114 | #endif
115 | 


--------------------------------------------------------------------------------
/ChessViewer/module_chessviewer.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <project name="module_chessviewer" default="compile.module.chessviewer">
 3 |   <dirname property="module.chessviewer.basedir" file="${ant.file.module_chessviewer}"/>
 4 |   
 5 |   <property name="module.jdk.home.chessviewer" value="${jdk.home.android_4.0.3_platform}"/>
 6 |   <property name="module.jdk.bin.chessviewer" value="${jdk.bin.android_4.0.3_platform}"/>
 7 |   <property name="module.jdk.classpath.chessviewer" value="jdk.classpath.android_4.0.3_platform"/>
 8 |   
 9 |   <property name="compiler.args.chessviewer" value="${compiler.args}"/>
10 |   
11 |   <property name="chessviewer.output.dir" value="${module.chessviewer.basedir}/out/production/ChessViewer"/>
12 |   <property name="chessviewer.testoutput.dir" value="${module.chessviewer.basedir}/out/test/ChessViewer"/>
13 |   
14 |   <path id="chessviewer.module.bootclasspath">
15 |     <!-- Paths to be included in compilation bootclasspath -->
16 |   </path>
17 |   
18 |   <path id="chessviewer.module.production.classpath">
19 |     <path refid="${module.jdk.classpath.chessviewer}"/>
20 |   </path>
21 |   
22 |   <path id="chessviewer.runtime.production.module.classpath">
23 |     <pathelement location="${chessviewer.output.dir}"/>
24 |   </path>
25 |   
26 |   <path id="chessviewer.module.classpath">
27 |     <path refid="${module.jdk.classpath.chessviewer}"/>
28 |     <pathelement location="${chessviewer.output.dir}"/>
29 |   </path>
30 |   
31 |   <path id="chessviewer.runtime.module.classpath">
32 |     <pathelement location="${chessviewer.testoutput.dir}"/>
33 |     <pathelement location="${chessviewer.output.dir}"/>
34 |   </path>
35 |   
36 |   
37 |   <patternset id="excluded.from.module.chessviewer">
38 |     <patternset refid="ignored.files"/>
39 |   </patternset>
40 |   
41 |   <patternset id="excluded.from.compilation.chessviewer">
42 |     <patternset refid="excluded.from.module.chessviewer"/>
43 |   </patternset>
44 |   
45 |   <path id="chessviewer.module.sourcepath">
46 |     <dirset dir="${module.chessviewer.basedir}">
47 |       <include name="gen"/>
48 |       <include name="src"/>
49 |     </dirset>
50 |   </path>
51 |   
52 |   
53 |   <target name="compile.module.chessviewer" depends="compile.module.chessviewer.production,compile.module.chessviewer.tests" description="Compile module ChessViewer"/>
54 |   
55 |   <target name="compile.module.chessviewer.production" depends="register.custom.compilers" description="Compile module ChessViewer; production classes">
56 |     <mkdir dir="${chessviewer.output.dir}"/>
57 |     <javac2 destdir="${chessviewer.output.dir}" debug="${compiler.debug}" nowarn="${compiler.generate.no.warnings}" memorymaximumsize="${compiler.max.memory}" fork="true" executable="${module.jdk.bin.chessviewer}/javac">
58 |       <compilerarg line="${compiler.args.chessviewer}"/>
59 |       <bootclasspath refid="chessviewer.module.bootclasspath"/>
60 |       <classpath refid="chessviewer.module.production.classpath"/>
61 |       <src refid="chessviewer.module.sourcepath"/>
62 |       <patternset refid="excluded.from.compilation.chessviewer"/>
63 |     </javac2>
64 |     
65 |     <copy todir="${chessviewer.output.dir}">
66 |       <fileset dir="${module.chessviewer.basedir}/gen">
67 |         <patternset refid="compiler.resources"/>
68 |         <type type="file"/>
69 |       </fileset>
70 |       <fileset dir="${module.chessviewer.basedir}/src">
71 |         <patternset refid="compiler.resources"/>
72 |         <type type="file"/>
73 |       </fileset>
74 |     </copy>
75 |   </target>
76 |   
77 |   <target name="compile.module.chessviewer.tests" depends="register.custom.compilers,compile.module.chessviewer.production" description="compile module ChessViewer; test classes" unless="skip.tests"/>
78 |   
79 |   <target name="clean.module.chessviewer" description="cleanup module">
80 |     <delete dir="${chessviewer.output.dir}"/>
81 |     <delete dir="${chessviewer.testoutput.dir}"/>
82 |   </target>
83 | </project>


--------------------------------------------------------------------------------
/src/minimax.cpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2012 Steve Brandt and Phillip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | 
  8 | #include "parallel_support.hpp"
  9 | #include "search.hpp"
 10 | #include <assert.h>
 11 | #include "parallel.hpp"
 12 | 
 13 | void search_pt(boost::shared_ptr<search_info> info) {
 14 |     info->result = search(info);
 15 |     task_counter.add(1);
 16 | }
 17 | 
 18 | score_t search(boost::shared_ptr<search_info> info)
 19 | {
 20 |   node_t board = info->board;
 21 |   int depth = info->depth;
 22 |   assert(depth >= 0);
 23 |   // if we are a leaf node, return the value from the eval() function
 24 |   if (depth == 0)
 25 |   {
 26 |     evaluator ev;
 27 |     DECL_SCORE(s,ev.eval(board, chosen_evaluator),board.hash);
 28 |     return s;
 29 |   }
 30 |   /* if this isn't the root of the search tree (where we have
 31 |      to pick a chess_move and can't simply return 0) then check to
 32 |      see if the position is a repeat. if so, we can assume that
 33 |      this line is a draw and return 0. */
 34 |   if (board.ply && reps(board)==3) {
 35 |     DECL_SCORE(s,0,board.hash);
 36 |     return s;
 37 |   }
 38 | 
 39 |   // fifty chess_move draw rule
 40 |   if (board.fifty >= 100) {
 41 |     DECL_SCORE(z,0,board.hash);
 42 |     return z;
 43 |   }
 44 | 
 45 |   score_t val, max;
 46 | 
 47 |   std::vector<chess_move> workq;
 48 |   chess_move max_move;
 49 |   max_move = INVALID_MOVE;
 50 | 
 51 |   gen(workq, board); // Generate the moves
 52 | 
 53 |   // DECL_SCORE(minf,-10000,board.hash);
 54 |   max = bad_min_score; // Set the max score to -infinity
 55 | 
 56 |   // const int worksq = workq.size();
 57 |   std::vector<boost::shared_ptr<task> > tasks;
 58 | 
 59 |   // loop through the moves
 60 |   // We do this twice. The first time we skip
 61 |   // quiescent searches, the second time we
 62 |   // do the quiescent search. By doing this
 63 |   // we get the best value of beta to produce
 64 |   // cutoffs within the quiescent search routine.
 65 |   // Without doing this, minimax runs extremely
 66 |   // slowly.
 67 |   for(size_t j=0;j < workq.size(); j++) {
 68 |     bool last = (j+1)==workq.size();
 69 |     chess_move g = workq[j];
 70 |     boost::shared_ptr<search_info> info{new search_info(board)};
 71 | 
 72 |     if (makemove(info->board, g)) {  
 73 |       DECL_SCORE(z,0,board.hash);
 74 |       info->depth = depth-1;
 75 |       info->mv = g;
 76 |       info->result = z;
 77 |       bool parallel=true;
 78 |       bool skip = true;
 79 |       boost::shared_ptr<task> t = 
 80 |         parallel_task(depth, &parallel);
 81 |       t->info = info;
 82 |       t->pfunc = search_f;
 83 |       tasks.push_back(t);
 84 |       t->start();
 85 |       skip = false;
 86 |     }
 87 |   }
 88 |   for(size_t n=0;n<tasks.size();n++) {
 89 |     boost::shared_ptr<task> taskn = tasks[n];
 90 |     boost::shared_ptr<search_info> info = taskn->info;
 91 |     taskn->join();
 92 |     val = -taskn->info->result;
 93 | 
 94 |     if (val > max)
 95 |     {
 96 |       max = val;
 97 |       max_move = info->mv;
 98 |     }
 99 |   }
100 |   tasks.clear();
101 |   assert(tasks.size()==0);
102 | 
103 |   // no legal moves? then we're in checkmate or stalemate
104 |   if (max_move == INVALID_MOVE) {
105 |     if (in_check(board, board.side))
106 |     {
107 |       DECL_SCORE(s,-10000 + board.ply,board.hash);
108 |       return s;
109 |     }
110 |     else
111 |     {
112 |       DECL_SCORE(z,0,board.hash);
113 |       return z;
114 |     }
115 |   }
116 | 
117 |   if (board.ply == 0) {
118 |     assert(max_move != INVALID_MOVE);
119 |     ScopedLock s(cmutex);
120 |     move_to_make = max_move;
121 |   }
122 | 
123 |   return max;
124 | }
125 | 


--------------------------------------------------------------------------------
/ChessViewer/chessviewer.xml:
--------------------------------------------------------------------------------
  1 | <?xml version="1.0" encoding="UTF-8"?>
  2 | <project name="chessviewer" default="all">
  3 |   
  4 |   
  5 |   <property file="chessviewer.properties"/>
  6 |   <!-- Uncomment the following property if no tests compilation is needed -->
  7 |   <!-- 
  8 |   <property name="skip.tests" value="true"/>
  9 |    -->
 10 |   
 11 |   <!-- Compiler options -->
 12 |   
 13 |   <property name="compiler.debug" value="on"/>
 14 |   <property name="compiler.generate.no.warnings" value="off"/>
 15 |   <property name="compiler.args" value=""/>
 16 |   <property name="compiler.max.memory" value="128m"/>
 17 |   <patternset id="ignored.files">
 18 |     <exclude name="**/CVS/**"/>
 19 |     <exclude name="**/SCCS/**"/>
 20 |     <exclude name="**/RCS/**"/>
 21 |     <exclude name="**/rcs/**"/>
 22 |     <exclude name="**/.DS_Store/**"/>
 23 |     <exclude name="**/.svn/**"/>
 24 |     <exclude name="**/.pyc/**"/>
 25 |     <exclude name="**/.pyo/**"/>
 26 |     <exclude name="**/*.pyc/**"/>
 27 |     <exclude name="**/*.pyo/**"/>
 28 |     <exclude name="**/.git/**"/>
 29 |     <exclude name="**/*.hprof/**"/>
 30 |     <exclude name="**/_svn/**"/>
 31 |     <exclude name="**/.hg/**"/>
 32 |     <exclude name="**/*.lib/**"/>
 33 |     <exclude name="**/*~/**"/>
 34 |     <exclude name="**/__pycache__/**"/>
 35 |     <exclude name="**/.bundle/**"/>
 36 |     <exclude name="**/*.rbc/**"/>
 37 |     <exclude name="**/vssver.scc/**"/>
 38 |     <exclude name="**/vssver2.scc/**"/>
 39 |   </patternset>
 40 |   <patternset id="library.patterns">
 41 |     <include name="*.war"/>
 42 |     <include name="*.ear"/>
 43 |     <include name="*.apk"/>
 44 |     <include name="*.zip"/>
 45 |     <include name="*.swc"/>
 46 |     <include name="*.ane"/>
 47 |     <include name="*.egg"/>
 48 |     <include name="*.jar"/>
 49 |   </patternset>
 50 |   <patternset id="compiler.resources">
 51 |     <exclude name="**/?*.java"/>
 52 |     <exclude name="**/?*.form"/>
 53 |     <exclude name="**/?*.class"/>
 54 |     <exclude name="**/?*.groovy"/>
 55 |     <exclude name="**/?*.scala"/>
 56 |     <exclude name="**/?*.flex"/>
 57 |     <exclude name="**/?*.kt"/>
 58 |     <exclude name="**/?*.clj"/>
 59 |   </patternset>
 60 |   
 61 |   <!-- JDK definitions -->
 62 |   
 63 |   <property name="jdk.bin.android_4.0.3_platform" value="${jdk.home.android_4.0.3_platform}/../../../../usr/java/jdk1.7.0_03/bin"/>
 64 |   <path id="jdk.classpath.android_4.0.3_platform">
 65 |     <fileset dir="${jdk.home.android_4.0.3_platform}">
 66 |       <include name="platforms/android-15/android.jar"/>
 67 |       <include name="platforms/android-15/data/res"/>
 68 |       <include name="tools/support/annotations.jar"/>
 69 |     </fileset>
 70 |   </path>
 71 |   
 72 |   <property name="project.jdk.home" value="${jdk.home.android_4.3_platform}"/>
 73 |   <property name="project.jdk.bin" value="${jdk.bin.android_4.3_platform}"/>
 74 |   <property name="project.jdk.classpath" value="jdk.classpath.android_4.3_platform"/>
 75 |   
 76 |   
 77 |   <!-- Project Libraries -->
 78 |   <!-- Register Custom Compiler Taskdefs -->
 79 |   <property name="javac2.home" value="${idea.home}/lib"/>
 80 |   <path id="javac2.classpath">
 81 |     <pathelement location="${javac2.home}/javac2.jar"/>
 82 |     <pathelement location="${javac2.home}/jdom.jar"/>
 83 |     <pathelement location="${javac2.home}/asm4-all.jar"/>
 84 |     <pathelement location="${javac2.home}/jgoodies-forms.jar"/>
 85 |   </path>
 86 |   <target name="register.custom.compilers">
 87 |     <taskdef name="javac2" classname="com.intellij.ant.Javac2" classpathref="javac2.classpath"/>
 88 |     <taskdef name="instrumentIdeaExtensions" classname="com.intellij.ant.InstrumentIdeaExtensions" classpathref="javac2.classpath"/>
 89 |   </target>
 90 |   
 91 |   <!-- Modules -->
 92 |   
 93 |   <import file="${basedir}/module_chessviewer.xml"/>
 94 |   
 95 |   <target name="init" description="Build initialization">
 96 |     <!-- Perform any build initialization in this target -->
 97 |   </target>
 98 |   
 99 |   <target name="clean" depends="clean.module.chessviewer" description="cleanup all"/>
100 |   
101 |   <target name="build.modules" depends="init, clean, compile.module.chessviewer" description="build all modules"/>
102 |   
103 |   <target name="all" depends="build.modules" description="build all"/>
104 | </project>


--------------------------------------------------------------------------------
/headers/combine.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef COMBINE_H
  2 | #define COMBINE_H
  3 | #include <iostream>
  4 | 
  5 | #include <string>
  6 | #ifdef SQLITE3_SUPPORT
  7 | #include "sqlite3.h"
  8 | #endif
  9 | #include "score.hpp"
 10 | #include <vector>
 11 | 
 12 | using namespace std;
 13 | using compare = std::vector<std::string>;
 14 | #ifdef SQLITE3_SUPPORT
 15 | sqlite3 *db;
 16 | sqlite3 *db2;
 17 | #endif
 18 | 
 19 | char *zErrMsg=0;
 20 | int rc;
 21 | const char *sql;
 22 | 
 23 | 
 24 | static int callback2(void *Used, int argc, char **argvalue, char **azColName);
 25 | static int callback(void *NotUsed, int argc, char **argvalue, char **azColName){
 26 | #ifdef SQLITE3_SUPPORT
 27 |   //get values from destination database if they exist
 28 |   std::ostringstream select2;
 29 |   select2<<"SELECT * FROM white WHERE DEPTH=\'"<<argvalue[0]<<"\' AND BOARD=\'"<<argvalue[1]<<"\';";
 30 |   std::string merge = select2.str();
 31 |   sql = merge.c_str();
 32 |   compare params;
 33 |   rc = sqlite3_exec(db, sql, callback2,&params,&zErrMsg);
 34 |   if (rc != SQLITE_OK){
 35 |     fprintf(stderr, "SQL error callback: %s\n", zErrMsg);
 36 |     std::cout<<sql<<std::endl;
 37 |     sqlite3_free(zErrMsg);
 38 |     }
 39 | 
 40 |   //preparing statement for if no match found then insert into db
 41 |   std::ostringstream ins;
 42 |   ins<<"INSERT OR REPLACE INTO white (depth, board, hi, lo, hash, sumdepth) VALUES (\'"<<argvalue[0]<<"\',\'"<<argvalue[1]<<"\',\'"<<argvalue[2]<<"\',\'"<<argvalue[3]<<"\',\'"<<argvalue[4]<<"\',\'"<<argvalue[5]<<"\');"; 
 43 |   std::string insert = ins.str();
 44 |   if (params.size() == 0){
 45 |     sql = insert.c_str();
 46 |     rc = sqlite3_exec(db, sql, 0,0, &zErrMsg);
 47 |     if (rc != SQLITE_OK){
 48 |       fprintf(stderr, "SQL error callbackFinal: %s\n", zErrMsg);
 49 |       sqlite3_free(zErrMsg);
 50 |     }
 51 |     return 0;
 52 |   }
 53 | 
 54 |   if (params.size() == 6){
 55 |     if (argvalue[3]== NULL)
 56 |       assert(false);
 57 |     score_t zlo = max(atoi(argvalue[3]), atol(params.at(3).c_str()));
 58 |     score_t zhi = min(atoi(argvalue[2]), atol(params.at(2).c_str())); 
 59 |     std::ostringstream o;
 60 |     o<<"UPDATE white SET \'"<<azColName[2]<<"\'=\'"<<zhi<<"\', \'"<<azColName[3]<<"\'=\'"<<zlo<<"\', \'"<<azColName[4]<<"\'=\'"<<argvalue[4]<<"\', \'"<<azColName[5]<<"\'=\'"<<argvalue[5]<<"\' WHERE BOARD=\'"<<argvalue[1]<<"\' AND DEPTH=\'"<<argvalue[0]<<"\';"; 
 61 |     std::string update = o.str();
 62 |     sql = update.c_str();
 63 |     rc = sqlite3_exec(db,sql,0,0,&zErrMsg);
 64 |     if (rc != SQLITE_OK){
 65 |       fprintf(stderr, "SQL error callback params: %s\n", zErrMsg);
 66 |       sqlite3_free(zErrMsg);
 67 |     }
 68 |   }
 69 | #endif
 70 |   return 0;
 71 | }
 72 | 
 73 | static int callback2(void *Used, int argc, char **argvalue, char **azColName){
 74 |   compare* params=static_cast<compare*>(Used);
 75 |   for(int i=0;i<argc;i++) {
 76 |     params->push_back(argvalue[i]);
 77 |   }
 78 |   return 0;
 79 | }
 80 | 
 81 | static int callback(void *NotUsed, int argc, char **argvalue, char **azColName);
 82 | 
 83 | void merge(std::vector<std::string> databases)
 84 | {
 85 | #ifdef SQLITE3_SUPPORT
 86 |   sqlite3_close(db);
 87 |   std::string current_database = databases.at(0).c_str();
 88 |   std::ostringstream l;
 89 |   l<<current_database<<".db";
 90 |   std::string open_1 = l.str();
 91 |   sql = open_1.c_str();
 92 |   rc = sqlite3_open(sql, &db);
 93 |     if(rc){
 94 |       fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
 95 |       exit(0);
 96 |     }else{
 97 |       fprintf(stderr, "Opened test1 database successfully\n");
 98 |       }
 99 |   for(int i(1); i<databases.size(); ++i)
100 |   {
101 |     std::string merging_database = databases.at(i).c_str();
102 |     std::ostringstream o;
103 |     o<<merging_database<<".db";
104 |     std::string open = o.str();
105 |     sql = open.c_str();
106 |     rc = sqlite3_open(sql, &db2);
107 |     if(rc){
108 |       fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
109 |       exit(0);
110 |     }else{
111 |       fprintf(stderr, "Opened database testx successfully\n");
112 |       }
113 | 
114 |     //rc = sqlite3_exec(db2,"BEGIN;", 0, 0, &zErrMsg);
115 |     rc = sqlite3_exec(db2, "SELECT * FROM white;",callback,0,&zErrMsg);
116 |     if (rc != SQLITE_OK){
117 |       fprintf(stderr, "SQL error 1st select: %s\n", zErrMsg);
118 |       sqlite3_free(zErrMsg);
119 |     }else{
120 |       fprintf(stderr, "Merged successfuly\n");  
121 |       } 
122 |    }
123 |   // sqlite3_close(db);
124 |    //sqlite3_close(db2);
125 |     
126 | #endif
127 | }
128 | 
129 | #endif
130 | 


--------------------------------------------------------------------------------
/README.rst:
--------------------------------------------------------------------------------
  1 | Compiling the chess benchmark:
  2 | ==============================
  3 | 
  4 | The Chess benchmark is compiled with cmake.
  5 | 
  6 |     cmake ./CMakeLists.txt
  7 |     make
  8 | 
  9 | The end result is an executable named ./src/chx.
 10 | The program can be executed either from the command
 11 | line, by supplying an ini file, or by using the
 12 | perl test harness.
 13 | 
 14 | Running the chess benchmark:
 15 | ============================
 16 | 
 17 | The Perl Test Harness
 18 | ---------------------
 19 | 
 20 | The perl test harness creates ini files and executes
 21 | the chess benchmark multiple times, executing the
 22 | chess benchmark to a number of different ply depths,
 23 | using a variety of algorithms, on a number of different
 24 | boards.
 25 | 
 26 | The benchmark does not attempt to play a game, instead
 27 | it attempts to make a single move by a single side. The
 28 | objective of the benchmark is to search to the deepest
 29 | ply depth possible in two hours.
 30 | 
 31 | Before running the test harness line 93 should be
 32 | edited to create an appropriate run command. By default
 33 | it reads as follows:
 34 | 
 35 | open($fd,"mpiexec -np 1 -env CHX_THREADS_PER_PROC 8 $ENV{PWD}/src/chx < .bench 2>/dev/null|");
 36 | 
 37 | This uses MPI to run in a single process using 8
 38 | threads per core. Please edit this line to match
 39 | the core count and number of processes appropriate
 40 | for your platform.
 41 | 
 42 | By default three algorithms are run by the benchmark:
 43 | 
 44 | 1) Minimax - This algorithm is a simple test program
 45 |    that provides a deterministic workload.
 46 | 
 47 | 2) Alpha Beta - This algorithm is actually the Alpha-
 48 |    Beta With Memory required by MTD-f. The macro definition
 49 |    
 50 |    #define PV_ON 1
 51 | 
 52 |    can be commented out to disable principle variation
 53 |    search.
 54 | 
 55 |    The macro definition
 56 | 
 57 |    #define TRANSPOSE_ON 1
 58 | 
 59 |    can be commented out to disable the use of a transposition
 60 |    table.
 61 | 
 62 | 3) MTD-f - The basic MTD-f algorithm has three parameters
 63 |    which modify its behavior. Strictly speaking, MTD-f does
 64 |    zero width searches. The code provided with the benchmark
 65 |    uses a narrow width instead, one which is permitted to
 66 |    grow as the number of searches increases, and which gives
 67 |    up after a set number of searches are tried and fail.
 68 | 
 69 |    start_width: This is the width in terms of the base
 70 |    score. This is the value of the score before the score
 71 |    is augmented by the hash value of the board.
 72 | 
 73 |    grow_width: This is a constant value that is added to
 74 |    the search width after each failure.
 75 | 
 76 |    max_tries: This is the maximum number of tries that
 77 |    should be made at finding the with MTD-f before giving up
 78 |    and doing a full Alpha-Beta search between the remaining
 79 |    lower/upper score range.
 80 | 
 81 | 4) Multistrike - This algorithm divides the possible range
 82 |    of scores into subranges and assigns a subrange to each
 83 |    available thread/core. Each subrange of Multistrike is
 84 |    searched completely by a strict Alpha-Beta search without
 85 |    recourse to principle variation. (The code might be improved
 86 |    by using MTD-f on each sub-range)
 87 | 
 88 |    The Multistrike code with the chess benchmark is not able
 89 |    to use MPI. This lack does not represent a limitation of the
 90 |    algorithm, but a feature that is not yet implemented.
 91 | 
 92 | Interactive Mode
 93 | ----------------
 94 | 
 95 | This mode is useful for actually playing chess. 
 96 | To understand how this mode is used, please type "help" at the prompt.
 97 | 
 98 | To display the board type "d". To make the first move, type
 99 | in a move (e.g. e2e4 to advance white's king pawn two squares).
100 | Type "d" again to see the result. Type "go" to let the chx
101 | program move on behalf of black. After this, the chx program
102 | will automatically move and redisplay the board after each
103 | move by white.
104 | 
105 | Configuring chx
106 | -----------------
107 | 
108 | In order to configure chx so that you don't have to use the
109 | interactive mode all the time, you may specify the commands to 
110 | do in a file and then pipe it in using stdin.
111 | 
112 | For example, to specify the search method to be multistrike and
113 | then run the benchmark, a file might look like:
114 | 
115 |   $ cat > input
116 |   search multistrike
117 |   bench some_board 3 1
118 |   $ ./src/chx < input
119 | 
120 | One parameter, the number of threads, is controlled through
121 | an environment variable: CHX_THREADS_PER_PROC.
122 | 
123 | Limitations of the CHX code
124 | ===========================
125 | 
126 | The current version of the CHX code suffers from a number
127 | of limitations, including:
128 | 
129 | 1) The parallel implementation does not have a proper mechanism
130 |    for aborting a subset of calculations. Because of this,
131 |    the Younger Brother's Wait algorithm must explore moves in
132 |    batches and wait for each batch to complete before moving
133 |    on to search new moves.
134 | 
135 | 2) The MPI implementation is more a proof of concept than an
136 |    optimal implementation. The transposition table is not
137 |    exchanged in the course of MPI searching. Like the threading
138 |    aspect of the parallel implementation, MPI moves must be
139 |    explored in batches.
140 | 
141 | 3) The Multistrike implementation has a number of defects
142 |    that are described above. In short, it needs to make use
143 |    of MTD-f, as well as MPI.
144 | 


--------------------------------------------------------------------------------
/harness_memcheck.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | ################################################################################
  3 | ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  4 | ##
  5 | ##  Distributed under the Boost Software License, Version 1.0. (See accompanying
  6 | ##  file BOOST_LICENSE_1_0.rst or copy at http:##www.boost.org#LICENSE_1_0.txt)
  7 | ################################################################################
  8 | use strict;
  9 | use FileHandle;
 10 | 
 11 | my $fsup = 0;
 12 | my $asup = 0;
 13 | my $nsup = 0;
 14 | my $msup = 1;
 15 | 
 16 | my $anskey = {};
 17 | my $scoretab = {};
 18 | my $speedtab = {};
 19 | 
 20 | #Answer key:
 21 | 
 22 | #board1
 23 | #ply | answer
 24 | #====+=======
 25 | #  7 |   e2e4
 26 | #  6 |   b1c3
 27 | #  5 |   b2b4
 28 | #  4 |   g1f3
 29 | #  3 |   g1f3
 30 | #  2 |   d2d4
 31 | 
 32 | $anskey->{1}->{2} = "e2e4";
 33 | $anskey->{1}->{3} = "e2e4";
 34 | $anskey->{1}->{4} = "d2d4";
 35 | $anskey->{1}->{5} = "g1f3";
 36 | 
 37 | #board2
 38 | #ply | answer
 39 | #====+=======
 40 | #  7 |   d1b3
 41 | #  6 |   c1d2
 42 | #  5 |   c1g5
 43 | #  4 |   c1g5
 44 | #  3 |   c1d2
 45 | #  2 |   e2e4
 46 | 
 47 | $anskey->{2}->{2} = "e2e4";
 48 | $anskey->{2}->{3} = "e1d2";
 49 | $anskey->{2}->{4} = "c1d2";
 50 | $anskey->{2}->{5} = "c1g5";
 51 | 
 52 | #board3
 53 | #ply | answer
 54 | #====+=======
 55 | #  7 |   f5h7
 56 | #  6 |   f5g7
 57 | #  5 |   f5h6
 58 | #  4 |   f5g7
 59 | #  3 |   f3b3
 60 | #  2 |   b2b3
 61 | 
 62 | $anskey->{3}->{2} = "f5g7";
 63 | $anskey->{3}->{3} = "b2b3";
 64 | $anskey->{3}->{4} = "f3h5";
 65 | $anskey->{3}->{5} = "g5g6";
 66 | 
 67 | #board4
 68 | #ply | answer
 69 | #====+=======
 70 | #  7 |   e5f5
 71 | #  6 |   e5e3
 72 | #  5 |   h5h6
 73 | #  4 |   e5e3
 74 | #  3 |   e5b5
 75 | #  2 |   e5e3
 76 | 
 77 | $anskey->{4}->{2} = "e5a5";
 78 | $anskey->{4}->{3} = "g5f7";
 79 | $anskey->{4}->{4} = "g5f7";
 80 | $anskey->{4}->{5} = "g5f7";
 81 | 
 82 | my $bad_score = -6666;
 83 | my $tot_time = 0;
 84 | 
 85 | for my $sm (("mtdf","alphabeta","minimax")) {
 86 |     for(my $b=1;$b<=4;$b++) {
 87 |         for(my $ply=2;$ply<=5;$ply++) {
 88 |             # It takes too long for minimax above ply 4
 89 |             # So I ran it once at 5 to verify the answer
 90 |             # and then introduced this next.
 91 |             if($sm eq "minimax" and $ply >= 5) {
 92 |                 next;
 93 |             }
 94 |             genbench($sm,$b,$ply);
 95 |             my $fd = new FileHandle;
 96 |             if($sm eq "mtdf") {
 97 |                 #sleep(1);
 98 |             }
 99 |             #open($fd,"mpiexec -np 2 -env CHX_THREADS_PER_PROC 2 $ENV{PWD}/src/chx -s .bench.ini 2>/dev/null|");
100 |             #open($fd,"CHX_THREADS_PER_PROC=8; mpiexec -np 1 src/chx -s .bench.ini 2>/dev/null|");
101 |             open($fd,"CHX_THREADS_PER_PROC=8 valgrind --tool=memcheck --leak-check=full src/chx < .bench 2>>log_memcheck.out");
102 | 
103 |             my $ans = "";
104 |             my $score = $bad_score;
105 | 
106 |             my $st = "OK ";
107 |             my $tm = 1e-6;
108 |             my $speedup = 1;
109 |             my $doc = "";
110 |             while(<$fd>) {
111 |                 $doc .= $_;
112 |                 if(/Computer's chess_move: ([a-h][1-8][a-h][1-8])/) {
113 |                     if($ans ne "" and $ans ne $1) {
114 |                         $st = "VARIABLE($ans != $1) ";
115 |                         #last;
116 |                     }
117 |                     $ans = $1;
118 |                 }
119 |                 if(/SCORE=(-?\d+)/) {
120 |                     if($score != $bad_score and $score != $1) {
121 |                         $st = "VARIABLE($score != $1) ";
122 |                         #last;
123 |                     }
124 |                     $score=$1;
125 |                 }
126 |                 if(/Average time for run: (\d+) ms/) {
127 |                     $tm = $1*1.0e-3;
128 |                     $tm = 1.0e-3 if($tm < 1.0e-3);
129 |                     $tot_time += $tm;
130 |                 }
131 |             }
132 |             if(defined($anskey->{$b}->{$ply})) {
133 |                 my $v = $anskey->{$b}->{$ply};
134 |                 if($ans ne $v) {
135 |                     $st .= "MOVE($v) ";
136 |                 }
137 |             }
138 |             if(defined($scoretab->{$b}->{$ply})) {
139 |                 my $s = $scoretab->{$b}->{$ply};
140 |                 if($s != $score) {
141 |                     $st .= "SCORE($s) ";
142 |                 }
143 |             }
144 |             if($st eq "OK ") {
145 |                 $scoretab->{$b}->{$ply} = $score;
146 |             }
147 |             if(defined($speedtab->{$b}->{$ply})) {
148 |                 $speedup = $speedtab->{$b}->{$ply}/$tm;
149 |             }
150 |             $speedtab->{$b}->{$ply} = $tm;
151 |             printf("%10s, %4d, %4d, %9d, %s, %s, %.2f\n",$sm,$b,$ply,$score,$ans,$st,$speedup);
152 |             die $doc if($st =~ /VARIABLE/);
153 |             if($sm eq "mtdf" or $sm eq "multistrike") {
154 |                 $fsup += 1 if($speedup > 1);
155 |                 $fsup += 0.5 if($speedup == 1);
156 |                 $asup += $speedup;
157 |                 $nsup += 1;
158 |                 $msup *= $speedup;
159 |             }
160 |             my $ret=close($fd);
161 |             unless($ret) {
162 |                 print $doc;
163 |                 die "error code returned r=($ret)";
164 |             }
165 | 			open($fd,"log.out");
166 | 			while(<$fd>) {
167 | 				if(/ERROR SUMMARY: (\d+) errors/) {
168 | 					if($1 > 0) {
169 | 						die $_;
170 | 					}
171 | 				}
172 | 			}
173 |         }
174 |     }
175 | }
176 | 
177 | printf("mtdf over alpha speedup: avg=%3.2f geometric mean=%3.2f fraction faster=%3.2f\n",$asup/$nsup,($msup)**(1.0/$nsup),$fsup/$nsup);
178 | 
179 | printf("total time: %3.2f\n",$tot_time);
180 | 
181 | sub genbench {
182 |     my $sm = shift;
183 |     my $b = shift;
184 |     my $ply = shift;
185 |     my $fd = new FileHandle;
186 |     my $runs = 1;
187 |     $runs = 1 if($sm eq "minimax");
188 |     $runs = 3 if($ply > 5);
189 |     open($fd,">.bench");
190 | print $fd qq{
191 | search $sm
192 | eval original
193 | bench inputs/board$b $ply $runs
194 | quit
195 | 
196 | };
197 |     close($fd);
198 | }
199 | 


--------------------------------------------------------------------------------
/harness_helgrind.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | ################################################################################
  3 | ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  4 | ##
  5 | ##  Distributed under the Boost Software License, Version 1.0. (See accompanying
  6 | ##  file BOOST_LICENSE_1_0.rst or copy at http:##www.boost.org#LICENSE_1_0.txt)
  7 | ################################################################################
  8 | use strict;
  9 | use FileHandle;
 10 | 
 11 | my $fsup = 0;
 12 | my $asup = 0;
 13 | my $nsup = 0;
 14 | my $msup = 1;
 15 | 
 16 | my $anskey = {};
 17 | my $scoretab = {};
 18 | my $speedtab = {};
 19 | 
 20 | #Answer key:
 21 | 
 22 | #board1
 23 | #ply | answer
 24 | #====+=======
 25 | #  7 |   e2e4
 26 | #  6 |   b1c3
 27 | #  5 |   b2b4
 28 | #  4 |   g1f3
 29 | #  3 |   g1f3
 30 | #  2 |   d2d4
 31 | 
 32 | $anskey->{1}->{2} = "e2e4";
 33 | $anskey->{1}->{3} = "e2e4";
 34 | $anskey->{1}->{4} = "d2d4";
 35 | $anskey->{1}->{5} = "g1f3";
 36 | 
 37 | #board2
 38 | #ply | answer
 39 | #====+=======
 40 | #  7 |   d1b3
 41 | #  6 |   c1d2
 42 | #  5 |   c1g5
 43 | #  4 |   c1g5
 44 | #  3 |   c1d2
 45 | #  2 |   e2e4
 46 | 
 47 | $anskey->{2}->{2} = "e2e4";
 48 | $anskey->{2}->{3} = "e1d2";
 49 | $anskey->{2}->{4} = "c1d2";
 50 | $anskey->{2}->{5} = "c1g5";
 51 | 
 52 | #board3
 53 | #ply | answer
 54 | #====+=======
 55 | #  7 |   f5h7
 56 | #  6 |   f5g7
 57 | #  5 |   f5h6
 58 | #  4 |   f5g7
 59 | #  3 |   f3b3
 60 | #  2 |   b2b3
 61 | 
 62 | $anskey->{3}->{2} = "f5g7";
 63 | $anskey->{3}->{3} = "b2b3";
 64 | $anskey->{3}->{4} = "f3h5";
 65 | $anskey->{3}->{5} = "g5g6";
 66 | 
 67 | #board4
 68 | #ply | answer
 69 | #====+=======
 70 | #  7 |   e5f5
 71 | #  6 |   e5e3
 72 | #  5 |   h5h6
 73 | #  4 |   e5e3
 74 | #  3 |   e5b5
 75 | #  2 |   e5e3
 76 | 
 77 | $anskey->{4}->{2} = "e5a5";
 78 | $anskey->{4}->{3} = "g5f7";
 79 | $anskey->{4}->{4} = "g5f7";
 80 | $anskey->{4}->{5} = "g5f7";
 81 | 
 82 | my $bad_score = -6666;
 83 | my $tot_time = 0;
 84 | 
 85 | for my $sm (("mtdf","alphabeta","minimax")) {
 86 |     for(my $b=1;$b<=4;$b++) {
 87 |         for(my $ply=2;$ply<=5;$ply++) {
 88 |             # It takes too long for minimax above ply 4
 89 |             # So I ran it once at 5 to verify the answer
 90 |             # and then introduced this next.
 91 |             if($sm eq "minimax" and $ply >= 5) {
 92 |                 next;
 93 |             }
 94 |             genbench($sm,$b,$ply);
 95 |             my $fd = new FileHandle;
 96 |             if($sm eq "mtdf") {
 97 |                 #sleep(1);
 98 |             }
 99 |             #open($fd,"mpiexec -np 2 -env CHX_THREADS_PER_PROC 2 $ENV{PWD}/src/chx -s .bench.ini 2>/dev/null|");
100 |             #open($fd,"CHX_THREADS_PER_PROC=8; mpiexec -np 1 src/chx -s .bench.ini 2>/dev/null|");
101 |             open($fd,"CHX_THREADS_PER_PROC=8 valgrind --tool=helgrind --log-file=log_helgrind.out src/chx < .bench 2>/dev/null|");
102 | 
103 |             my $ans = "";
104 |             my $score = $bad_score;
105 | 
106 |             my $st = "OK ";
107 |             my $tm = 1e-6;
108 |             my $speedup = 1;
109 |             my $doc = "";
110 |             while(<$fd>) {
111 |                 $doc .= $_;
112 |                 if(/Computer's chess_move: ([a-h][1-8][a-h][1-8])/) {
113 |                     if($ans ne "" and $ans ne $1) {
114 |                         $st = "VARIABLE($ans != $1) ";
115 |                         #last;
116 |                     }
117 |                     $ans = $1;
118 |                 }
119 |                 if(/SCORE=(-?\d+)/) {
120 |                     if($score != $bad_score and $score != $1) {
121 |                         $st = "VARIABLE($score != $1) ";
122 |                         #last;
123 |                     }
124 |                     $score=$1;
125 |                 }
126 |                 if(/Average time for run: (\d+) ms/) {
127 |                     $tm = $1*1.0e-3;
128 |                     $tm = 1.0e-3 if($tm < 1.0e-3);
129 |                     $tot_time += $tm;
130 |                 }
131 |             }
132 |             if(defined($anskey->{$b}->{$ply})) {
133 |                 my $v = $anskey->{$b}->{$ply};
134 |                 if($ans ne $v) {
135 |                     $st .= "MOVE($v) ";
136 |                 }
137 |             }
138 |             if(defined($scoretab->{$b}->{$ply})) {
139 |                 my $s = $scoretab->{$b}->{$ply};
140 |                 if($s != $score) {
141 |                     $st .= "SCORE($s) ";
142 |                 }
143 |             }
144 |             if($st eq "OK ") {
145 |                 $scoretab->{$b}->{$ply} = $score;
146 |             }
147 |             if(defined($speedtab->{$b}->{$ply})) {
148 |                 $speedup = $speedtab->{$b}->{$ply}/$tm;
149 |             }
150 |             $speedtab->{$b}->{$ply} = $tm;
151 |             printf("%10s, %4d, %4d, %9d, %s, %s, %.2f\n",$sm,$b,$ply,$score,$ans,$st,$speedup);
152 |             die $doc if($st =~ /VARIABLE/);
153 |             if($sm eq "mtdf" or $sm eq "multistrike") {
154 |                 $fsup += 1 if($speedup > 1);
155 |                 $fsup += 0.5 if($speedup == 1);
156 |                 $asup += $speedup;
157 |                 $nsup += 1;
158 |                 $msup *= $speedup;
159 |             }
160 |             my $ret=close($fd);
161 |             unless($ret) {
162 |                 print $doc;
163 |                 die "error code returned r=($ret)";
164 |             }
165 | 			open($fd,"log.out");
166 | 			while(<$fd>) {
167 | 				if(/ERROR SUMMARY: (\d+) errors/) {
168 | 					if($1 > 0) {
169 | 						die $_;
170 | 					}
171 | 				}
172 | 			}
173 |         }
174 |     }
175 | }
176 | 
177 | printf("mtdf over alpha speedup: avg=%3.2f geometric mean=%3.2f fraction faster=%3.2f\n",$asup/$nsup,($msup)**(1.0/$nsup),$fsup/$nsup);
178 | 
179 | printf("total time: %3.2f\n",$tot_time);
180 | 
181 | sub genbench {
182 |     my $sm = shift;
183 |     my $b = shift;
184 |     my $ply = shift;
185 |     my $fd = new FileHandle;
186 |     my $runs = 1;
187 |     $runs = 1 if($sm eq "minimax");
188 |     $runs = 3 if($ply > 5);
189 |     open($fd,">.bench");
190 | print $fd qq{
191 | search $sm
192 | eval original
193 | bench inputs/board$b $ply $runs
194 | quit
195 | 
196 | };
197 |     close($fd);
198 | }
199 | 


--------------------------------------------------------------------------------
/docs/algorithms/src/edu/lsu/cct/minimax/Node.java:
--------------------------------------------------------------------------------
  1 | package edu.lsu.cct.minimax;
  2 | 
  3 | import java.util.ArrayList;
  4 | import java.util.Collections;
  5 | import java.util.Comparator;
  6 | import java.util.HashMap;
  7 | import java.util.List;
  8 | import java.util.Map;
  9 | import java.util.Random;
 10 | 
 11 | public class Node {
 12 | 	public final static int MAX=1000;
 13 | 	final int value;
 14 | 	int score;
 15 | 	List<Node> children = new ArrayList<Node>();
 16 | 	final private static Comparator<? super Node> sorter = new Comparator<Node>() {
 17 | 		@Override
 18 | 		public int compare(Node arg0, Node arg1) {
 19 | 			return arg0.score - arg1.score;
 20 | 		}
 21 | 	};
 22 | 	Node(Random r,int depth,int branching,int sign) {
 23 | 		int v = sign*r.nextInt(MAX);
 24 | 		score = 0;
 25 | 		if(depth > 0) {
 26 | 			v = 0;
 27 | 			for(int i=0;i<branching;i++) {
 28 | 				Node child = new Node(r,depth-1,branching,sign);
 29 | 				children.add(child);
 30 | 				v += child.value;
 31 | 			}
 32 | 			value = -(int)((1.0*v)/branching+.5);
 33 | 		} else {
 34 | 			value = v;
 35 | 		}
 36 | 	}
 37 | 	void clear() {
 38 | 		score = 0;
 39 | 		nlower = -MAX;
 40 | 		nupper = MAX;
 41 | 		for(Node child : children)
 42 | 			child.clear();
 43 | 	}
 44 | 	
 45 | 	void minimax() {
 46 | 		Counter c= new Counter();
 47 | 		clear();
 48 | 		minimax(c);
 49 | 		System.out.println("minimax: score="+score+" in "+c+" steps");
 50 | 	}
 51 | 	void minimax(Counter c) {
 52 | 		c.inc();
 53 | 		if(children.size()==0) {
 54 | 			score = value;
 55 | 			return;
 56 | 		}
 57 | 		score = -MAX;
 58 | 		for(Node child : children) {
 59 | 			child.minimax(c);
 60 | 			score = Math.max(score,-child.score);
 61 | 		}
 62 | 		Collections.sort(children,sorter);
 63 | 		if(Game.rand.nextInt(3)==0)
 64 | 			swap(0,1);
 65 | 	}
 66 | 	
 67 | 	private void swap(int i, int j) {
 68 | 		Node n = children.get(i);
 69 | 		children.set(i, children.get(j));
 70 | 		children.set(j, n);
 71 | 	}
 72 | 	public void check(int ans) {
 73 | 		if(ans != score)
 74 | 			throw new Error(ans+" != "+score);
 75 | 	}
 76 | 
 77 | 	void alphabeta(int ans) {
 78 | 		Counter c= new Counter();
 79 | 		clear();
 80 | 		alphabeta(-MAX,MAX,c);
 81 | 		check(ans);
 82 | 		System.out.println("alphabeta: score="+score+" in "+c+" steps");
 83 | 	}
 84 | 	void alphabeta(int alpha,int beta,Counter c) {
 85 | 		c.inc();
 86 | 		if(children.size()==0) {
 87 | 			score = value;
 88 | 			return;
 89 | 		}
 90 | 		for(Node child : children) {
 91 | 			child.alphabeta(-beta,-alpha,c);
 92 | 			alpha = Math.max(alpha,-child.score);
 93 | 			if(alpha >= beta)
 94 | 				break;
 95 | 		}
 96 | 		score = alpha;
 97 | 	}
 98 | 	
 99 | 	int nlower = -MAX, nupper = MAX;
100 | 	void alphabetamem(int ans) {
101 | 		Counter c= new Counter();
102 | 		clear();
103 | 		alphabetamem(-MAX,MAX,c);
104 | 		check(ans);
105 | 		System.out.println("alphabetamem: score="+score+" in "+c+" steps");
106 | 	}
107 | 	void alphabetamem(int alpha,int beta,Counter c) {
108 | 		if(beta > nupper)
109 | 			beta = nupper;
110 | 		if(alpha < nlower)
111 | 			alpha = nlower;
112 | 		if(alpha >= beta) {
113 | 			score = alpha;
114 | 			return;
115 | 		}
116 | 		c.inc();
117 | 		if(children.size()==0) {
118 | 			nlower = nupper = score = value;
119 | 			return;
120 | 		}
121 | 		int a = alpha;
122 | 		for(Node child : children) {
123 | 			child.alphabetamem(-beta,-a,c);
124 | 			a = Math.max(a,-child.score);
125 | 			if(a >= beta)
126 | 				break;
127 | 		}
128 | 		score = a;
129 | 		if(a < beta)
130 | 			nupper = a;
131 | 		if(a > alpha)
132 | 			nlower = a;
133 | 	}
134 | 	
135 | 	void negascout(int ans) {
136 | 		Counter c= new Counter();
137 | 		clear();
138 | 		negascout(-MAX,MAX,c);
139 | 		check(ans);
140 | 		System.out.println("negascout: score="+score+" in "+c+" steps");
141 | 	}
142 | 	void negascout(int alpha,int beta,Counter c) {
143 | 		c.inc();
144 | 		if(children.size()==0) {
145 | 			score = value;
146 | 			return;
147 | 		}
148 | 		int b = beta;
149 | 		for(Node child : children) {
150 | 			child.negascout(-b,-alpha,c);
151 | 			int a = -child.score;
152 | 			if(alpha < a && a < beta && beta > b) {
153 | 				child.negascout(-beta, -alpha, c);
154 | 				a = -child.score;
155 | 			}
156 | 			alpha = Math.max(a,alpha);
157 | 			if(alpha >= beta) {
158 | 				score = alpha;
159 | 				return;
160 | 			}
161 | 			b = alpha+1;
162 | 		}
163 | 		score = alpha;
164 | 	}
165 | 	
166 | 	void mtdf2(int ans,int f) {
167 | 		Counter c= new Counter();
168 | 		clear();
169 | 		mtdf2(f,c);
170 | 		check(ans);
171 | 		System.out.println("mtd-f2: score="+score+" in "+c+" steps");
172 | 	}
173 | 	void mtdf2(int f,Counter c) {
174 | 		int g = f;
175 | 		int upper = MAX;
176 | 		int lower = -MAX;
177 | 		while(lower < upper) {
178 | 			int beta = g;
179 | 			if(g == lower)
180 | 				beta = g+1;
181 | 			alphabeta(beta-1,beta,c);
182 | 			g = score;
183 | 			if(g < beta) {
184 | 				upper = g;
185 | 			}
186 | 			if(g > beta-1){
187 | 				lower = g;
188 | 			}
189 | 		}
190 | 		score = g;
191 | 	}
192 | 
193 | 	
194 | 	void mtdf(int ans,int f) {
195 | 		Counter c= new Counter();
196 | 		clear();
197 | 		mtdf(f,c);
198 | 		check(ans);
199 | 		System.out.println("mtd-f: score="+score+" in "+c+" steps");
200 | 	}
201 | 	void mtdf(int f,Counter c) {
202 | 		int g = f;
203 | 		int upper = MAX;
204 | 		int lower = -MAX;
205 | 		while(lower < upper) {
206 | 			int beta = g;
207 | 			if(g == lower)
208 | 				beta = g+1;
209 | 			alphabetamem(beta-1,beta,c);
210 | 			g = score;
211 | 			if(g < beta) {
212 | 				upper = g;
213 | 			}
214 | 			if(g > beta-1){
215 | 				lower = g;
216 | 			}
217 | 		}
218 | 		score = g;
219 | 	}
220 | 	
221 | 
222 | 	void srb(int ans,int f1,int f2) {
223 | 		Counter c= new Counter();
224 | 		clear();
225 | 		srb(f1,f2,c);
226 | 		check(ans);
227 | 		System.out.println("srb: score="+score+" in "+c+" steps");
228 | 	}
229 | 	void srb(int f1,int f2,Counter c) {
230 | 		alphabetamem(f1,f2,c);
231 | 		int g = score;
232 | 		int upper = nupper;
233 | 		int lower = nlower;
234 | 		while(lower < upper) {
235 | 			int beta = g;
236 | 			if(g == lower)
237 | 				beta = g+1;
238 | 			alphabetamem(beta-1,beta,c);
239 | 			g = score;
240 | 			if(g < beta) {
241 | 				upper = g;
242 | 			}
243 | 			if(g > beta-1){
244 | 				lower = g;
245 | 			}
246 | 		}
247 | 		score = g;
248 | 	}
249 | 	
250 | 	void print(Out out) {
251 | 		out.println(""+Math.abs(score)+"/"+Math.abs(value));
252 | 		out.indent += 2;
253 | 		for(Node child : children) {
254 | 			child.print(out);
255 | 		}
256 | 		out.indent -= 2;
257 | 	}
258 | }
259 | 


--------------------------------------------------------------------------------
/headers/parallel_support.hpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | #ifndef PARALLEL_SUPPORT_HPP
  8 | #define PARALLEL_SUPPORT_HPP
  9 | 
 10 | #include <sys/time.h>
 11 | #include "node.hpp"
 12 | #include "score.hpp"
 13 | #include "chess_move.hpp"
 14 | #include <boost/atomic.hpp>
 15 | #include "parallel.hpp"
 16 | #include <boost/shared_ptr.hpp>
 17 | #include <future>
 18 | #include <sstream>
 19 | 
 20 | extern bool par_enabled;
 21 | int chx_threads_per_proc();
 22 | 
 23 | struct task;
 24 | 
 25 | struct search_info {
 26 | private:
 27 |     template<class Archive>
 28 |     void serialize(Archive & ar, const unsigned int version) {
 29 |       // TODO: Write a real serializer
 30 |       abort();
 31 |     }
 32 | public:
 33 |     std::ostringstream log;
 34 |     boost::atomic<bool>  abort_flag_;
 35 |     boost::atomic<bool> *abort_flag;
 36 |     bool get_abort() { return *abort_flag; }
 37 |     void set_abort(bool b) { *abort_flag = b; }
 38 |     void set_abort_ref(search_info *s) {
 39 |         abort_flag = s->abort_flag;
 40 |     }
 41 |     bool use_srand = false;
 42 |     node_t board;
 43 |     bool par_done;
 44 |     chess_move mv;
 45 |     score_t result;
 46 |     int depth;
 47 |     int incr=0;
 48 |     score_t alpha;
 49 |     score_t beta;
 50 |     score_t printed_board=0;
 51 |     int excess;
 52 |     bool quiescent;
 53 |     bool draw;
 54 |     search_info(const node_t& board_) : abort_flag_(false), abort_flag(&abort_flag_), board(board_), par_done(false), 
 55 |             result(bad_min_score),excess(0),quiescent(false), draw(false) {
 56 |             }
 57 | 
 58 |     search_info() : abort_flag_(false), abort_flag(&abort_flag_), par_done(false), result(bad_min_score), excess(0),quiescent(false),draw(false) {
 59 |     }
 60 | 
 61 |     ~search_info() {
 62 |     }
 63 | 
 64 | #ifdef HPX_SUPPORT
 65 |     friend hpx::serialization::access;
 66 | #endif
 67 | };
 68 | 
 69 | void print_board(const node_t& board, std::ostream& out,bool trimmed=false);
 70 | 
 71 | #define INFO(X) o << " " << #X << "=" << info->X;
 72 | inline
 73 | std::ostream& operator<<(std::ostream& o,boost::shared_ptr<search_info> info) {
 74 |   print_board(info->board,o,true);
 75 |   print_board(info->board,o,false);
 76 |   INFO(board.hash);
 77 |   INFO(board.excess_depth);
 78 |   INFO(board.side);
 79 |   INFO(board.castle);
 80 |   INFO(board.ep);
 81 |   INFO(board.move_num);
 82 |   INFO(board.follow_capt);
 83 |   INFO(board.root_side);
 84 |   INFO(board.follow_score);
 85 |   INFO(board.follow_depth);
 86 |   INFO(board.search_depth);
 87 |   INFO(board.ply);
 88 |   INFO(board.p_board);
 89 |   INFO(board.fifty);
 90 |   INFO(board.hist_dat.size());
 91 |   node_t& board = info->board;
 92 |   o << " hist={";
 93 |   for(int i=0;i<board.hist_dat.size();i++) {
 94 |     if(i > 0) o << ",";
 95 |     o << board.hist_dat.at(i);
 96 |   }
 97 |   o << "}" << std::endl;
 98 |   INFO(mv.str());
 99 |   INFO(par_done);
100 |   INFO(result);
101 |   INFO(depth);
102 |   INFO(alpha);
103 |   INFO(beta);
104 |   INFO(printed_board);
105 |   INFO(excess);
106 |   INFO(quiescent);
107 |   INFO(draw);
108 |   INFO(incr);
109 |   INFO(abort_flag);
110 |   INFO(abort_flag_);
111 |   INFO(log.str());
112 |   return o;
113 | }
114 | 
115 | void search_pt(boost::shared_ptr<search_info>);
116 | void search_ab_pt(boost::shared_ptr<search_info>);
117 | void qeval_pt(boost::shared_ptr<search_info>);
118 | 
119 | score_t search(boost::shared_ptr<search_info>);
120 | score_t search_ab(boost::shared_ptr<search_info>);
121 | score_t qeval(boost::shared_ptr<search_info>);
122 | 
123 | enum pfunc_v { no_f, search_f, search_ab_f, qeval_f };
124 | 
125 | struct task {
126 |     boost::shared_ptr<search_info> info;
127 | 
128 |     pfunc_v pfunc;
129 |     task() : pfunc(no_f) {
130 |     }
131 |     virtual ~task() {
132 |         info = 0;
133 |     }
134 | 
135 |     virtual void start() = 0;
136 | 
137 |     virtual void join() = 0;
138 | };
139 | 
140 | struct serial_task : public task {
141 |     bool joined;
142 |     serial_task(): joined(false) {}
143 |     ~serial_task() {
144 |         info = 0;
145 |     }
146 | 
147 |     virtual void start() { }
148 | 
149 |     virtual void join() {
150 |         if (joined)
151 |             return;
152 |         if(info.get() == nullptr)
153 |             return;
154 |         if(pfunc == search_f)
155 |             info->result = search(info);
156 |         else if(pfunc == search_ab_f)
157 |             info->result = search_ab(info);
158 |         else if(pfunc == qeval_f)
159 |             info->result = qeval(info);
160 |         else
161 |             abort();
162 |         joined = true;
163 |     }
164 | };
165 | class pcounter {
166 |     boost::atomic<int> count;
167 |     int max_count;
168 | public:
169 |     pcounter() : count(0), max_count(1) {
170 |     }
171 |     pcounter(const pcounter& pc) : count(pc.count.load()), max_count(pc.max_count) {
172 |     }
173 |     void set_max(int n) {
174 |         count = max_count = n;
175 |     }
176 |     int get() { return max_count; }
177 |     int add(int n) {
178 |         count += n;
179 |         assert(count <= max_count);
180 |         int m = count;
181 |         return m;
182 |     }
183 |     int dec() {
184 |         int n = count--;
185 |         if(n <= 0)
186 |             count++;
187 |         return n;
188 |     }
189 | };
190 | 
191 | extern pcounter task_counter;
192 | 
193 | struct thread_task : public task {
194 |     bool joined;
195 |     std::shared_future<void> th;
196 |     thread_task() : joined(true) {}
197 |     ~thread_task() {
198 |         info = 0;
199 |     }
200 |     virtual void start() {
201 |         joined = false;
202 |         //assert(info.valid());
203 |         if(pfunc == search_f) {
204 |             th = std::async(std::launch::async,search_pt,info);
205 |         } else if(pfunc == search_ab_f) {
206 |             th = std::async(std::launch::async,search_ab_pt,info);
207 |         } else if(pfunc == qeval_f) {
208 |             th = std::async(std::launch::async,qeval_pt,info);
209 |         } else {
210 |             abort();
211 |         }
212 |     }
213 |     virtual void join() {
214 |         if(joined)
215 |             return;
216 |         th.get();
217 |         joined = true;
218 |     }
219 | };
220 | 
221 | #ifdef HPX_SUPPORT
222 | #include "hpx_support.hpp"
223 | #include <hpx/include/iostreams.hpp>
224 | #include <time.h>
225 | struct hpx_task : public task {
226 |     hpx::lcos::shared_future<void> result;
227 |     hpx_task()  {
228 |     }
229 | 
230 |     virtual void start();
231 | 
232 |     virtual void join() {
233 |         result.get();
234 |     }
235 | };
236 | #endif
237 | 
238 | #endif
239 | 


--------------------------------------------------------------------------------
/harness_plain.pl:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/perl
  2 | ################################################################################
  3 | ##  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  4 | ##
  5 | ##  Distributed under the Boost Software License, Version 1.0. (See accompanying
  6 | ##  file BOOST_LICENSE_1_0.rst or copy at http:##www.boost.org#LICENSE_1_0.txt)
  7 | ################################################################################
  8 | use strict;
  9 | use FileHandle;
 10 | 
 11 | my $fsup = 0;
 12 | my $asup = 0;
 13 | my $nsup = 0;
 14 | my $msup = 1;
 15 | 
 16 | my $anskey = {};
 17 | my $scoretab = {};
 18 | my $speedtab = {};
 19 | 
 20 | #Answer key:
 21 | 
 22 | #board1
 23 | #ply | answer
 24 | #====+=======
 25 | #  7 |   e2e4
 26 | #  6 |   b1c3
 27 | #  5 |   b2b4
 28 | #  4 |   g1f3
 29 | #  3 |   g1f3
 30 | #  2 |   d2d4
 31 | 
 32 | $anskey->{1}->{2} = "e2e4";
 33 | $anskey->{1}->{3} = "e2e4";
 34 | $anskey->{1}->{4} = "d2d4";
 35 | $anskey->{1}->{5} = "g1f3";
 36 | 
 37 | #board2
 38 | #ply | answer
 39 | #====+=======
 40 | #  7 |   d1b3
 41 | #  6 |   c1d2
 42 | #  5 |   c1g5
 43 | #  4 |   c1g5
 44 | #  3 |   c1d2
 45 | #  2 |   e2e4
 46 | 
 47 | $anskey->{2}->{2} = "e2e4";
 48 | $anskey->{2}->{3} = "e1d2";
 49 | $anskey->{2}->{4} = "c1d2";
 50 | $anskey->{2}->{5} = "c1g5";
 51 | 
 52 | #board3
 53 | #ply | answer
 54 | #====+=======
 55 | #  7 |   f5h7
 56 | #  6 |   f5g7
 57 | #  5 |   f5h6
 58 | #  4 |   f5g7
 59 | #  3 |   f3b3
 60 | #  2 |   b2b3
 61 | 
 62 | $anskey->{3}->{2} = "f5g7";
 63 | $anskey->{3}->{3} = "b2b3";
 64 | $anskey->{3}->{4} = "f3h5";
 65 | $anskey->{3}->{5} = "g5g6";
 66 | 
 67 | #board4
 68 | #ply | answer
 69 | #====+=======
 70 | #  7 |   e5f5
 71 | #  6 |   e5e3
 72 | #  5 |   h5h6
 73 | #  4 |   e5e3
 74 | #  3 |   e5b5
 75 | #  2 |   e5e3
 76 | 
 77 | $anskey->{4}->{2} = "e5a5";
 78 | $anskey->{4}->{3} = "g5f7";
 79 | $anskey->{4}->{4} = "g5f7";
 80 | $anskey->{4}->{5} = "g5f7";
 81 | 
 82 | my $bad_score = -6666;
 83 | my $tot_time = 0;
 84 | 
 85 | my $threads = 1;
 86 | my $mem = "";
 87 | 
 88 | for my $a (@ARGV) {
 89 |     if($a =~ /^-t=(\d+)$/) {
 90 |         $threads = $1;
 91 |     }
 92 |     if($a =~ /^-m$/) {
 93 |         $mem = " valgrind --log-file=val.out ";
 94 |     }
 95 | }
 96 | 
 97 | for(my $ply=4;$ply<=6;$ply++) {
 98 |     for(my $b=1;$b<=4;$b++) {
 99 |         for my $sm (("alphabeta")) {
100 |             # It takes too long for minimax above ply 4
101 |             # So I ran it once at 5 to verify the answer
102 |             # and then introduced this next.
103 |             if($sm eq "minimax" and $ply >= 5) {
104 |                 next;
105 |             }
106 |             genbench($sm,$b,$ply);
107 |             my $fd = new FileHandle;
108 |             if($sm eq "mtdf") {
109 |                 #sleep(1);
110 |             }
111 |             #open($fd,"mpiexec -np 2 -env CHX_THREADS_PER_PROC 2 $ENV{PWD}/src/chx -s .bench.ini 2>/dev/null|");
112 |             #open($fd,"CHX_THREADS_PER_PROC=8; mpiexec -np 1 src/chx -s .bench.ini 2>/dev/null|");
113 |             my @chx =  (
114 |                 "/home/sbrandt/chess-build/src/chx",
115 |                 "/home/sbrandt/chess-build/bin/chx",
116 |                 "./src/chx",
117 |                 #"/home/sbrandt/chess-buildd/src/chx",
118 |                 #"/home/sbrandt/chess-buildd/bin/chx"
119 |                 );
120 |             my $chx = undef;
121 |             for my $c (@chx) {
122 |                 if(-e $c) {
123 |                     die "$c vs. $chx" if(defined($chx));
124 |                     $chx = $c;
125 |                 }
126 |             }
127 |             my $hpx = 0;
128 |             $hpx = 1 if($chx =~ /bin/);
129 |             my $cmd;
130 |             if($hpx) {
131 |                 $cmd="CHX_THREADS_PER_PROC=100 $mem $chx --hpx:t=$threads < .bench|";
132 |             } else {
133 |                 $cmd="CHX_THREADS_PER_PROC=$threads $mem $chx < .bench|";
134 |             }
135 |             print "cmd=$cmd\n";
136 |             system("rm -f test.db");
137 |             open($fd,$cmd);
138 |             my $ans = "";
139 |             my $score = $bad_score;
140 | 
141 |             my $st = "OK ";
142 |             my $tm = 1e-6;
143 |             my $speedup = 1;
144 |             my $doc = "";
145 |             while(<$fd>) {
146 |                 $doc .= $_;
147 |                 if(/Computer's chess_move: ([a-h][1-8][a-h][1-8])/) {
148 |                     if($ans ne "" and $ans ne $1) {
149 |                         $st = "VARIABLE($ans != $1) ";
150 |                         #last;
151 |                     }
152 |                     $ans = $1;
153 |                 }
154 |                 if(/SCORE=(-?\d+)/) {
155 |                     if($score != $bad_score and $score != $1) {
156 |                         $st = "VARIABLE($score != $1) ";
157 |                         #last;
158 |                     }
159 |                     $score=$1;
160 |                 }
161 |                 if(/Average time for run: (\d+) ms/) {
162 |                     $tm = $1*1.0e-3;
163 |                     $tm = 1.0e-3 if($tm < 1.0e-3);
164 |                     $tot_time += $tm;
165 |                 }
166 |             }
167 |             if(defined($anskey->{$b}->{$ply})) {
168 |                 my $v = $anskey->{$b}->{$ply};
169 |                 if($ans ne $v) {
170 |                     $st .= "MOVE($ans != $v) ";
171 |                 }
172 |             }
173 |             if(defined($scoretab->{$b}->{$ply})) {
174 |                 my $s = $scoretab->{$b}->{$ply};
175 |                 if($s != $score) {
176 |                     $st .= "SCORE($score != $s) ";
177 |                 }
178 |             }
179 |             if($st eq "OK ") {
180 |                 $scoretab->{$b}->{$ply} = $score;
181 |             }
182 |             if(defined($speedtab->{$b}->{$ply})) {
183 |                 $speedup = $speedtab->{$b}->{$ply}/$tm;
184 |             }
185 |             $speedtab->{$b}->{$ply} = $tm;
186 |             printf("%10s, %4d, %4d, %9d, %s, %s, %.2f\n",$sm,$b,$ply,$score,$ans,$st,$speedup);
187 |             die $doc if($st =~ /VARIABLE/);
188 |             if($sm eq "mtdf" or $sm eq "multistrike") {
189 |                 $fsup += 1 if($speedup > 1);
190 |                 $fsup += 0.5 if($speedup == 1);
191 |                 $asup += $speedup;
192 |                 $nsup += 1;
193 |                 $msup *= $speedup;
194 |             }
195 |             my $ret=close($fd);
196 |             unless($ret) {
197 |                 print $doc;
198 |                 die "error code returned r=($ret)";
199 |             }
200 | 			open($fd,"val.out");
201 | 			while(<$fd>) {
202 | 				if(/ERROR SUMMARY: (\d+) errors/) {
203 | 					if($1 > 0) {
204 | 						die $_;
205 | 					}
206 | 				}
207 | 			}
208 |         }
209 |     }
210 | }
211 | 
212 | printf("mtdf over alpha speedup: avg=%3.2f geometric mean=%3.2f fraction faster=%3.2f\n",$asup/$nsup,($msup)**(1.0/$nsup),$fsup/$nsup);
213 | 
214 | printf("total time: %3.2f\n",$tot_time);
215 | 
216 | sub genbench {
217 |     my $sm = shift;
218 |     my $b = shift;
219 |     my $ply = shift;
220 |     my $fd = new FileHandle;
221 |     my $runs = 3;
222 |     $runs = 1 if($sm eq "minimax");
223 |     $runs = 3 if($ply > 5);
224 |     open($fd,">.bench");
225 | print $fd qq{
226 | search $sm
227 | eval original
228 | bench inputs/board$b $ply $runs
229 | quit
230 | 
231 | };
232 |     close($fd);
233 | }
234 | 


--------------------------------------------------------------------------------
/ChessViewer/src/edu/lsu/cct/chess/Board.java:
--------------------------------------------------------------------------------
  1 | package edu.lsu.cct.chess;
  2 | 
  3 | import java.io.IOException;
  4 | import java.io.InputStream;
  5 | import java.net.MalformedURLException;
  6 | import java.net.URL;
  7 | import java.util.ArrayList;
  8 | import java.util.List;
  9 | import java.io.File;
 10 | import java.io.FileInputStream;
 11 | 
 12 | import android.content.Context;
 13 | import android.graphics.Bitmap;
 14 | import android.graphics.BitmapFactory;
 15 | import android.graphics.Canvas;
 16 | import android.graphics.Paint;
 17 | import android.graphics.Point;
 18 | import android.graphics.RectF;
 19 | import android.os.AsyncTask;
 20 | import android.util.AttributeSet;
 21 | import android.view.View;
 22 | 
 23 | import edu.lsu.cct.chessviewer.chessviewer.R;
 24 | 
 25 | 
 26 | public class Board extends View {
 27 |     final static String INPUTS = "prnbkqPRNBKQ.";
 28 | 
 29 |     final int nbx = 2;
 30 |     final int nby = 3;
 31 |     final int nboards = nbx*nby;
 32 |     int size_ = 0;
 33 |     public int tstep = 1;
 34 |     public int now;
 35 |     public final int[] current = new int[nboards];
 36 |     public final int[] old = new int[nboards];
 37 |     public int size() throws NotReady {
 38 |         if(size_ == 0) {
 39 |             size_ = Math.min(getWidth()/(9*nbx+1), getHeight()/(9*nby+1));
 40 |             if(size_ != 0) {
 41 |                 System.out.println("Size="+size_);
 42 |             }
 43 |         }
 44 |         if(size_ == 0)
 45 |             throw new NotReady();
 46 |         return size_;
 47 |     }
 48 | 
 49 |     public List<Piece> pieces = new ArrayList<Piece>();
 50 |     Bitmap[] pieceBitmaps = new Bitmap[255];
 51 |     boolean scaled = false;
 52 | 
 53 |     public Board(Context context, AttributeSet attrs) {
 54 |         super(context, attrs);
 55 |         init();
 56 |         new readTask().execute();
 57 | 
 58 |     }
 59 | 
 60 |     void init() {
 61 |         pieceBitmaps['p'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_pawn);
 62 |         pieceBitmaps['r'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_rook);
 63 |         pieceBitmaps['b'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_bishop);
 64 |         pieceBitmaps['n'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_knight);
 65 |         pieceBitmaps['k'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_king);
 66 |         pieceBitmaps['q'] = BitmapFactory.decodeResource(getResources(), R.drawable.black_queen);
 67 | 
 68 |         pieceBitmaps['P'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_pawn);
 69 |         pieceBitmaps['R'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_rook);
 70 |         pieceBitmaps['B'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_bishop);
 71 |         pieceBitmaps['N'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_knight);
 72 |         pieceBitmaps['K'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_king);
 73 |         pieceBitmaps['Q'] = BitmapFactory.decodeResource(getResources(), R.drawable.white_queen);
 74 | 
 75 |     }
 76 | 
 77 |     synchronized void scaleBitmaps() throws NotReady {
 78 |         if(!scaled) {
 79 |             for(int i=0;i<pieceBitmaps.length;i++) {
 80 |                 Bitmap bitm = pieceBitmaps[i];
 81 |                 if(bitm != null) {
 82 |                     pieceBitmaps[i] = Bitmap.createScaledBitmap(bitm, size(), size(), false);
 83 |                 }
 84 |             }
 85 |             scaled = true;
 86 |         }
 87 |     }
 88 |     @Override
 89 |     public synchronized void draw(Canvas canvas) {
 90 |         try {
 91 |             scaleBitmaps();
 92 | //		Log.i("Board-Draw", "Draw called");
 93 |             int width = getWidth();
 94 |             int height = getHeight();
 95 |             Paint black = new Paint();
 96 |             black.setColor(0xFFCC0000);
 97 |             Paint background_black=new Paint(0x00000000);
 98 |             Paint white = new Paint();
 99 |             white.setColor(0xFFEEEEEE);
100 |             Point window_size;
101 |             //WindowManager wm=(WindowManager)Context.getSystemService(Context.WINDOW_SERVICE);
102 |             //getWindowManager().getDefaultDisplay().getSize(window_size);
103 |             canvas.drawRect(0,0,10000,10000,background_black);
104 |             for(int boardnum=0;boardnum<6;boardnum++) {
105 |                 for(int i=0;i<8;i++) {
106 |                     for(int j=0;j<8;j++) {
107 |                         int offx = (width-nbx*8*size())/(nbx+1);
108 |                         int offy = (height-nby*8*size())/(nby+1);
109 |                         int bx = boardnum % nbx;
110 |                         int by = (boardnum / nbx) % nby;
111 |                         int x = (bx+1)*offx+size()*i+bx*8*size();
112 |                         int y = (by+1)*offy+size()*j+by*8*size();
113 |                         RectF r = new RectF(x,y,x+size(),y+size());
114 |                         canvas.drawRect(r, (i+j)%2==0 ? white : black);
115 |                     }
116 |                 }
117 |             }
118 | //            System.out.println("pieces="+pieces.size());
119 |             for(Piece p : new ArrayList<Piece>(pieces)) {
120 |                 Bitmap bitm = pieceBitmaps[p.p];
121 |                 if(bitm != null) {
122 |                     if(p.time != current[p.boardnum])
123 |                         continue;
124 |                     int boardnum = (p.boardnum)%(nbx*nby);
125 |                     int i = p.x;
126 |                     int j = p.y;
127 |                     int offx = (width-nbx*8*size())/(nbx+1);
128 |                     int offy = (height-nby*8*size())/(nby+1);
129 |                     int bx = boardnum % nbx;
130 |                     int by = (boardnum / nbx) % nby;
131 |                     int x = (bx+1)*offx+size()*i+bx*8*size();
132 |                     int y = (by+1)*offy+size()*j+by*8*size();
133 |                     Paint trans = new Paint();
134 | //                    trans.setAlpha(0x50);
135 |                     canvas.drawBitmap(bitm, x, y, trans);
136 | //                    System.out.println("draw "+bitm+","+x+","+y);
137 |                 }
138 |             }
139 |         } catch(Exception e) {
140 |             e.printStackTrace();
141 |         }
142 |     }
143 | 
144 |     /*
145 |      * This task will read in the file in the background, then set the List we create
146 |      * here to the list that will be rendered and used by draw and animate to avoid
147 |      * ConcurrentModificationException
148 |      */
149 |     private class readTask extends AsyncTask<Void, Void, Void> {
150 | //        private List<Piece> pieces = new ArrayList<Piece>();
151 | 
152 |         @Override
153 |         protected Void doInBackground(Void... params) {
154 | 
155 | 
156 |             try {
157 |                 InputStream in;
158 |                 try{
159 |                     File input=new File("/sdcard/chx_log.txt");
160 |                     in=new FileInputStream(input);
161 |                 }
162 |                 catch (IOException e){
163 |                     URL url = new URL("http://stevenrbrandt.com/board.txt");
164 |                     in = url.openStream();
165 |                 }
166 |                 int x = 0, y = 0, boardnum = 0;
167 |                 pieces.clear();
168 |                 outer: while (true) {
169 |                     int c = in.read();
170 |                     if (c < 0)
171 |                         break;
172 | 
173 |                     // parse comment
174 |                     if (c == '#') {
175 |                         while (true) {
176 |                             c = in.read();
177 |                             if (c < 0)
178 |                                 break outer;
179 |                             if (c == '\n')
180 |                                 continue outer;
181 |                         }
182 |                     }
183 | 
184 |                     if (INPUTS.indexOf(c)>=0) {
185 |                         pieces.add(new Piece(tstep, boardnum, x, y, c));
186 | //                        System.out.println("Loaded piece "+ pieces.get(pieces.size()-1)+"/size="+pieces.size());
187 |                         x++;
188 |                         if(x == 8) {
189 |                             y++;
190 |                             x=0;
191 |                         }
192 |                         if(y == 8) {
193 |                             x = y = 0;
194 |                         }
195 |                     } else if(c >= '0' && c <='9') {
196 |                         boardnum = c - '0';
197 |                         tstep++;
198 |                     }
199 |                 }
200 |             } catch (MalformedURLException e) {
201 |                 e.printStackTrace();
202 |             } catch (IOException e) {
203 |                 e.printStackTrace();
204 |             }
205 |             return null;
206 |         }
207 | 
208 |         @Override
209 |         protected void onPostExecute(Void result) {
210 |             super.onPostExecute(result);
211 |             Board.this.pieces = pieces; //Set our list to the list being rendered.
212 |             invalidate();
213 |         }
214 | 
215 |     }
216 | }
217 | 


--------------------------------------------------------------------------------
/headers/database.hpp:
--------------------------------------------------------------------------------
  1 | #ifndef DATABASE_H
  2 | #define DATABASE_H
  3 | #include <sstream>
  4 | #include <iostream>
  5 | #include "hash.hpp"
  6 | #include "node.hpp"
  7 | #include "data.hpp"
  8 | #include "defs.hpp"
  9 | #include "chess_move.hpp"
 10 | #ifdef SQLITE3_SUPPORT
 11 | #include "sqlite3.h"
 12 | #endif
 13 | #include "main.hpp"
 14 | #include "search.hpp"
 15 | #include <assert.h>
 16 | #include "parallel.hpp"
 17 | #include "zkey.hpp"
 18 | #include <atomic>
 19 | #include <vector>
 20 | 
 21 | using namespace std;
 22 | //using something = std::vector<std::string>;
 23 | using pseudo = std::vector<std::string>;
 24 | 
 25 | class database {
 26 |   public:
 27 |      #ifdef SQLITE3_SUPPORT
 28 |     sqlite3 *db;
 29 |     #endif
 30 |     char *zErrMsg=0;
 31 |     int rc;
 32 |     struct args;
 33 | 
 34 |     database(){
 35 |     #ifdef SQLITE3_SUPPORT
 36 |         const char *sql;
 37 |         rc = sqlite3_open("test1.db", &db);
 38 | 
 39 |         if( rc ){
 40 |         fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
 41 |          exit(0);
 42 |         }else{
 43 |           fprintf(stderr, "Opened database successfully\n");
 44 |         }
 45 |         rc = sqlite3_exec(db, "PRAGMA journal_mode=WAL;", 0, 0, &zErrMsg);
 46 |         /* Create SQL statement */
 47 |         sql = "CREATE TABLE  white("  \
 48 |         "DEPTH            INTEGER     NOT NULL," \
 49 |         "BOARD               TEXT     NOT NULL,"\
 50 |         "HI               NUMERIC(20) NOT NULL,"\
 51 |         "LO               NUMERIC(20) NOT NULL,"\
 52 |         "EVAL                TEXT     NOT NULL,"\
 53 |         "HASH             INTEGER     NOT NULL,"\
 54 |         "SUMDEPTH         INTEGER     NOT NULL,"\
 55 |         "PRIMARY KEY (DEPTH, BOARD));";
 56 |        //Execute SQL statement
 57 |         //cout << "SQL: "<< sql << endl;
 58 |         rc = sqlite3_exec(db, sql, 0, 0, &zErrMsg);
 59 |         if( rc != SQLITE_OK ){
 60 |             fprintf(stderr, "%s\n", zErrMsg);
 61 |             sqlite3_free(zErrMsg);
 62 |         }else{
 63 |             fprintf(stdout, "Table created successfully\n");
 64 |         }
 65 |         sql = "CREATE TABLE black("  \
 66 |         "DEPTH            INTEGER     NOT NULL," \
 67 |         "BOARD               TEXT     NOT NULL,"\
 68 |         "HI               NUMERIC(20) NOT NULL,"\
 69 |         "LO               NUMERIC(20) NOT NULL,"\
 70 |         "EVAL                TEXT     NOT NULL,"\
 71 |         "HASH             INTEGER     NOT NULL,"\
 72 |         "SUMDEPTH         INTEGER     NOT NULL,"\
 73 |         "PRIMARY KEY (DEPTH, BOARD));";
 74 |         rc = sqlite3_exec(db, sql, 0, 0, &zErrMsg);
 75 |         if( rc != SQLITE_OK ){
 76 |             fprintf(stderr, "%s\n", zErrMsg);
 77 |             sqlite3_free(zErrMsg);
 78 |         }else{
 79 |             fprintf(stdout, "Table created successfully\n");
 80 |         }
 81 | //    deleteAll();
 82 |     #endif
 83 |     };
 84 | 
 85 | //destructor
 86 |     ~database(){
 87 |      #ifdef SQLITE3_SUPPORT
 88 |      // get_data();
 89 |       sqlite3_close(db);
 90 |       cout<<"database closed. \n";
 91 |      #endif
 92 |     }
 93 | 
 94 |  score_t score_board (const node_t& board) {
 95 |     evaluator ev;
 96 |     DECL_SCORE(s, ev.eval(board, chosen_evaluator), board.hash)
 97 |     return s;
 98 |   }
 99 | /*
100 |   void deleteAll(){
101 |     const char *sql;
102 |     std::ostringstream o;
103 |     o<<"delete from \"MoveSet\"";
104 |     std::string result = o.str();
105 |     sql=result.c_str();
106 |     rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
107 |     if ( rc == SQLITE_OK) cout<<"MoveSet sucessfully reset";
108 |         else{ cout<<zErrMsg<<"/n"; sqlite3_free(zErrMsg);}
109 |   }
110 | */
111 |     void add_data(node_t& board, score_t lo, score_t hi, bool white, int excess){
112 |      #ifdef SQLITE3_SUPPORT
113 |       assert(lo < hi);
114 |       assert(excess == 0);
115 |       white == board.side == LIGHT;
116 |       {
117 |         score_t s_unused;
118 |         int excess_unused;
119 |         score_t zlo, zhi;
120 |         bool found = get_transposition_value(board, zlo, zhi, white,s_unused,excess_unused, true,board.depth+excess);
121 |         if(found) {
122 |           assert(excess == 0);
123 |           if(lo <= zlo && zhi <= hi)
124 |             return;
125 |           if(board.depth > 2)
126 |             cout << "Narrowing ";
127 |           int olo = lo, ohi = hi;
128 |           lo = max(lo,zlo);
129 |           hi = min(hi,zhi);
130 |           if(lo >= hi)
131 |             std::cout << "olo=" << olo << " ohi=" << ohi << " zlo=" << zlo << " zhi=" << zhi << std::endl;
132 |           assert(lo < hi);
133 |           if(lo >= hi)
134 |            hi = lo+1;
135 |         }
136 |       }
137 |       //if(board.depth > 2)
138 |         //cout << "add_data(" << board.hash <<','<<board.depth<<','<<lo<<','<<hi<<','<<chosen_evaluator<<')'<<endl;
139 |       int depth = board.depth;
140 |       auto hash= board.hash;
141 |       const char *sql;    //maybe find a way to make work without const
142 |       //create SQL statement from string into char * array
143 |       std::ostringstream bsm;
144 |       print_board(board,bsm,true);
145 |       std::string bs = bsm.str();
146 | 
147 |       std::ostringstream o;
148 | 
149 |       o<< "INSERT OR REPLACE INTO "<< (white ? "white" : "black") <<" (depth, board, hi, lo,eval, hash, sumdepth) VALUES ("<<excess+depth<<",'"<<bs<<"',"<<hi<<","<<lo<<","<<chosen_evaluator<<","<<hash<< ","<<excess+depth<<");";
150 |       std::string result = o.str();
151 |       sql=result.c_str();
152 |       //char *sql = "REPLACE INTO \"MOVELIST\"VALUES (69,0);";
153 |       //"INSERT INTO \"MOVELIST\"VALUES (66,0);";
154 |       //execute SQL statement
155 |       rc = sqlite3_exec(db, sql, 0, 0, &zErrMsg);
156 |       if ( rc!= SQLITE_OK ){
157 |         fprintf(stderr, "SQL error: %s\n", zErrMsg);
158 |         sqlite3_free(zErrMsg);
159 |       }else{
160 |         //fprintf(stdout, "Records created sucessfully\n");
161 |       }
162 |       if (board.depth>3){
163 |         ;//cout<<"Adding depth of "<<board.depth<<endl;
164 |       }
165 |      #endif
166 |     }
167 | //look for boards that are the same, look for boards >= to current depth, most importantly score greater than the current score
168 | /*    int get_data(){
169 |       const char *data= "Callback function called";
170 |       const char *sql= "SELECT * from MoveSet";
171 |       rc= sqlite3_exec(db, sql, 0, (void*)data, &zErrMsg);
172 |       if (rc!= SQLITE_OK ){
173 |          fprintf(stderr, "SQL error: %s\n", zErrMsg);
174 |          sqlite3_free(zErrMsg);
175 |       }else
176 |          fprintf(stdout, "Operation done  sucessfully\n");
177 |          return 0;
178 |     }
179 | */
180 |    /* bool get_database_value(const node_t& board, score_t& zlo, score_t& zhi, bool white){
181 |       bool gotten = false;
182 |       const char *sql;
183 |       std::ostringstream current, out;
184 |       print_board(board, current, true);
185 |       std::string curr = current.str();
186 |       out<< "SELECT LO, HI, PLY FROM "<<( white ? "white" :"black")<<" WHERE \"BOARD\"=\""<<curr<<"\" AND \"PLY\"="<<board.depth<<";";
187 |       std::string result = out.str();
188 |       sql=result.c_str();
189 |       int nrow, ncolumn;
190 |       char ** azResult=NULL;//index:5=ply,6=board, 7=hi, 8=lo
191 |       rc= sqlite3_get_table(db, sql, &azResult, &nrow, &ncolumn, &zErrMsg);
192 |       if(nrow > 0) {
193 |         cout << "nrow=" << nrow << " ncol=" << ncolumn <<"       depth="<<azResult[ncolumn*nrow+2]<<" board.depth="<<board.depth<< endl;
194 |         stringstream strValue;
195 |         strValue <<*azResult[5];
196 |         //std::string s= *azResult[5];
197 |         int num;//= atoi(s.c_str());
198 |         strValue>>num;
199 |         if (num == board.depth)
200 |         if (score_board(board) < atoi(azResult[ncolumn*nrow+0]));{
201 |         zlo = atoi(azResult[ncolumn*nrow+0]);
202 |         zhi = atoi(azResult[ncolumn*nrow+1]);
203 |         cout << "zlo=" << zlo << " zhi=" << zhi << endl;
204 |         gotten=true; 
205 |       }else{
206 |         gotten=true;}
207 |         zhi = bad_max_score;
208 |       }
209 |       sqlite3_free_table(azResult);
210 | 
211 |    return gotten;
212 |     }*/
213 | 
214 |   struct args{
215 |     //int argc;
216 |     char* argv1;
217 |     char* argv2;
218 |     args(char* v, char* c): argv1(v),argv2(c){}
219 |     };
220 | 
221 |   friend std::ostream& operator<<(std::ostream& o, const args& a){
222 |     o<<a.argv1<<"\n";
223 |     o<<a.argv2<<endl;
224 |     return o;
225 |     }
226 | 
227 |   pseudo search_board(const node_t& board,std::ostringstream& out, const char *select, const char *value, std::string& search, bool white, score_t s,bool exact, int depth){
228 |     pseudo v_score;
229 | #ifdef SQLITE3_SUPPORT
230 |     const char *sql;
231 |     int delta = max(0, board.follow_depth - board.search_depth);
232 |     //int delta = max(0, depth - board.depth);
233 |     //std::vector<args> a;
234 |     if (exact)
235 |       out<< "SELECT "<<select<<" FROM "<<( white ? "white" : "black") <<" WHERE "<<value<<"=\""<<search<<"\" AND EVAL="<<chosen_evaluator<<" AND DEPTH"<< (white ? "=": "=") <<depth<<";";
236 |     else
237 |       out<< "SELECT "<<select<<" FROM "<<( white ? "white" : "black") <<" WHERE "<<value<<"=\""<<search<<"\" AND EVAL="<<chosen_evaluator<<" AND DEPTH > " <<board.depth+delta<<" AND LO>="<< s<< " ORDER BY DEPTH"<<";";
238 |     std::string result = out.str();
239 |     sql = result.c_str();
240 |     rc = sqlite3_exec(db,sql,callback,&v_score ,&zErrMsg);
241 |     if (rc!= SQLITE_OK){
242 |       fprintf(stderr, "SQL error: %s\n", zErrMsg);
243 |       sqlite3_free(zErrMsg);
244 |     }
245 |     //fprintf(stdout, "Looked through board successfully\n");
246 | #endif
247 |     return v_score;
248 |   }
249 | 
250 |   bool get_transposition_value(node_t& board, score_t& lower, score_t& upper, bool white,score_t& p_board,int& excess_depth, bool exact, int depth){
251 |     #ifdef SQLITE3_SUPPORT
252 |     bool gotten = false;
253 |     std::ostringstream current;
254 |     print_board(board,current,true);
255 |     std::string curr = current.str();
256 |     const char *select = "HI, LO, DEPTH";
257 |     const char *b = "BOARD";
258 |     std::ostringstream search;
259 |     pseudo v_score = search_board(board, search, select, b, curr, white, p_board,exact, depth);
260 |     if (v_score.size() == 3){
261 |       //int sum_depth = atoi(v_score.at(3).c_str());
262 |       excess_depth = atoi(v_score.at(2).c_str()) - board.depth;
263 |       //int excess= sum_depth-depth;
264 |       lower =  atol(v_score.at(1).c_str());
265 |       upper =  atol(v_score.at(0).c_str());
266 |       assert(lower < upper);
267 |       //cout<<"upper ="<<upper<<" lower ="<<lower<<endl;
268 |       gotten = true;
269 |     }
270 |     if(!gotten) {
271 |       excess_depth = 0;
272 |       lower = bad_min_score;
273 |       upper = bad_max_score;
274 |     }
275 |     //deeper= false;
276 |     return gotten;
277 |     #else
278 |     excess_depth = 0;
279 |     lower = bad_min_score;
280 |     upper = bad_max_score;
281 |     return false;
282 |     #endif
283 |   }
284 | 
285 |     //callback used for select operation
286 |     static int callback(void *Used, int argc, char **argvalue, char **azColName){
287 |         //cout<<"callback is called"<<endl;
288 |         pseudo* v_score=static_cast<pseudo*>(Used);
289 |         v_score->clear();
290 |         /*
291 |         v_score->push_back(argvalue[argc-4]);
292 |         v_score->push_back(argvalue[argc-3]);
293 |         v_score->push_back(argvalue[argc-2]);
294 |         v_score->push_back(argvalue[argc-1]);
295 |         */
296 |         for(int i=0;i<argc;i++) {
297 |           v_score->push_back(argvalue[i]);
298 |         }
299 |         //args (a){argvalue[argc-2],argvalue[argc-1]};
300 |         //std::cout<<a<<std::endl;
301 |         return 0;
302 |        };
303 |     int main(){
304 |         return 0;
305 |     }
306 | 
307 | };
308 | 
309 | #endif
310 | 


--------------------------------------------------------------------------------
/src/alphabeta.cpp:
--------------------------------------------------------------------------------
  1 | //////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2012 Steve Brandt and Phillip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | 
  8 | //#undef NDEBUG
  9 | 
 10 | #include "parallel_support.hpp"
 11 | #include "database.hpp"
 12 | #include "main.hpp"
 13 | #include "search.hpp"
 14 | #include <assert.h>
 15 | #include "parallel.hpp"
 16 | #include "zkey.hpp"
 17 | #include <atomic>
 18 | 
 19 | database dbase;
 20 | 
 21 | void search_ab_pt(boost::shared_ptr<search_info> info)
 22 | {
 23 |     info->result = search_ab(info);
 24 |     task_counter.add(1);
 25 | }
 26 | 
 27 | #define WHEN 1
 28 | struct When {
 29 | //#ifdef HPX_SUPPORT
 30 | #if 0
 31 |     typedef HPX_STD_TUPLE<int, hpx::lcos::future<score_t> > result_type;
 32 |     std::vector<hpx::lcos::future<score_t> > vec;
 33 |     When(std::vector<boost::shared_ptr<task> >& tasks) {
 34 |         for(unsigned int i=0;i<tasks.size();i++) {
 35 |             hpx_task *hpx = dynamic_cast<hpx_task*>(tasks[i].ptr());
 36 |             if(hpx != NULL) {
 37 |                 #ifdef WHEN
 38 |                 vec.push_back(hpx->result);
 39 |                 #endif
 40 |             }
 41 |         }
 42 |     }
 43 |     int any() {
 44 |         if(vec.size()==0) {
 45 |             return 0;
 46 |         }
 47 |         result_type r = hpx::wait_any(vec);
 48 |         int i = HPX_STD_GET(0,r);
 49 |         vec.erase(vec.begin()+i);
 50 |         return i;
 51 |     }
 52 | #else
 53 |     When(std::vector<boost::shared_ptr<task> >& tasks) {}
 54 |     int any() { return 0; }
 55 | #endif
 56 | };
 57 | 
 58 | bool db_on = true;
 59 | 
 60 | // TODO: The verify routine should take the string
 61 | // representation of a board, not a const ref.
 62 | void verify(std::string strBoard,int side,const int depth,int castle,int ep,const score_t alpha0,const score_t beta0) {
 63 |   bool exact = false;
 64 |   bool db_save = db_on;
 65 |   db_on = false;
 66 |   score_t alpha = alpha0, beta = beta0;
 67 |   alpha = max(ADD_SCORE(alpha,-1),bad_min_score);
 68 |   beta  = min(ADD_SCORE(beta,1),bad_max_score);
 69 | 
 70 |   boost::shared_ptr<search_info> info{new search_info};
 71 |   node_t board(strBoard);
 72 |   board.castle = castle;
 73 |   board.ep = ep;
 74 |   board.side = side;
 75 |   info->board = board;
 76 |   //int n = board.hist_dat.size();
 77 |   //info->board.clear();
 78 |   //assert(n == board.hist_dat.size());
 79 |   info->alpha = alpha;
 80 |   info->beta = beta;
 81 |   info->depth = depth;
 82 |   info->board.depth = info->depth;
 83 |   db_on = false;
 84 |   score_t g = search_ab(info);
 85 |   db_on = true;
 86 |   if(info->draw)
 87 |     return;
 88 |   if (!(alpha < g && g < beta))
 89 |     std::cout<<"(g,a,b,depth)=" << g << "," << alpha << "," << beta << "," << depth << std::endl;
 90 |   assert(alpha < g && g < beta);
 91 |   db_on = db_save;
 92 | }
 93 | 
 94 | score_t search_ab(boost::shared_ptr<search_info> proc_info)
 95 | {
 96 |     if(proc_info->get_abort())
 97 |         return bad_min_score;
 98 |     // Unmarshall the info struct
 99 |     node_t board = proc_info->board;
100 |     const int depth = proc_info->depth;
101 |     if(depth != board.depth) {
102 |       std::cout << "depth=" << depth << "board.depth=" << board.depth << std::endl;
103 |     }
104 |     assert(depth == board.depth);
105 |     score_t alpha = proc_info->alpha;
106 |     score_t beta = proc_info->beta;
107 |     assert(depth >= 0);
108 |     
109 |     std::ostringstream strB;
110 |     print_board(board, strB, true);
111 |     std::string strBoard = strB.str();
112 |     
113 |     // if we are a leaf node, return the value from the eval() function
114 |     if (depth == 0)
115 |     {
116 |         evaluator ev;
117 |         DECL_SCORE(s,ev.eval(board, chosen_evaluator),board.hash);
118 |         return s;
119 |     }
120 | 
121 | 
122 |     /* if this isn't the root of the search tree (where we have
123 |        to pick a chess_move and can't simply return 0) then check to
124 |        see if the position is a repeat. if so, we can assume that
125 |        this line is a draw and return 0. */
126 |     if (board.ply && reps(board)==3) {
127 |         DECL_SCORE(z,0,board.hash);
128 |         proc_info->draw = true;
129 |         return z;
130 |     }
131 | 
132 |     // fifty chess_move draw rule
133 |     if (board.fifty >= 100) {
134 |         DECL_SCORE(z,0,board.hash);
135 |         proc_info->draw = true;
136 |         return z;
137 |     }
138 | 
139 | 
140 |     score_t max_val = bad_min_score;
141 |     score_t p_board = board.p_board;
142 |     score_t zlo = bad_min_score,zhi = bad_max_score;
143 |     bool white =board.side == LIGHT;
144 |     bool entry_found = false;
145 |     int excess =0;
146 |     bool exact = false;
147 |     if (white && board.root_side == LIGHT && db_on && board.ply > 0 && !proc_info->quiescent){
148 |       entry_found = dbase.get_transposition_value (board, zlo, zhi, white,p_board,excess,exact,board.depth);
149 |       int pe = proc_info->excess;
150 |       if (excess > proc_info->excess){
151 |         proc_info->excess = excess;
152 |         //if (!board.follow_capt && search_method == MTDF)
153 |         board.follow_capt = true;
154 |       }
155 |       else{
156 |         //board.follow_depth = 0;
157 |       }
158 |       if(entry_found && excess > 0) {
159 |         assert(depth == board.depth);
160 |         std::cout << "excess = " << (excess+depth) << std::endl;
161 |         zhi = bad_max_score;
162 |         verify(strBoard,board.side,depth+excess,board.castle,board.ep,zlo,bad_max_score);
163 |       }
164 |     }
165 |       
166 |     if (entry_found){
167 |       return zlo;
168 |     }
169 |    
170 |     if(!entry_found) {
171 |       entry_found = get_transposition_value (board, zlo, zhi);
172 | 
173 |       if(!entry_found && db_on && board.side == LIGHT){
174 |         entry_found = dbase.get_transposition_value(board,zlo,zhi,white,p_board,excess,true,depth);
175 |         verify(strBoard,board.side,depth,board.castle,board.ep,zlo,zhi);
176 |       }
177 |     }
178 | 
179 |     if (entry_found) {
180 |         if(zlo >= beta) {
181 |             return zlo;
182 |         }
183 |         if(alpha >= zhi) {
184 |             return zhi;
185 |         }
186 |         alpha = max(zlo,alpha);
187 |         beta  = min(zhi,beta);
188 |     }
189 |     
190 |     if(alpha >= beta) {
191 |         //proc_info->stop=false;
192 |         //deeper= false;
193 |         return alpha;
194 |     }
195 | 
196 |     const score_t alpha0 = alpha;
197 | 
198 |     std::vector<chess_move> workq;
199 |     std::vector<chess_move> max_move;
200 |     
201 | 
202 |     gen(workq, board); // Generate the moves
203 | 
204 | #ifdef PV_ON
205 |     if(!proc_info->use_srand)
206 |       proc_info->incr = rand();
207 |     proc_info->use_srand = false;
208 |     srand(proc_info->incr);
209 |     sort_pv(workq, board.depth); // Part of iterative deepening
210 | #endif
211 | 
212 |     const int worksq = workq.size();
213 |     std::vector<boost::shared_ptr<task> > tasks;
214 | 
215 |     int j=0;
216 |     score_t val;
217 |     bool aborted = false;
218 |     bool children_aborted = false;
219 |     // loop through the moves
220 |     //for (; j < worksq; j++) 
221 |     while(j < worksq) {
222 |         while(j < worksq) {
223 |             chess_move g = workq[j++];
224 | 
225 |             boost::shared_ptr<search_info> child_info{new search_info(board)};
226 |             bool parallel;
227 |             if (!aborted && !proc_info->get_abort() && makemove(child_info->board, g)) {
228 |             
229 |                 parallel = j > 0 && !capture(board,g);
230 |                 boost::shared_ptr<task> t = parallel_task(depth, &parallel);
231 | 
232 |                 t->info = child_info;
233 |                 int d = depth - 1;
234 |                 if(!test_alphabeta && d == 0 && capture(board,g)) {
235 |                   d = 1;
236 |                   /*
237 |                   if(!proc_info->quiescent) {
238 |                     t->info->alpha = bad_min_score;
239 |                     t->info->beta = bad_max_score;
240 |                   }
241 |                   */
242 |                   t->info->quiescent = true;
243 |                 } else if(proc_info->quiescent) {
244 |                   t->info->quiescent = true;
245 |                 }
246 |                 t->info->board.depth = child_info->depth = d;
247 |                 assert(depth >= 0);
248 |                 t->info->alpha = -beta;
249 |                 t->info->beta = -alpha;
250 |                 t->info->mv = g;
251 |                 t->pfunc = search_ab_f;
252 |                 t->start();
253 |                 tasks.push_back(t);
254 | 
255 |                 // Control branching
256 |                 if (!parallel)
257 |                     break;
258 |                 /*
259 |                 else if (beta >= max_score*.9)
260 |                     continue;
261 |                     */
262 |                 else if (tasks.size() < 5)
263 |                     continue;
264 |                 else
265 |                     break;
266 |             }
267 |         }
268 | 
269 |         When when(tasks);
270 |         size_t const count = tasks.size();
271 |         for(size_t n_=0;n_<count;n_++) {
272 |             int n = when.any();
273 |             boost::shared_ptr<task> child_task = tasks[n];
274 |             //assert(child_task.valid());
275 |             child_task->join();
276 |             
277 |             boost::shared_ptr<search_info> child_info = child_task->info;
278 |             
279 |             tasks.erase(tasks.begin()+n);
280 | 
281 |             if(!children_aborted && (aborted || child_info->get_abort())) {
282 |                 for(unsigned int m = 0;m < tasks.size();m++) {
283 |                      tasks[m]->info->set_abort(true);
284 |                 }
285 |                 children_aborted = true;
286 |             }
287 | 
288 |             //child_task->join();
289 |             if(child_info->get_abort()) 
290 |                 continue;
291 |             
292 |             if(child_info->draw)
293 |               proc_info->draw = true;
294 | 
295 |             val = -child_info->result;
296 |             proc_info->log << " " << child_info->mv << "=" << val;
297 | 
298 |             bool found = false; 
299 |             if (child_info->excess > proc_info->excess){
300 |               proc_info->excess = child_info->excess;
301 |               found = true;
302 |               if (!board.follow_capt){
303 |                 board.follow_capt = true;
304 |               }
305 |             }
306 |             
307 |             if (val > max_val || found ) {
308 |                 max_move.clear();
309 |                 max_move.push_back(child_info->mv); 
310 |                 if (val > max_val)
311 |                   max_val = val;
312 |                 if (val > alpha)
313 |                 {
314 |                     alpha = val;
315 | #ifdef PV_ON
316 |                     if(!child_info->get_abort())
317 |                         ;//pv[board.search_depth - 1].set(child_info->mv);
318 | #endif
319 |                     if(alpha >= beta) {
320 |                       //aborted = true;
321 |                       j += worksq;
322 |                       continue;
323 |                     }
324 |                 }
325 |             } else if(val == max_val && proc_info->excess == 0) {
326 |               max_move.push_back(child_info->mv);
327 |             }
328 |         }
329 |         if(alpha >= beta) {
330 |             j += worksq;
331 |             break;
332 |         }
333 |     
334 |     }
335 |     // no legal moves? then we're in checkmate or stalemate
336 |     if (max_move.size()==0) {
337 |         if (in_check(board, board.side))
338 |         {
339 |             DECL_SCORE(s,max_score,board.hash);
340 |             return s;
341 |        }
342 |         else
343 |         {
344 |             DECL_SCORE(z,0,board.hash);
345 |             return z;
346 |         }
347 |     }
348 |     if(db_on) {
349 |       if (board.ply == 0 || board.depth>0) {
350 |         assert(max_move.size() != 0);
351 |         ScopedLock s(cmutex);
352 |         move_to_make = max_move.at(rand() % max_move.size());
353 |       }
354 |     }
355 |     
356 |     bool store = true;
357 |     if(proc_info->draw) {
358 |       store = false;
359 |     }
360 |     if(proc_info->quiescent)
361 |       store = false;
362 | 
363 |     score_t lo, hi;
364 |     if(proc_info->excess) {
365 |       lo = max_val;
366 |       hi = max_score;
367 |       //std::cout<<"Max depth: "<<proc_info->excess+depth<<std::endl;
368 |       store = false;
369 |     } else if(alpha0 < max_val && max_val < beta) {
370 |       lo = max_val-1;
371 |       hi = max_val;
372 |     } else if(max_val <= alpha0) {
373 |       hi = max_val;
374 |       lo = zlo;
375 |       if(lo == zlo)
376 |         store = false;
377 |     } else if (max_val >= beta){
378 |       lo = max_val;
379 |       hi = zhi;
380 |       if(hi == zhi)
381 |         store = false;
382 |     } else {
383 |       store = false;
384 |       lo = hi = 0;
385 |     }
386 |     if(store && lo > hi) {
387 |       std::cout << "lo=" << lo << " hi=" << hi << std::endl;
388 |       abort();
389 |     }
390 | 
391 |     if(store && db_on) {
392 |       verify(strBoard,board.side,depth,board.castle,board.ep,lo,hi);
393 |     }
394 |     if(store) {
395 |       //if(board.depth > 1)
396 |         dbase.add_data(board,lo,hi,white,proc_info->excess);
397 |       set_transposition_value(board,lo,hi);
398 |     }
399 |     return max_val;
400 | }
401 | 


--------------------------------------------------------------------------------
/src/eval.cpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | /*
  8 |  *  eval.cpp
  9 |  */
 10 | 
 11 | #include "eval.hpp"
 12 | 
 13 | // the values of the pieces
 14 | const int piece_value[6] = {
 15 |     100, 300, 300, 500, 900, 0
 16 | };
 17 | 
 18 | /* The "pcsq" arrays are piece/square tables. They're values
 19 |    added to the material value of the piece based on the
 20 |    location of the piece. */
 21 | 
 22 | const int pawn_pcsq[] = {
 23 |       0,   0,   0,   0,   0,   0,   0,   0,
 24 |       5,  10,  15,  20,  20,  15,  10,   5,
 25 |       4,   8,  12,  16,  16,  12,   8,   4,
 26 |       3,   6,   9,  12,  12,   9,   6,   3,
 27 |       2,   4,   6,   8,   8,   6,   4,   2,
 28 |       1,   2,   3, -10, -10,   3,   2,   1,
 29 |       0,   0,   0, -40, -40,   0,   0,   0,
 30 |       0,   0,   0,   0,   0,   0,   0,   0
 31 | };
 32 | 
 33 | const int knight_pcsq[] = {
 34 |     -10, -10, -10, -10, -10, -10, -10, -10,
 35 |     -10,   0,   0,   0,   0,   0,   0, -10,
 36 |     -10,   0,   5,   5,   5,   5,   0, -10,
 37 |     -10,   0,   5,  10,  10,   5,   0, -10,
 38 |     -10,   0,   5,  10,  10,   5,   0, -10,
 39 |     -10,   0,   5,   5,   5,   5,   0, -10,
 40 |     -10,   0,   0,   0,   0,   0,   0, -10,
 41 |     -10, -30, -10, -10, -10, -10, -30, -10
 42 | };
 43 | 
 44 | const int bishop_pcsq[] = {
 45 |     -10, -10, -10, -10, -10, -10, -10, -10,
 46 |     -10,   0,   0,   0,   0,   0,   0, -10,
 47 |     -10,   0,   5,   5,   5,   5,   0, -10,
 48 |     -10,   0,   5,  10,  10,   5,   0, -10,
 49 |     -10,   0,   5,  10,  10,   5,   0, -10,
 50 |     -10,   0,   5,   5,   5,   5,   0, -10,
 51 |     -10,   0,   0,   0,   0,   0,   0, -10,
 52 |     -10, -10, -20, -10, -10, -20, -10, -10
 53 | };
 54 | 
 55 | const int king_pcsq[] = {
 56 |     -40, -40, -40, -40, -40, -40, -40, -40,
 57 |     -40, -40, -40, -40, -40, -40, -40, -40,
 58 |     -40, -40, -40, -40, -40, -40, -40, -40,
 59 |     -40, -40, -40, -40, -40, -40, -40, -40,
 60 |     -40, -40, -40, -40, -40, -40, -40, -40,
 61 |     -40, -40, -40, -40, -40, -40, -40, -40,
 62 |     -20, -20, -20, -20, -20, -20, -20, -20,
 63 |       0,  20,  40, -20,   0, -20,  40,  20
 64 | };
 65 | 
 66 | const int king_endgame_pcsq[] = {
 67 |       0,  10,  20,  30,  30,  20,  10,   0,
 68 |      10,  20,  30,  40,  40,  30,  20,  10,
 69 |      20,  30,  40,  50,  50,  40,  30,  20,
 70 |      30,  40,  50,  60,  60,  50,  40,  30,
 71 |      30,  40,  50,  60,  60,  50,  40,  30,
 72 |      20,  30,  40,  50,  50,  40,  30,  20,
 73 |      10,  20,  30,  40,  40,  30,  20,  10,
 74 |       0,  10,  20,  30,  30,  20,  10,   0
 75 | };
 76 | 
 77 | /* The flip array is used to calculate the piece/square
 78 |    values for DARK pieces. The piece/square value of a
 79 |    LIGHT pawn is pawn_pcsq[sq] and the value of a DARK
 80 |    pawn is pawn_pcsq[flip[sq]] */
 81 | const int flip[] = {
 82 |      56,  57,  58,  59,  60,  61,  62,  63,
 83 |      48,  49,  50,  51,  52,  53,  54,  55,
 84 |      40,  41,  42,  43,  44,  45,  46,  47,
 85 |      32,  33,  34,  35,  36,  37,  38,  39,
 86 |      24,  25,  26,  27,  28,  29,  30,  31,
 87 |      16,  17,  18,  19,  20,  21,  22,  23,
 88 |       8,   9,  10,  11,  12,  13,  14,  15,
 89 |       0,   1,   2,   3,   4,   5,   6,   7
 90 | };
 91 | 
 92 | /* pawn_rank[x][y] is the rank of the least advanced pawn of color x on file
 93 |    y - 1. There are "buffer files" on the left and right to avoid special-case
 94 |    logic later. If there's no pawn on a rank, we pretend the pawn is
 95 |    impossibly far advanced (0 for LIGHT and 7 for DARK). This makes it easy to
 96 |    test for pawns on a rank and it simplifies some pawn evaluation code. */
 97 | /*
 98 | int pawn_rank[2][10];
 99 | 
100 | int piece_mat[2];  // the value of a side's pieces
101 | int pawn_mat[2];  // the value of a side's pawns
102 | */
103 | 
104 | int evaluator::eval(const node_t& board, int evaluator)
105 | {
106 |     // Interface function that selects which evaluator to use
107 |     
108 |     if (evaluator == ORIGINAL)
109 |         return eval_orig(board);
110 |     else
111 |         return eval_simple(board);
112 | }
113 | 
114 | int evaluator::eval_simple(const node_t& board)
115 | {
116 |     // A simple material evaluator
117 |     
118 |     enum material_weight {KING_WEIGHT = 200, QUEEN_WEIGHT = 9, ROOK_WEIGHT = 5, BISHOP_WEIGHT = 3, KNIGHT_WEIGHT = 3, PAWN_WEIGHT = 1};
119 |     
120 |     int score[2];
121 |     int i;
122 |     score[LIGHT]=0;
123 |     score[DARK]=0;
124 |     
125 |     for (i = 0; i < 64; ++i)
126 |     {
127 |         if (board.color[i] == EMPTY)
128 |             continue;
129 |         switch (board.piece[i]) {
130 |             case KING:
131 |                 score[(int)board.color[i]]+=KING_WEIGHT;
132 |                 break;
133 |             case QUEEN:
134 |                 score[(int)board.color[i]]+=QUEEN_WEIGHT;
135 |                 break;
136 |             case ROOK:
137 |                 score[(int)board.color[i]]+=ROOK_WEIGHT;
138 |                 break;
139 |             case BISHOP:
140 |                 score[(int)board.color[i]]+=BISHOP_WEIGHT;
141 |                 break;
142 |             case KNIGHT:
143 |                 score[(int)board.color[i]]+=KNIGHT_WEIGHT;
144 |                 break;
145 |             case PAWN:
146 |                 score[(int)board.color[i]]+=PAWN_WEIGHT;
147 |                 break;
148 |         }
149 |     }
150 |     
151 |     if (board.side == LIGHT)
152 |         return score[LIGHT] - score[DARK];
153 |     return score[DARK] - score[LIGHT];
154 | }
155 | 
156 | int evaluator::eval_orig(const node_t& board)
157 | {
158 |     int i;
159 |     int f;  // file
160 |     int score[2];  // each side's score
161 | 
162 |     f = i = 0;
163 |     score[0] = score[1] = 0;
164 | 
165 |     // this is the first pass: set up pawn_rank, piece_mat, and pawn_mat.
166 |     for (i = 0; i < 10; ++i) {
167 |         pawn_rank[LIGHT][i] = 0;
168 |         pawn_rank[DARK][i] = 7;
169 |     }
170 |     piece_mat[LIGHT] = 0;
171 |     piece_mat[DARK] = 0;
172 |     pawn_mat[LIGHT] = 0;
173 |     pawn_mat[DARK] = 0;
174 |     for (i = 0; i < 64; ++i) {
175 |         if (board.color[i] == EMPTY)
176 |             continue;
177 |         if (board.piece[i] == PAWN) {
178 |             pawn_mat[(int)board.color[i]] += piece_value[PAWN];
179 |             f = COL(i) + 1;  // add 1 because of the extra file in the array
180 |             if (board.color[i] == LIGHT) {
181 |                 if (pawn_rank[LIGHT][f] < ROW(i))
182 |                     pawn_rank[LIGHT][f] = ROW(i);
183 |             }
184 |             else {
185 |                 if (pawn_rank[DARK][f] > ROW(i))
186 |                     pawn_rank[DARK][f] = ROW(i);
187 |             }
188 |         }
189 |         else
190 |             piece_mat[(int)board.color[i]] += piece_value[(int)board.piece[i]];
191 |     }
192 | 
193 |     // this is the second pass: evaluate each piece
194 |     score[LIGHT] = piece_mat[LIGHT] + pawn_mat[LIGHT];
195 |     score[DARK] = piece_mat[DARK] + pawn_mat[DARK];
196 |     for (i = 0; i < 64; ++i) {
197 |         if (board.color[i] == EMPTY)
198 |             continue;
199 |         if (board.color[i] == LIGHT) {
200 |             switch (board.piece[i]) {
201 |                 case PAWN:
202 |                     score[LIGHT] += eval_light_pawn(i);
203 |                     break;
204 |                 case KNIGHT:
205 |                     score[LIGHT] += knight_pcsq[i];
206 |                     break;
207 |                 case BISHOP:
208 |                     score[LIGHT] += bishop_pcsq[i];
209 |                     break;
210 |                 case ROOK:
211 |                     if (pawn_rank[LIGHT][COL(i) + 1] == 0) {
212 |                         if (pawn_rank[DARK][COL(i) + 1] == 7)
213 |                             score[LIGHT] += ROOK_OPEN_FILE_BONUS;
214 |                         else
215 |                             score[LIGHT] += ROOK_SEMI_OPEN_FILE_BONUS;
216 |                     }
217 |                     if (ROW(i) == 1)
218 |                         score[LIGHT] += ROOK_ON_SEVENTH_BONUS;
219 |                     break;
220 |                 case KING:
221 |                     if (piece_mat[DARK] <= 1200)
222 |                         score[LIGHT] += king_endgame_pcsq[i];
223 |                     else
224 |                         score[LIGHT] += eval_light_king(i);
225 |                     break;
226 |             }
227 |         }
228 |         else {
229 |             switch (board.piece[i]) {
230 |                 case PAWN:
231 |                     score[DARK] += eval_dark_pawn(i);
232 |                     break;
233 |                 case KNIGHT:
234 |                     score[DARK] += knight_pcsq[flip[i]];
235 |                     break;
236 |                 case BISHOP:
237 |                     score[DARK] += bishop_pcsq[flip[i]];
238 |                     break;
239 |                 case ROOK:
240 |                     if (pawn_rank[DARK][COL(i) + 1] == 7) {
241 |                         if (pawn_rank[LIGHT][COL(i) + 1] == 0)
242 |                             score[DARK] += ROOK_OPEN_FILE_BONUS;
243 |                         else
244 |                             score[DARK] += ROOK_SEMI_OPEN_FILE_BONUS;
245 |                     }
246 |                     if (ROW(i) == 6)
247 |                         score[DARK] += ROOK_ON_SEVENTH_BONUS;
248 |                     break;
249 |                 case KING:
250 |                     if (piece_mat[LIGHT] <= 1200)
251 |                         score[DARK] += king_endgame_pcsq[flip[i]];
252 |                     else
253 |                         score[DARK] += eval_dark_king(i);
254 |                     break;
255 |             }
256 |         }
257 |     }
258 | 
259 |     /* the score[] array is set, now return the score relative
260 |        to the side to chess_move */
261 |     if (board.side == LIGHT)
262 |         return score[LIGHT] - score[DARK];
263 |     return score[DARK] - score[LIGHT];
264 | }
265 | 
266 | int evaluator::eval_light_pawn(int sq)
267 | {
268 |     int r;  // the value to return
269 |     int f;  // the pawn's file
270 | 
271 |     r = 0;
272 |     f = COL(sq) + 1;
273 | 
274 |     r += pawn_pcsq[sq];
275 | 
276 |     // if there's a pawn behind this one, it's doubled
277 |     if (pawn_rank[LIGHT][f] > ROW(sq))
278 |         r -= DOUBLED_PAWN_PENALTY;
279 | 
280 |     /* if there aren't any friendly pawns on either side of
281 |        this one, it's isolated */
282 |     if ((pawn_rank[LIGHT][f - 1] == 0) &&
283 |             (pawn_rank[LIGHT][f + 1] == 0))
284 |         r -= ISOLATED_PAWN_PENALTY;
285 | 
286 |     // if it's not isolated, it might be backwards
287 |     else if ((pawn_rank[LIGHT][f - 1] < ROW(sq)) &&
288 |             (pawn_rank[LIGHT][f + 1] < ROW(sq)))
289 |         r -= BACKWARDS_PAWN_PENALTY;
290 | 
291 |     // add a bonus if the pawn is passed
292 |     if ((pawn_rank[DARK][f - 1] >= ROW(sq)) &&
293 |             (pawn_rank[DARK][f] >= ROW(sq)) &&
294 |             (pawn_rank[DARK][f + 1] >= ROW(sq)))
295 |         r += (7 - ROW(sq)) * PASSED_PAWN_BONUS;
296 | 
297 |     return r;
298 | }
299 | 
300 | int evaluator::eval_dark_pawn(int sq)
301 | {
302 |     int r;  // the value to return
303 |     int f;  // the pawn's file
304 | 
305 |     r = 0;
306 |     f = COL(sq) + 1;
307 | 
308 |     r += pawn_pcsq[flip[sq]];
309 | 
310 |     // if there's a pawn behind this one, it's doubled
311 |     if (pawn_rank[DARK][f] < ROW(sq))
312 |         r -= DOUBLED_PAWN_PENALTY;
313 | 
314 |     /* if there aren't any friendly pawns on either side of
315 |        this one, it's isolated */
316 |     if ((pawn_rank[DARK][f - 1] == 7) &&
317 |             (pawn_rank[DARK][f + 1] == 7))
318 |         r -= ISOLATED_PAWN_PENALTY;
319 | 
320 |     // if it's not isolated, it might be backwards
321 |     else if ((pawn_rank[DARK][f - 1] > ROW(sq)) &&
322 |             (pawn_rank[DARK][f + 1] > ROW(sq)))
323 |         r -= BACKWARDS_PAWN_PENALTY;
324 | 
325 |     // add a bonus if the pawn is passed
326 |     if ((pawn_rank[LIGHT][f - 1] <= ROW(sq)) &&
327 |             (pawn_rank[LIGHT][f] <= ROW(sq)) &&
328 |             (pawn_rank[LIGHT][f + 1] <= ROW(sq)))
329 |         r += ROW(sq) * PASSED_PAWN_BONUS;
330 | 
331 |     return r;
332 | }
333 | 
334 | int evaluator::eval_light_king(int sq)
335 | {
336 |     int r;  //the value to return
337 |     int i;
338 | 
339 |     r = king_pcsq[sq];
340 | 
341 |     /* if the king is castled, use a special function to evaluate the
342 |        pawns on the appropriate side */
343 |     if (COL(sq) < 3) {
344 |         r += eval_lkp(1);
345 |         r += eval_lkp(2);
346 |         r += eval_lkp(3) / 2;  /* problems with pawns on the c & f files
347 |                                   are not as severe */
348 |     }
349 |     else if (COL(sq) > 4) {
350 |         r += eval_lkp(8);
351 |         r += eval_lkp(7);
352 |         r += eval_lkp(6) / 2;
353 |     }
354 | 
355 |     /* otherwise, just assess a penalty if there are open files near
356 |        the king */
357 |     else {
358 |         for (i = COL(sq); i <= COL(sq) + 2; ++i)
359 |             if ((pawn_rank[LIGHT][i] == 0) &&
360 |                     (pawn_rank[DARK][i] == 7))
361 |                 r -= 10;
362 |     }
363 | 
364 |     /* scale the king safety value according to the opponent's material;
365 |        the premise is that your king safety can only be bad if the
366 |        opponent has enough pieces to attack you */
367 |     r *= piece_mat[DARK];
368 |     r /= 3100;
369 | 
370 |     return r;
371 | }
372 | 
373 | // eval_lkp(f) evaluates the Light King Pawn on file f
374 | 
375 | int evaluator::evaluator::eval_lkp(int f)
376 | {
377 |     int r = 0;
378 | 
379 |     if (pawn_rank[LIGHT][f] == 6);  // pawn hasn't moved
380 |     else if (pawn_rank[LIGHT][f] == 5)
381 |         r -= 10;  // pawn moved one square
382 |     else if (pawn_rank[LIGHT][f] != 0)
383 |         r -= 20;  // pawn moved more than one square
384 |     else
385 |         r -= 25;  // no pawn on this file
386 | 
387 |     if (pawn_rank[DARK][f] == 7)
388 |         r -= 15;  // no enemy pawn
389 |     else if (pawn_rank[DARK][f] == 5)
390 |         r -= 10;  // enemy pawn on the 3rd rank
391 |     else if (pawn_rank[DARK][f] == 4)
392 |         r -= 5;   // enemy pawn on the 4th rank
393 | 
394 |     return r;
395 | }
396 | 
397 | int evaluator::eval_dark_king(int sq)
398 | {
399 |     int r;
400 |     int i;
401 | 
402 |     r = king_pcsq[flip[sq]];
403 |     if (COL(sq) < 3) {
404 |         r += eval_dkp(1);
405 |         r += eval_dkp(2);
406 |         r += eval_dkp(3) / 2;
407 |     }
408 |     else if (COL(sq) > 4) {
409 |         r += eval_dkp(8);
410 |         r += eval_dkp(7);
411 |         r += eval_dkp(6) / 2;
412 |     }
413 |     else {
414 |         for (i = COL(sq); i <= COL(sq) + 2; ++i)
415 |             if ((pawn_rank[LIGHT][i] == 0) &&
416 |                     (pawn_rank[DARK][i] == 7))
417 |                 r -= 10;
418 |     }
419 |     r *= piece_mat[LIGHT];
420 |     r /= 3100;
421 |     return r;
422 | }
423 | 
424 | int evaluator::eval_dkp(int f)
425 | {
426 |     int r = 0;
427 | 
428 |     if (pawn_rank[DARK][f] == 1);
429 |     else if (pawn_rank[DARK][f] == 2)
430 |         r -= 10;
431 |     else if (pawn_rank[DARK][f] != 7)
432 |         r -= 20;
433 |     else
434 |         r -= 25;
435 | 
436 |     if (pawn_rank[LIGHT][f] == 0)
437 |         r -= 15;
438 |     else if (pawn_rank[LIGHT][f] == 2)
439 |         r -= 10;
440 |     else if (pawn_rank[LIGHT][f] == 3)
441 |         r -= 5;
442 | 
443 |     return r;
444 | }
445 | 


--------------------------------------------------------------------------------
/src/data.cpp:
--------------------------------------------------------------------------------
  1 | ////////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | /*
  8 |  *  data.cpp
  9 |  */
 10 | 
 11 | #include "hash.hpp"
 12 | #include "defs.hpp"
 13 | #include "data.hpp"
 14 | 
 15 | int depth[2] = {3,3};
 16 | 
 17 | chess_move move_to_make; // Global variable keeping track of the next chess_move to
 18 |                    // make at the root level
 19 | 
 20 | int output = 1; //Used to tell the engine whether to output or not.
 21 | 
 22 | int chosen_evaluator = ORIGINAL; // Which evaluation function to use
 23 | 
 24 | int search_method = ALPHABETA;
 25 | 
 26 | int light_search_method = ALPHABETA; // Which search method to use
 27 | 
 28 | int dark_search_method = ALPHABETA;
 29 | 
 30 | int iter_depth = 5;  // See search.cpp for usage
 31 | 
 32 | int mpi_depth = -1;
 33 | 
 34 | bool bench_mode = false;
 35 | 
 36 | bool logging_enabled = false;
 37 | 
 38 | /* random numbers used to compute hash; see set_hash() in board.c */
 39 | hash_t hash_piece[2][6][64];  /* indexed by piece [color][type][square] */
 40 | hash_t hash_side;
 41 | hash_t hash_ep[64];
 42 | 
 43 | /* Now we have the mailbox array, so called because it looks like a
 44 |    mailbox, at least according to Bob Hyatt. This is useful when we
 45 |    need to figure out what pieces can go where. Let's say we have a
 46 |    rook on square a4 (32) and we want to know if it can chess_move one
 47 |    square to the left. We subtract 1, and we get 31 (h5). The rook
 48 |    obviously can't chess_move to h5, but we don't know that without doing
 49 |    a lot of annoying work. Sooooo, what we do is figure out a4's
 50 |    mailbox number, which is 61. Then we subtract 1 from 61 (60) and
 51 |    see what mailbox[60] is. In this case, it's -1, so it's out of
 52 |    bounds and we can forget it. You can see how mailbox[] is used
 53 |    in attack() in board.cpp. */
 54 | 
 55 | int mailbox[120]={
 56 |      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 57 |      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 58 |      -1,  0,  1,  2,  3,  4,  5,  6,  7, -1,
 59 |      -1,  8,  9, 10, 11, 12, 13, 14, 15, -1,
 60 |      -1, 16, 17, 18, 19, 20, 21, 22, 23, -1,
 61 |      -1, 24, 25, 26, 27, 28, 29, 30, 31, -1,
 62 |      -1, 32, 33, 34, 35, 36, 37, 38, 39, -1,
 63 |      -1, 40, 41, 42, 43, 44, 45, 46, 47, -1,
 64 |      -1, 48, 49, 50, 51, 52, 53, 54, 55, -1,
 65 |      -1, 56, 57, 58, 59, 60, 61, 62, 63, -1,
 66 |      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
 67 |      -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
 68 | };
 69 | 
 70 | int mailbox64[64] = {
 71 |     21, 22, 23, 24, 25, 26, 27, 28,
 72 |     31, 32, 33, 34, 35, 36, 37, 38,
 73 |     41, 42, 43, 44, 45, 46, 47, 48,
 74 |     51, 52, 53, 54, 55, 56, 57, 58,
 75 |     61, 62, 63, 64, 65, 66, 67, 68,
 76 |     71, 72, 73, 74, 75, 76, 77, 78,
 77 |     81, 82, 83, 84, 85, 86, 87, 88,
 78 |     91, 92, 93, 94, 95, 96, 97, 98
 79 | };
 80 | 
 81 | /* slide, offsets, and offset are basically the vectors that
 82 |    pieces can chess_move in. If slide for the piece is FALSE, it can
 83 |    only chess_move one square in any one direction. offsets is the
 84 |    number of directions it can chess_move in, and offset is an array
 85 |    of the actual directions. */
 86 | 
 87 | bool slide[6] = {
 88 |     false, false, true, true, true, false
 89 | };
 90 | 
 91 | int offsets[6] = {
 92 |     0, 8, 4, 4, 8, 8
 93 | };
 94 | 
 95 | int offset[6][8] = {
 96 |     { 0, 0, 0, 0, 0, 0, 0, 0 },
 97 |     { -21, -19, -12, -8, 8, 12, 19, 21 },
 98 |     { -11, -9, 9, 11, 0, 0, 0, 0 },
 99 |     { -10, -1, 1, 10, 0, 0, 0, 0 },
100 |     { -11, -10, -9, -1, 1, 9, 10, 11 },
101 |     { -11, -10, -9, -1, 1, 9, 10, 11 }
102 | };
103 | 
104 | 
105 | /* This is the castle_mask array. We can use it to determine
106 |    the castling permissions after a chess_move. What we do is
107 |    logical-AND the castle bits with the castle_mask bits for
108 |    both of the chess_move's squares. Let's say castle is 1, meaning
109 |    that white can still castle kingside. Now we play a chess_move
110 |    where the rook on h1 gets captured. We AND castle with
111 |    castle_mask[63], so we have 1&14, and castle becomes 0 and
112 |    white can't castle kingside anymore. */
113 | 
114 | int castle_mask[64] = {
115 |      7, 15, 15, 15,  3, 15, 15, 11,
116 |     15, 15, 15, 15, 15, 15, 15, 15,
117 |     15, 15, 15, 15, 15, 15, 15, 15,
118 |     15, 15, 15, 15, 15, 15, 15, 15,
119 |     15, 15, 15, 15, 15, 15, 15, 15,
120 |     15, 15, 15, 15, 15, 15, 15, 15,
121 |     15, 15, 15, 15, 15, 15, 15, 15,
122 |     13, 15, 15, 15, 12, 15, 15, 14
123 | };
124 | 
125 | 
126 | /* the piece letters, for print_board() */
127 | char piece_char[6] = {
128 |     'P', 'N', 'B', 'R', 'Q', 'K'
129 | };
130 | 
131 | 
132 | /* the initial board state */
133 | 
134 | int init_color[64] = {
135 |     1, 1, 1, 1, 1, 1, 1, 1,
136 |     1, 1, 1, 1, 1, 1, 1, 1,
137 |     6, 6, 6, 6, 6, 6, 6, 6,
138 |     6, 6, 6, 6, 6, 6, 6, 6,
139 |     6, 6, 6, 6, 6, 6, 6, 6,
140 |     6, 6, 6, 6, 6, 6, 6, 6,
141 |     0, 0, 0, 0, 0, 0, 0, 0,
142 |     0, 0, 0, 0, 0, 0, 0, 0
143 | };
144 | 
145 | int init_piece[64] = {
146 |     3, 1, 2, 4, 5, 2, 1, 3,
147 |     0, 0, 0, 0, 0, 0, 0, 0,
148 |     6, 6, 6, 6, 6, 6, 6, 6,
149 |     6, 6, 6, 6, 6, 6, 6, 6,
150 |     6, 6, 6, 6, 6, 6, 6, 6,
151 |     6, 6, 6, 6, 6, 6, 6, 6,
152 |     0, 0, 0, 0, 0, 0, 0, 0,
153 |     3, 1, 2, 4, 5, 2, 1, 3
154 | };
155 | 
156 | // Most epic array of all time. Instead of generating random numbers
157 | // which change based on the system in use,
158 | // we will just use these. See http://xkcd.com/221/
159 | // This allows us to have a more deterministic value to the Zobrist hash
160 | 
161 | int rnum[] = {-1375691353, -815332770, 1270435042, -815154522, -1828625225, 1123318779, 1586732881, 857454044, 1654565544, -1990485649, 2106160544, 184179035, 1209203939,
162 |  1483071411, -2091589446, 2093958737, -773212423, -1271181000, 2015271137, -1746164393, -1500599766, 746565161, -1144048956, 1075289478, -709069829, -727667196,
163 |   -824597445, 2008785879, 1301640596, 628405905, -1446285938, -1396859346, 1304116003, 1529756628, -1260898178, 1548840462, 1447397889, -1168954670,
164 |    -1110898275, -1887639445, 656075682, -608339955, 814079338, 669245026, 1951647292, 729497249, -1419458719, 139036579, 906750875, -637959262, -538307760,
165 |     -289848741, 390743293, -1392095696, -290713914, -96147628, 1829599151, -1194787978, -722043991, -1336964562, -1893933781, 711448809, 452310116, -1790640062,
166 |      1240635447, -1090754494, -1366933250, 1026665666, 1488680893, -1182950434, -1036598065, -1518587701, -1705523470, 613658306, -462949775, 847198738,
167 |       -732921441, -2113608628, 1158295339, -1157309526, 2062687380, 1413227593, -1024939018, -1816787874, -54007899, -1717278380, -1837297588, -1056044958, 
168 |       -1291246157, 276592038, 1613838755, 34683531, 1350934634, 640892970, 415940656, -1949618028, 688189903, 729352085, 763586243, 1277784286, 102547099,
169 |        -1931527498, -662674335, 1379412912, 1130758820, -1109813417, 94863152, 439861828, -656297575, -297754430, -291657712, 1935923230, 627029289, 226975126, 
170 |        1373414176, 1056215175, 1421451740, 1251571972, -1672699341, 582724960, -610310652, 1438938119, 311337903, -1018674686, -1180634787, 1543440686, -808781742,
171 |         512295663, -1703545903, -1887569569, -654402996, -608600128, -1165478630, -2119870803, -1272310406, 1812679606, -492895663, 609050460, -546074727,
172 |          -1689436117, -952504417, 1078064762, 113536934, -86350164, 1456463674, -1701142525, -1226278781, 198525399, 1157930485, 1812450545, 1413032896, 1248413683,
173 |          -1075168881, 651085383, -1520706675, 691519880, -1288911069, 1676743630, 883153765, -308042273, 1827315269, -725870439, -1642113407, 1025972529,
174 |          60346175, -834260693, 1714914958, 1095334436, 199467091, 401005219, 2009410235, -250446121, -1386325239, -630436295, 1833561609, 1742709651, 1459353016, 1641947266, 
175 |          1379142135, 532899165, -1362569384, 500795808, -830962876, -996676912, 1549245911, 1355179167, 271327382, -949261846, 1233054023, -1053836109, 1668182700, -1487569706,
176 |           -544624098, 1157977139, 995174067, 2070858457, 590816556, -1575447317, 329817928, 684881059, -1828668549, -2097821451, 1081241918, -1426356220, 1904640967, 
177 |           1587271147, -431280759, 1904249134, -574730985, -1139617870, -1178961234, -854663274, 1183979582, -315094807, 736472885, -18167186, -1546611745, 1133240316,
178 |            17124755, -1350239844, 2046858810, -2086466194, 193299102, 2011342833, -547003777, 1807590682, -374781964, -650568704, 180864404, 685539032, -2013963463, 
179 |            -1129280027, 1064773528, -409672602, 1604725066, 938442808, 413375282, 2127247451, -1630779532, 1948799454, -1741363010, 1487533867, -849218221, 2022189902, 
180 |            -735174666, 1946376332, -1460818666, -188708345, 2143825943, -472547261, -128094424, 1826264571, 1569486888, 979450246, -1463464169, -311635906, -297451731, 
181 |            817216563, 101222677, -1974054867, -1147766291, -2060887972, 1707287962, 1280643622, 974655394, 907680894, 2059208893, -2137005112, 1908886366, -1625352439, 
182 |            345573456, -1596980567, 681984966, 1038557843, 1530313477, -1335045415, 1400194473, 1427668388, -375472568, 344559433, 949168958, 262828278, 2070051419, 
183 |            -1210776390, 959309822, 403069609, 1715556413, 120094498, -336049045, 1950397331, -1226101646, -835948869, 1065804868, 698288285, 780812127, 406409475, 
184 |            -559843137, 544097536, -946551559, -2011382080, 733320348, -1048186862, -353038361, -1551087253, -1290715539, 1904301307, -1340103962, -1836562869, -122773, 
185 |            312238919, -347781465, 1587205732, -427594604, -1920337529, 1907802319, -869049189, 1582817200, 38336562, -1257585619, -1190681950, 123976489, 2095725586, 
186 |            660883173, 1333163072, -899402007, -1745805072, -1826750344, 1673278933, 1132136481, -557967763, -173613481, -943598801, -1646576385, -1185767779, 1838379753, 
187 |            1409329249, -764796466, 637144576, 30186182, -672433705, -554506382, 869272714, -546944310, 153236972, 1454531688, -1891628639, 1395897246, -2016360301, 
188 |            2055404017, -55937434, 585785387, -2050326257, -1266577672, 894800972, -191550946, -1788929886, 1319552325, -1080091367, 1257936612, -410626080, -1055026548, 
189 |            1767774339, 855670297, 873791534, -1737466439, -1920764111, 1301448760, -1979341976, 2105377795, -881268731, -939911764, -1989581621, -1640401784, -606474356, 
190 |            -538220714, 2057392201, 297497315, -22919917, 1011396007, 1921888076, 1829473842, -1442390336, 1678104219, -737187726, -611118529, -1564841347, 889657389, 
191 |            -197994960, 1302218290, -1607816891, -730063008, -606685813, -549842703, 690332807, 52746390, -385037492, 144835809, 1258281397, -315354791, 619132497, 
192 |            -2083805361, -781579543, -1349976266, 1649485857, -2085490875, -56009810, -896253771, -1319967044, 122915942, -2082553209, -571714661, 786568408, 501247347, 
193 |            -894093864, 894104255, -908197825, 1718690980, -1893016836, -243836998, 1823961932, -1999640014, 1326760877, 1938000673, -658170866, 1187124517, 1809550885, 
194 |            -1710749122, 1751509988, 632513242, -1005512481, 726043554, -303133420, -44278973, 568601838, 1180179580, -912514772, -1889187108, 80384393, -1494454427, 
195 |            435243275, 1507883780, 777494842, 1307519970, 779957481, -359955920, -1040276974, 165271113, 428497902, -1822406714, 64225599, 1158265374, 2038318762, 
196 |            1317044555, 1263278645, -548542054, -994485892, -1843213881, 818075904, 1454941838, -686198328, -646751033, -510204315, -323595522, -775251282, 553360923, 
197 |            -1083225933, -1228318013, -998645797, 2117128171, -1176446316, -1440569719, 1446398381, -409549028, 1998680878, -1587088128, -959930764, 586009656, -1570469262,
198 |             1501714559, 2141459072, -1504268510, 1882086418, 1912361895, -516063059, -310842703, -1082497806, -660441551, -684637327, 902487239, -2024453217, 1034803275, 
199 |             -493630353, -504666380, 1143222261, -1440524675, 1433233778, 647399391, -932062223, 319188997, 1017372678, -894409248, -2134117852, 1278832514, -12408891, 
200 |             -1052836120, 1782461278, -988029708, 799360300, -154110670, 1088003992, -549138973, -1376752782, 753138999, -763830290, -332247794, -1943080392, -909199657, 
201 |             516948973, -1912092042, -859308114, -565013371, 1569743918, 1628505426, -280543402, -609536342, -1721778883, 830434974, -282269279, -594066245, 992128544, 
202 |             433927970, 2027531313, -1036055730, -2099464812, 2100125147, 1644190609, -373278536, -237645688, 1167676571, 977989817, 1199280930, -1542074841, 943834945, 
203 |             -1353382962, 785846154, -726208052, -1652790954, 1909585367, 282077466, 60989368, -221895455, -1317228546, -329903534, 854222170, 337314794, 1305971116, 
204 |             1137522229, -1944987349, 968914230, -483622662, 27098646, -1859312288, 23848124, 1208923116, 263442456, -2037250970, -1439193251, -959067260, 110315055, 
205 |             -739181986, -625710345, 2049918536, -207116348, -1500082272, -1985904423, 1080874838, -617779411, -1624598356, -1035118215, 1719103191, -1276904137, 
206 |             1266930316, 2022325921, 1594219885, -1818727277, -1894110496, -565130384, -1210887000, -149745002, -576976594, 864995759, -1602787427, 135088234, 100190937,
207 |              993795333, 1522703810, -1911809212, 439933463, -1125501668, 1489348252, -1692425596, -1002043576, -1652911323, 1015941990, -1812171023, 457372637, 180282768, 
208 |              -1800922358, -262363121, 2120081339, -1193545562, -1543524046, -1583174895, -2031005556, 349033442, -1785891880, -1356995852, -687177503, 780623691, 
209 |              -1758595264, 1978409162, -1677811597, 688706128, -1194306389, 2088029583, 1901085910, -414585820, 945181588, 1732628380, 1997536572, 1921249042, 1464297509, 
210 |              -696443016, 1974908578, 1615956839, -825773837, -904956818, 453790738, 738029432, 653664587, -437424409, -1922878181, 900617716, 1188094639, 2121486321, 
211 |              820684703, -988742803, -241422538, 989676825, -814832498, 2038780257, 159620734, 1364360781, 1449255413, 1265871076, -717101654, 1395976052, 949042731, 
212 |              -2137751811, 273854421, 1018624402, 1921200404, 1616784863, 211107945, 1098148302, 607585893, 975208288, -1237933390, 1269274127, 487898188, 277345838, 
213 |              -1736718033, -2098397403, 1618402453, 2003836453, 197188199, -193847657, -2052745692, 2022634489, 1052205963, -694794693, 924738795, -134215191, -1391551474, 
214 |              1295584409, 1718607010, 1159212596, -1263572377, 573209358, -1789252908, -1725168794, -1073713500, -5646656, 919556534, -90499447, 1554293354, -1774752365, 
215 |              -1308259916, 1713365419, 1544721594, 1616792682, 344046183, -2013373653, -1066252094, -302573581, 1952252157, 37815513, -1745648091, 1650386572, 1723542194, 
216 |              -722484046, 1608792354, 2136510712, -805216663, 1213934869, 1959105325, 1808643316, -1195113746, 260794778, -830703833, -770271226, 914209247, 1329702509,
217 |               837128418, 702966889, 2146826647, -1350884408, -1119142048, -688451252, 1427902685, 1948010911, -255264230, 1041931386, -1399862577, -643520742, 2097390205, 
218 |               72184878, 192963205, 1492848707, -497437609, 1569326999, -1157543008, -493572054, 1497219200, -1276857332, 825631433, 1323349720, -1736175242, 1353061198, 
219 |               -83500446, -1512474165, -1920521641, 565969935, -124461125, -1402936864, -27511239, 1276363241, -1826736738, -650841617, 587174754, -1207621394, 597035948, 
220 |               -458937340, 177321906, 2131100064, 267205535, -347682509, -1365124557, 539520824, 262437709, -358609081, -1371005820, 2030513325, -1825828174, -236169767, 
221 |               -1950292432, 1577286567, 920893200, -908032481, 972243975, 1416637188, -801048442, 878685784, -853134546, 1417388542, 1383174484, 1238224817, -873710267, 
222 |               56328097, -1059157426, -1966121117, -288091202, 155845611, 1062473195, -1898626185, 786599984, 744831, -782930019, 1058322004, 620275163, -1017387688, 
223 |               -1927136883, 1953762841, -1608996307, 491743052, 1110023243, 654981824, -156656233, -1354834651, 1913577297, -1069771815, 989295738, -745285664, 706463106, 
224 |               -273032762, 1855115570, 1369625253, -1124634729, -795264460, -1877909797, 925295611, 1230708208, 1604016295, -1590401876, 506061340, 832574895, -1996896332, 
225 |               445392553, 523375176, -1853400155, 994301827, 236662122, -1234129967};
226 | int x;
227 | void do_data() {}
228 | 


--------------------------------------------------------------------------------
/src/search.cpp:
--------------------------------------------------------------------------------
  1 | ///////////////////////////////////////////////////////////////////////////////
  2 | //  Copyright (c) 2011 Steve Brandt and Philip LeBlanc
  3 | //
  4 | //  Distributed under the Boost Software License, Version 1.0. (See accompanying
  5 | //  file BOOST_LICENSE_1_0.rst or copy at http://www.boost.org/LICENSE_1_0.txt)
  6 | ////////////////////////////////////////////////////////////////////////////////
  7 | /*
  8 |  *  search.cpp
  9 |  */
 10 | #ifdef HPX_SUPPORT
 11 | #include <hpx/hpx_fwd.hpp>
 12 | #endif
 13 | 
 14 | #include "parallel_support.hpp"
 15 | #include "search.hpp"
 16 | #include "parallel.hpp"
 17 | #include <algorithm>
 18 | #include <math.h>
 19 | #include <assert.h>
 20 | #include "here.hpp"
 21 | #include "zkey.hpp"
 22 | #include "log_board.hpp"
 23 | #include <fstream>
 24 | #include <sstream>
 25 | 
 26 | const bool test_mtdf = false;
 27 | 
 28 | #define TRANSPOSE_ON 1
 29 | 
 30 | Mutex cmutex;
 31 | const int num_proc = chx_threads_per_proc();
 32 | 
 33 | int min(int a,int b) { return a < b ? a : b; }
 34 | int max(int a,int b) { return a > b ? a : b; }
 35 | 
 36 | std::vector<safe_move> pv;  // Principle Variation, used in iterative deepening
 37 | 
 38 | /**
 39 |  * This determines whether we have a capture. It's not sophisticated
 40 |  * enough to do en passant.
 41 |  */
 42 | bool capture(const node_t& board,chess_move& g) {
 43 |   //bool b1 = board.color[g.getTo()] != EMPTY
 44 |       //&& board.color[g.getTo()] != board.color[g.getFrom()];
 45 |   bool b2 = g.getCapture();
 46 |   //if(b1 != b2) abort();
 47 |   return b2;
 48 | }
 49 | 
 50 | /**
 51 |  * Quiescent evaluator. Originally we wished to avoid the complexity
 52 |  * of quiescent chess_move searches, but MTD-f does not seem to work properly
 53 |  * without it. This particular search evaluates each chess_move using the
 54 |  * evalutaor, unless the chess_move is a capture then it calls itself
 55 |  * recursively. The quiescent chess_move search uses alpha-beta to speed
 56 |  * itself along, and evaluates non-captures first to get the greatest
 57 |  * cutoff.
 58 |  **/
 59 | score_t qeval(boost::shared_ptr<search_info> info)
 60 | {
 61 | #ifdef HPX_SUPPORT
 62 |     if(file_output_enabled) {
 63 |         int n = hpx::get_worker_thread_num();
 64 |         if(streams[n] == NULL) {
 65 |             std::stringstream outname;
 66 |             streams[n] = new std::ofstream();
 67 |             outname << "chess_out" << n << ".txt";
 68 |             streams[n]->open(outname.str());
 69 |             std::cout << "file: " << outname.str() << std::endl;
 70 |         }
 71 |         log_board(info->board,*streams[n]);
 72 |     }
 73 | #endif
 74 |     node_t board = info->board;
 75 |     score_t lower = info->alpha;
 76 |     score_t upper = info->beta;
 77 |     evaluator ev;
 78 |     DECL_SCORE(s,ev.eval(board, chosen_evaluator),board.hash);
 79 |     return s;
 80 |     s = max(lower,s);
 81 |     std::vector<chess_move> workq;
 82 |     gen(workq, board); // Generate the moves
 83 |     for(size_t j=0;j < workq.size(); j++) {
 84 |         chess_move g = workq[j];
 85 |         if(g.getCapture())
 86 |             continue;
 87 |         if(info->get_abort())
 88 |             return s;
 89 |         node_t p_board = board;
 90 |         if(!makemove(p_board,g))
 91 |             continue;
 92 |         DECL_SCORE(v,ev.eval(p_board,chosen_evaluator),p_board.hash);
 93 |         s = max(v,s);
 94 |         if(s > upper) {
 95 |             return s;
 96 |         }
 97 |     }
 98 |     for(size_t j=0;j < workq.size(); j++) {
 99 |         if(!workq[j].getCapture())
100 |             continue;
101 |         if(info->get_abort())
102 |             return s;
103 |         chess_move g = workq[j];
104 |         node_t p_board = board;
105 |         if(!makemove(p_board,g))
106 |             continue;
107 |         boost::shared_ptr<search_info> new_info{new search_info};
108 |         new_info->set_abort_ref(info.get());
109 |         new_info->board = p_board;
110 |         new_info->alpha = -upper;
111 |         new_info->beta = -lower;
112 |         s = max(-qeval(new_info),s);
113 |         if(s > upper) {
114 |             return s;
115 |         }
116 |     }
117 |     return s;
118 | }
119 | 
120 | void qeval_pt(boost::shared_ptr<search_info> info)
121 | {
122 |   info->result = qeval(info);
123 |   task_counter.add(1);
124 | }
125 | 
126 | boost::shared_ptr<task> parallel_task(int depth, bool *parallel) {
127 | 
128 |     if(!*parallel) {
129 |         boost::shared_ptr<task> t{new serial_task};
130 |         return t;
131 |     }
132 |     bool use_parallel = false;
133 |     use_parallel = depth >= 3;
134 |     if(use_parallel) {
135 |         int n = task_counter.dec();
136 |         if(n > 0) {
137 | #ifdef HPX_SUPPORT
138 |             boost::shared_ptr<task> t{new hpx_task};
139 | #else
140 |             boost::shared_ptr<task> t{new thread_task};
141 | #endif
142 |             *parallel = (n > 1);
143 |             return t;
144 |         }
145 |     }
146 |     *parallel = false;
147 |     boost::shared_ptr<task> t{new serial_task};
148 |     return t;
149 | }
150 | 
151 | score_t target_score;
152 | 
153 | // think() calls a search function 
154 | int think(node_t& board,bool parallel)
155 | {
156 |   evaluator ev;
157 |   DECL_SCORE(curr, ev.eval(board, chosen_evaluator),board.hash);
158 |   score_t score_plus = ADD_SCORE(curr,1);
159 |   board.root_side = board.side;// == LIGHT;
160 |   
161 |   if (board.root_side == LIGHT)
162 |     search_method = light_search_method;
163 |   else
164 |     search_method = dark_search_method;
165 | 
166 |   boost::shared_ptr<task> root{new serial_task};
167 | #ifdef PV_ON
168 |   pv.clear();
169 |   pv.resize(depth[board.side]);
170 |   chess_move mvz;
171 |   mvz = INVALID_MOVE;
172 |   for(size_t i=0;i<pv.size();i++) {
173 |     pv[i].set(mvz);
174 |   }
175 | #endif
176 |   for(int i=0;i<table_size;i++) {
177 |     transposition_table[i].depth = -1;
178 |     transposition_table[i].lower = bad_min_score;
179 |     transposition_table[i].upper = bad_max_score;
180 |   }
181 |   board.ply = 0;
182 | 
183 |   if (search_method == MINIMAX) {
184 |     root->pfunc = search_f;
185 |     
186 |     boost::shared_ptr<search_info> info{new search_info};
187 |     info->board = board;
188 |     info->depth = depth[board.side];
189 |     score_t f = search(info);
190 | 
191 |     assert(move_to_make != INVALID_MOVE);
192 |     if (bench_mode)
193 |       std::cout << "SCORE=" << f << std::endl;
194 |   } else if (search_method == MTDF) {
195 |     if (board.move_num == 0){
196 |       board.p_board = score_plus;
197 |       target_score = score_plus;
198 |     }
199 |     root->pfunc = search_ab_f;
200 |     DECL_SCORE(alpha,-10000,board.hash);
201 |     DECL_SCORE(beta,10000,board.hash);
202 |     const int stepsize = 1;
203 |     int d = 2;//depth[board.side] % stepsize;
204 |     board.search_depth = depth[board.side];
205 |     board.depth = d;
206 |     boost::shared_ptr<search_info> info{new search_info};
207 |     info->board = board;
208 |     info->depth = d;
209 |     info->alpha = alpha;
210 |     info->beta = beta;
211 |     score_t f(search_ab(info));
212 | 
213 |     score_t moving = target_score;
214 | 
215 |     while(d < depth[board.side]) {
216 |         d+=stepsize;
217 |         int excess = 0;
218 |         board.depth = d;
219 |         std::cout << "iter(" << d << ")" << std::endl;
220 |         f = mtdf(board,f,d,target_score,moving);
221 |         if (f > moving){
222 |           moving = f;
223 |         }
224 |         std::cout<< "  d="<< d << " target=" << target_score << " moving="<< moving << " f="<< f<< std::endl;
225 |         if(board.follow_capt && board.follow_depth <= board.search_depth) {
226 |           board.follow_capt = false;
227 |         }
228 |         boost::shared_ptr<task> new_root{new serial_task};
229 |         root = new_root;
230 |     }
231 |     target_score = ADD_SCORE(f,1);
232 |     if (bench_mode)
233 |       std::cout << "SCORE=" << f << std::endl;
234 |   } else if (search_method == ALPHABETA) {
235 |     score_t mf=0;
236 |     if(test_alphabeta) {
237 |       boost::shared_ptr<search_info> info{new search_info};
238 |       info->board = board;
239 |       info->depth = depth[board.side];
240 |       mf = -search(info);
241 |       std::cout << "mf=" << mf << std::endl;
242 |     }
243 |     if (!board.follow_capt){
244 |       board.p_board = score_plus;
245 |     }
246 |     else{
247 |       board.follow_depth-=1;
248 |       if (board.follow_depth == 0)
249 |         board.follow_capt = false;
250 |     }
251 |     root->pfunc = search_ab_f;
252 |     // Initially alpha is -infinity, beta is infinity
253 |     DECL_SCORE(f,0,0);
254 |     DECL_SCORE(alpha,-10000,board.hash);
255 |     DECL_SCORE(beta,10000,board.hash);
256 |     bool brk = false;  /* Indicates whether we broke away from iterative deepening 
257 |                           and need to call search on the actual ply */ 
258 |     board.search_depth = depth[board.side];
259 |     int low = 2;
260 |     if(depth[board.side] % 2 == 1)
261 |         low = 1;
262 |     int excess = 0;
263 |     boost::shared_ptr<search_info> best_info;
264 |     chess_move best_move;
265 |     for (int i = low; i <= depth[board.side]; i++) // Iterative deepening
266 |     {
267 |       excess = 0; 
268 |       std::cout << "iter(" << i << ")" << std::endl;
269 |       board.depth = i;
270 |       boost::shared_ptr<search_info> info{new search_info};
271 |       info->board = board;
272 |       info->depth = i;
273 |       info->alpha = alpha;
274 |       info->beta = beta;
275 |       info->excess = excess;
276 |       //bool stop = info-> stop; 
277 |       f = search_ab(info);
278 |       if (info->excess > 0) {
279 |         excess = info->excess;
280 |         int reach = excess + info->depth;
281 |         board.follow_capt = true;
282 |         std::cout << "Excess: " << excess << " Reach: " << reach << std::endl;
283 |         if(best_info == nullptr || reach > best_info->excess + best_info->depth) {
284 |           best_info = info;
285 |           best_move = move_to_make;
286 |           std::cout << "  set best info " << f << std::endl;
287 |         }
288 |       }
289 |       if (i > depth[board.side])  // if our ply is greater than the iter_depth, then break
290 |       {
291 |         if(test_alphabeta) {
292 |           assert(f == mf);
293 |         }
294 |         brk = true;
295 |         break;
296 |       }
297 |     }
298 | 
299 |     // Get the best stuff
300 |     if(best_info != nullptr) {
301 |       move_to_make = best_move;
302 |       board = best_info->board;
303 |       excess =  best_info->excess;
304 |       std::cout << "best: " << (excess+board.depth) << std::endl;
305 |     }
306 |     std::cout << "p_board = " << board.p_board << std::endl;
307 | 
308 |     if(board.follow_capt && board.follow_depth <= board.search_depth) {
309 |       board.follow_capt = false;
310 |     }
311 |     if ((f >= board.p_board && (excess+board.depth)>board.follow_depth) || !board.follow_capt) {// || score_plus>=board.p_board){
312 |       if (score_plus>=board.p_board)
313 |         std::cout<<"Greater score"<<std::endl;
314 |       if (board.side == LIGHT){
315 |         board.p_board = f;
316 |         board.follow_capt = true;
317 |         board.follow_depth = board.depth + excess;
318 |       }
319 |       if (board.side == DARK && board.follow_capt){
320 |         board.follow_capt = false;
321 |         board.follow_depth = 2;
322 |       }
323 |     }
324 |     std::cout<<"Follow "<<board.follow_depth<<" Follow capt "<<board.follow_capt<< " Follow score: " << board.p_board << std::endl;
325 |     
326 |     /*
327 |     if (brk) {
328 |       boost::shared_ptr<search_info> info{new search_info};
329 |       info->board = board;
330 |       info->depth = depth[board.side];
331 |       info->alpha = alpha;
332 |       info->beta = beta;
333 |       f=search_ab(info);
334 |     }
335 |     */
336 |     if (bench_mode)
337 |       std::cout << "SCORE=" << f << std::endl;
338 |   }
339 |   return 1;
340 | }
341 | 
342 | /** MTD-f */
343 | score_t mtdf(node_t& board,score_t f,int depth,const score_t target,score_t moving){
344 |     score_t g = f;
345 |     evaluator ev;
346 |     DECL_SCORE(curr, ev.eval(board, chosen_evaluator),board.hash);
347 |     score_t score_plus = ADD_SCORE(curr,1);
348 |     DECL_SCORE(upper,10000,board.hash);
349 |     DECL_SCORE(lower,-10000,board.hash);
350 |     // Technically, MTD-f uses "zero-width" searches
351 |     // However, Aske Plaat points out that it performs
352 |     // better with a coarser evaluation function. Since
353 |     // this maps readily onto a wider, non-zero width
354 |     // we provide a width setting for optimization.
355 |     const int start_width = 0;//atoi(getenv("START_WIDTH"));
356 |     // Sometimes MTD-f gets stuck and can try many
357 |     // times without finding an answer. If this happens
358 |     // we want to set a threshold for bailing out.
359 |     const int max_tries = 9;//atoi(getenv("MAX_TRIES"));
360 |     // If our first guess isn't right, chances are
361 |     // we want to search a little wider the next try
362 |     // to improve our odds.
363 |     const int grow_width = 2;//atoi(getenv("GROW_WIDTH"));
364 | 
365 |     score_t g2;
366 |     if(test_mtdf) {
367 |       boost::shared_ptr<search_info> info{new search_info};
368 |       info->board = board;
369 |       info->depth = depth;
370 |       info->alpha = -max_score;
371 |       info->beta = max_score;
372 |       g2 = search_ab(info);
373 |       for(int i=0;i<table_size;i++) {
374 |         transposition_table[i].depth = -1;
375 |         transposition_table[i].lower = bad_min_score;
376 |         transposition_table[i].upper = bad_max_score;
377 |       }
378 |     }
379 | 
380 |     int width = start_width;
381 |     const int max_width = start_width+grow_width*max_tries;
382 |     score_t alpha = ADD_SCORE(target,-width), beta = ADD_SCORE(moving,width+1); 
383 |     boost::shared_ptr<search_info> best_info;
384 |     chess_move best_move;
385 |     int excess = 0;
386 |     score_t tmp = board.p_board;
387 |     g = target;
388 |     while(lower < upper) {
389 |         if(width >= max_width) {
390 |             alpha = lower;
391 |             beta = upper;
392 |         } else {
393 |           if(g == lower) {
394 |             beta = ADD_SCORE(g,+1);
395 |             alpha = ADD_SCORE(beta,-1);
396 |             alpha = ADD_SCORE(beta,width);
397 |           } else {
398 |             beta = g;
399 |             alpha = ADD_SCORE(beta,-1);
400 |             beta = ADD_SCORE(alpha,-width);
401 |           }
402 |           alpha = max(alpha,lower);
403 |           beta  = min(beta ,upper);
404 |         }
405 |         boost::shared_ptr<search_info> info{new search_info};
406 |         info->board = board;
407 |         info->depth = depth;
408 |         info->alpha = alpha;
409 |         info->beta = beta;
410 |         g = search_ab(info);
411 |         std::cout << " g=" << g << " target="<< target <<std::endl;
412 |         int excess = 0;
413 |         if (info->excess > 0) {
414 |           excess = info->excess;
415 |           int reach = excess + info->depth;
416 |           board.follow_capt = true;
417 |           std::cout << "Excess: " << excess << " Reach: " << reach << std::endl;
418 |           if(best_info == nullptr || reach > best_info->excess + best_info->depth) {
419 |             best_info = info;
420 |             best_move = move_to_make;
421 |             std::cout << "  set best info " << f << std::endl;
422 |           }
423 |         }
424 |         if(g < beta) {
425 |           upper = g;
426 |         }
427 |         if(g > alpha) {
428 |           lower = g;
429 |           if(!test_mtdf && lower >= target) {
430 |             std::cout << "First blood!" << std::endl;
431 |             break;
432 |           }
433 |         }
434 |         width += grow_width;
435 |         assert(lower <= upper);
436 |     }
437 |     if(test_mtdf && g != g2) {
438 |       std::cerr << "g=" << g << " g2=" << g2 << " lower=" << lower << " upper=" << upper << std::endl;
439 |       abort();
440 |     }
441 | 
442 |     if(best_info != nullptr) {
443 |       move_to_make = best_move;
444 |       board = best_info->board;
445 |       int excess =  best_info->excess;
446 |       std::cout << "best: " << (excess+board.depth) << std::endl;
447 |     }
448 |             
449 |     std::cout << "p_board = " << board.p_board << std::endl;
450 |     if ((g >= board.p_board && (excess+board.depth)>board.follow_depth) || !board.follow_capt) {// || score_plus>=board.p_board)
451 |       if (score_plus>=board.p_board)
452 |         std::cout<<"Greater score"<<std::endl;
453 |       if (board.side == LIGHT){
454 |         board.p_board = g;
455 |         board.follow_capt = true;
456 |         board.follow_depth = board.depth + excess;
457 |       }
458 |       if (board.side == DARK && board.follow_capt){
459 |         board.follow_capt = false;
460 |         board.follow_depth = 2;
461 |       }
462 |     }
463 |     return g;
464 | }
465 | 
466 | 
467 | 
468 | /* reps() return the number of times the current position
469 |    has been repeated. It compares the current value of hash
470 |    to previous values. */
471 | 
472 | int reps(const node_t& board)
473 | {
474 |   int i;
475 |   int r1 = 1;
476 |   int r2 = 0;
477 |   if(board.hist_dat.size()==0)
478 |     return 0;
479 |   hash_t h2 = board.hist_dat[board.hist_dat.size()-1];
480 | 
481 |   for (i = 0; i < board.hist_dat.size(); ++i) {
482 |     assert(i < board.hist_dat.size());
483 |     assert(board.hash != 0);
484 |     if (board.hist_dat[i] == board.hash)
485 |       ++r1;
486 |     if(r1 == 3) return 3;
487 |     if (board.hist_dat[i] == h2)
488 |       ++r2;
489 |     if(r2 == 3) return 3;
490 |   }
491 |   return max(r1,r2);
492 | }
493 | 
494 | 
495 | template<typename T>
496 | void mqswap(std::vector<T>& vec,int i1,int i2) {
497 |   if(i1 == i2) return;
498 |   T tmp = vec.at(i1);
499 |   vec.at(i1) = vec.at(i2);
500 |   vec.at(i2) = tmp;
501 | }
502 | 
503 | void sort_pv(std::vector<chess_move>& workq, int index)
504 | {
505 |   chess_move mv1,mv2;
506 |   int i1=0, i2=workq.size()-1;
507 |   // put the last 2 pv searches first
508 |   if(pv.size()>0) {
509 |     mv1 = pv[pv.size()-1].mv;
510 |     for(int i=0;i<workq.size();i++) {
511 |       if(mv1 == workq[i]) {
512 |         mqswap(workq,i,i1);
513 |         i1++;
514 |         break;
515 |       }
516 |     }
517 |   }
518 |   if(pv.size()>2) {
519 |     mv2 = pv[pv.size()-2].mv;
520 |     if(mv2 != mv1) {
521 |       for(int i=i1;i<workq.size();i++) {
522 |         if(mv2 == workq[i]) {
523 |           mqswap(workq,i,i1);
524 |           i1++;
525 |           break;
526 |         }
527 |       }
528 |     }
529 |   }
530 |   // shuffle
531 |   int n = workq.size();
532 |   while(n > 1) {
533 |     int n1 = n - 1;
534 |     int nr = rand()%(n);
535 |     mqswap(workq,n1,nr);
536 |     n = n1;
537 |   }
538 |   if(index < 2) {
539 |     // put captures last
540 |     while(i1 < i2) {
541 |       if(!workq[i1].getCapture())
542 |         i1++;
543 |       else if(workq[i2].getCapture())
544 |         i2--;
545 |       else
546 |         mqswap(workq,i1,i2);
547 |     }
548 |   } else {
549 |       // put captures first
550 |       while(i1 < i2) {
551 |         if(workq[i1].getCapture())
552 |           i1++;
553 |         else if(!workq[i2].getCapture())
554 |           i2--;
555 |         else
556 |           mqswap(workq,i1,i2);
557 |       }
558 |     }
559 |   }
560 | 
561 | inline int iabs(int n) {
562 |   if(n < 0)
563 |     return -n;
564 |   else
565 |     return n;
566 | }
567 | 
568 | zkey_t transposition_table[table_size];
569 | 
570 | bool get_transposition_value(const node_t& board,score_t& lower,score_t& upper) {
571 |     bool gotten = false;
572 | #ifdef TRANSPOSE_ON
573 |     int side = board.side == LIGHT ? 1 : 0;
574 |     int n = iabs((((board.hash << 4) ^ board.depth) << 1) | side) % table_size;
575 |     zkey_t *z = &transposition_table[n];
576 |     ScopedLock s(z->mut);
577 |     if(board_equals(board,z->board)) {
578 |         lower = z->lower;
579 |         upper = z->upper;
580 |         gotten = true;
581 |     } else {
582 |         lower = bad_min_score;
583 |         upper = bad_max_score;
584 |     }
585 | #endif
586 |     return gotten;
587 | }
588 | 
589 | void set_transposition_value(const node_t& board,score_t lower,score_t upper) {
590 | #ifdef TRANSPOSE_ON
591 |     assert(lower <= upper);
592 |     int side = board.side == LIGHT ? 1 : 0;
593 |     int n = iabs((((board.hash << 4) ^ board.depth) << 1) | side) % table_size;
594 |     zkey_t *z = &transposition_table[n];
595 |     ScopedLock s(z->mut);
596 |     z->board = board;
597 |     z->lower = lower;
598 |     z->upper = upper;
599 |     z->depth = board.depth;
600 | #endif
601 | }
602 | 


--------------------------------------------------------------------------------