mirror of
https://github.com/sockspls/badfish
synced 2025-05-03 01:59:36 +00:00
8c4338ae49
Small tweak of parameters, yielding some Elo. The cluster branch can now be considered to be in good shape. In local testing, it runs stable for >30k games. Performance benefits from an MPI implementation that is able to make asynchronous progress. The code should be run with 1 MPI rank per node, and threaded on the node. Performance against master has now been measured. Master has been given 1 node with 32 cores/threads in standard SMP, the cluster branch has been given N=2..20 of those nodes, running the corresponding number of MPI processes, each with 32 threads. Time control has been 10s+0.1s, Hash 8MB/core, the book 8moves_v3.pgn, the number of games 400. ``` Score of cluster-2mpix32t vs master-32t: 96 - 27 - 277 [0.586] 400 Elo difference: 60.54 +/- 18.49 Score of cluster-3mpix32t vs master-32t: 101 - 18 - 281 [0.604] 400 Elo difference: 73.16 +/- 17.94 Score of cluster-4mpix32t vs master-32t: 126 - 18 - 256 [0.635] 400 Elo difference: 96.19 +/- 19.68 Score of cluster-5mpix32t vs master-32t: 110 - 5 - 285 [0.631] 400 Elo difference: 93.39 +/- 17.09 Score of cluster-6mpix32t vs master-32t: 117 - 9 - 274 [0.635] 400 Elo difference: 96.19 +/- 18.06 Score of cluster-7mpix32t vs master-32t: 142 - 10 - 248 [0.665] 400 Elo difference: 119.11 +/- 19.89 Score of cluster-8mpix32t vs master-32t: 125 - 14 - 261 [0.639] 400 Elo difference: 99.01 +/- 19.18 Score of cluster-9mpix32t vs master-32t: 137 - 7 - 256 [0.662] 400 Elo difference: 117.16 +/- 19.20 Score of cluster-10mpix32t vs master-32t: 145 - 8 - 247 [0.671] 400 Elo difference: 124.01 +/- 19.86 Score of cluster-16mpix32t vs master-32t: 153 - 6 - 241 [0.684] 400 Elo difference: 133.95 +/- 20.17 Score of cluster-20mpix32t vs master-32t: 134 - 8 - 258 [0.657] 400 Elo difference: 113.29 +/- 19.11 ``` As the cluster parallelism is essentially lazyMPI, the nodes per second has been verified to scale perfectly to large node counts. Unfortunately, that is not necessarily indicative of playing strength. In the following 2min search from startPos, we reach about 4.8Gnps (128 nodes). ``` info depth 38 seldepth 51 multipv 1 score cp 53 nodes 576165794092 nps 4801341606 hashfull 1000 tbhits 0 time 120001 pv e2e4 c7c5 g1f3 d7d6 f1b5 c8d7 b5d7 d8d7 c2c4 b8c6 b1c3 g8f6 d2d4 d7g4 d4d5 c6d4 f3d4 g4d1 e1d1 c5d4 c3b5 a8c8 b2b3 a7a6 b5d4 f6e4 d1e2 g7g6 c1e3 f8g7 a1c1 e4c5 f2f3 f7f5 h1d1 e8g8 d4c2 c5d7 a2a4 a6a5 e3d4 f5f4 d4f2 f8f7 h2h3 d7c5 ```
106 lines
3 KiB
C++
106 lines
3 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef CLUSTER_H_INCLUDED
|
|
#define CLUSTER_H_INCLUDED
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <istream>
|
|
#include <string>
|
|
|
|
#include "tt.h"
|
|
|
|
class Thread;
|
|
|
|
namespace Cluster {
|
|
|
|
struct MoveInfo {
|
|
int move;
|
|
int ponder;
|
|
int depth;
|
|
int score;
|
|
int rank;
|
|
};
|
|
|
|
#ifdef USE_MPI
|
|
using KeyedTTEntry = std::pair<Key, TTEntry>;
|
|
|
|
constexpr std::size_t TTCacheSize = 16;
|
|
template <std::size_t N> class TTCache : public std::array<KeyedTTEntry, N> {
|
|
|
|
struct Compare {
|
|
inline bool operator()(const KeyedTTEntry& lhs, const KeyedTTEntry& rhs) {
|
|
return lhs.second.depth() > rhs.second.depth();
|
|
}
|
|
};
|
|
Compare compare;
|
|
|
|
public:
|
|
bool replace(const KeyedTTEntry& value) {
|
|
|
|
if (compare(value, this->front()))
|
|
{
|
|
std::pop_heap(this->begin(), this->end(), compare);
|
|
this->back() = value;
|
|
std::push_heap(this->begin(), this->end(), compare);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
void init();
|
|
void finalize();
|
|
bool getline(std::istream& input, std::string& str);
|
|
int size();
|
|
int rank();
|
|
inline bool is_root() { return rank() == 0; }
|
|
void save(Thread* thread, TTEntry* tte, Key k, Value v, Bound b, Depth d, Move m, Value ev);
|
|
void pick_moves(MoveInfo& mi, std::string& PVLine);
|
|
void ttRecvBuff_resize(size_t nThreads);
|
|
uint64_t nodes_searched();
|
|
uint64_t tb_hits();
|
|
void signals_init();
|
|
void signals_poll();
|
|
void signals_sync();
|
|
|
|
#else
|
|
|
|
inline void init() { }
|
|
inline void finalize() { }
|
|
inline bool getline(std::istream& input, std::string& str) { return static_cast<bool>(std::getline(input, str)); }
|
|
constexpr int size() { return 1; }
|
|
constexpr int rank() { return 0; }
|
|
constexpr bool is_root() { return true; }
|
|
inline void save(Thread*, TTEntry* tte, Key k, Value v, Bound b, Depth d, Move m, Value ev) { tte->save(k, v, b, d, m, ev); }
|
|
inline void pick_moves(MoveInfo&, std::string&) { }
|
|
inline void ttRecvBuff_resize(size_t) { }
|
|
uint64_t nodes_searched();
|
|
uint64_t tb_hits();
|
|
inline void signals_init() { }
|
|
inline void signals_poll() { }
|
|
inline void signals_sync() { }
|
|
|
|
#endif /* USE_MPI */
|
|
|
|
}
|
|
|
|
#endif // #ifndef CLUSTER_H_INCLUDED
|