xZero707/droidfish
1
0
Fork 0
mirror of https://github.com/peterosterlund2/droidfish.git synced 2025-12-17 19:22:18 +01:00
Code Issues Packages Projects Releases Wiki Activity

DroidFish: Updated stockfish to version 231015.

Browse Source
This commit is contained in:
Peter Osterlund
2015-10-23 22:58:14 +02:00
parent e768c9408a
commit 0d72a21f27
39 changed files with 2118 additions and 2574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
DroidFish/jni/stockfish/misc.cpp
View File

@@ -31,43 +31,39 @@ namespace {
/// Version number. If Version is left empty, then compile date in the format
/// DD-MM-YY and show in engine_info.
const string Version = "6";
/// Debug counters
int64_t hits[2], means[2];
const string Version = "231015";
/// 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!
/// 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 splitted streambuf for cin and cout
Tie(streambuf* b, ofstream* f) : buf(b), file(f) {}
Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {}
int sync() { return file->rdbuf()->pubsync(), buf->pubsync(); }
int sync() { return logBuf->pubsync(), buf->pubsync(); }
int overflow(int c) { return log(buf->sputc((char)c), "<< "); }
int underflow() { return buf->sgetc(); }
int uflow() { return log(buf->sbumpc(), ">> "); }
streambuf* buf;
ofstream* file;
streambuf *buf, *logBuf;
int log(int c, const char* prefix) {
static int last = '\n';
static int last = '\n'; // Single log file
if (last == '\n')
file->rdbuf()->sputn(prefix, 3);
logBuf->sputn(prefix, 3);
return last = file->rdbuf()->sputc((char)c);
return last = logBuf->sputc((char)c);
}
};
class Logger {
Logger() : in(cin.rdbuf(), &file), out(cout.rdbuf(), &file) {}
Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {}
~Logger() { start(false); }
ofstream file;
@@ -80,7 +76,7 @@ public:
if (b && !l.file.is_open())
{
l.file.open("io_log.txt", ifstream::out | ifstream::app);
l.file.open("io_log.txt", ifstream::out);
cin.rdbuf(&l.in);
cout.rdbuf(&l.out);
}
@@ -117,16 +113,17 @@ const string engine_info(bool to_uci) {
ss << (Is64Bit ? " 64" : "")
<< (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : ""))
<< (to_uci ? "\nid author ": " by ")
<< "Tord Romstad, Marco Costalba and Joona Kiiski";
<< "T. Romstad, M. Costalba, J. Kiiski, G. Linscott";
return ss.str();
}
/// Debug functions used mainly to collect run-time statistics
static int64_t hits[2], means[2];
void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; }
void dbg_hit_on_c(bool c, bool b) { if (c) dbg_hit_on(b); }
void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); }
void dbg_mean_of(int v) { ++means[0]; means[1] += v; }
void dbg_print() {
@@ -162,35 +159,16 @@ std::ostream& operator<<(std::ostream& os, SyncCout sc) {
void start_logger(bool b) { Logger::start(b); }
/// timed_wait() waits for msec milliseconds. It is mainly a helper to wrap
/// the conversion from milliseconds to struct timespec, as used by pthreads.
void timed_wait(WaitCondition& sleepCond, Lock& sleepLock, int msec) {
#ifdef _WIN32
int tm = msec;
#else
timespec ts, *tm = &ts;
uint64_t ms = Time::now() + msec;
ts.tv_sec = ms / 1000;
ts.tv_nsec = (ms % 1000) * 1000000LL;
#endif
cond_timedwait(sleepCond, sleepLock, tm);
}
/// 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(char*) {}
void prefetch(void*) {}
#else
void prefetch(char* addr) {
void prefetch(void* addr) {
# if defined(__INTEL_COMPILER)
// This hack prevents prefetches from being optimized away by
@@ -199,7 +177,7 @@ void prefetch(char* addr) {
# endif
# if defined(__INTEL_COMPILER) || defined(_MSC_VER)
_mm_prefetch(addr, _MM_HINT_T0);
_mm_prefetch((char*)addr, _MM_HINT_T0);
# else
__builtin_prefetch(addr);
# endif