AREXPORT bool ArUrg::asyncConnect(void)
{
myStartConnect = true;
if (!getRunning())
runAsync();
return true;
}
void Raids::checkRaids()
{
if(!getRunning()){
uint64_t now = OTSYS_TIME();
for(RaidList::iterator it = raidList.begin(); it != raidList.end(); ++it){
if(now >= (getLastRaidEnd() + (*it)->getMargin())){
if(MAX_RAND_RANGE*CHECK_RAIDS_INTERVAL/(*it)->getInterval() >= (uint32_t)random_range(0, MAX_RAND_RANGE)){
#ifdef __DEBUG_RAID__
char buffer[32];
time_t tmp = time(NULL);
formatDate(tmp, buffer);
std::cout << buffer << " [Notice] Raids: Starting raid " << (*it)->getName() << std::endl;
#endif
setRunning(*it);
(*it)->startRaid();
break;
}
}
}
}
checkRaidsEvent = Scheduler::getScheduler().addEvent(createSchedulerTask(CHECK_RAIDS_INTERVAL*1000,
boost::bind(&Raids::checkRaids, this)));
}
void processTasks()
{
cocos2d::CCLog("==HTTP Started");
std::unique_lock<std::mutex>
lock(_cond_mutex);
while(true)
{
startTasks();
int still_running = 0;
curl_multi_perform(cm, &still_running);
int msgs_left = 0;
CURLMsg *msg=NULL;
while ((msg = curl_multi_info_read(cm, &msgs_left))) {
if (msg->msg == CURLMSG_DONE) {
CURL* curl = msg->easy_handle;
CURLcode return_code = msg->data.result;
onEnd(curl, return_code);
}
else {
fprintf(stderr, "error: after curl_multi_info_read(), CURLMsg=%d\n", msg->msg);
}
}
int old_running = getRunning();
startTasks();
int new_running = getRunning();
if(!still_running && new_running == 0)
{
cocos2d::CCLog("==HTTP sleep");
_cond.wait(lock);
cocos2d::CCLog("==HTTP wakeup");
if(stop)
return;
}
if(still_running && old_running == new_running)
{
int numfds=0;
curl_multi_wait(cm, NULL, 0, 1000, &numfds);
}
}
}
virtual void* runThread(void* arg)
{
while(getRunning())
{
ArSystemStatus::invalidate();
ArUtil::sleep(myRefreshFrequency);
}
return NULL;
}
int Search::checkTime() {
if (getRunning() == 2) {
return 2;
}
if (ponder) {
return 1;
}
auto t_current = std::chrono::high_resolution_clock::now();
return Time::diffTime(t_current, startTime) >= maxTimeMillsec ? 0 : 1;
}
virtual void* runThread(void* arg)
{
threadStarted();
while(Aria::getRunning() && getRunning())
{
ArSystemStatus::invalidate();
ArUtil::sleep(myRefreshFrequency);
}
threadFinished();
return NULL;
}
// The main loop for the threads. It checks to see if its still running.
// If not, it exits. The running variable is managed by ArThread. While its
// running, it waits on the condition variable.
void * Task::runThread(void *arg)
{
threadStarted();
while (getRunning())
{
printf("Task %d waiting\n", myNum);
myCond->wait();
printf("Task %d woke up\n", myNum);
}
return(NULL);
}
void Raids::checkRaids()
{
checkRaidsEvent = Scheduler::getInstance().addEvent(createSchedulerTask(
CHECK_RAIDS_INTERVAL * 1000, boost::bind(&Raids::checkRaids, this)));
if(getRunning())
return;
uint64_t now = OTSYS_TIME();
for(RaidList::iterator it = raidList.begin(); it != raidList.end(); ++it)
{
if((*it)->isEnabled() && !(*it)->hasRef() && now > (lastRaidEnd + (*it)->getMargin()) &&
(MAX_RAND_RANGE * CHECK_RAIDS_INTERVAL / (*it)->getInterval()) >= (
uint32_t)random_range(0, MAX_RAND_RANGE) && (*it)->startRaid())
break;
}
}
AREXPORT void * ArUrg::runThread(void *arg)
{
while (getRunning())
{
lockDevice();
if (myStartConnect)
{
myStartConnect = false;
myTryingToConnect = true;
unlockDevice();
blockingConnect();
lockDevice();
myTryingToConnect = false;
unlockDevice();
continue;
}
unlockDevice();
if (!myIsConnected)
{
ArUtil::sleep(100);
continue;
}
// if we have a robot but it isn't running yet then don't have a
// connection failure
if (laserCheckLostConnection())
{
ArLog::log(ArLog::Terse,
"%s: Lost connection to the laser because of error. Nothing received for %g seconds (greater than the timeout of %g).", getName(),
myLastReading.mSecSince()/1000.0,
getConnectionTimeoutSeconds());
myIsConnected = false;
laserDisconnectOnError();
continue;
}
internalGetReading();
ArUtil::sleep(1);
}
return NULL;
}
void Raids::checkRaids()
{
if (!getRunning()) {
uint64_t now = OTSYS_TIME();
for (auto it = raidList.begin(); it != raidList.end(); ++it) {
if (now >= (getLastRaidEnd() + (*it)->getMargin())) {
if (MAX_RAND_RANGE * CHECK_RAIDS_INTERVAL / (*it)->getInterval() >= (uint32_t)uniform_random(0, MAX_RAND_RANGE)) {
setRunning(*it);
(*it)->startRaid();
if (g_config.getBoolean(ConfigManager::SHUTDOWN_AT_SERVERSAVE)) {
raidList.erase(it);
}
break;
}
}
}
}
checkRaidsEvent = g_scheduler.addEvent(createSchedulerTask(CHECK_RAIDS_INTERVAL * 1000, boost::bind(&Raids::checkRaids, this)));
}
void Raids::checkRaids()
{
if (!getRunning()) {
uint64_t now = OTSYS_TIME();
for (auto it = raidList.begin(); it != raidList.end(); ++it) {
Raid* raid = *it;
if (now >= (getLastRaidEnd() + raid->getMargin())) {
if (MAX_RAND_RANGE * CHECK_RAIDS_INTERVAL / raid->getInterval() >= static_cast<uint32_t>(uniform_random(0, MAX_RAND_RANGE))) {
setRunning(raid);
raid->startRaid();
if (!raid->canBeRepeated()) {
raidList.erase(it);
}
break;
}
}
}
}
checkRaidsEvent = g_scheduler.addEvent(createSchedulerTask(CHECK_RAIDS_INTERVAL * 1000, std::bind(&Raids::checkRaids, this)));
}
void Search::aspirationWindow(const int depth, const int valWin) {
valWindow = valWin;
init();
if (depth == 1) {
valWindow = search(SMP_NO, depth, -_INFINITE, _INFINITE);
} else {
ASSERT(INT_MAX != valWindow);
int tmp = search(SMP_NO, mainDepth, valWindow - VAL_WINDOW, valWindow + VAL_WINDOW);
if (tmp <= valWindow - VAL_WINDOW || tmp >= valWindow + VAL_WINDOW) {
if (tmp <= valWindow - VAL_WINDOW) {
tmp = search(SMP_NO, mainDepth, valWindow - VAL_WINDOW * 2, valWindow + VAL_WINDOW);
} else {
tmp = search(SMP_NO, mainDepth, valWindow - VAL_WINDOW, valWindow + VAL_WINDOW * 2);
}
if (tmp <= valWindow - VAL_WINDOW || tmp >= valWindow + VAL_WINDOW) {
if (tmp <= valWindow - VAL_WINDOW) {
tmp = search(SMP_NO, mainDepth, valWindow - VAL_WINDOW * 4, valWindow + VAL_WINDOW);
} else {
tmp = search(SMP_NO, mainDepth, valWindow - VAL_WINDOW, valWindow + VAL_WINDOW * 4);
}
if (tmp <= valWindow - VAL_WINDOW || tmp >= valWindow + VAL_WINDOW) {
tmp = search(SMP_NO, mainDepth, -_INFINITE, _INFINITE);
}
}
}
if (getRunning()) {
valWindow = tmp;
}
}
}
int Search::quiescence(int alpha, int beta, const char promotionPiece, int N_PIECE, int depth) {
if (!getRunning()) {
return 0;
}
ASSERT(chessboard[KING_BLACK + side]);
if (!(numMovesq++ & 1023)) {
setRunning(checkTime());
}
int score = getScore(side, N_PIECE, alpha, beta, false);
if (score >= beta) {
return beta;
}
///************* hash ****************
char hashf = Hash::hashfALPHA;
u64 zobristKeyR = chessboard[ZOBRISTKEY_IDX] ^_random::RANDSIDE[side];
_TcheckHash checkHashStruct;
if (checkHash<Hash::HASH_GREATER, smp>(true, alpha, beta, depth, zobristKeyR, checkHashStruct)) {
return checkHashStruct.res;
};
if (checkHash<Hash::HASH_ALWAYS, smp>(true, alpha, beta, depth, zobristKeyR, checkHashStruct)) {
return checkHashStruct.res;
};
///********** end hash ***************
/**************Delta Pruning ****************/
char fprune = 0;
int fscore;
if ((fscore = score + (promotionPiece == NO_PROMOTION ? VALUEQUEEN : 2 * VALUEQUEEN)) < alpha) {
fprune = 1;
}
/************ end Delta Pruning *************/
if (score > alpha) {
alpha = score;
}
incListId();
u64 friends = getBitmap<side>();
u64 enemies = getBitmap<side ^ 1>();
if (generateCaptures<side>(enemies, friends)) {
decListId();
return _INFINITE - (mainDepth + depth);
}
if (!getListSize()) {
--listId;
return score;
}
_Tmove *move;
_Tmove *best = nullptr;
u64 oldKey = chessboard[ZOBRISTKEY_IDX];
if (checkHashStruct.hashFlag[Hash::HASH_GREATER]) {
sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_GREATER]);
} else if (checkHashStruct.hashFlag[Hash::HASH_ALWAYS]) {
sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_ALWAYS]);
}
while ((move = getNextMove(&gen_list[listId]))) {
if (!makemove(move, false, true)) {
takeback(move, oldKey, false);
continue;
}
/**************Delta Pruning ****************/
if (fprune && ((move->type & 0x3) != PROMOTION_MOVE_MASK) && fscore + PIECES_VALUE[move->capturedPiece] <= alpha) {
INC(nCutFp);
takeback(move, oldKey, false);
continue;
}
/************ end Delta Pruning *************/
int val = -quiescence<side ^ 1, smp>(-beta, -alpha, move->promotionPiece, N_PIECE - 1, depth - 1);
score = max(score, val);
takeback(move, oldKey, false);
if (score > alpha) {
if (score >= beta) {
decListId();
ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]);
ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]);
recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth, Hash::hashfBETA, zobristKeyR, score, move);
return beta;
}
best = move;
alpha = score;
hashf = Hash::hashfEXACT;
}
}
ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]);
ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]);
recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth, hashf, zobristKeyR, score, best);
decListId();
return score;
}
void Search::run() {
if (getRunning()) {
aspirationWindow(mainDepth, valWindow);
}
}
AREXPORT bool ArUrg::blockingConnect(void)
{
if (!getRunning())
runAsync();
myConnMutex.lock();
if (myConn == NULL)
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because there is no connection defined",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
ArSerialConnection *serConn = NULL;
serConn = dynamic_cast<ArSerialConnection *>(myConn);
if (serConn != NULL)
serConn->setBaud(atoi(getStartingBaudChoice()));
if (myConn->getStatus() != ArDeviceConnection::STATUS_OPEN &&
!myConn->openSimple())
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because the connection was not open and could not open it",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
myConnMutex.unlock();
lockDevice();
myTryingToConnect = true;
unlockDevice();
laserPullUnsetParamsFromRobot();
laserCheckParams();
setParams(getStartDegrees(), getEndDegrees(), getIncrement(), getFlipped());
ArUtil::sleep(100);
bool connected = false;
if (internalConnect())
connected = true;
if (connected)
{
lockDevice();
myIsConnected = true;
myTryingToConnect = false;
unlockDevice();
ArLog::log(ArLog::Normal, "%s: Connected to laser", getName());
laserConnect();
return true;
}
else
{
failedToConnect();
return false;
}
}
AREXPORT bool ArLMS1XX::blockingConnect(void)
{
char buf[1024];
if (!getRunning())
runAsync();
myConnMutex.lock();
if (myConn == NULL)
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because there is no connection defined",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
if (myConn->getStatus() != ArDeviceConnection::STATUS_OPEN &&
!myConn->openSimple())
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because the connection was not open and could not open it", getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
myReceiver.setDeviceConnection(myConn);
myConnMutex.unlock();
lockDevice();
myTryingToConnect = true;
unlockDevice();
laserPullUnsetParamsFromRobot();
laserCheckParams();
int size = (270 / .25 + 1);
ArLog::log(myInfoLogLevel, "%s: Setting current buffer size to %d",
getName(), size);
setCurrentBufferSize(size);
ArTime timeDone;
if (myPowerControlled)
timeDone.addMSec(60 * 1000);
else
timeDone.addMSec(30 * 1000);
ArLMS1XXPacket *packet;
ArLMS1XXPacket sendPacket;
sendPacket.empty();
sendPacket.strToBuf("sMN");
sendPacket.strToBuf("SetAccessMode");
sendPacket.uByteToBuf(0x3); // level
sendPacket.strToBuf("F4724744"); // hashed password
sendPacket.finalizePacket();
if ((packet = sendAndRecv(timeDone, &sendPacket, "SetAccessMode")) != NULL)
{
int val;
val = packet->bufToUByte();
delete packet;
packet = NULL;
if (val == 1)
{
ArLog::log(myLogLevel, "%s: Changed access mode (%d)",
getName(), val);
}
else
{
ArLog::log(ArLog::Terse,
"%s: Could not change access mode (%d)", getName(), val);
failedToConnect();
return false;
}
}
else
{
failedToConnect();
return false;
}
sendPacket.empty();
sendPacket.strToBuf("sMN");
sendPacket.strToBuf("mLMPsetscancfg");
sendPacket.byte4ToBuf(5000); // scanning freq
sendPacket.byte2ToBuf(1); // number segments
sendPacket.byte4ToBuf(getIncrementChoiceDouble() * 10000); // angle resolution
//sendPacket.byte4ToBuf((getStartDegrees() + 90) * 10000); // starting angle
sendPacket.byte4ToBuf(-45 * 10000); // can't change starting angle
//sendPacket.byte4ToBuf((getEndDegrees() + 90) * 10000); // ending angle
sendPacket.byte4ToBuf(225 * 10000); // can't change ending angle
sendPacket.finalizePacket();
ArLog::log(myLogLevel, "%s: setscancfg: %s", getName(),
sendPacket.getBuf());
if ((packet = sendAndRecv(timeDone, &sendPacket, "mLMPsetscancfg")) != NULL)
{
int val;
val = packet->bufToUByte();
delete packet;
packet = NULL;
if (val == 0)
{
ArLog::log(myLogLevel, "%s: setscancfg succeeded (%d)",
getName(), val);
}
else
{
ArLog::log(ArLog::Terse,
"%s: Setscancfg failed (%d)", getName(), val);
failedToConnect();
return false;
}
}
else
{
failedToConnect();
return false;
}
sendPacket.empty();
sendPacket.strToBuf("sWN");
sendPacket.strToBuf("LMDscandatacfg");
sendPacket.uByte2ToBuf(0x1); // output channel
sendPacket.uByteToBuf(0x0); // remission
sendPacket.uByteToBuf(0x0); // remission resolution
sendPacket.uByteToBuf(0x0); // unit
sendPacket.uByte2ToBuf(0x0); // encoder
sendPacket.uByteToBuf(0x0); // position
sendPacket.uByteToBuf(0x0); // device name
sendPacket.uByteToBuf(0x0); // comment
sendPacket.uByteToBuf(0x0); // time
sendPacket.byteToBuf(5); // which scan
//sendPacket.byteToBuf(1); // which scan
sendPacket.finalizePacket();
ArLog::log(myLogLevel, "%s: scandatacfg: %s", getName(), sendPacket.getBuf());
if ((packet = sendAndRecv(timeDone, &sendPacket, "LMDscandatacfg")) != NULL)
{
ArLog::log(myLogLevel, "%s: scandatacfg succeeded", getName());
delete packet;
packet = NULL;
}
else
{
failedToConnect();
return false;
}
sendPacket.empty();
sendPacket.strToBuf("sMN");
sendPacket.strToBuf("Run");
sendPacket.finalizePacket();
if ((packet = sendAndRecv(timeDone, &sendPacket, "Run")) != NULL)
{
int val;
val = packet->bufToUByte();
delete packet;
packet = NULL;
if (val == 1)
{
ArLog::log(myLogLevel, "%s: Run succeeded (%d)",
getName(), val);
}
else
{
ArLog::log(ArLog::Terse,
"%s: Could not run (%d)", getName(), val);
failedToConnect();
return false;
}
}
else
{
failedToConnect();
return false;
}
/* when asking one at a time
sendPacket.empty();
sendPacket.strToBuf("sRN");
sendPacket.strToBuf("LMDscandata");
sendPacket.finalizePacket();
if ((packet = sendAndRecv(timeDone, &sendPacket, "LMDscandata")) != NULL)
{
ArLog::log(myLogLevel, "%s: Got %s scan data %d", getName(),
packet->getCommandType(), packet->getLength());
myPacketsMutex.lock();
myPackets.push_back(packet);
myPacketsMutex.unlock();
sensorInterp();
ArLog::log(myLogLevel, "%s: Processed scan data", getName());
}
else
{
failedToConnect();
return false;
}
*/
sendPacket.empty();
sendPacket.strToBuf("sEN");
sendPacket.strToBuf("LMDscandata");
sendPacket.uByteToBuf(1);
sendPacket.finalizePacket();
//printf("(%s)\n", sendPacket.getBuf());
// just ask for continuous data
if (!myConn->write(sendPacket.getBuf(), sendPacket.getLength()))
{
ArLog::log(ArLog::Terse,
"%s: Could not send %s to laser", getName(), "LMDscandata");
failedToConnect();
return false;
}
while (timeDone.mSecTo())
{
packet = myReceiver.receivePacket(1000);
if (packet != NULL &&
strcasecmp(packet->getCommandType(), "sSN") == 0 &&
strcasecmp(packet->getCommandName(), "LMDscandata") == 0)
{
delete packet;
packet = NULL;
lockDevice();
myIsConnected = true;
myTryingToConnect = false;
unlockDevice();
ArLog::log(ArLog::Normal, "%s: Connected to laser", getName());
laserConnect();
return true;
}
else if (packet != NULL)
{
ArLog::log(myLogLevel, "%s: Got %s %s (%d long)", getName(),
packet->getCommandType(), packet->getCommandName(),
packet->getLength());
delete packet;
packet = NULL;
}
}
ArLog::log(ArLog::Terse,
"%s: Did not get scandata back from laser", getName());
failedToConnect();
return false;
}
AREXPORT void * ArLMS1XX::runThread(void *arg)
{
char buf[1024];
ArLMS1XXPacket *packet;
/*
ArTime dataRequested;
ArLMS1XXPacket requestPacket;
requestPacket.strToBuf("sRN");
requestPacket.strToBuf("LMDscandata");
requestPacket.finalizePacket();
*/
while (getRunning())
{
lockDevice();
if (myStartConnect)
{
myStartConnect = false;
myTryingToConnect = true;
unlockDevice();
blockingConnect();
lockDevice();
myTryingToConnect = false;
unlockDevice();
continue;
}
unlockDevice();
if (!myIsConnected)
{
ArUtil::sleep(100);
continue;
}
/*
dataRequested.setToNow();
if (myConn == NULL || !myConn->write(requestPacket.getBuf(),
requestPacket.getLength()))
{
ArLog::log(ArLog::Terse, "Could not send packets request to lms1XX");
continue;
}
*/
while (getRunning() && myIsConnected &&
(packet = myReceiver.receivePacket(50, true)) != NULL)
{
myPacketsMutex.lock();
myPackets.push_back(packet);
myPacketsMutex.unlock();
if (myRobot == NULL)
sensorInterp();
// if we have a robot but it isn't running yet then don't have a
// connection failure
if (laserCheckLostConnection())
{
ArLog::log(ArLog::Terse,
"%s: Lost connection to the laser because of error. Nothing received for %g seconds (greater than the timeout of %g).", getName(),
myLastReading.mSecSince()/1000.0,
getConnectionTimeoutSeconds());
myIsConnected = false;
laserDisconnectOnError();
continue;
}
}
ArUtil::sleep(1);
//ArUtil::sleep(2000);
//ArUtil::sleep(500);
}
return NULL;
}
AREXPORT bool ArUrg_2_0::blockingConnect(void)
{
if (!getRunning())
runAsync();
myConnMutex.lock();
if (myConn == NULL)
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because there is no connection defined",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
ArSerialConnection *serConn = NULL;
serConn = dynamic_cast<ArSerialConnection *>(myConn);
// if we have a starting baud and are a serial port, then change the
// baud rate... not by default this will set it to 0 baud which'll
// cause the serial stuff not to touch it
if (serConn != NULL)
serConn->setBaud(atoi(getStartingBaudChoice()));
if (myConn->getStatus() != ArDeviceConnection::STATUS_OPEN &&
!myConn->openSimple())
{
ArLog::log(ArLog::Terse,
"%s: Could not connect because the connection was not open and could not open it",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
myConnMutex.unlock();
lockDevice();
myTryingToConnect = true;
unlockDevice();
laserPullUnsetParamsFromRobot();
laserCheckParams();
ArUtil::sleep(100);
bool connected = false;
if (internalConnect())
connected = true;
if (connected)
{
lockDevice();
myIsConnected = true;
myTryingToConnect = false;
unlockDevice();
ArLog::log(ArLog::Normal, "%s: Connected to laser", getName());
laserConnect();
return true;
}
else
{
failedToConnect();
return false;
}
}
/// This should be its own thread here
void *ArCentralManager::runThread(void *arg)
{
std::list<ArSocket *>::iterator sIt;
std::list<std::string>::iterator nIt;
std::list<ArCentralForwarder *>::iterator fIt;
ArSocket *socket;
std::string robotName;
ArCentralForwarder *forwarder;
ArNetPacket *packet;
std::list<ArNetPacket *> addPackets;
std::list<ArNetPacket *> remPackets;
threadStarted();
while (getRunning())
{
int numForwarders = 0;
int numClients = 0;
myDataMutex.lock();
// this is where the original code to add forwarders was before we
// changed the unique behavior to drop old ones...
std::list<ArCentralForwarder *> connectedRemoveList;
std::list<ArCentralForwarder *> unconnectedRemoveList;
for (fIt = myForwarders.begin(); fIt != myForwarders.end(); fIt++)
{
forwarder = (*fIt);
numForwarders++;
if (forwarder->getServer() != NULL)
numClients += forwarder->getServer()->getNumClients();
bool connected = forwarder->isConnected();
bool removed = false;
if (!forwarder->callOnce(myHeartbeatTimeout, myUdpHeartbeatTimeout,
myRobotBackupTimeout, myClientBackupTimeout))
{
if (connected)
{
ArLog::log(ArLog::Normal, "Will remove forwarder from %s",
forwarder->getRobotName());
connectedRemoveList.push_back(forwarder);
removed = true;
}
else
{
ArLog::log(ArLog::Normal, "Failed to connect to forwarder from %s",
forwarder->getRobotName());
unconnectedRemoveList.push_back(forwarder);
removed = true;
}
}
if (!connected && !removed && forwarder->isConnected())
{
ArLog::log(ArLog::Normal, "Adding forwarder %s",
forwarder->getRobotName());
ArTime *newTime = new ArTime;
newTime->setSec(0);
myUsedPorts[forwarder->getPort()] = newTime;
std::multimap<int, ArFunctor1<ArCentralForwarder *> *>::iterator it;
for (it = myForwarderAddedCBList.begin();
it != myForwarderAddedCBList.end();
it++)
{
if ((*it).second->getName() == NULL ||
(*it).second->getName()[0] == '\0')
ArLog::log(ArLog::Normal, "Calling unnamed add functor at %d",
-(*it).first);
else
ArLog::log(ArLog::Normal, "Calling %s add functor at %d",
(*it).second->getName(), -(*it).first);
(*it).second->invoke(forwarder);
}
ArLog::log(ArLog::Normal, "Added forwarder %s",
forwarder->getRobotName());
ArNetPacket *sendPacket = new ArNetPacket;
sendPacket->strToBuf("");
sendPacket->uByte2ToBuf(forwarder->getPort());
sendPacket->strToBuf(forwarder->getRobotName());
sendPacket->strToBuf("");
sendPacket->strToBuf(
forwarder->getClient()->getTcpSocket()->getIPString());
addPackets.push_back(sendPacket);
// MPL added this at the same time as the changes for the deadlock that happened down below
//myClientServer->broadcastPacketTcp(&sendPacket, "clientAdded");
}
}
while ((fIt = connectedRemoveList.begin()) != connectedRemoveList.end())
{
forwarder = (*fIt);
ArLog::log(ArLog::Normal, "Removing forwarder %s",
forwarder->getRobotName());
std::multimap<int, ArFunctor1<ArCentralForwarder *> *>::iterator it;
for (it = myForwarderRemovedCBList.begin();
it != myForwarderRemovedCBList.end();
it++)
{
if ((*it).second->getName() == NULL ||
(*it).second->getName()[0] == '\0')
ArLog::log(ArLog::Normal, "Calling unnamed remove functor at %d",
-(*it).first);
else
ArLog::log(ArLog::Normal, "Calling %s remove functor at %d",
(*it).second->getName(), -(*it).first);
(*it).second->invoke(forwarder);
}
ArLog::log(ArLog::Normal, "Called forwarder removed for %s",
forwarder->getRobotName());
ArNetPacket *sendPacket = new ArNetPacket;
sendPacket->strToBuf("");
sendPacket->uByte2ToBuf(forwarder->getPort());
sendPacket->strToBuf(forwarder->getRobotName());
sendPacket->strToBuf("");
sendPacket->strToBuf(
forwarder->getClient()->getTcpSocket()->getIPString());
// MPL making this just push packets into a list to broadcast at the end since this was deadlocking
//myClientServer->broadcastPacketTcp(&sendPacket, "clientRemoved");
remPackets.push_back(sendPacket);
if (myUsedPorts.find(forwarder->getPort()) != myUsedPorts.end() &&
myUsedPorts[forwarder->getPort()] != NULL)
myUsedPorts[forwarder->getPort()]->setToNow();
myForwarders.remove(forwarder);
delete forwarder;
connectedRemoveList.pop_front();
ArLog::log(ArLog::Normal, "Removed forwarder");
}
while ((fIt = unconnectedRemoveList.begin()) !=
unconnectedRemoveList.end())
{
forwarder = (*fIt);
ArLog::log(ArLog::Normal, "Removing unconnected forwarder %s",
forwarder->getRobotName());
if (myUsedPorts.find(forwarder->getPort()) != myUsedPorts.end() &&
myUsedPorts[forwarder->getPort()] != NULL)
myUsedPorts[forwarder->getPort()]->setToNow();
myForwarders.remove(forwarder);
delete forwarder;
unconnectedRemoveList.pop_front();
ArLog::log(ArLog::Normal, "Removed unconnected forwarder");
}
// this code was up above just after the lock before we changed
// the behavior for unique names
while ((sIt = myClientSockets.begin()) != myClientSockets.end() &&
(nIt = myClientNames.begin()) != myClientNames.end())
{
socket = (*sIt);
robotName = (*nIt);
myClientSockets.pop_front();
myClientNames.pop_front();
ArLog::log(ArLog::Normal,
"New forwarder for socket from %s with name %s",
socket->getIPString(), robotName.c_str());
forwarder = new ArCentralForwarder(myClientServer, socket,
robotName.c_str(),
myClientServer->getTcpPort() + 1,
&myUsedPorts,
&myForwarderServerClientRemovedCB,
myEnforceProtocolVersion.c_str(),
myEnforceType);
myForwarders.push_back(forwarder);
}
numClients += myRobotServer->getNumClients();
if (myRobotServer != myClientServer)
numClients += myClientServer->getNumClients();
// end of code moved for change in unique behavior
if (numClients > myMostClients)
{
ArLog::log(ArLog::Normal, "CentralManager: New most clients: %d",
numClients);
myMostClients = numClients;
}
if (numForwarders > myMostForwarders)
myMostForwarders = numForwarders;
if (numClients > myMostClients)
{
ArLog::log(ArLog::Normal, "CentralManager: New most forwarders: %d",
numForwarders);
myMostForwarders = numForwarders;
}
myRobotServer->internalSetNumClients(numForwarders +
myClientSockets.size());
myDataMutex.unlock();
while (addPackets.begin() != addPackets.end())
{
packet = addPackets.front();
myClientServer->broadcastPacketTcp(packet, "clientAdded");
addPackets.pop_front();
delete packet;
}
while (remPackets.begin() != remPackets.end())
{
packet = remPackets.front();
myClientServer->broadcastPacketTcp(packet, "clientRemoved");
remPackets.pop_front();
delete packet;
}
ArUtil::sleep(1);
//make this a REALLY long sleep to test the duplicate pending
//connection code
//ArUtil::sleep(20000);
}
threadFinished();
return NULL;
}
// Main program entry point
int main(int argc, char **argv) {
for (int i = 0; i < (1 + MAX_PLAYERS); i++)
threadsFree[i] = -1;
setProgName(argv[0]);
debugDisable();
infoPrint("Server Gruppe 01");
userInit();
// Create PID lock file or exit if it already exists
debugPrint("Making sure we're running only once...");
if (singleton(LOCKFILE) != 0)
return 1;
// Socket structure that could be modified by the command line arguments
struct sockaddr_in server;
server.sin_family = AF_INET;
server.sin_addr.s_addr = htonl(INADDR_ANY);
server.sin_port = htons(PORT); // Use the default port defined in "common"!
// Prepare parsing the command line options using getopt()
debugPrint("Parsing command line options...");
const char* short_options = "hvp:";
struct option long_options[] = {
{ "help", no_argument, 0, 'h' },
{ "verbose", no_argument, 0, 'v' },
{ "port", required_argument, 0, 'p' },
{ NULL, 0, NULL, 0 }
};
// Actual getopt() loop
int option_index = 0;
int loop = 1;
while (loop != 0) {
int c = getopt_long(argc, argv, short_options, long_options, &option_index);
switch (c) {
// Show help text when using -h
case 'h':
show_help();
exit(1);
break;
// Enable verbose (debug) output
case 'v':
debugEnable();
break;
// Set port to listen on
case 'p':
if(optarg) {
if (isOnlyDigits(optarg)) {
server.sin_port = htons(atoi(optarg));
} else {
errorPrint("Port has to be a decimal number!");
exit(1);
}
}
break;
// Unknown option, show error & help message
default:
case '?':
errorPrint("Option not implemented yet -- %s (%c)", argv[optind-1], c);
show_help();
exit(1);
break;
// All options have been parsed
case -1:
loop = 0;
break;
}
}
infoPrint("Serverport: %i", ntohs(server.sin_port));
// Create the pipes that will be used to communicate with the loader
debugPrint("Creating Pipes...");
if (!createPipes())
return 1;
// Actually fork and run the loader as child process
debugPrint("Forking to run loader...");
if (!forkLoader())
return 1;
debugPrint("Starting Threads...");
// Start the score agent thread
if (pthread_create(&threads[0], NULL, scoreThread, NULL) != 0) {
threadsFree[0] = -2;
errnoPrint("pthread_create");
return 1;
}
clientInit();
// Create the listening socket
debugPrint("Creating socket...");
int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
if (listen_socket == -1) {
errnoPrint("socket");
return 1;
}
// Enable address reusing, so we don't get bind errors
int on = 1;
setsockopt(listen_socket, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
// Register our Interrupt Signal handler
signal(SIGINT, intHandler);
// Store the listening socket in our user database
userSetMainSocket(listen_socket);
// Actually bind the listening socket
if (bind(listen_socket, (struct sockaddr*) &server, sizeof(struct sockaddr_in)) == -1) {
errnoPrint("bind");
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
return 1;
}
// Prepare the pselect() timeout data structure
fd_set fds;
struct timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = SOCKET_TIMEOUT * 1000000;
sigset_t blockset;
sigfillset(&blockset);
sigdelset(&blockset, SIGINT);
// Main thread main loop, waiting for new connections
debugPrint("Waiting for connections...");
while (getRunning()) {
// Listen to the listening socket
if (listen(listen_socket, MAX_QUERYS) == -1) {
errnoPrint("listen");
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
cleanCategories();
return 1;
}
// Wait for activity on the listening socket
FD_ZERO(&fds);
FD_SET(listen_socket, &fds);
int retval = pselect(listen_socket + 1, &fds, NULL, NULL, &ts, &blockset);
if (retval == -1) {
if (errno == EINTR) {
// We should exit because the user pressed Ctrl + C
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
cleanCategories();
return 0;
} else {
// pselect encountered an error!
errnoPrint("select");
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
cleanCategories();
return 1;
}
} else if (retval == 0) {
// Nothing happened and pselect timed out
continue;
} else {
// We have a new connection, accept it
struct sockaddr_in remote_host;
socklen_t sin_size = sizeof(struct sockaddr_in);
int client_socket = accept(listen_socket, (struct sockaddr *) &remote_host, &sin_size);
if (client_socket == -1) {
errnoPrint("accept");
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
cleanCategories();
return 1;
}
debugPrint("Got a new connection! Performing Login...");
loginHandleSocket(client_socket);
}
}
// Clean up behind ourselves
close(listen_socket);
closePipes();
loaderCloseSharedMemory();
cleanCategories();
pthread_exit(NULL);
return 0;
}
AREXPORT bool ArSZSeries::blockingConnect(void) {
if (!getRunning())
runAsync();
myConnMutex.lock();
if (myConn == NULL) {
ArLog::log(ArLog::Terse,
"%s: Could not connect because there is no connection defined",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
// myPrevSensorIntTime = myConn->getTimeRead(0);
// PS 9/9/11 - moved this here to fix issue with setting baud in mt400.p
laserPullUnsetParamsFromRobot();
laserCheckParams();
// PS 9/9/11 - add setting baud
ArSerialConnection *serConn = NULL;
serConn = dynamic_cast<ArSerialConnection *>(myConn);
if (serConn != NULL)
serConn->setBaud(atoi(getStartingBaudChoice()));
if (myConn->getStatus() != ArDeviceConnection::STATUS_OPEN
&& !myConn->openSimple()) {
ArLog::log(
ArLog::Terse,
"%s: Could not connect because the connection was not open and could not open it",
getName());
myConnMutex.unlock();
failedToConnect();
return false;
}
// PS - set logging level and laser type in packet receiver class
myReceiver.setmyInfoLogLevel(myInfoLogLevel);
myReceiver.setmyName(getName());
myReceiver.setDeviceConnection(myConn);
myConnMutex.unlock();
lockDevice();
myTryingToConnect = true;
unlockDevice();
// PS 9/9/11 - moved up top
//laserPullUnsetParamsFromRobot();
//laserCheckParams();
int size = ArMath::roundInt((270/.3) + 1);
ArLog::log(myInfoLogLevel,
"%s::blockingConnect() Setting current buffer size to %d",
getName(), size);
setCurrentBufferSize(size);
ArTime timeDone;
if (myPowerControlled)
{
if (!timeDone.addMSec(60 * 1000))
{
ArLog::log(ArLog::Normal,
"%s::blockingConnect() error adding msecs (60 * 1000)",
getName());
}
}
else
{
if (!timeDone.addMSec(30 * 1000))
{
ArLog::log(ArLog::Normal,
"%s::blockingConnect() error adding msecs (30 * 1000)",
getName());
}
}
ArSZSeriesPacket *packet;
ArSZSeriesPacket sendPacket;
#if 0
sendPacket.empty();
sendPacket.uByteToBuf(0xA0); // stop continous sending
sendPacket.uByteToBuf(0x00);
sendPacket.uByteToBuf(0x1D);
sendPacket.uByteToBuf(0x7E);
sendPacket.finalizePacket();
if ((myConn->write(sendPacket.getBuf(), sendPacket.getLength())) == -1)
{
ArLog::log(ArLog::Terse,
"%s::blockingConnect() Could not send Stop Continuous mode to laser", getName());
failedToConnect();
return false;
}
#endif
// Build the Start Continuous sending packet and set it
// once we get a response, then we are connected, note
// the response needs to be a real reading
sendPacket.empty();
// command id = 0x91
//sendPacket.uByteToBuf(145);
sendPacket.uByteToBuf(0x91);
// note communication ID default is 0
// this value is set via the SZ Configurator
// ???? not sure what to do if it fails
// and put in CRC - from manual, this is
// specific to the communication ID = 0
sendPacket.uByteToBuf(0);
sendPacket.uByteToBuf(43);
sendPacket.uByteToBuf(218);
unsigned short crc = myReceiver.CRC16((unsigned char *)sendPacket.getBuf(), 2);
#if 0
// other communications IDs and CRC
// communication ID =1
sendPacket.uByteToBuf(1);
sendPacket.uByteToBuf(59);
sendPacket.uByteToBuf(251);
// communication ID =2
sendPacket.uByteToBuf(2);
sendPacket.uByteToBuf(11);
sendPacket.uByteToBuf(152);
// communication ID =3
sendPacket.uByteToBuf(3);
sendPacket.uByteToBuf(27);
sendPacket.uByteToBuf(185);
#endif
sendPacket.finalizePacket();
IFDEBUG(
int i;
char x[100000];
printf("buffer with len = %d: ",sendPacket.getLength());
for (i = 0;i < sendPacket.getLength();i++)
{
printf("0x%x ",sendPacket.getBuf()[i] & 0xff);
//sprintf(&x[i], "%2x", (char *)sendPacket.getBuf()[i]);
}
printf("\n");
//ArLog::log(ArLog::Terse,
// "%s::blockingConnect() write Buffer = %s", getName(), x);
); // end IFDEBUG
void Interpreter::run()
{
int res;
QTime time;
// init
try
{
ChirpProc versionProc;
uint16_t *version;
uint32_t verLen, responseInt;
if (m_link.open()<0)
throw std::runtime_error("Unable to open USB device.");
m_chirp = new ChirpMon(this, &m_link);
// get version and compare
versionProc = m_chirp->getProc("version");
if (versionProc<0)
throw std::runtime_error("Can't get firmware version.");
res = m_chirp->callSync(versionProc, END_OUT_ARGS, &responseInt, &verLen, &version, END_IN_ARGS);
if (res<0)
throw std::runtime_error("Can't get firmware version.");
memcpy(m_version, version, 3*sizeof(uint16_t));
if (m_version[0]!=VER_MAJOR || m_version[1]>VER_MINOR)
{
char buf[0x100];
sprintf(buf, "This Pixy's firmware version (%d.%d.%d) is not compatible with this PixyMon version (%d.%d.%d).",
m_version[0], m_version[1], m_version[2], VER_MAJOR, VER_MINOR, VER_BUILD);
throw std::runtime_error(buf);
}
m_exec_run = m_chirp->getProc("run");
m_exec_running = m_chirp->getProc("running");
m_exec_stop = m_chirp->getProc("stop");
m_exec_get_action = m_chirp->getProc("getAction");
m_get_param = m_chirp->getProc("prm_get");
m_getAll_param = m_chirp->getProc("prm_getAll");
m_set_param = m_chirp->getProc("prm_set");
if (m_exec_run<0 || m_exec_running<0 || m_exec_stop<0 || m_exec_get_action<0 ||
m_get_param<0 || m_getAll_param<0 || m_set_param<0)
throw std::runtime_error("Communication error with Pixy.");
}
catch (std::runtime_error &exception)
{
emit error(QString(exception.what()));
return;
}
qDebug() << "*** init done";
time.start();
getRunning();
handleLoadParams(); // load params upon initialization
while(m_run)
{
if (!m_programming &&
((m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_FAST) ||
(!m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_SLOW)))
{
getRunning();
time.start();
}
else
{
m_chirp->service(false);
msleep(1); // give config thread time to run
}
handlePendingCommand();
if (!m_running)
{
if (m_localProgramRunning)
execute();
else
{
Sleeper::msleep(10);
if (m_mutexProg.tryLock())
{
if (m_argv.size())
{
if (m_externalCommand!="") // print command to make things explicit and all pretty
emit textOut(PROMPT " " + m_externalCommand);
if (m_argv[0]=="help")
handleHelp();
else
{
res = call(m_argv, true);
if (res<0)
{
if (m_programming)
{
endLocalProgram();
clearLocalProgram();
}
m_commandList.clear(); // abort our little scriptlet
}
}
m_argv.clear();
if (m_externalCommand=="")
prompt(); // print prompt only if we expect an actual human to be typing into the command window
else
m_externalCommand = "";
// check quickly to see if we're running after this command
if (!m_programming)
getRunning();
// is there another command in our little scriptlet?
if (m_commandList.size())
{
execute(m_commandList[0]);
m_commandList.removeFirst();
}
}
m_mutexProg.unlock();
}
}
}
}
sendStop();
msleep(200); // let things settle a bit
qDebug("worker thead exiting");
}
void Interpreter::run()
{
int res;
QTime time;
QString paramScriptlet;
// init
try
{
int i;
ChirpProc versionProc;
uint16_t *ver;
uint32_t verLen, responseInt;
if (m_link.open()<0)
throw std::runtime_error("Unable to open USB device.");
m_chirp = new ChirpMon(this, &m_link);
// get version and compare
versionProc = m_chirp->getProc("version");
if (versionProc<0)
throw std::runtime_error("Can't get firmware version.");
res = m_chirp->callSync(versionProc, END_OUT_ARGS, &responseInt, &verLen, &ver, END_IN_ARGS);
if (res<0)
throw std::runtime_error("Can't get firmware version.");
memcpy(m_version, ver, 3*sizeof(uint16_t));
emit version(m_version[0], m_version[1], m_version[2]);
if (m_version[0]!=VER_MAJOR || m_version[1]>VER_MINOR)
{
char buf[0x100];
sprintf(buf, "This Pixy's firmware version (%d.%d.%d) is not compatible with this PixyMon version (%d.%d.%d).",
m_version[0], m_version[1], m_version[2], VER_MAJOR, VER_MINOR, VER_BUILD);
throw std::runtime_error(buf);
}
m_exec_run = m_chirp->getProc("run");
m_exec_running = m_chirp->getProc("running");
m_exec_stop = m_chirp->getProc("stop");
m_exec_get_action = m_chirp->getProc("getAction");
m_get_param = m_chirp->getProc("prm_get");
m_getAll_param = m_chirp->getProc("prm_getAll");
m_set_param = m_chirp->getProc("prm_set");
m_reload_params = m_chirp->getProc("prm_reload");
m_set_shadow_param = m_chirp->getProc("prm_setShadow");
m_reset_shadows = m_chirp->getProc("prm_resetShadows");
if (m_exec_run<0 || m_exec_running<0 || m_exec_stop<0 || m_exec_get_action<0 ||
m_get_param<0 || m_getAll_param<0 || m_set_param<0 || m_reload_params<0 ||
m_set_shadow_param<0 || m_reset_shadows<0)
throw std::runtime_error("Hmm... missing procedures.");
// create pixymon modules
m_modules.push_back(m_renderer); // add renderer to monmodule list so we can send it updates, etc
MonModuleUtil::createModules(&m_modules, this);
// reload any parameters that the mon modules might have created
m_pixymonParameters->load();
// notify mon modules of parameter change
sendMonModulesParamChange();
// load debug
m_pixymonParameters->clean();
// get all actions
for (i=0; sendGetAction(i)>=0; i++);
}
catch (std::runtime_error &exception)
{
emit error(QString(exception.what()) + '\n');
return;
}
DBG("*** init done");
time.start();
getRunning();
paramScriptlet = m_pixymonParameters->value("Pixy start command").toString();
paramScriptlet.remove(QRegExp("^\\s+")); // remove initial whitespace
handleLoadParams(); // load params upon initialization
if (m_initScript!="")
execute(parseScriptlet(m_initScript));
else if (paramScriptlet!="")
execute(paramScriptlet);
while(m_run)
{
// poll to see if we're still connected
if (!m_programming &&
((m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_FAST) ||
(!m_fastPoll && time.elapsed()>RUN_POLL_PERIOD_SLOW)))
{
getRunning();
time.start();
}
// service chirps -- but if we're running a local program it just slows things down
else if (!m_localProgramRunning)
{
m_chirp->service(false);
msleep(1); // give config thread time to run
}
handlePendingCommand();
handleLocalProgram();
if (!m_running && !m_localProgramRunning)
{
emit enableConsole(true);
Sleeper::msleep(10);
if (m_mutexProg.tryLock())
{
if (m_argv.size())
{
if (m_argv[0]=="help")
handleHelp();
else
{
res = call(m_argv, true);
if (res<0)
{
if (m_programming)
{
endLocalProgram();
clearLocalProgram();
}
m_commandList.clear(); // abort our little scriptlet
}
}
m_argv.clear();
// check quickly to see if we're running after this command
if (!m_programming)
getRunning();
// is there another command in our little scriptlet?
if (m_commandList.size())
{
execute(m_commandList[0]);
m_commandList.removeFirst();
}
}
m_mutexProg.unlock();
}
}
}
DBG("worker thead exiting");
}
int Search::search(int depth, int alpha, int beta, _TpvLine *pline, int N_PIECE, int *mateIn) {
ASSERT_RANGE(depth, 0, MAX_PLY);
INC(cumulativeMovesCount);
*mateIn = INT_MAX;
ASSERT_RANGE(side, 0, 1);
if (!getRunning()) {
return 0;
}
int score = -_INFINITE;
/* gtb */
if (gtb && pline->cmove && maxTimeMillsec > 1000 && gtb->isInstalledPieces(N_PIECE) && depth >= gtb->getProbeDepth()) {
int v = gtb->getDtm<side, false>(chessboard, (uchar) chessboard[RIGHT_CASTLE_IDX], depth);
if (abs(v) != INT_MAX) {
*mateIn = v;
int res = 0;
if (v == 0) {
res = 0;
} else {
res = _INFINITE - (abs(v));
if (v < 0) {
res = -res;
}
}
ASSERT_RANGE(res, -_INFINITE, _INFINITE);
ASSERT(mainDepth >= depth);
return res;
}
}
u64 oldKey = chessboard[ZOBRISTKEY_IDX];
#ifdef DEBUG_MODE
double betaEfficiencyCount = 0.0;
#endif
ASSERT(chessboard[KING_BLACK]);
ASSERT(chessboard[KING_WHITE]);
ASSERT(chessboard[KING_BLACK + side]);
int extension = 0;
int is_incheck_side = inCheck<side>();
if (!is_incheck_side && depth != mainDepth) {
if (checkInsufficientMaterial(N_PIECE)) {
if (inCheck<side ^ 1>()) {
return _INFINITE - (mainDepth - depth + 1);
}
return -lazyEval<side>() * 2;
}
if (checkDraw(chessboard[ZOBRISTKEY_IDX])) {
return -lazyEval<side>() * 2;
}
}
if (is_incheck_side) {
extension++;
}
depth += extension;
if (depth == 0) {
return quiescence<side, smp>(alpha, beta, -1, N_PIECE, 0);
}
//************* hash ****************
u64 zobristKeyR = chessboard[ZOBRISTKEY_IDX] ^_random::RANDSIDE[side];
_TcheckHash checkHashStruct;
if (checkHash<Hash::HASH_GREATER, smp>(false, alpha, beta, depth, zobristKeyR, checkHashStruct)) {
return checkHashStruct.res;
};
if (checkHash<Hash::HASH_ALWAYS, smp>(false, alpha, beta, depth, zobristKeyR, checkHashStruct)) {
return checkHashStruct.res;
};
///********** end hash ***************
if (!(numMoves & 1023)) {
setRunning(checkTime());
}
++numMoves;
///********* null move ***********
int n_pieces_side;
_TpvLine line;
line.cmove = 0;
if (!is_incheck_side && !nullSearch && depth >= NULLMOVE_DEPTH && (n_pieces_side = getNpiecesNoPawnNoKing<side>()) >= NULLMOVES_MIN_PIECE) {
nullSearch = true;
int nullScore = -search<side ^ 1, smp>(depth - (NULLMOVES_R1 + (depth > (NULLMOVES_R2 + (n_pieces_side < NULLMOVES_R3 ? NULLMOVES_R4 : 0)))) - 1, -beta, -beta + 1, &line, N_PIECE, mateIn);
nullSearch = false;
if (nullScore >= beta) {
INC(nNullMoveCut);
return nullScore;
}
}
///******* null move end ********
/**************Futility Pruning****************/
/**************Futility Pruning razor at pre-pre-frontier*****/
bool futilPrune = false;
int futilScore = 0;
if (depth <= 3 && !is_incheck_side) {
int matBalance = lazyEval<side>();
if ((futilScore = matBalance + FUTIL_MARGIN) <= alpha) {
if (depth == 3 && (matBalance + RAZOR_MARGIN) <= alpha && getNpiecesNoPawnNoKing<side ^ 1>() > 3) {
INC(nCutRazor);
depth--;
} else
///**************Futility Pruning at pre-frontier*****
if (depth == 2 && (futilScore = matBalance + EXT_FUTILY_MARGIN) <= alpha) {
futilPrune = true;
score = futilScore;
} else
///**************Futility Pruning at frontier*****
if (depth == 1) {
futilPrune = true;
score = futilScore;
}
}
}
/************ end Futility Pruning*************/
incListId();
ASSERT_RANGE(KING_BLACK + side, 0, 11);
ASSERT_RANGE(KING_BLACK + (side ^ 1), 0, 11);
u64 friends = getBitmap<side>();
u64 enemies = getBitmap<side ^ 1>();
if (generateCaptures<side>(enemies, friends)) {
decListId();
score = _INFINITE - (mainDepth - depth + 1);
return score;
}
generateMoves<side>(friends | enemies);
int listcount = getListSize();
if (!listcount) {
--listId;
if (is_incheck_side) {
return -_INFINITE + (mainDepth - depth + 1);
} else {
return -lazyEval<side>() * 2;
}
}
_Tmove *best = nullptr;
if (checkHashStruct.hashFlag[Hash::HASH_GREATER]) {
sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_GREATER]);
} else if (checkHashStruct.hashFlag[Hash::HASH_ALWAYS]) {
sortHashMoves(listId, checkHashStruct.phasheType[Hash::HASH_ALWAYS]);
}
INC(totGen);
_Tmove *move;
bool checkInCheck = false;
int countMove = 0;
char hashf = Hash::hashfALPHA;
while ((move = getNextMove(&gen_list[listId]))) {
countMove++;
INC(betaEfficiencyCount);
if (!makemove(move, true, checkInCheck)) {
takeback(move, oldKey, true);
continue;
}
checkInCheck = true;
if (futilPrune && ((move->type & 0x3) != PROMOTION_MOVE_MASK) && futilScore + PIECES_VALUE[move->capturedPiece] <= alpha && !inCheck<side>()) {
INC(nCutFp);
takeback(move, oldKey, true);
continue;
}
//Late Move Reduction
int val = INT_MAX;
if (countMove > 4 && !is_incheck_side && depth >= 3 && move->capturedPiece == SQUARE_FREE && move->promotionPiece == NO_PROMOTION) {
currentPly++;
val = -search<side ^ 1, smp>(depth - 2, -(alpha + 1), -alpha, &line, N_PIECE, mateIn);
ASSERT(val != INT_MAX);
currentPly--;
}
if (val > alpha) {
int doMws = (score > -_INFINITE + MAX_PLY);
int lwb = max(alpha, score);
int upb = (doMws ? (lwb + 1) : beta);
currentPly++;
val = -search<side ^ 1, smp>(depth - 1, -upb, -lwb, &line, move->capturedPiece == SQUARE_FREE ? N_PIECE : N_PIECE - 1, mateIn);
ASSERT(val != INT_MAX);
currentPly--;
if (doMws && (lwb < val) && (val < beta)) {
currentPly++;
val = -search<side ^ 1, smp>(depth - 1, -beta, -val + 1, &line, move->capturedPiece == SQUARE_FREE ? N_PIECE : N_PIECE - 1, mateIn);
currentPly--;
}
}
score = max(score, val);
takeback(move, oldKey, true);
move->score = score;
if (score > alpha) {
if (score >= beta) {
decListId();
ASSERT(move->score == score);
INC(nCutAB);
ADD(betaEfficiency, betaEfficiencyCount / (double) listcount * 100.0);
ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]);
ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]);
recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth - extension, Hash::hashfBETA, zobristKeyR, score, move);
setKillerHeuristic(move->from, move->to, 0x400);
return score;
}
alpha = score;
hashf = Hash::hashfEXACT;
best = move;
move->score = score; //used in it
updatePv(pline, &line, move);
}
}
ASSERT(checkHashStruct.rootHash[Hash::HASH_GREATER]);
ASSERT(checkHashStruct.rootHash[Hash::HASH_ALWAYS]);
recordHash<smp>(getRunning(), checkHashStruct.rootHash, depth - extension, hashf, zobristKeyR, score, best);
decListId();
return score;
}
