### ==========================================================================
### Establish the operating system name
- KERNEL = $(shell uname -s)
+ KERNEL := $(shell uname -s)
ifeq ($(KERNEL),Linux)
- OS = $(shell uname -o)
+ OS := $(shell uname -o)
endif
### Target Windows OS
else ifeq ($(COMP),mingw)
target_windows = yes
ifeq ($(WINE_PATH),)
- WINE_PATH = $(shell which wine)
+ WINE_PATH := $(shell which wine)
endif
endif
BINDIR = $(PREFIX)/bin
### Built-in benchmark for pgo-builds
- ifeq ($(SDE_PATH),)
- PGOBENCH = $(WINE_PATH) ./$(EXE) bench
- else
- PGOBENCH = $(SDE_PATH) -- $(WINE_PATH) ./$(EXE) bench
- endif
+ PGOBENCH = $(WINE_PATH) ./$(EXE) bench
### Source and object files
SRCS = benchmark.cpp bitboard.cpp evaluate.cpp main.cpp \
- misc.cpp movegen.cpp movepick.cpp position.cpp psqt.cpp \
+ misc.cpp movegen.cpp movepick.cpp position.cpp \
search.cpp thread.cpp timeman.cpp tt.cpp uci.cpp ucioption.cpp tune.cpp syzygy/tbprobe.cpp \
- nnue/evaluate_nnue.cpp nnue/features/half_ka_v2_hm.cpp
+ nnue/evaluate_nnue.cpp nnue/features/half_ka_v2_hm.cpp \
+ hashprobe.grpc.pb.cc hashprobe.pb.cc
+CLISRCS = client.cpp hashprobe.grpc.pb.cc hashprobe.pb.cc uci.cpp
+ HEADERS = benchmark.h bitboard.h evaluate.h misc.h movegen.h movepick.h \
+ nnue/evaluate_nnue.h nnue/features/half_ka_v2_hm.h nnue/layers/affine_transform.h \
+ nnue/layers/affine_transform_sparse_input.h nnue/layers/clipped_relu.h nnue/layers/simd.h \
+ nnue/layers/sqr_clipped_relu.h nnue/nnue_accumulator.h nnue/nnue_architecture.h \
+ nnue/nnue_common.h nnue/nnue_feature_transformer.h position.h \
+ search.h syzygy/tbprobe.h thread.h thread_win32_osx.h timeman.h \
+ tt.h tune.h types.h uci.h
+
OBJS = $(notdir $(SRCS:.cpp=.o))
+CLIOBJS = $(notdir $(CLISRCS:.cpp=.o))
VPATH = syzygy:nnue:nnue/features
### 2.1. General and architecture defaults
ifeq ($(ARCH),)
- ARCH = x86-64-modern
- help_skip_sanity = yes
+ ARCH = native
endif
+
+ ifeq ($(ARCH), native)
+ override ARCH := $(shell $(SHELL) ../scripts/get_native_properties.sh | cut -d " " -f 1)
+ endif
+
# explicitly check for the list of supported architectures (as listed with make help),
# the user can override with `make ARCH=x86-32-vnni256 SUPPORTED_ARCH=true`
ifeq ($(ARCH), $(filter $(ARCH), \
x86-64-vnni512 x86-64-vnni256 x86-64-avx512 x86-64-avxvnni x86-64-bmi2 \
x86-64-avx2 x86-64-sse41-popcnt x86-64-modern x86-64-ssse3 x86-64-sse3-popcnt \
x86-64 x86-32-sse41-popcnt x86-32-sse2 x86-32 ppc-64 ppc-32 e2k \
- armv7 armv7-neon armv8 armv8-dotprod apple-silicon general-64 general-32 riscv64))
+ armv7 armv7-neon armv8 armv8-dotprod apple-silicon general-64 general-32 riscv64 loongarch64))
SUPPORTED_ARCH=true
else
SUPPORTED_ARCH=false
arm_version = 0
STRIP = strip
+ ifneq ($(shell which clang-format-17 2> /dev/null),)
+ CLANG-FORMAT = clang-format-17
+ else
+ CLANG-FORMAT = clang-format
+ endif
+
### 2.2 Architecture specific
ifeq ($(findstring x86,$(ARCH)),x86)
endif
ifeq ($(findstring -modern,$(ARCH)),-modern)
+ $(warning *** ARCH=$(ARCH) is deprecated, defaulting to ARCH=x86-64-sse41-popcnt. Execute `make help` for a list of available architectures. ***)
+ $(shell sleep 5)
popcnt = yes
sse = yes
sse2 = yes
ifeq ($(ARCH),riscv64)
arch = riscv64
endif
+
+ ifeq ($(ARCH),loongarch64)
+ arch = loongarch64
+ endif
endif
ifeq ($(COMP),gcc)
comp=gcc
CXX=g++
- CXXFLAGS += -pedantic -Wextra -Wshadow -Wmissing-declarations
+ CXXFLAGS += -pedantic -Wextra -Wmissing-declarations
ifeq ($(arch),$(filter $(arch),armv7 armv8 riscv64))
ifeq ($(OS),Android)
ifeq ($(ARCH),riscv64)
CXXFLAGS += -latomic
endif
+ else ifeq ($(ARCH),loongarch64)
+ CXXFLAGS += -latomic
else
CXXFLAGS += -m$(bits)
LDFLAGS += -m$(bits)
ifeq ($(ARCH),riscv64)
CXXFLAGS += -latomic
endif
+ else ifeq ($(ARCH),loongarch64)
+ CXXFLAGS += -latomic
else
CXXFLAGS += -m$(bits)
LDFLAGS += -m$(bits)
### Sometimes gcc is really clang
ifeq ($(COMP),gcc)
- gccversion = $(shell $(CXX) --version 2>/dev/null)
- gccisclang = $(findstring clang,$(gccversion))
+ gccversion := $(shell $(CXX) --version 2>/dev/null)
+ gccisclang := $(findstring clang,$(gccversion))
ifneq ($(gccisclang),)
profile_make = clang-profile-make
profile_use = clang-profile-use
### 3.3 Optimization
ifeq ($(optimize),yes)
- CXXFLAGS += -O3 -g
- CXXFLAGS += -O3 -funroll-loops
++ CXXFLAGS += -O3 -g -funroll-loops
ifeq ($(comp),gcc)
ifeq ($(OS), Android)
endif
ifeq ($(comp),clang)
- clangmajorversion = $(shell $(CXX) -dumpversion 2>/dev/null | cut -f1 -d.)
+ clangmajorversion := $(shell $(CXX) -dumpversion 2>/dev/null | cut -f1 -d.)
ifeq ($(shell expr $(clangmajorversion) \< 16),1)
CXXFLAGS += -fexperimental-new-pass-manager
endif
endif
ifeq ($(mmx),yes)
- CXXFLAGS += -DUSE_MMX
ifeq ($(comp),$(filter $(comp),gcc clang mingw icx))
CXXFLAGS += -mmmx
endif
endif
endif
- ### 3.7.1 Try to include git commit sha for versioning
- GIT_SHA = $(shell git rev-parse HEAD 2>/dev/null | cut -c 1-8)
+ ### 3.8.1 Try to include git commit sha for versioning
+ GIT_SHA := $(shell git rev-parse HEAD 2>/dev/null | cut -c 1-8)
ifneq ($(GIT_SHA), )
CXXFLAGS += -DGIT_SHA=$(GIT_SHA)
endif
- ### 3.7.2 Try to include git commit date for versioning
- GIT_DATE = $(shell git show -s --date=format:'%Y%m%d' --format=%cd HEAD 2>/dev/null)
+ ### 3.8.2 Try to include git commit date for versioning
+ GIT_DATE := $(shell git show -s --date=format:'%Y%m%d' --format=%cd HEAD 2>/dev/null)
ifneq ($(GIT_DATE), )
CXXFLAGS += -DGIT_DATE=$(GIT_DATE)
endif
- ### 3.8 Link Time Optimization
+ ### 3.8.3 Try to include architecture
+ ifneq ($(ARCH), )
+ CXXFLAGS += -DARCH=$(ARCH)
+ endif
+
+ ### 3.9 Link Time Optimization
### This is a mix of compile and link time options because the lto link phase
### needs access to the optimization flags.
ifeq ($(optimize),yes)
endif
endif
- ### 3.9 Android 5 can only run position independent executables. Note that this
+ ### 3.10 Android 5 can only run position independent executables. Note that this
### breaks Android 4.0 and earlier.
ifeq ($(OS), Android)
CXXFLAGS += -fPIE
### Section 4. Public Targets
### ==========================================================================
-
help:
@echo ""
@echo "To compile stockfish, type: "
@echo ""
- @echo "make target ARCH=arch [COMP=compiler] [COMPCXX=cxx]"
+ @echo "make -j target [ARCH=arch] [COMP=compiler] [COMPCXX=cxx]"
@echo ""
@echo "Supported targets:"
@echo ""
@echo ""
@echo "Supported archs:"
@echo ""
+ @echo "native > select the best architecture for the host processor (default)"
@echo "x86-64-vnni512 > x86 64-bit with vnni 512bit support"
@echo "x86-64-vnni256 > x86 64-bit with vnni 512bit support, limit operands to 256bit wide"
@echo "x86-64-avx512 > x86 64-bit with avx512 support"
@echo "x86-64-bmi2 > x86 64-bit with bmi2 support"
@echo "x86-64-avx2 > x86 64-bit with avx2 support"
@echo "x86-64-sse41-popcnt > x86 64-bit with sse41 and popcnt support"
- @echo "x86-64-modern > common modern CPU, currently x86-64-sse41-popcnt"
+ @echo "x86-64-modern > deprecated, currently x86-64-sse41-popcnt"
@echo "x86-64-ssse3 > x86 64-bit with ssse3 support"
- @echo "x86-64-sse3-popcnt > x86 64-bit with sse3 and popcnt support"
+ @echo "x86-64-sse3-popcnt > x86 64-bit with sse3 compile and popcnt support"
@echo "x86-64 > x86 64-bit generic (with sse2 support)"
@echo "x86-32-sse41-popcnt > x86 32-bit with sse41 and popcnt support"
@echo "x86-32-sse2 > x86 32-bit with sse2 support"
- @echo "x86-32 > x86 32-bit generic (with mmx and sse support)"
+ @echo "x86-32 > x86 32-bit generic (with mmx compile support)"
@echo "ppc-64 > PPC 64-bit"
@echo "ppc-32 > PPC 32-bit"
@echo "armv7 > ARMv7 32-bit"
@echo "general-64 > unspecified 64-bit"
@echo "general-32 > unspecified 32-bit"
@echo "riscv64 > RISC-V 64-bit"
+ @echo "loongarch64 > LoongArch 64-bit"
@echo ""
@echo "Supported compilers:"
@echo ""
- @echo "gcc > Gnu compiler (default)"
- @echo "mingw > Gnu compiler with MinGW under Windows"
+ @echo "gcc > GNU compiler (default)"
+ @echo "mingw > GNU compiler with MinGW under Windows"
@echo "clang > LLVM Clang compiler"
@echo "icx > Intel oneAPI DPC++/C++ Compiler"
@echo "ndk > Google NDK to cross-compile for Android"
@echo "Simple examples. If you don't know what to do, you likely want to run one of: "
@echo ""
@echo "make -j profile-build ARCH=x86-64-avx2 # typically a fast compile for common systems "
- @echo "make -j profile-build ARCH=x86-64-modern # A more portable compile for 64-bit systems "
+ @echo "make -j profile-build ARCH=x86-64-sse41-popcnt # A more portable compile for 64-bit systems "
@echo "make -j profile-build ARCH=x86-64 # A portable compile for 64-bit systems "
@echo ""
@echo "Advanced examples, for experienced users: "
@echo ""
- @echo "make -j profile-build ARCH=x86-64-bmi2"
- @echo "make -j profile-build ARCH=x86-64-bmi2 COMP=gcc COMPCXX=g++-9.0"
+ @echo "make -j profile-build ARCH=x86-64-avxvnni"
+ @echo "make -j profile-build ARCH=x86-64-avxvnni COMP=gcc COMPCXX=g++-12.0"
@echo "make -j build ARCH=x86-64-ssse3 COMP=clang"
@echo ""
- @echo "-------------------------------"
- ifeq ($(SUPPORTED_ARCH)$(help_skip_sanity), true)
- @echo "The selected architecture $(ARCH) will enable the following configuration: "
- @$(MAKE) ARCH=$(ARCH) COMP=$(COMP) config-sanity
- else
+ ifneq ($(SUPPORTED_ARCH), true)
@echo "Specify a supported architecture with the ARCH option for more details"
@echo ""
endif
- .PHONY: help build profile-build strip install clean net objclean profileclean \
- config-sanity \
+ .PHONY: help analyze build profile-build strip install clean net \
+ objclean profileclean config-sanity \
icx-profile-use icx-profile-make \
gcc-profile-use gcc-profile-make \
- clang-profile-use clang-profile-make FORCE
+ clang-profile-use clang-profile-make FORCE \
+ format analyze
+
+ analyze: net config-sanity objclean
+ $(MAKE) -k ARCH=$(ARCH) COMP=$(COMP) $(OBJS)
build: net config-sanity
$(MAKE) ARCH=$(ARCH) COMP=$(COMP) all
$(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make)
@echo ""
@echo "Step 2/4. Running benchmark for pgo-build ..."
- $(PGOBENCH) 2>&1 | tail -n 4
+ $(PGOBENCH) > PGOBENCH.out 2>&1
+ tail -n 4 PGOBENCH.out
@echo ""
@echo "Step 3/4. Building optimized executable ..."
$(MAKE) ARCH=$(ARCH) COMP=$(COMP) objclean
clean: objclean profileclean
@rm -f .depend *~ core
- # evaluation network (nnue)
- net:
- $(eval nnuenet := $(shell grep EvalFileDefaultName evaluate.h | grep define | sed 's/.*\(nn-[a-z0-9]\{12\}.nnue\).*/\1/'))
- @echo "Default net: $(nnuenet)"
- $(eval nnuedownloadurl1 := https://tests.stockfishchess.org/api/nn/$(nnuenet))
- $(eval nnuedownloadurl2 := https://github.com/official-stockfish/networks/raw/master/$(nnuenet))
- $(eval curl_or_wget := $(shell if hash curl 2>/dev/null; then echo "curl -skL"; elif hash wget 2>/dev/null; then echo "wget -qO-"; fi))
- @if [ "x$(curl_or_wget)" = "x" ]; then \
- echo "Neither curl nor wget is installed. Install one of these tools unless the net has been downloaded manually"; \
- fi
- $(eval shasum_command := $(shell if hash shasum 2>/dev/null; then echo "shasum -a 256 "; elif hash sha256sum 2>/dev/null; then echo "sha256sum "; fi))
- @if [ "x$(shasum_command)" = "x" ]; then \
- echo "shasum / sha256sum not found, skipping net validation"; \
- fi
- @for nnuedownloadurl in "$(nnuedownloadurl1)" "$(nnuedownloadurl2)"; do \
- if test -f "$(nnuenet)"; then \
- echo "$(nnuenet) available."; \
- else \
- if [ "x$(curl_or_wget)" != "x" ]; then \
- echo "Downloading $${nnuedownloadurl}"; $(curl_or_wget) $${nnuedownloadurl} > $(nnuenet);\
- else \
- echo "No net found and download not possible"; exit 1;\
- fi; \
- fi; \
- if [ "x$(shasum_command)" != "x" ]; then \
- if [ "$(nnuenet)" != "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
- echo "Removing failed download"; rm -f $(nnuenet); \
- else \
- echo "Network validated"; break; \
- fi; \
- fi; \
- done
- @if ! test -f "$(nnuenet)"; then \
- echo "Failed to download $(nnuenet)."; \
- fi
-
# clean binaries and objects
objclean:
@rm -f stockfish stockfish.exe *.o ./syzygy/*.o ./nnue/*.o ./nnue/features/*.o
# clean auxiliary profiling files
profileclean:
@rm -rf profdir
- @rm -f bench.txt *.gcda *.gcno ./syzygy/*.gcda ./nnue/*.gcda ./nnue/features/*.gcda *.s
+ @rm -f bench.txt *.gcda *.gcno ./syzygy/*.gcda ./nnue/*.gcda ./nnue/features/*.gcda *.s PGOBENCH.out
@rm -f stockfish.profdata *.profraw
@rm -f stockfish.*args*
@rm -f stockfish.*lt*
@rm -f stockfish.res
@rm -f ./-lstdc++.res
+ # set up shell variables for the net stuff
+ netvariables:
+ $(eval nnuenet := $(shell grep EvalFileDefaultName evaluate.h | grep define | sed 's/.*\(nn-[a-z0-9]\{12\}.nnue\).*/\1/'))
+ $(eval nnuedownloadurl1 := https://tests.stockfishchess.org/api/nn/$(nnuenet))
+ $(eval nnuedownloadurl2 := https://github.com/official-stockfish/networks/raw/master/$(nnuenet))
+ $(eval curl_or_wget := $(shell if hash curl 2>/dev/null; then echo "curl -skL"; elif hash wget 2>/dev/null; then echo "wget -qO-"; fi))
+ $(eval shasum_command := $(shell if hash shasum 2>/dev/null; then echo "shasum -a 256 "; elif hash sha256sum 2>/dev/null; then echo "sha256sum "; fi))
+
+ # evaluation network (nnue)
+ net: netvariables
+ @echo "Default net: $(nnuenet)"
+ @if [ "x$(curl_or_wget)" = "x" ]; then \
+ echo "Neither curl nor wget is installed. Install one of these tools unless the net has been downloaded manually"; \
+ fi
+ @if [ "x$(shasum_command)" = "x" ]; then \
+ echo "shasum / sha256sum not found, skipping net validation"; \
+ elif test -f "$(nnuenet)"; then \
+ if [ "$(nnuenet)" != "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
+ echo "Removing invalid network"; rm -f $(nnuenet); \
+ fi; \
+ fi;
+ @for nnuedownloadurl in "$(nnuedownloadurl1)" "$(nnuedownloadurl2)"; do \
+ if test -f "$(nnuenet)"; then \
+ echo "$(nnuenet) available : OK"; break; \
+ else \
+ if [ "x$(curl_or_wget)" != "x" ]; then \
+ echo "Downloading $${nnuedownloadurl}"; $(curl_or_wget) $${nnuedownloadurl} > $(nnuenet);\
+ else \
+ echo "No net found and download not possible"; exit 1;\
+ fi; \
+ fi; \
+ if [ "x$(shasum_command)" != "x" ]; then \
+ if [ "$(nnuenet)" != "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
+ echo "Removing failed download"; rm -f $(nnuenet); \
+ fi; \
+ fi; \
+ done
+ @if ! test -f "$(nnuenet)"; then \
+ echo "Failed to download $(nnuenet)."; \
+ fi;
+ @if [ "x$(shasum_command)" != "x" ]; then \
+ if [ "$(nnuenet)" = "nn-"`$(shasum_command) $(nnuenet) | cut -c1-12`".nnue" ]; then \
+ echo "Network validated"; break; \
+ fi; \
+ fi; \
+
+ format:
+ $(CLANG-FORMAT) -i $(SRCS) $(HEADERS) -style=file
+
+ # default target
default:
help
### Section 5. Private Targets
### ==========================================================================
-all: $(EXE) .depend
+all: $(EXE) client .depend
config-sanity: net
@echo ""
@test "$(SUPPORTED_ARCH)" = "true"
@test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \
test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "e2k" || \
- test "$(arch)" = "armv7" || test "$(arch)" = "armv8" || test "$(arch)" = "arm64" || test "$(arch)" = "riscv64"
+ test "$(arch)" = "armv7" || test "$(arch)" = "armv8" || test "$(arch)" = "arm64" || test "$(arch)" = "riscv64" || test "$(arch)" = "loongarch64"
@test "$(bits)" = "32" || test "$(bits)" = "64"
@test "$(prefetch)" = "yes" || test "$(prefetch)" = "no"
@test "$(popcnt)" = "yes" || test "$(popcnt)" = "no"
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 += -Wl,--start-group /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/libaddress_sorting.a /usr/lib/x86_64-linux-gnu/libupb.a /usr/lib/x86_64-linux-gnu/libcares.a /usr/lib/x86_64-linux-gnu/libgpr.a /usr/lib/x86_64-linux-gnu/libabsl_*.a -Wl,--end-group -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
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <deque>
+ #include <cstddef>
#include <iostream>
+#include <stack>
+#include <thread>
#include "bitboard.h"
+ #include "evaluate.h"
+ #include "misc.h"
#include "position.h"
- #include "psqt.h"
#include "search.h"
- #include "syzygy/tbprobe.h"
#include "thread.h"
- #include "tt.h"
+ #include "tune.h"
+ #include "types.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 &= ~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;
+ std::cout << engine_info() << std::endl;
- CommandLine::init(argc, argv);
- UCI::init(Options);
- Tune::init();
- PSQT::init();
- Bitboards::init();
- Position::init();
- Threads.set(size_t(Options["Threads"]));
- Search::clear(); // After threads are up
- Eval::NNUE::init();
+ CommandLine::init(argc, argv);
+ UCI::init(Options);
+ Tune::init();
+ Bitboards::init();
+ Position::init();
+ Threads.set(size_t(Options["Threads"]));
+ Search::clear(); // After threads are up
+ Eval::NNUE::init();
- UCI::loop(argc, argv);
+ UCI::loop(argc, argv);
- Threads.set(0);
- return 0;
+ Threads.set(0);
+ return 0;
}
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+ #include "misc.h"
+
#ifdef _WIN32
- #if _WIN32_WINNT < 0x0601
- #undef _WIN32_WINNT
- #define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
- #endif
+ #if _WIN32_WINNT < 0x0601
+ #undef _WIN32_WINNT
+ #define _WIN32_WINNT 0x0601 // Force to include needed API prototypes
+ #endif
- #ifndef NOMINMAX
- #define NOMINMAX
- #endif
+ #ifndef NOMINMAX
+ #define NOMINMAX
+ #endif
- #include <windows.h>
+ #include <windows.h>
// The needed Windows API for processor groups could be missed from old Windows
// versions, so instead of calling them directly (forcing the linker to resolve
// the calls at compile time), try to load them at runtime. To do this we need
// first to define the corresponding function pointers.
extern "C" {
- using fun1_t = bool(*)(LOGICAL_PROCESSOR_RELATIONSHIP,
- PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD);
- using fun2_t = bool(*)(USHORT, PGROUP_AFFINITY);
- using fun3_t = bool(*)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
- using fun4_t = bool(*)(USHORT, PGROUP_AFFINITY, USHORT, PUSHORT);
- using fun5_t = WORD(*)();
- using fun6_t = bool(*)(HANDLE, DWORD, PHANDLE);
- using fun7_t = bool(*)(LPCSTR, LPCSTR, PLUID);
- using fun8_t = bool(*)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
+ using fun1_t = bool (*)(LOGICAL_PROCESSOR_RELATIONSHIP,
+ PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX,
+ PDWORD);
+ using fun2_t = bool (*)(USHORT, PGROUP_AFFINITY);
+ using fun3_t = bool (*)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY);
+ using fun4_t = bool (*)(USHORT, PGROUP_AFFINITY, USHORT, PUSHORT);
+ using fun5_t = WORD (*)();
+ using fun6_t = bool (*)(HANDLE, DWORD, PHANDLE);
+ using fun7_t = bool (*)(LPCSTR, LPCSTR, PLUID);
+ using fun8_t = bool (*)(HANDLE, BOOL, PTOKEN_PRIVILEGES, DWORD, PTOKEN_PRIVILEGES, PDWORD);
}
#endif
+ #include <atomic>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
+ #include <mutex>
#include <sstream>
#include <string_view>
- #include <vector>
+
+ #include "types.h"
#if defined(__linux__) && !defined(__ANDROID__)
- #include <stdlib.h>
- #include <sys/mman.h>
+ #include <sys/mman.h>
#endif
- #if defined(__APPLE__) || defined(__ANDROID__) || defined(__OpenBSD__) || (defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC) && !defined(_WIN32)) || defined(__e2k__)
- #define POSIXALIGNEDALLOC
- #include <stdlib.h>
+ #if defined(__APPLE__) || defined(__ANDROID__) || defined(__OpenBSD__) \
+ || (defined(__GLIBCXX__) && !defined(_GLIBCXX_HAVE_ALIGNED_ALLOC) && !defined(_WIN32)) \
+ || defined(__e2k__)
+ #define POSIXALIGNEDALLOC
+ #include <stdlib.h>
#endif
- #include "misc.h"
- #include "thread.h"
-
- using namespace std;
-
namespace Stockfish {
namespace {
- /// Version number or dev.
- constexpr string_view version = "dev";
+ // Version number or dev.
+ constexpr std::string_view version = "dev";
- /// Our fancy logging facility. The trick here is to replace cin.rdbuf() and
- /// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
- /// can toggle the logging of std::cout and std:cin at runtime whilst preserving
- /// usual I/O functionality, all without changing a single line of code!
- /// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
+ // Our fancy logging facility. The trick here is to replace cin.rdbuf() and
+ // cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We
+ // can toggle the logging of std::cout and std:cin at runtime whilst preserving
+ // usual I/O functionality, all without changing a single line of code!
+ // Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81
- struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout
+ struct Tie: public std::streambuf { // MSVC requires split streambuf for cin and cout
- Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
+ Tie(std::streambuf* b, std::streambuf* l) :
+ buf(b),
+ logBuf(l) {}
- int sync() override { return logBuf->pubsync(), buf->pubsync(); }
- int overflow(int c) override { return log(buf->sputc((char)c), "<< "); }
- int underflow() override { return buf->sgetc(); }
- int uflow() override { return log(buf->sbumpc(), ">> "); }
+ int sync() override { return logBuf->pubsync(), buf->pubsync(); }
+ int overflow(int c) override { return log(buf->sputc(char(c)), "<< "); }
+ int underflow() override { return buf->sgetc(); }
+ int uflow() override { return log(buf->sbumpc(), ">> "); }
- streambuf *buf, *logBuf;
+ std::streambuf *buf, *logBuf;
- int log(int c, const char* prefix) {
+ int log(int c, const char* prefix) {
- static int last = '\n'; // Single log file
+ static int last = '\n'; // Single log file
- if (last == '\n')
- logBuf->sputn(prefix, 3);
+ if (last == '\n')
+ logBuf->sputn(prefix, 3);
- return last = logBuf->sputc((char)c);
- }
+ return last = logBuf->sputc(char(c));
+ }
};
class Logger {
- Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
- ~Logger() { start(""); }
+ Logger() :
+ in(std::cin.rdbuf(), file.rdbuf()),
+ out(std::cout.rdbuf(), file.rdbuf()) {}
+ ~Logger() { start(""); }
- ofstream file;
- Tie in, out;
+ std::ofstream file;
+ Tie in, out;
- public:
- static void start(const std::string& fname) {
-
- static Logger l;
-
- if (l.file.is_open())
- {
- cout.rdbuf(l.out.buf);
- cin.rdbuf(l.in.buf);
- l.file.close();
- }
+ public:
+ static void start(const std::string& fname) {
- if (!fname.empty())
- {
- l.file.open(fname, ifstream::out);
+ static Logger l;
- if (!l.file.is_open())
+ if (l.file.is_open())
{
- cerr << "Unable to open debug log file " << fname << endl;
- exit(EXIT_FAILURE);
+ std::cout.rdbuf(l.out.buf);
+ std::cin.rdbuf(l.in.buf);
+ l.file.close();
}
- cin.rdbuf(&l.in);
- cout.rdbuf(&l.out);
+ if (!fname.empty())
+ {
+ l.file.open(fname, std::ifstream::out);
+
+ if (!l.file.is_open())
+ {
+ std::cerr << "Unable to open debug log file " << fname << std::endl;
+ exit(EXIT_FAILURE);
+ }
+
+ std::cin.rdbuf(&l.in);
+ std::cout.rdbuf(&l.out);
+ }
}
- }
};
- } // namespace
-
+ } // namespace
- /// engine_info() returns the full name of the current Stockfish version.
- /// For local dev compiles we try to append the commit sha and commit date
- /// from git if that fails only the local compilation date is set and "nogit" is specified:
- /// Stockfish dev-YYYYMMDD-SHA
- /// or
- /// Stockfish dev-YYYYMMDD-nogit
- ///
- /// For releases (non dev builds) we only include the version number:
- /// Stockfish version
- string engine_info(bool to_uci) {
- stringstream ss;
- ss << "Stockfish " << version << setfill('0');
+ // Returns the full name of the current Stockfish version.
+ // For local dev compiles we try to append the commit sha and commit date
+ // from git if that fails only the local compilation date is set and "nogit" is specified:
+ // Stockfish dev-YYYYMMDD-SHA
+ // or
+ // Stockfish dev-YYYYMMDD-nogit
+ //
+ // For releases (non-dev builds) we only include the version number:
+ // Stockfish version
+ std::string engine_info(bool to_uci) {
+ std::stringstream ss;
+ ss << "Stockfish " << version << std::setfill('0');
+
+ if constexpr (version == "dev")
+ {
+ ss << "-";
+ #ifdef GIT_DATE
+ ss << stringify(GIT_DATE);
+ #else
+ constexpr std::string_view months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
+ std::string month, day, year;
+ std::stringstream date(__DATE__); // From compiler, format is "Sep 21 2008"
- if constexpr (version == "dev")
- {
- ss << "-";
- #ifdef GIT_DATE
- ss << stringify(GIT_DATE);
- #else
- constexpr string_view months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec");
- string month, day, year;
- stringstream date(__DATE__); // From compiler, format is "Sep 21 2008"
+ date >> month >> day >> year;
+ ss << year << std::setw(2) << std::setfill('0') << (1 + months.find(month) / 4)
+ << std::setw(2) << std::setfill('0') << day;
+ #endif
- date >> month >> day >> year;
- ss << year << setw(2) << setfill('0') << (1 + months.find(month) / 4) << setw(2) << setfill('0') << day;
- #endif
+ ss << "-";
- ss << "-asn";
- }
+ #ifdef GIT_SHA
+ ss << stringify(GIT_SHA);
+ #else
+ ss << "nogit";
+ #endif
++ ss << "-asn";
+ }
- ss << (to_uci ? "\nid author ": " by ")
- << "the Stockfish developers (see AUTHORS file)";
+ ss << (to_uci ? "\nid author " : " by ") << "the Stockfish developers (see AUTHORS file)";
- return ss.str();
+ return ss.str();
}
- /// compiler_info() returns a string trying to describe the compiler we use
-
+ // Returns a string trying to describe the compiler we use
std::string compiler_info() {
- #define make_version_string(major, minor, patch) stringify(major) "." stringify(minor) "." stringify(patch)
-
- /// Predefined macros hell:
- ///
- /// __GNUC__ Compiler is gcc, Clang or Intel on Linux
- /// __INTEL_COMPILER Compiler is Intel
- /// _MSC_VER Compiler is MSVC or Intel on Windows
- /// _WIN32 Building on Windows (any)
- /// _WIN64 Building on Windows 64 bit
-
- std::string compiler = "\nCompiled by ";
-
- #ifdef __clang__
- compiler += "clang++ ";
- compiler += make_version_string(__clang_major__, __clang_minor__, __clang_patchlevel__);
- #elif __INTEL_COMPILER
- compiler += "Intel compiler ";
- compiler += "(version ";
- compiler += stringify(__INTEL_COMPILER) " update " stringify(__INTEL_COMPILER_UPDATE);
- compiler += ")";
- #elif _MSC_VER
- compiler += "MSVC ";
- compiler += "(version ";
- compiler += stringify(_MSC_FULL_VER) "." stringify(_MSC_BUILD);
- compiler += ")";
- #elif defined(__e2k__) && defined(__LCC__)
+ #define make_version_string(major, minor, patch) \
+ stringify(major) "." stringify(minor) "." stringify(patch)
+
+ // Predefined macros hell:
+ //
+ // __GNUC__ Compiler is GCC, Clang or ICX
+ // __clang__ Compiler is Clang or ICX
+ // __INTEL_LLVM_COMPILER Compiler is ICX
+ // _MSC_VER Compiler is MSVC
+ // _WIN32 Building on Windows (any)
+ // _WIN64 Building on Windows 64 bit
+
+ std::string compiler = "\nCompiled by : ";
+
+ #if defined(__INTEL_LLVM_COMPILER)
+ compiler += "ICX ";
+ compiler += stringify(__INTEL_LLVM_COMPILER);
+ #elif defined(__clang__)
+ compiler += "clang++ ";
+ compiler += make_version_string(__clang_major__, __clang_minor__, __clang_patchlevel__);
+ #elif _MSC_VER
+ compiler += "MSVC ";
+ compiler += "(version ";
+ compiler += stringify(_MSC_FULL_VER) "." stringify(_MSC_BUILD);
+ compiler += ")";
+ #elif defined(__e2k__) && defined(__LCC__)
#define dot_ver2(n) \
- compiler += (char)'.'; \
- compiler += (char)('0' + (n) / 10); \
- compiler += (char)('0' + (n) % 10);
-
- compiler += "MCST LCC ";
- compiler += "(version ";
- compiler += std::to_string(__LCC__ / 100);
- dot_ver2(__LCC__ % 100)
- dot_ver2(__LCC_MINOR__)
- compiler += ")";
- #elif __GNUC__
- compiler += "g++ (GNUC) ";
- compiler += make_version_string(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
- #else
- compiler += "Unknown compiler ";
- compiler += "(unknown version)";
- #endif
-
- #if defined(__APPLE__)
- compiler += " on Apple";
- #elif defined(__CYGWIN__)
- compiler += " on Cygwin";
- #elif defined(__MINGW64__)
- compiler += " on MinGW64";
- #elif defined(__MINGW32__)
- compiler += " on MinGW32";
- #elif defined(__ANDROID__)
- compiler += " on Android";
- #elif defined(__linux__)
- compiler += " on Linux";
- #elif defined(_WIN64)
- compiler += " on Microsoft Windows 64-bit";
- #elif defined(_WIN32)
- compiler += " on Microsoft Windows 32-bit";
- #else
- compiler += " on unknown system";
- #endif
-
- compiler += "\nCompilation settings include: ";
- compiler += (Is64Bit ? " 64bit" : " 32bit");
- #if defined(USE_VNNI)
+ compiler += char('.'); \
+ compiler += char('0' + (n) / 10); \
+ compiler += char('0' + (n) % 10);
+
+ compiler += "MCST LCC ";
+ compiler += "(version ";
+ compiler += std::to_string(__LCC__ / 100);
+ dot_ver2(__LCC__ % 100) dot_ver2(__LCC_MINOR__) compiler += ")";
+ #elif __GNUC__
+ compiler += "g++ (GNUC) ";
+ compiler += make_version_string(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
+ #else
+ compiler += "Unknown compiler ";
+ compiler += "(unknown version)";
+ #endif
+
+ #if defined(__APPLE__)
+ compiler += " on Apple";
+ #elif defined(__CYGWIN__)
+ compiler += " on Cygwin";
+ #elif defined(__MINGW64__)
+ compiler += " on MinGW64";
+ #elif defined(__MINGW32__)
+ compiler += " on MinGW32";
+ #elif defined(__ANDROID__)
+ compiler += " on Android";
+ #elif defined(__linux__)
+ compiler += " on Linux";
+ #elif defined(_WIN64)
+ compiler += " on Microsoft Windows 64-bit";
+ #elif defined(_WIN32)
+ compiler += " on Microsoft Windows 32-bit";
+ #else
+ compiler += " on unknown system";
+ #endif
+
+ compiler += "\nCompilation architecture : ";
+ #if defined(ARCH)
+ compiler += stringify(ARCH);
+ #else
+ compiler += "(undefined architecture)";
+ #endif
+
+ compiler += "\nCompilation settings : ";
+ compiler += (Is64Bit ? "64bit" : "32bit");
+ #if defined(USE_VNNI)
compiler += " VNNI";
- #endif
- #if defined(USE_AVX512)
+ #endif
+ #if defined(USE_AVX512)
compiler += " AVX512";
- #endif
- compiler += (HasPext ? " BMI2" : "");
- #if defined(USE_AVX2)
+ #endif
+ compiler += (HasPext ? " BMI2" : "");
+ #if defined(USE_AVX2)
compiler += " AVX2";
- #endif
- #if defined(USE_SSE41)
+ #endif
+ #if defined(USE_SSE41)
compiler += " SSE41";
- #endif
- #if defined(USE_SSSE3)
+ #endif
+ #if defined(USE_SSSE3)
compiler += " SSSE3";
- #endif
- #if defined(USE_SSE2)
+ #endif
+ #if defined(USE_SSE2)
compiler += " SSE2";
- #endif
- compiler += (HasPopCnt ? " POPCNT" : "");
- #if defined(USE_MMX)
- compiler += " MMX";
- #endif
- #if defined(USE_NEON)
+ #endif
+ compiler += (HasPopCnt ? " POPCNT" : "");
+ #if defined(USE_NEON_DOTPROD)
+ compiler += " NEON_DOTPROD";
+ #elif defined(USE_NEON)
compiler += " NEON";
- #endif
+ #endif
- #if !defined(NDEBUG)
+ #if !defined(NDEBUG)
compiler += " DEBUG";
- #endif
+ #endif
+
+ compiler += "\nCompiler __VERSION__ macro : ";
+ #ifdef __VERSION__
+ compiler += __VERSION__;
+ #else
+ compiler += "(undefined macro)";
+ #endif
- compiler += "\n__VERSION__ macro expands to: ";
- #ifdef __VERSION__
- compiler += __VERSION__;
- #else
- compiler += "(undefined macro)";
- #endif
- compiler += "\n";
+ compiler += "\n";
- return compiler;
+ return compiler;
}
- /// Debug functions used mainly to collect run-time statistics
+ // Debug functions used mainly to collect run-time statistics
constexpr int MaxDebugSlots = 32;
namespace {
template<size_t N>
struct DebugInfo {
- std::atomic<int64_t> data[N] = { 0 };
+ std::atomic<int64_t> data[N] = {0};
constexpr inline std::atomic<int64_t>& operator[](int index) { return data[index]; }
};
void dbg_print() {
int64_t n;
- auto E = [&n](int64_t x) { return double(x) / n; };
- auto sqr = [](double x) { return x * x; };
+ auto E = [&n](int64_t x) { return double(x) / n; };
+ auto sqr = [](double x) { return x * x; };
for (int i = 0; i < MaxDebugSlots; ++i)
if ((n = hit[i][0]))
- std::cerr << "Hit #" << i
- << ": Total " << n << " Hits " << hit[i][1]
- << " Hit Rate (%) " << 100.0 * E(hit[i][1])
- << std::endl;
+ std::cerr << "Hit #" << i << ": Total " << n << " Hits " << hit[i][1]
+ << " Hit Rate (%) " << 100.0 * E(hit[i][1]) << std::endl;
for (int i = 0; i < MaxDebugSlots; ++i)
if ((n = mean[i][0]))
{
- std::cerr << "Mean #" << i
- << ": Total " << n << " Mean " << E(mean[i][1])
- << std::endl;
+ std::cerr << "Mean #" << i << ": Total " << n << " Mean " << E(mean[i][1]) << std::endl;
}
for (int i = 0; i < MaxDebugSlots; ++i)
if ((n = stdev[i][0]))
{
- double r = sqrtl(E(stdev[i][2]) - sqr(E(stdev[i][1])));
- std::cerr << "Stdev #" << i
- << ": Total " << n << " Stdev " << r
- << std::endl;
+ double r = sqrt(E(stdev[i][2]) - sqr(E(stdev[i][1])));
+ std::cerr << "Stdev #" << i << ": Total " << n << " Stdev " << r << std::endl;
}
for (int i = 0; i < MaxDebugSlots; ++i)
if ((n = correl[i][0]))
{
double r = (E(correl[i][5]) - E(correl[i][1]) * E(correl[i][3]))
- / ( sqrtl(E(correl[i][2]) - sqr(E(correl[i][1])))
- * sqrtl(E(correl[i][4]) - sqr(E(correl[i][3]))));
- std::cerr << "Correl. #" << i
- << ": Total " << n << " Coefficient " << r
- << std::endl;
+ / (sqrt(E(correl[i][2]) - sqr(E(correl[i][1])))
+ * sqrt(E(correl[i][4]) - sqr(E(correl[i][3]))));
+ std::cerr << "Correl. #" << i << ": Total " << n << " Coefficient " << r << std::endl;
}
}
- /// Used to serialize access to std::cout to avoid multiple threads writing at
- /// the same time.
-
+ // Used to serialize access to std::cout
+ // to avoid multiple threads writing at the same time.
std::ostream& operator<<(std::ostream& os, SyncCout sc) {
- static std::mutex m;
+ static std::mutex m;
- if (sc == IO_LOCK)
- m.lock();
+ if (sc == IO_LOCK)
+ m.lock();
- if (sc == IO_UNLOCK)
- m.unlock();
+ if (sc == IO_UNLOCK)
+ m.unlock();
- return os;
+ return os;
}
- /// Trampoline helper to avoid moving Logger to misc.h
+ // Trampoline helper to avoid moving Logger to misc.h
void start_logger(const std::string& fname) { Logger::start(fname); }
- /// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking
- /// function that doesn't stall the CPU waiting for data to be loaded from memory,
- /// which can be quite slow.
#ifdef NO_PREFETCH
void prefetch(void*) {}
void prefetch(void* addr) {
- # if defined(__INTEL_COMPILER)
- // This hack prevents prefetches from being optimized away by
- // Intel compiler. Both MSVC and gcc seem not be affected by this.
- __asm__ ("");
- # endif
-
- # if defined(__INTEL_COMPILER) || defined(_MSC_VER)
- _mm_prefetch((char*)addr, _MM_HINT_T0);
- # else
- __builtin_prefetch(addr);
- # endif
+ #if defined(_MSC_VER)
+ _mm_prefetch((char*) addr, _MM_HINT_T0);
+ #else
+ __builtin_prefetch(addr);
+ #endif
}
#endif
- /// std_aligned_alloc() is our wrapper for systems where the c++17 implementation
- /// does not guarantee the availability of aligned_alloc(). Memory allocated with
- /// std_aligned_alloc() must be freed with std_aligned_free().
-
+ // Wrapper for systems where the c++17 implementation
+ // does not guarantee the availability of aligned_alloc(). Memory allocated with
+ // std_aligned_alloc() must be freed with std_aligned_free().
void* std_aligned_alloc(size_t alignment, size_t size) {
#if defined(POSIXALIGNEDALLOC)
- void *mem;
- return posix_memalign(&mem, alignment, size) ? nullptr : mem;
+ void* mem;
+ return posix_memalign(&mem, alignment, size) ? nullptr : mem;
#elif defined(_WIN32) && !defined(_M_ARM) && !defined(_M_ARM64)
- return _mm_malloc(size, alignment);
+ return _mm_malloc(size, alignment);
#elif defined(_WIN32)
- return _aligned_malloc(size, alignment);
+ return _aligned_malloc(size, alignment);
#else
- return std::aligned_alloc(alignment, size);
+ return std::aligned_alloc(alignment, size);
#endif
}
void std_aligned_free(void* ptr) {
#if defined(POSIXALIGNEDALLOC)
- free(ptr);
+ free(ptr);
#elif defined(_WIN32) && !defined(_M_ARM) && !defined(_M_ARM64)
- _mm_free(ptr);
+ _mm_free(ptr);
#elif defined(_WIN32)
- _aligned_free(ptr);
+ _aligned_free(ptr);
#else
- free(ptr);
+ free(ptr);
#endif
}
- /// aligned_large_pages_alloc() will return suitably aligned memory, if possible using large pages.
+ // aligned_large_pages_alloc() will return suitably aligned memory, if possible using large pages.
#if defined(_WIN32)
static void* aligned_large_pages_alloc_windows([[maybe_unused]] size_t allocSize) {
- #if !defined(_WIN64)
+ #if !defined(_WIN64)
return nullptr;
- #else
-
- HANDLE hProcessToken { };
- LUID luid { };
- void* mem = nullptr;
-
- const size_t largePageSize = GetLargePageMinimum();
- if (!largePageSize)
- return nullptr;
-
- // Dynamically link OpenProcessToken, LookupPrivilegeValue and AdjustTokenPrivileges
-
- HMODULE hAdvapi32 = GetModuleHandle(TEXT("advapi32.dll"));
-
- if (!hAdvapi32)
- hAdvapi32 = LoadLibrary(TEXT("advapi32.dll"));
-
- auto fun6 = (fun6_t)(void(*)())GetProcAddress(hAdvapi32, "OpenProcessToken");
- if (!fun6)
- return nullptr;
- auto fun7 = (fun7_t)(void(*)())GetProcAddress(hAdvapi32, "LookupPrivilegeValueA");
- if (!fun7)
- return nullptr;
- auto fun8 = (fun8_t)(void(*)())GetProcAddress(hAdvapi32, "AdjustTokenPrivileges");
- if (!fun8)
- return nullptr;
-
- // We need SeLockMemoryPrivilege, so try to enable it for the process
- if (!fun6( // OpenProcessToken()
- GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hProcessToken))
- return nullptr;
-
- if (fun7( // LookupPrivilegeValue(nullptr, SE_LOCK_MEMORY_NAME, &luid)
- nullptr, "SeLockMemoryPrivilege", &luid))
- {
- TOKEN_PRIVILEGES tp { };
- TOKEN_PRIVILEGES prevTp { };
- DWORD prevTpLen = 0;
-
- tp.PrivilegeCount = 1;
- tp.Privileges[0].Luid = luid;
- tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
-
- // Try to enable SeLockMemoryPrivilege. Note that even if AdjustTokenPrivileges() succeeds,
- // we still need to query GetLastError() to ensure that the privileges were actually obtained.
- if (fun8( // AdjustTokenPrivileges()
- hProcessToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &prevTp, &prevTpLen) &&
- GetLastError() == ERROR_SUCCESS)
- {
- // Round up size to full pages and allocate
- allocSize = (allocSize + largePageSize - 1) & ~size_t(largePageSize - 1);
- mem = VirtualAlloc(
- nullptr, allocSize, MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);
-
- // Privilege no longer needed, restore previous state
- fun8( // AdjustTokenPrivileges ()
+ #else
+
+ HANDLE hProcessToken{};
+ LUID luid{};
+ void* mem = nullptr;
+
+ const size_t largePageSize = GetLargePageMinimum();
+ if (!largePageSize)
+ return nullptr;
+
+ // Dynamically link OpenProcessToken, LookupPrivilegeValue and AdjustTokenPrivileges
+
+ HMODULE hAdvapi32 = GetModuleHandle(TEXT("advapi32.dll"));
+
+ if (!hAdvapi32)
+ hAdvapi32 = LoadLibrary(TEXT("advapi32.dll"));
+
+ auto fun6 = fun6_t((void (*)()) GetProcAddress(hAdvapi32, "OpenProcessToken"));
+ if (!fun6)
+ return nullptr;
+ auto fun7 = fun7_t((void (*)()) GetProcAddress(hAdvapi32, "LookupPrivilegeValueA"));
+ if (!fun7)
+ return nullptr;
+ auto fun8 = fun8_t((void (*)()) GetProcAddress(hAdvapi32, "AdjustTokenPrivileges"));
+ if (!fun8)
+ return nullptr;
+
+ // We need SeLockMemoryPrivilege, so try to enable it for the process
+ if (!fun6( // OpenProcessToken()
+ GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hProcessToken))
+ return nullptr;
+
+ if (fun7( // LookupPrivilegeValue(nullptr, SE_LOCK_MEMORY_NAME, &luid)
+ nullptr, "SeLockMemoryPrivilege", &luid))
+ {
+ TOKEN_PRIVILEGES tp{};
+ TOKEN_PRIVILEGES prevTp{};
+ DWORD prevTpLen = 0;
+
+ tp.PrivilegeCount = 1;
+ tp.Privileges[0].Luid = luid;
+ tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
+
+ // Try to enable SeLockMemoryPrivilege. Note that even if AdjustTokenPrivileges() succeeds,
+ // we still need to query GetLastError() to ensure that the privileges were actually obtained.
+ if (fun8( // AdjustTokenPrivileges()
+ hProcessToken, FALSE, &tp, sizeof(TOKEN_PRIVILEGES), &prevTp, &prevTpLen)
+ && GetLastError() == ERROR_SUCCESS)
+ {
+ // Round up size to full pages and allocate
+ allocSize = (allocSize + largePageSize - 1) & ~size_t(largePageSize - 1);
+ mem = VirtualAlloc(nullptr, allocSize, MEM_RESERVE | MEM_COMMIT | MEM_LARGE_PAGES,
+ PAGE_READWRITE);
+
+ // Privilege no longer needed, restore previous state
+ fun8( // AdjustTokenPrivileges ()
hProcessToken, FALSE, &prevTp, 0, nullptr, nullptr);
- }
- }
+ }
+ }
- CloseHandle(hProcessToken);
+ CloseHandle(hProcessToken);
- return mem;
+ return mem;
- #endif
+ #endif
}
void* aligned_large_pages_alloc(size_t allocSize) {
- // Try to allocate large pages
- void* mem = aligned_large_pages_alloc_windows(allocSize);
+ // Try to allocate large pages
+ void* mem = aligned_large_pages_alloc_windows(allocSize);
- // Fall back to regular, page aligned, allocation if necessary
- if (!mem)
- mem = VirtualAlloc(nullptr, allocSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+ // Fall back to regular, page-aligned, allocation if necessary
+ if (!mem)
+ mem = VirtualAlloc(nullptr, allocSize, MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
- return mem;
+ return mem;
}
#else
void* aligned_large_pages_alloc(size_t allocSize) {
- #if defined(__linux__)
- constexpr size_t alignment = 2 * 1024 * 1024; // assumed 2MB page size
- #else
- constexpr size_t alignment = 4096; // assumed small page size
- #endif
-
- // round up to multiples of alignment
- size_t size = ((allocSize + alignment - 1) / alignment) * alignment;
- void *mem = std_aligned_alloc(alignment, size);
- #if defined(MADV_HUGEPAGE)
- madvise(mem, size, MADV_HUGEPAGE);
- #endif
- return mem;
+ #if defined(__linux__)
+ constexpr size_t alignment = 2 * 1024 * 1024; // assumed 2MB page size
+ #else
+ constexpr size_t alignment = 4096; // assumed small page size
+ #endif
+
+ // Round up to multiples of alignment
+ size_t size = ((allocSize + alignment - 1) / alignment) * alignment;
+ void* mem = std_aligned_alloc(alignment, size);
+ #if defined(MADV_HUGEPAGE)
+ madvise(mem, size, MADV_HUGEPAGE);
+ #endif
+ return mem;
}
#endif
- /// aligned_large_pages_free() will free the previously allocated ttmem
+ // aligned_large_pages_free() will free the previously allocated ttmem
#if defined(_WIN32)
void aligned_large_pages_free(void* mem) {
- if (mem && !VirtualFree(mem, 0, MEM_RELEASE))
- {
- DWORD err = GetLastError();
- std::cerr << "Failed to free large page memory. Error code: 0x"
- << std::hex << err
- << std::dec << std::endl;
- exit(EXIT_FAILURE);
- }
+ if (mem && !VirtualFree(mem, 0, MEM_RELEASE))
+ {
+ DWORD err = GetLastError();
+ std::cerr << "Failed to free large page memory. Error code: 0x" << std::hex << err
+ << std::dec << std::endl;
+ exit(EXIT_FAILURE);
+ }
}
#else
- void aligned_large_pages_free(void *mem) {
- std_aligned_free(mem);
- }
+ void aligned_large_pages_free(void* mem) { std_aligned_free(mem); }
#endif
#else
- /// best_node() retrieves logical processor information using Windows specific
- /// API and returns the best node id for the thread with index idx. Original
- /// code from Texel by Peter Österlund.
-
+ // Retrieves logical processor information using Windows-specific
+ // API and returns the best node id for the thread with index idx. Original
+ // code from Texel by Peter Österlund.
static int best_node(size_t idx) {
- int threads = 0;
- int nodes = 0;
- int cores = 0;
- DWORD returnLength = 0;
- DWORD byteOffset = 0;
-
- // Early exit if the needed API is not available at runtime
- HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
- auto fun1 = (fun1_t)(void(*)())GetProcAddress(k32, "GetLogicalProcessorInformationEx");
- if (!fun1)
- return -1;
-
- // First call to GetLogicalProcessorInformationEx() to get returnLength.
- // We expect the call to fail due to null buffer.
- if (fun1(RelationAll, nullptr, &returnLength))
- return -1;
-
- // Once we know returnLength, allocate the buffer
- SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr;
- ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(returnLength);
-
- // Second call to GetLogicalProcessorInformationEx(), now we expect to succeed
- if (!fun1(RelationAll, buffer, &returnLength))
- {
- free(buffer);
- return -1;
- }
-
- while (byteOffset < returnLength)
- {
- if (ptr->Relationship == RelationNumaNode)
- nodes++;
-
- else if (ptr->Relationship == RelationProcessorCore)
- {
- cores++;
- threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
- }
-
- assert(ptr->Size);
- byteOffset += ptr->Size;
- ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size);
- }
-
- free(buffer);
-
- std::vector<int> groups;
-
- // Run as many threads as possible on the same node until core limit is
- // reached, then move on filling the next node.
- for (int n = 0; n < nodes; n++)
- for (int i = 0; i < cores / nodes; i++)
- groups.push_back(n);
-
- // In case a core has more than one logical processor (we assume 2) and we
- // have still threads to allocate, then spread them evenly across available
- // nodes.
- for (int t = 0; t < threads - cores; t++)
- groups.push_back(t % nodes);
-
- // If we still have more threads than the total number of logical processors
- // then return -1 and let the OS to decide what to do.
- return idx < groups.size() ? groups[idx] : -1;
- }
+ int threads = 0;
+ int nodes = 0;
+ int cores = 0;
+ DWORD returnLength = 0;
+ DWORD byteOffset = 0;
+
+ // Early exit if the needed API is not available at runtime
+ HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
+ auto fun1 = (fun1_t) (void (*)()) GetProcAddress(k32, "GetLogicalProcessorInformationEx");
+ if (!fun1)
+ return -1;
+
+ // First call to GetLogicalProcessorInformationEx() to get returnLength.
+ // We expect the call to fail due to null buffer.
+ if (fun1(RelationAll, nullptr, &returnLength))
+ return -1;
+
+ // Once we know returnLength, allocate the buffer
+ SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr;
+ ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*) malloc(returnLength);
+
+ // Second call to GetLogicalProcessorInformationEx(), now we expect to succeed
+ if (!fun1(RelationAll, buffer, &returnLength))
+ {
+ free(buffer);
+ return -1;
+ }
+
+ while (byteOffset < returnLength)
+ {
+ if (ptr->Relationship == RelationNumaNode)
+ nodes++;
+
+ else if (ptr->Relationship == RelationProcessorCore)
+ {
+ cores++;
+ threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1;
+ }
+
+ assert(ptr->Size);
+ byteOffset += ptr->Size;
+ ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*) (((char*) ptr) + ptr->Size);
+ }
+ free(buffer);
- /// bindThisThread() set the group affinity of the current thread
+ std::vector<int> groups;
+ // Run as many threads as possible on the same node until the core limit is
+ // reached, then move on to filling the next node.
+ for (int n = 0; n < nodes; n++)
+ for (int i = 0; i < cores / nodes; i++)
+ groups.push_back(n);
+
+ // In case a core has more than one logical processor (we assume 2) and we
+ // still have threads to allocate, spread them evenly across available nodes.
+ for (int t = 0; t < threads - cores; t++)
+ groups.push_back(t % nodes);
+
+ // If we still have more threads than the total number of logical processors
+ // then return -1 and let the OS to decide what to do.
+ return idx < groups.size() ? groups[idx] : -1;
+ }
+
+
+ // Sets the group affinity of the current thread
void bindThisThread(size_t idx) {
- // Use only local variables to be thread-safe
- int node = best_node(idx);
-
- if (node == -1)
- return;
-
- // Early exit if the needed API are not available at runtime
- HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
- auto fun2 = (fun2_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMaskEx");
- auto fun3 = (fun3_t)(void(*)())GetProcAddress(k32, "SetThreadGroupAffinity");
- auto fun4 = (fun4_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMask2");
- auto fun5 = (fun5_t)(void(*)())GetProcAddress(k32, "GetMaximumProcessorGroupCount");
-
- if (!fun2 || !fun3)
- return;
-
- if (!fun4 || !fun5)
- {
- GROUP_AFFINITY affinity;
- if (fun2(node, &affinity)) // GetNumaNodeProcessorMaskEx
- fun3(GetCurrentThread(), &affinity, nullptr); // SetThreadGroupAffinity
- }
- else
- {
- // If a numa node has more than one processor group, we assume they are
- // sized equal and we spread threads evenly across the groups.
- USHORT elements, returnedElements;
- elements = fun5(); // GetMaximumProcessorGroupCount
- GROUP_AFFINITY *affinity = (GROUP_AFFINITY*)malloc(elements * sizeof(GROUP_AFFINITY));
- if (fun4(node, affinity, elements, &returnedElements)) // GetNumaNodeProcessorMask2
- fun3(GetCurrentThread(), &affinity[idx % returnedElements], nullptr); // SetThreadGroupAffinity
- free(affinity);
- }
+ // Use only local variables to be thread-safe
+ int node = best_node(idx);
+
+ if (node == -1)
+ return;
+
+ // Early exit if the needed API are not available at runtime
+ HMODULE k32 = GetModuleHandle(TEXT("Kernel32.dll"));
+ auto fun2 = fun2_t((void (*)()) GetProcAddress(k32, "GetNumaNodeProcessorMaskEx"));
+ auto fun3 = fun3_t((void (*)()) GetProcAddress(k32, "SetThreadGroupAffinity"));
+ auto fun4 = fun4_t((void (*)()) GetProcAddress(k32, "GetNumaNodeProcessorMask2"));
+ auto fun5 = fun5_t((void (*)()) GetProcAddress(k32, "GetMaximumProcessorGroupCount"));
+
+ if (!fun2 || !fun3)
+ return;
+
+ if (!fun4 || !fun5)
+ {
+ GROUP_AFFINITY affinity;
+ if (fun2(node, &affinity)) // GetNumaNodeProcessorMaskEx
+ fun3(GetCurrentThread(), &affinity, nullptr); // SetThreadGroupAffinity
+ }
+ else
+ {
+ // If a numa node has more than one processor group, we assume they are
+ // sized equal and we spread threads evenly across the groups.
+ USHORT elements, returnedElements;
+ elements = fun5(); // GetMaximumProcessorGroupCount
+ GROUP_AFFINITY* affinity = (GROUP_AFFINITY*) malloc(elements * sizeof(GROUP_AFFINITY));
+ if (fun4(node, affinity, elements, &returnedElements)) // GetNumaNodeProcessorMask2
+ fun3(GetCurrentThread(), &affinity[idx % returnedElements],
+ nullptr); // SetThreadGroupAffinity
+ free(affinity);
+ }
}
#endif
- } // namespace WinProcGroup
+ } // namespace WinProcGroup
#ifdef _WIN32
- #include <direct.h>
- #define GETCWD _getcwd
+ #include <direct.h>
+ #define GETCWD _getcwd
#else
- #include <unistd.h>
- #define GETCWD getcwd
+ #include <unistd.h>
+ #define GETCWD getcwd
#endif
namespace CommandLine {
- string argv0; // path+name of the executable binary, as given by argv[0]
- string binaryDirectory; // path of the executable directory
- string workingDirectory; // path of the working directory
+ std::string argv0; // path+name of the executable binary, as given by argv[0]
+ std::string binaryDirectory; // path of the executable directory
+ std::string workingDirectory; // path of the working directory
void init([[maybe_unused]] int argc, char* argv[]) {
- string pathSeparator;
+ std::string pathSeparator;
- // extract the path+name of the executable binary
+ // Extract the path+name of the executable binary
argv0 = argv[0];
#ifdef _WIN32
pathSeparator = "\\";
- #ifdef _MSC_VER
+ #ifdef _MSC_VER
// Under windows argv[0] may not have the extension. Also _get_pgmptr() had
- // issues in some windows 10 versions, so check returned values carefully.
+ // issues in some Windows 10 versions, so check returned values carefully.
char* pgmptr = nullptr;
if (!_get_pgmptr(&pgmptr) && pgmptr != nullptr && *pgmptr)
argv0 = pgmptr;
- #endif
+ #endif
#else
pathSeparator = "/";
#endif
- // extract the working directory
+ // Extract the working directory
workingDirectory = "";
- char buff[40000];
+ char buff[40000];
char* cwd = GETCWD(buff, 40000);
if (cwd)
workingDirectory = cwd;
- // extract the binary directory path from argv0
+ // Extract the binary directory path from argv0
binaryDirectory = argv0;
- size_t pos = binaryDirectory.find_last_of("\\/");
+ size_t pos = binaryDirectory.find_last_of("\\/");
if (pos == std::string::npos)
binaryDirectory = "." + pathSeparator;
else
binaryDirectory.resize(pos + 1);
- // pattern replacement: "./" at the start of path is replaced by the working directory
+ // Pattern replacement: "./" at the start of path is replaced by the working directory
if (binaryDirectory.find("." + pathSeparator) == 0)
binaryDirectory.replace(0, 1, workingDirectory);
}
- } // namespace CommandLine
+ } // namespace CommandLine
- } // namespace Stockfish
+ } // namespace Stockfish
#include <algorithm>
#include <cassert>
+ #include <cctype>
+ #include <cstddef>
+ #include <iosfwd>
+ #include <istream>
+ #include <map>
#include <ostream>
#include <sstream>
+ #include <string>
#include "evaluate.h"
#include "misc.h"
#include "search.h"
+ #include "syzygy/tbprobe.h"
#include "thread.h"
#include "tt.h"
+ #include "types.h"
#include "uci.h"
- #include "syzygy/tbprobe.h"
+#include "hashprobe.h"
using std::string;
namespace Stockfish {
- UCI::OptionsMap Options; // Global object
+ UCI::OptionsMap Options; // Global object
+std::unique_ptr<HashProbeThread> hash_probe_thread;
namespace UCI {
- /// 'On change' actions, triggered by an option's value change
+ // 'On change' actions, triggered by an option's value change
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_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 {
+ // Our case insensitive less() function as required by UCI protocol
+ bool CaseInsensitiveLess::operator()(const string& s1, const string& s2) const {
- return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
- [](char c1, char c2) { return tolower(c1) < tolower(c2); });
+ return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(),
+ [](char c1, char c2) { return tolower(c1) < tolower(c2); });
}
- /// UCI::init() initializes the UCI options to their hard-coded default values
-
+ // Initializes the UCI options to their hard-coded default values
void init(OptionsMap& o) {
- constexpr int MaxHashMB = Is64Bit ? 33554432 : 2048;
-
- o["Debug Log File"] << Option("", on_logger);
- o["Threads"] << Option(1, 1, 1024, on_threads);
- o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size);
- o["Clear Hash"] << Option(on_clear_hash);
- o["Ponder"] << Option(false);
- o["MultiPV"] << Option(1, 1, 500);
- o["Skill Level"] << Option(20, 0, 20);
- o["Move Overhead"] << Option(10, 0, 5000);
- o["Slow Mover"] << Option(100, 10, 1000);
- o["nodestime"] << Option(0, 0, 10000);
- o["UCI_Chess960"] << Option(false);
- o["UCI_AnalyseMode"] << Option(false);
- o["UCI_LimitStrength"] << Option(false);
- o["UCI_Elo"] << Option(1320, 1320, 3190);
- o["UCI_ShowWDL"] << Option(false);
- o["SyzygyPath"] << Option("<empty>", on_tb_path);
- o["SyzygyProbeDepth"] << Option(1, 1, 100);
- o["Syzygy50MoveRule"] << Option(true);
- o["SyzygyProbeLimit"] << Option(7, 0, 7);
- o["EvalFile"] << Option(EvalFileDefaultName, on_eval_file);
- o["RPCServerAddress"] << Option("<empty>", on_rpc_server_address);
+ constexpr int MaxHashMB = Is64Bit ? 33554432 : 2048;
+
+ o["Debug Log File"] << Option("", on_logger);
+ o["Threads"] << Option(1, 1, 1024, on_threads);
+ o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size);
+ o["Clear Hash"] << Option(on_clear_hash);
+ o["Ponder"] << Option(false);
+ o["MultiPV"] << Option(1, 1, 500);
+ o["Skill Level"] << Option(20, 0, 20);
+ o["Move Overhead"] << Option(10, 0, 5000);
+ o["nodestime"] << Option(0, 0, 10000);
+ o["UCI_Chess960"] << Option(false);
+ o["UCI_LimitStrength"] << Option(false);
+ o["UCI_Elo"] << Option(1320, 1320, 3190);
+ o["UCI_ShowWDL"] << Option(false);
+ o["SyzygyPath"] << Option("<empty>", on_tb_path);
+ o["SyzygyProbeDepth"] << Option(1, 1, 100);
+ o["Syzygy50MoveRule"] << Option(true);
+ o["SyzygyProbeLimit"] << Option(7, 0, 7);
+ o["EvalFile"] << Option(EvalFileDefaultName, on_eval_file);
++ o["RPCServerAddress"] << Option("<empty>", on_rpc_server_address);
}
- /// operator<<() is used to print all the options default values in chronological
- /// insertion order (the idx field) and in the format defined by the UCI protocol.
-
+ // Used to print all the options default values in chronological
+ // insertion order (the idx field) and in the format defined by the UCI protocol.
std::ostream& operator<<(std::ostream& os, const OptionsMap& om) {
- for (size_t idx = 0; idx < om.size(); ++idx)
- for (const auto& it : om)
- if (it.second.idx == idx)
- {
- const Option& o = it.second;
- os << "\noption name " << it.first << " type " << o.type;
+ for (size_t idx = 0; idx < om.size(); ++idx)
+ for (const auto& it : om)
+ if (it.second.idx == idx)
+ {
+ const Option& o = it.second;
+ os << "\noption name " << it.first << " type " << o.type;
- if (o.type == "string" || o.type == "check" || o.type == "combo")
- os << " default " << o.defaultValue;
+ if (o.type == "string" || o.type == "check" || o.type == "combo")
+ os << " default " << o.defaultValue;
- if (o.type == "spin")
- os << " default " << int(stof(o.defaultValue))
- << " min " << o.min
- << " max " << o.max;
+ if (o.type == "spin")
+ os << " default " << int(stof(o.defaultValue)) << " min " << o.min << " max "
+ << o.max;
- break;
- }
+ break;
+ }
- return os;
+ return os;
}
- /// Option class constructors and conversion operators
-
- Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f)
- { defaultValue = currentValue = v; }
+ // Option class constructors and conversion operators
- Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f)
- { defaultValue = currentValue = (v ? "true" : "false"); }
+ Option::Option(const char* v, OnChange f) :
+ type("string"),
+ min(0),
+ max(0),
+ on_change(f) {
+ defaultValue = currentValue = v;
+ }
- Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f)
- {}
+ Option::Option(bool v, OnChange f) :
+ type("check"),
+ min(0),
+ max(0),
+ on_change(f) {
+ defaultValue = currentValue = (v ? "true" : "false");
+ }
- Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f)
- { defaultValue = currentValue = std::to_string(v); }
+ Option::Option(OnChange f) :
+ type("button"),
+ min(0),
+ max(0),
+ on_change(f) {}
+
+ Option::Option(double v, int minv, int maxv, OnChange f) :
+ type("spin"),
+ min(minv),
+ max(maxv),
+ on_change(f) {
+ defaultValue = currentValue = std::to_string(v);
+ }
- Option::Option(const char* v, const char* cur, OnChange f) : type("combo"), min(0), max(0), on_change(f)
- { defaultValue = v; currentValue = cur; }
+ Option::Option(const char* v, const char* cur, OnChange f) :
+ type("combo"),
+ min(0),
+ max(0),
+ on_change(f) {
+ defaultValue = v;
+ currentValue = cur;
+ }
Option::operator int() const {
- assert(type == "check" || type == "spin");
- return (type == "spin" ? std::stoi(currentValue) : currentValue == "true");
+ assert(type == "check" || type == "spin");
+ return (type == "spin" ? std::stoi(currentValue) : currentValue == "true");
}
Option::operator std::string() const {
- assert(type == "string");
- return currentValue;
+ assert(type == "string");
+ return currentValue;
}
bool Option::operator==(const char* s) const {
- assert(type == "combo");
- return !CaseInsensitiveLess()(currentValue, s)
- && !CaseInsensitiveLess()(s, currentValue);
+ assert(type == "combo");
+ return !CaseInsensitiveLess()(currentValue, s) && !CaseInsensitiveLess()(s, currentValue);
}
- /// operator<<() inits options and assigns idx in the correct printing order
+ // Inits options and assigns idx in the correct printing order
void Option::operator<<(const Option& o) {
- static size_t insert_order = 0;
+ static size_t insert_order = 0;
- *this = o;
- idx = insert_order++;
+ *this = o;
+ idx = insert_order++;
}
- /// operator=() updates currentValue and triggers on_change() action. It's up to
- /// the GUI to check for option's limits, but we could receive the new value
- /// from the user by console window, so let's check the bounds anyway.
-
+ // Updates currentValue and triggers on_change() action. It's up to
+ // the GUI to check for option's limits, but we could receive the new value
+ // from the user by console window, so let's check the bounds anyway.
Option& Option::operator=(const string& v) {
- assert(!type.empty());
+ assert(!type.empty());
- if ( (type != "button" && type != "string" && v.empty())
- || (type == "check" && v != "true" && v != "false")
- || (type == "spin" && (stof(v) < min || stof(v) > max)))
- return *this;
+ if ((type != "button" && type != "string" && v.empty())
+ || (type == "check" && v != "true" && v != "false")
+ || (type == "spin" && (stof(v) < min || stof(v) > max)))
+ return *this;
- if (type == "combo")
- {
- OptionsMap comboMap; // To have case insensitive compare
- string token;
- std::istringstream ss(defaultValue);
- while (ss >> token)
- comboMap[token] << Option();
- if (!comboMap.count(v) || v == "var")
- return *this;
- }
+ if (type == "combo")
+ {
+ OptionsMap comboMap; // To have case insensitive compare
+ string token;
+ std::istringstream ss(defaultValue);
+ while (ss >> token)
+ comboMap[token] << Option();
+ if (!comboMap.count(v) || v == "var")
+ return *this;
+ }
- if (type != "button")
- currentValue = v;
+ if (type != "button")
+ currentValue = v;
- if (on_change)
- on_change(*this);
+ if (on_change)
+ on_change(*this);
- return *this;
+ return *this;
}
- } // namespace UCI
+ } // namespace UCI
- } // namespace Stockfish
+ } // namespace Stockfish
projects / stockfish / commitdiff