From: Steinar H. Gunderson <sgunderson@bigfoot.com>
Date: Mon, 3 Aug 2020 10:27:33 +0000 (+0200)
Subject: Merge remote-tracking branch 'upstream/master' into HEAD
X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=a24f28be8567c2527b154ef981090368a2bd8f76

Merge remote-tracking branch 'upstream/master' into HEAD
---

a24f28be8567c2527b154ef981090368a2bd8f76
diff --cc src/Makefile
index 06c95faf,c3660a20..9b10a195
--- a/src/Makefile
+++ b/src/Makefile
@@@ -35,12 -35,14 +35,17 @@@ BINDIR = $(PREFIX)/bi
  ### Built-in benchmark for pgo-builds
  PGOBENCH = ./$(EXE) bench
  
- ### Object files
- OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \
- 	material.o misc.o movegen.o movepick.o pawns.o position.o psqt.o \
- 	search.o thread.o timeman.o tt.o uci.o ucioption.o syzygy/tbprobe.o \
- 	hashprobe.grpc.pb.o hashprobe.pb.o
- CLIOBJS = client.o hashprobe.grpc.pb.o hashprobe.pb.o uci.o
+ ### Source and object files
+ SRCS = benchmark.cpp bitbase.cpp bitboard.cpp endgame.cpp evaluate.cpp main.cpp \
+ 	material.cpp misc.cpp movegen.cpp movepick.cpp pawns.cpp position.cpp psqt.cpp \
 -	search.cpp thread.cpp timeman.cpp tt.cpp uci.cpp ucioption.cpp tune.cpp syzygy/tbprobe.cpp
++	search.cpp thread.cpp timeman.cpp tt.cpp uci.cpp ucioption.cpp tune.cpp syzygy/tbprobe.cpp \
++	hashprobe.grpc.pb.cc hashprobe.pb.cc
++CLISRCS = client.cpp hashprobe.grpc.pb.cc hashprobe.pb.cc uci.cpp
+ 
+ OBJS = $(notdir $(SRCS:.cpp=.o))
++CLIOBJS = $(notdir $(CLISRCS:.cpp=.o))
+ 
+ VPATH = syzygy
  
  ### Establish the operating system name
  KERNEL = $(shell uname -s)
@@@ -160,9 -165,9 +168,9 @@@ endi
  ifeq ($(COMP),gcc)
  	comp=gcc
  	CXX=g++
 -	CXXFLAGS += -pedantic -Wextra -Wshadow
 +	CXXFLAGS += -pedantic -Wextra
  
- 	ifeq ($(ARCH),armv7)
+ 	ifeq ($(ARCH),$(filter $(ARCH),armv7 armv8))
  		ifeq ($(OS),Android)
  			CXXFLAGS += -m$(bits)
  			LDFLAGS += -m$(bits)
@@@ -459,10 -467,10 +470,10 @@@ default
  	help
  
  ### ==========================================================================
- ### Section 5. Private targets
+ ### Section 5. Private Targets
  ### ==========================================================================
  
 -all: $(EXE) .depend
 +all: $(EXE) client .depend
  
  config-sanity:
  	@echo ""
@@@ -537,34 -546,7 +549,33 @@@ icc-profile-use
  	EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
  	all
  
 +### GRPC
 +
 +PROTOS_PATH = .
 +PROTOC = protoc
 +GRPC_CPP_PLUGIN = grpc_cpp_plugin
 +GRPC_CPP_PLUGIN_PATH ?= `which $(GRPC_CPP_PLUGIN)`
 +
 +%.grpc.pb.h %.grpc.pb.cc: %.proto
 +	$(PROTOC) -I $(PROTOS_PATH) --grpc_out=. --plugin=protoc-gen-grpc=$(GRPC_CPP_PLUGIN_PATH) $<
 +
 +# oh my
 +%.cpp: %.cc
 +	cp $< $@
 +
 +%.pb.h %.pb.cc: %.proto
 +	$(PROTOC) -I $(PROTOS_PATH) --cpp_out=. $<
 +
 +#LDFLAGS += -Wl,-Bstatic -Wl,-\( -lprotobuf -lgrpc++_unsecure -lgrpc_unsecure -lgrpc -lz -Wl,-\) -Wl,-Bdynamic -ldl
 +LDFLAGS += /usr/lib/x86_64-linux-gnu/libprotobuf.a /usr/lib/x86_64-linux-gnu/libgrpc++_unsecure.a /usr/lib/x86_64-linux-gnu/libgrpc_unsecure.a /usr/lib/x86_64-linux-gnu/libgrpc.a /usr/lib/x86_64-linux-gnu/libcares.a -ldl -lz
 +#LDFLAGS += /usr/lib/x86_64-linux-gnu/libprotobuf.a /usr/lib/libgrpc++_unsecure.a /usr/lib/libgrpc_unsecure.a /usr/lib/libgrpc.a /usr/lib/x86_64-linux-gnu/libcares.a -ldl -lz
 +
 +client: $(CLIOBJS)
 +	$(CXX) -o $@ $(CLIOBJS) $(LDFLAGS)
 +
 +# Other stuff
 +
  .depend:
- 	-@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) $(OBJS:.o=.cc) > $@ 2> /dev/null
+ 	-@$(CXX) $(DEPENDFLAGS) -MM $(SRCS) > $@ 2> /dev/null
  
  -include .depend
- 
diff --cc src/main.cpp
index dc8487e9,fafefee2..98cbfc97
--- a/src/main.cpp
+++ b/src/main.cpp
@@@ -18,211 -18,17 +18,211 @@@
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
  
 +#include <deque>
  #include <iostream>
 +#include <stack>
 +#include <thread>
  
  #include "bitboard.h"
+ #include "endgame.h"
  #include "position.h"
  #include "search.h"
  #include "thread.h"
  #include "tt.h"
  #include "uci.h"
- #include "endgame.h"
  #include "syzygy/tbprobe.h"
  
 +#include <grpc/grpc.h>
 +#include <grpc++/server.h>
 +#include <grpc++/server_builder.h>
 +#include "hashprobe.h"
 +#include "hashprobe.grpc.pb.h"
 +#include "tt.h"
 +
 +using grpc::Server;
 +using grpc::ServerBuilder;
 +using grpc::ServerContext;
 +using grpc::Status;
 +using grpc::StatusCode;
 +using namespace hashprobe;
 +
 +Status HashProbeImpl::Probe(ServerContext* context,
 +                            const HashProbeRequest* request,
 +			    HashProbeResponse *response) {
 +	Position pos;
 +	StateInfo st;
 +	pos.set(request->fen(), /*isChess960=*/false, &st, Threads.main());
 +	if (!pos.pos_is_ok()) {
 +		return Status(StatusCode::INVALID_ARGUMENT, "Invalid FEN");
 +	}
 +
 +	bool invert = (pos.side_to_move() == BLACK);
 +	StateListPtr setup_states = StateListPtr(new std::deque<StateInfo>(1));
 +
 +	ProbeMove(&pos, setup_states.get(), invert, response->mutable_root());
 +
 +	MoveList<LEGAL> moves(pos);
 +	for (const ExtMove* em = moves.begin(); em != moves.end(); ++em) {
 +		HashProbeLine *line = response->add_line();
 +		FillMove(&pos, em->move, line->mutable_move());
 +		setup_states->push_back(StateInfo());
 +		pos.do_move(em->move, setup_states->back());
 +		ProbeMove(&pos, setup_states.get(), !invert, line);
 +		pos.undo_move(em->move);
 +	}
 +
 +	return Status::OK;
 +}
 +
 +void HashProbeImpl::FillMove(Position *pos, Move move, HashProbeMove* decoded) {
 +	if (!is_ok(move)) return;
 +
 +	Square from = from_sq(move);
 +	Square to = to_sq(move);
 +
 +	if (type_of(move) == CASTLING) {
 +		to = make_square(to > from ? FILE_G : FILE_C, rank_of(from));
 +	}
 +
 +	Piece moved_piece = pos->moved_piece(move);
 +	std::string pretty;
 +	if (type_of(move) == CASTLING) {
 +		if (to > from) {
 +			pretty = "O-O";
 +		} else {
 +			pretty = "O-O-O";
 +		}
 +	} else if (type_of(moved_piece) == PAWN) {
 +		if (type_of(move) == ENPASSANT || pos->piece_on(to) != NO_PIECE) {
 +			// Capture.
 +			pretty = char('a' + file_of(from));
 +			pretty += "x";
 +		}
 +		pretty += UCI::square(to);
 +		if (type_of(move) == PROMOTION) {
 +			pretty += "=";
 +			pretty += " PNBRQK"[promotion_type(move)];
 +		}
 +	} else {
 +		pretty = " PNBRQK"[type_of(moved_piece)];
 +		Bitboard attackers = pos->attackers_to(to) & pos->pieces(color_of(moved_piece), type_of(moved_piece));
 +		if (more_than_one(attackers)) {
 +			// Remove all illegal moves to disambiguate.
 +			Bitboard att_copy = attackers;
 +			while (att_copy) {
 +				Square s = pop_lsb(&att_copy);
 +				Move m = make_move(s, to);
 +				if (!pos->pseudo_legal(m) || !pos->legal(m)) {
 +					attackers &= ~SquareBB[s];
 +				}
 +			}
 +		}
 +		if (more_than_one(attackers)) {
 +			// Disambiguate by file if possible.
 +			Bitboard attackers_this_file = attackers & file_bb(file_of(from));
 +			if (attackers != attackers_this_file) {
 +				pretty += char('a' + file_of(from));
 +				attackers = attackers_this_file;
 +			}
 +			if (more_than_one(attackers)) {
 +				// Still ambiguous, so need to disambiguate by rank.
 +				pretty += char('1' + rank_of(from));
 +			}
 +		}
 +
 +		if (type_of(move) == ENPASSANT || pos->piece_on(to) != NO_PIECE) {
 +			pretty += "x";
 +		}
 +
 +		pretty += UCI::square(to);
 +	}
 +
 +	if (pos->gives_check(move)) {
 +		// Check if mate.
 +		StateInfo si;
 +		pos->do_move(move, si, true);
 +		if (MoveList<LEGAL>(*pos).size() > 0) {
 +			pretty += "+";
 +		} else {
 +			pretty += "#";
 +		}
 +		pos->undo_move(move);
 +	}
 +
 +	decoded->set_pretty(pretty);
 +}
 +
 +void HashProbeImpl::ProbeMove(Position* pos, std::deque<StateInfo>* setup_states, bool invert, HashProbeLine* response) {
 +	bool found;
 +	TTEntry *entry = TT.probe(pos->key(), found);
 +	response->set_found(found);
 +	if (found) {
 +		Value value = entry->value();
 +		Value eval = entry->eval();
 +		Bound bound = entry->bound();
 +
 +		if (invert) {
 +			value = -value;
 +			eval = -eval;
 +			if (bound == BOUND_UPPER) {
 +				bound = BOUND_LOWER;
 +			} else if (bound == BOUND_LOWER) {
 +				bound = BOUND_UPPER;
 +			}
 +		}
 +
 +		response->set_depth(entry->depth());
 +		FillValue(eval, response->mutable_eval());
 +		if (entry->depth() > DEPTH_NONE) {
 +			FillValue(value, response->mutable_value());
 +		}
 +		response->set_bound(HashProbeLine::ValueBound(bound));
 +
 +		// Follow the PV until we hit an illegal move.
 +		std::stack<Move> pv;
 +		std::set<Key> seen;
 +		while (found && is_ok(entry->move()) &&
 +		       pos->pseudo_legal(entry->move()) &&
 +		       pos->legal(entry->move())) {
 +			FillMove(pos, entry->move(), response->add_pv());
 +			if (seen.count(pos->key())) break;
 +			pv.push(entry->move());
 +			seen.insert(pos->key());
 +			setup_states->push_back(StateInfo());
 +			pos->do_move(entry->move(), setup_states->back());
 +			entry = TT.probe(pos->key(), found);
 +		}
 +
 +		// Unroll the PV back again, so the Position object remains unchanged.
 +		while (!pv.empty()) {
 +			pos->undo_move(pv.top());
 +			pv.pop();
 +		}
 +	}
 +}
 +
 +void HashProbeImpl::FillValue(Value value, HashProbeScore* score) {
 +	if (abs(value) < VALUE_MATE - MAX_PLY) {
 +		score->set_score_type(HashProbeScore::SCORE_CP);
 +		score->set_score_cp(value * 100 / PawnValueEg);
 +	} else {
 +		score->set_score_type(HashProbeScore::SCORE_MATE);
 +		score->set_score_mate((value > 0 ? VALUE_MATE - value + 1 : -VALUE_MATE - value) / 2);
 +	}
 +}
 +
 +HashProbeThread::HashProbeThread(const std::string &server_address) {
 +	builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
 +	builder.RegisterService(&service);
 +	server = std::move(builder.BuildAndStart());
 +	std::cout << "Server listening on " << server_address << std::endl;
 +	std::thread([this]{ server->Wait(); }).detach();
 +}
 +
 +void HashProbeThread::Shutdown() {
 +	server->Shutdown();
 +}
 +
  namespace PSQT {
    void init();
  }
diff --cc src/ucioption.cpp
index 78e3d465,ef54ef4e..5982f26a
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@@ -40,17 -38,11 +40,17 @@@ namespace UCI 
  
  /// 'On change' actions, triggered by an option's value change
  void on_clear_hash(const Option&) { Search::clear(); }
- void on_hash_size(const Option& o) { TT.resize(o); }
+ void on_hash_size(const Option& o) { TT.resize(size_t(o)); }
  void on_logger(const Option& o) { start_logger(o); }
- void on_threads(const Option& o) { Threads.set(o); }
+ void on_threads(const Option& o) { Threads.set(size_t(o)); }
  void on_tb_path(const Option& o) { Tablebases::init(o); }
 -
 +void on_rpc_server_address(const Option& o) {
 +	if (hash_probe_thread) {
 +		hash_probe_thread->Shutdown();
 +	}
 +	std::string addr = o;
 +	hash_probe_thread.reset(new HashProbeThread(addr));
 +}
  
  /// Our case insensitive less() function as required by UCI protocol
  bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const {