Board::initHash();

Logger logger;

logger.setLogToStdout(true);

logger.addFile("tmp.txt");

string tensorflowGpuVisibleDeviceList = ""; //use default

double tensorflowPerProcessGpuMemoryFraction = -1; //use default

NeuralNet::globalInitialize(tensorflowGpuVisibleDeviceList,tensorflowPerProcessGpuMemoryFraction);

int modelFileIdx = 0;

int maxBatchSize = 1;

int posLen = 19;

bool inputsUseNHWC = true;

int nnCacheSizePowerOfTwo = 16;

bool debugSkipNeuralNet = false;

NNEvaluator* nnEval = new NNEvaluator(

// "/efs/data/GoNN/exportedmodels/tensorflow/value24-140/model.graph_optimized.pb",

"/efs/data/GoNN/exportedmodels/cuda/value33-140/model.txt",

// "/efs/data/GoNN/exportedmodels/cuda/value24-140/model.txt",

modelFileIdx,

maxBatchSize,

posLen,

inputsUseNHWC,

nnCacheSizePowerOfTwo,

debugSkipNeuralNet

);

int numNNServerThreads = 1;

bool doRandomize = true;

string randSeed = "abc";

int defaultSymmetry = 0;

vector<int> cudaGpuIdxByServerThread = {0};

bool cudaUseFP16 = false;

bool cudaUseNHWC = false;

nnEval->spawnServerThreads(

numNNServerThreads,doRandomize,randSeed,defaultSymmetry,logger,cudaGpuIdxByServerThread,cudaUseFP16,cudaUseNHWC

);

Rules rules;

rules.koRule = Rules::KO_POSITIONAL;

rules.scoringRule = Rules::SCORING_AREA;

rules.multiStoneSuicideLegal = true;

rules.komi = 7.5f;

Player pla = P_BLACK;

Board board = Board::parseBoard(19,19,R"(

)");

BoardHistory hist(board,pla,rules);

ostream* logStream = logger.createOStream();

NNResultBuf buf;

nnEval->evaluate(board, hist, pla, buf, logStream, false);

for(int y = 0; y<NNPos::MAX_BOARD_LEN; y++) {

for(int x = 0; x<NNPos::MAX_BOARD_LEN; x++) {

if(buf.result->policyProbs[x+y*NNPos::MAX_BOARD_LEN] >= 0)

printf("%6.2f%%", buf.result->policyProbs[x+y*NNPos::MAX_BOARD_LEN] * 100.0);

else

printf(" . ");

}

cout << endl;

}

printf("%4.1f%%", buf.result->policyProbs[NNPos::NN_POLICY_SIZE-1] * 100.0);

cout << endl;

cout << buf.result->whiteValue << endl;

delete logStream;

SearchParams params;

params.maxPlayouts = 180;

params.numThreads = 1;

params.fpuUseParentAverage = false;

// params.moveProbModelExponent = 0.0;

// params.moveProbModelPolicyExponent = 0.0;

AsyncBot* bot = new AsyncBot(params, nnEval, &logger, "def");

bot->setPosition(pla,board,hist);

cout << bot->getRootBoard() << endl;

bot->genMoveSynchronous(pla);

bot->getSearch()->printTree(cout, bot->getSearch()->rootNode, PrintTreeOptions().maxDepth(1));

cout << "NN rows: " << nnEval->numRowsProcessed() << endl;

cout << "NN batches: " << nnEval->numBatchesProcessed() << endl;

cout << "NN avg batch size: " << nnEval->averageProcessedBatchSize() << endl;

bot->clearSearch();

nnEval->clearCache();

bot->makeMove(Location::ofString("F15",board),pla);

cout << bot->getRootBoard() << endl;

bot->genMoveSynchronous(getOpp(pla));

bot->getSearch()->printTree(cout, bot->getSearch()->rootNode, PrintTreeOptions().maxDepth(1));

cout << "NN rows: " << nnEval->numRowsProcessed() << endl;

cout << "NN batches: " << nnEval->numBatchesProcessed() << endl;

cout << "NN avg batch size: " << nnEval->averageProcessedBatchSize() << endl;

// cout << "sizeof(uint8_t) " << sizeof(uint8_t) << endl;

// cout << "sizeof(uint16_t) " << sizeof(uint16_t) << endl;

// cout << "sizeof(uint32_t) " << sizeof(uint32_t) << endl;

// cout << "sizeof(uint64_t) " << sizeof(uint64_t) << endl;

// cout << "sizeof(std::atomic_flag) " << sizeof(std::atomic_flag) << endl;;

// cout << "sizeof(std::mutex) " << sizeof(std::mutex) << endl;;

// cout << "sizeof(std::shared_ptr<NNOutput>) " << sizeof(std::shared_ptr<NNOutput>) << endl;;

// {

// atomic<bool>* b = new atomic<bool>(false);

// cout << "atomic<bool> lock free " << std::atomic_is_lock_free(b) << endl;

// delete b;

// }

// {

// atomic<uint64_t>* b = new atomic<uint64_t>(0);

// cout << "atomic<uint64_t> lock free " << std::atomic_is_lock_free(b) << endl;

// delete b;

// }

nnEval->killServerThreads();

delete bot;

delete nnEval;

cout << "Done" << endl;

return 0;