From: Steinar H. Gunderson <sgunderson@bigfoot.com>
Date: Sun, 9 Apr 2023 09:25:35 +0000 (+0200)
Subject: Merge remote-tracking branch 'upstream/master'
X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=b8499fa7a5bb7ecb71f004bff92eda04b2e21924

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

b8499fa7a5bb7ecb71f004bff92eda04b2e21924
diff --cc src/Makefile
index 171f966c,abcf11b0..e55d52e0
--- a/src/Makefile
+++ b/src/Makefile
@@@ -369,7 -378,7 +381,7 @@@ endi
  ifeq ($(COMP),gcc)
  	comp=gcc
  	CXX=g++
- 	CXXFLAGS += -pedantic -Wextra
 -	CXXFLAGS += -pedantic -Wextra -Wshadow -Wmissing-declarations
++	CXXFLAGS += -pedantic -Wextra -Wmissing-declarations
  
  	ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
  		ifeq ($(OS),Android)
@@@ -998,43 -1022,19 +1025,45 @@@ gcc-profile-use
  	EXTRALDFLAGS='-lgcov' \
  	all
  
- icc-profile-make:
- 	@mkdir -p profdir
+ icx-profile-make:
  	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
- 	EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \
+ 	EXTRACXXFLAGS='-fprofile-instr-generate ' \
+ 	EXTRALDFLAGS=' -fprofile-instr-generate' \
  	all
  
- icc-profile-use:
+ icx-profile-use:
+ 	$(XCRUN) llvm-profdata merge -output=stockfish.profdata *.profraw
  	$(MAKE) ARCH=$(ARCH) COMP=$(COMP) \
- 	EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \
+ 	EXTRACXXFLAGS='-fprofile-instr-use=stockfish.profdata' \
+ 	EXTRALDFLAGS='-fprofile-use ' \
  	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 /usr/lib/x86_64-linux-gnu/libgpr.a /usr/lib/x86_64-linux-gnu/libabsl_str_format_internal.a /usr/lib/x86_64-linux-gnu/libabsl_strings.a /usr/lib/x86_64-linux-gnu/libabsl_flags_marshalling.a /usr/lib/x86_64-linux-gnu/libabsl_throw_delegate.a /usr/lib/x86_64-linux-gnu/libabsl_raw_logging_internal.a /usr/lib/x86_64-linux-gnu/libabsl_base.a /usr/lib/x86_64-linux-gnu/libabsl_int128.a /usr/lib/x86_64-linux-gnu/libabsl_bad_optional_access.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: $(SRCS)
  	-@$(CXX) $(DEPENDFLAGS) -MM $(SRCS) > $@ 2> /dev/null
  
diff --cc src/main.cpp
index 435e436c,c40e0fa3..557c8c27
--- a/src/main.cpp
+++ b/src/main.cpp
@@@ -31,203 -28,8 +31,203 @@@
  #include "tt.h"
  #include "uci.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;
  using namespace Stockfish;
  
 +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) == EN_PASSANT || 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];
++					attackers &= ~square_bb(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) == EN_PASSANT || 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) {
 +		TTEntry entry_copy = *entry;
 +		Value value = entry_copy.value();
 +		Value eval = entry_copy.eval();
 +		Bound bound = entry_copy.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_copy.depth());
 +		FillValue(eval, response->mutable_eval());
 +		if (entry_copy.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 (is_ok(entry_copy.move()) &&
 +		       pos->pseudo_legal(entry_copy.move()) &&
 +		       pos->legal(entry_copy.move())) {
 +			FillMove(pos, entry_copy.move(), response->add_pv());
 +			if (seen.count(pos->key())) break;
 +			pv.push(entry_copy.move());
 +			seen.insert(pos->key());
 +			setup_states->push_back(StateInfo());
 +			pos->do_move(entry_copy.move(), setup_states->back());
 +			entry = TT.probe(pos->key(), found);
 +			if (!found) {
 +				break;
 +			}
 +			entry_copy = *entry;
 +		}
 +
 +		// 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();
 +}
 +
  int main(int argc, char* argv[]) {
  
    std::cout << engine_info() << std::endl;
diff --cc src/position.cpp
index e0d432e8,e6fdb511..3cfc23d3
--- a/src/position.cpp
+++ b/src/position.cpp
@@@ -281,8 -282,10 +282,8 @@@ Position& Position::set(const string& f
  
    chess960 = isChess960;
    thisThread = th;
-   set_state(st);
+   set_state();
  
 -  assert(pos_is_ok());
 -
    return *this;
  }
  
diff --cc src/ucioption.cpp
index 8dd10a48,39933ea5..ee84e253
--- a/src/ucioption.cpp
+++ b/src/ucioption.cpp
@@@ -40,20 -38,13 +40,20 @@@ std::unique_ptr<HashProbeThread> hash_p
  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(size_t(o)); }
- void on_logger(const Option& o) { start_logger(o); }
- void on_threads(const Option& o) { Threads.set(size_t(o)); }
- void on_tb_path(const Option& o) { Tablebases::init(o); }
- void on_use_NNUE(const Option& ) { Eval::NNUE::init(); }
- void on_eval_file(const Option& ) { Eval::NNUE::init(); }
- void on_rpc_server_address(const Option& o) {
+ static void on_clear_hash(const Option&) { Search::clear(); }
+ static void on_hash_size(const Option& o) { TT.resize(size_t(o)); }
+ static void on_logger(const Option& o) { start_logger(o); }
+ static void on_threads(const Option& o) { Threads.set(size_t(o)); }
+ static void on_tb_path(const Option& o) { Tablebases::init(o); }
 -static void on_use_NNUE(const Option&) { Eval::NNUE::init(); }
 -static void on_eval_file(const Option&) { Eval::NNUE::init(); }
++static void on_use_NNUE(const Option& ) { Eval::NNUE::init(); }
++static void on_eval_file(const Option& ) { Eval::NNUE::init(); }
++static 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 {