No functional change.
for (size_t i = 0; i < Threads.size(); ++i)
{
- const int size = Threads[i]->splitPointsSize; // Local copy
+ const size_t size = Threads[i]->splitPointsSize; // Local copy
sp = size ? &Threads[i]->splitPoints[size - 1] : NULL;
if ( sp
// Loop across all split points and sum accumulated SplitPoint nodes plus
// all the currently active positions nodes.
for (size_t i = 0; i < Threads.size(); ++i)
- for (int j = 0; j < Threads[i]->splitPointsSize; ++j)
+ for (size_t j = 0; j < Threads[i]->splitPointsSize; ++j)
{
SplitPoint& sp = Threads[i]->splitPoints[j];
Thread::Thread() /* : splitPoints() */ { // Initialization of non POD broken in MSVC
searching = false;
- maxPly = splitPointsSize = 0;
+ maxPly = 0;
+ splitPointsSize = 0;
activeSplitPoint = NULL;
activePosition = NULL;
idx = Threads.size(); // Starts from 0
// Make a local copy to be sure it doesn't become zero under our feet while
// testing next condition and so leading to an out of bounds access.
- const int size = splitPointsSize;
+ const size_t size = splitPointsSize;
// No split points means that the thread is available as a slave for any
// other thread otherwise apply the "helpful master" concept if possible.
struct Thread;
-const int MAX_THREADS = 128;
-const int MAX_SPLITPOINTS_PER_THREAD = 8;
+const size_t MAX_THREADS = 128;
+const size_t MAX_SPLITPOINTS_PER_THREAD = 8;
const size_t MAX_SLAVES_PER_SPLITPOINT = 4;
/// Mutex and ConditionVariable struct are wrappers of the low level locking
size_t idx;
int maxPly;
SplitPoint* volatile activeSplitPoint;
- volatile int splitPointsSize;
+ volatile size_t splitPointsSize;
volatile bool searching;
};