static void bnode_add_index(struct bnode *node, struct index_entry *p,
block_t child, u64 childkey)
{
unsigned count = bcount(node);
vecmove(p + 1, p, node->entries + count - p);
p->block = cpu_to_be64(child);
p->key = cpu_to_be64(childkey);
node->count = cpu_to_be32(count + 1);
}
static void bnode_add_index(struct bnode *node, struct index_entry *p,
block_t child, u64 childkey)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
unsigned count = bcount(node);
vecmove(p + 1, p, node->entries + count - p);
p->block = cpu_to_be64(child);
p->key = cpu_to_be64(childkey);
node->count = cpu_to_be32(count + 1);
}
static void cursor_root_add(struct cursor *cursor, struct buffer_head *buffer,
struct index_entry *next)
{
#ifdef CURSOR_DEBUG
assert(cursor->level < cursor->maxlevel);
assert(cursor->path[cursor->level + 1].buffer == FREE_BUFFER);
assert(cursor->path[cursor->level + 1].next == FREE_NEXT);
#endif
vecmove(cursor->path + 1, cursor->path, cursor->level + 1);
cursor->level++;
cursor->path[0].buffer = buffer;
cursor->path[0].next = next;
}
static void cursor_root_add(struct cursor *cursor, struct buffer_head *buffer,
struct index_entry *next)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
#ifdef CURSOR_DEBUG
assert(cursor->level < cursor->maxlevel);
assert(cursor->path[cursor->level + 1].buffer == FREE_BUFFER);
assert(cursor->path[cursor->level + 1].next == FREE_NEXT);
#endif
vecmove(cursor->path + 1, cursor->path, cursor->level + 1);
cursor->level++;
cursor->path[0].buffer = buffer;
cursor->path[0].next = next;
}
/*
* This is range deletion. So, instead of adjusting balance of the
* space on sibling nodes for each change, this just removes the range
* and merges from right to left even if it is not same parent.
*
* +--------------- (A, B, C)--------------------+
* | | |
* +-- (AA, AB, AC) -+ +- (BA, BB, BC) -+ + (CA, CB, CC) +
* | | | | | | | | |
* (AAA,AAB)(ABA,ABB)(ACA,ACB) (BAA,BAB)(BBA)(BCA,BCB) (CAA)(CBA,CBB)(CCA)
*
* [less : A, AA, AAA, AAB, AB, ABA, ABB, AC, ACA, ACB, B, BA ... : greater]
*
* If we merged from cousin (or re-distributed), we may have to update
* the index until common parent. (e.g. removed (ACB), then merged
* from (BAA,BAB) to (ACA), we have to adjust B in root node to BB)
*
* See, adjust_parent_sep().
*
* FIXME: no re-distribute. so, we don't guarantee above than 50%
* space efficiency. And if range is end of key (truncate() case), we
* don't need to merge, and adjust_parent_sep().
*
* FIXME2: we may want to split chop work for each step. instead of
* blocking for a long time.
*/
int btree_chop(struct btree *btree, tuxkey_t start, u64 len)
{
if(DEBUG_MODE_K==1)
{
printf("\t\t\t\t%25s[K] %25s %4d #in\n",__FILE__,__func__,__LINE__);
}
struct sb *sb = btree->sb;
struct btree_ops *ops = btree->ops;
struct buffer_head **prev, *leafprev = NULL;
struct chopped_index_info *cii;
struct cursor *cursor;
tuxkey_t limit;
int ret, done = 0;
if (!has_root(btree))
return 0;
/* Chop all range if len >= TUXKEY_LIMIT */
limit = (len >= TUXKEY_LIMIT) ? TUXKEY_LIMIT : start + len;
prev = malloc(sizeof(*prev) * btree->root.depth);
if (prev == NULL)
return -ENOMEM;
memset(prev, 0, sizeof(*prev) * btree->root.depth);
cii = malloc(sizeof(*cii) * btree->root.depth);
if (cii == NULL) {
ret = -ENOMEM;
goto error_cii;
}
memset(cii, 0, sizeof(*cii) * btree->root.depth);
cursor = alloc_cursor(btree, 0);
if (!cursor) {
ret = -ENOMEM;
goto error_alloc_cursor;
}
down_write(&btree->lock);
ret = btree_probe(cursor, start);
if (ret)
goto error_btree_probe;
/* Walk leaves */
while (1) {
struct buffer_head *leafbuf;
tuxkey_t this_key;
/*
* FIXME: If leaf was merged and freed later, we don't
* need to redirect leaf and leaf_chop()
*/
if ((ret = cursor_redirect(cursor)))
goto out;
leafbuf = cursor_pop(cursor);
/* Adjust start and len for this leaf */
this_key = cursor_level_this_key(cursor);
if (start < this_key) {
if (limit < TUXKEY_LIMIT)
len -= this_key - start;
start = this_key;
}
ret = ops->leaf_chop(btree, start, len, bufdata(leafbuf));
if (ret) {
if (ret < 0) {
blockput(leafbuf);
goto out;
}
mark_buffer_dirty_non(leafbuf);
}
/* Try to merge this leaf with prev */
if (leafprev) {
if (try_leaf_merge(btree, leafprev, leafbuf)) {
trace(">>> can merge leaf %p into leaf %p", leafbuf, leafprev);
remove_index(cursor, cii);
mark_buffer_dirty_non(leafprev);
blockput_free(sb, leafbuf);
goto keep_prev_leaf;
}
blockput(leafprev);
}
leafprev = leafbuf;
keep_prev_leaf:
if (cursor_level_next_key(cursor) >= limit)
done = 1;
/* Pop and try to merge finished nodes */
while (done || cursor_level_finished(cursor)) {
struct buffer_head *buf;
int level = cursor->level;
struct chopped_index_info *ciil = &cii[level];
/* Get merge src buffer, and go parent level */
buf = cursor_pop(cursor);
/*
* Logging chopped indexes
* FIXME: If node is freed later (e.g. merged),
* we dont't need to log this
*/
if (ciil->count) {
log_bnode_del(sb, bufindex(buf), ciil->start,
ciil->count);
}
memset(ciil, 0, sizeof(*ciil));
/* Try to merge node with prev */
if (prev[level]) {
assert(level);
if (try_bnode_merge(sb, prev[level], buf)) {
trace(">>> can merge node %p into node %p", buf, prev[level]);
remove_index(cursor, cii);
mark_buffer_unify_non(prev[level]);
blockput_free_unify(sb, buf);
goto keep_prev_node;
}
blockput(prev[level]);
}
prev[level] = buf;
keep_prev_node:
if (!level)
goto chop_root;
}
/* Push back down to leaf level */
do {
ret = cursor_advance_down(cursor);
if (ret < 0)
goto out;
} while (ret);
}
chop_root:
/* Remove depth if possible */
while (btree->root.depth > 1 && bcount(bufdata(prev[0])) == 1) {
trace("drop btree level");
btree->root.block = bufindex(prev[1]);
btree->root.depth--;
tux3_mark_btree_dirty(btree);
/*
* We know prev[0] is redirected and dirty. So, in
* here, we can just cancel bnode_redirect by bfree(),
* instead of defered_bfree()
* FIXME: we can optimize freeing bnode without
* bnode_redirect, and if we did, this is not true.
*/
bfree(sb, bufindex(prev[0]), 1);
log_bnode_free(sb, bufindex(prev[0]));
blockput_free_unify(sb, prev[0]);
vecmove(prev, prev + 1, btree->root.depth);
}
ret = 0;
out:
if (leafprev)
blockput(leafprev);
for (int i = 0; i < btree->root.depth; i++) {
if (prev[i])
blockput(prev[i]);
}
release_cursor(cursor);
error_btree_probe:
up_write(&btree->lock);
free_cursor(cursor);
error_alloc_cursor:
free(cii);
error_cii:
free(prev);
return ret;
}
void AgentMCTS::search(double time, uint64_t max_runs, int verbose){
Side toplay = rootboard.toplay();
if(rootboard.won() >= Outcome::DRAW || (time <= 0 && max_runs == 0))
return;
Time starttime;
pool.pause();
if(runs)
logerr("Pondered " + to_str(runs) + " runs\n");
runs = 0;
maxruns = max_runs;
pool.reset();
//let them run!
pool.resume();
pool.wait_pause(time);
double time_used = Time() - starttime;
if(verbose){
DepthStats gamelen, treelen;
double times[4] = {0,0,0,0};
for(auto & t : pool){
gamelen += t->gamelen;
treelen += t->treelen;
for(int a = 0; a < 4; a++)
times[a] += t->times[a];
}
logerr("Finished: " + to_str(runs) + " runs in " + to_str(time_used*1000, 0) + " msec: " + to_str(runs/time_used, 0) + " Games/s\n");
if(runs > 0){
logerr("Game length: " + gamelen.to_s() + "\n");
logerr("Tree depth: " + treelen.to_s() + "\n");
if(profile)
logerr("Times: " + to_str(times[0], 3) + ", " + to_str(times[1], 3) + ", " + to_str(times[2], 3) + ", " + to_str(times[3], 3) + "\n");
}
if(root.outcome != Outcome::UNKNOWN)
logerr("Solved as a " + root.outcome.to_s_rel(toplay) + "\n");
std::string pvstr;
for(auto m : get_pv())
pvstr += " " + m.to_s();
logerr("PV: " + pvstr + "\n");
if(verbose >= 3 && !root.children.empty())
logerr("Move stats:\n" + move_stats(vecmove()));
}
pool.reset();
runs = 0;
if(ponder && root.outcome < Outcome::DRAW)
pool.resume();
}
int tree_chop(struct btree *btree, struct delete_info *info, millisecond_t deadline)
{
int depth = btree->root.depth, level = depth - 1, suspend = 0;
struct cursor *cursor;
struct buffer_head *leafbuf, **prev, *leafprev = NULL;
struct btree_ops *ops = btree->ops;
struct sb *sb = btree->sb;
int ret;
cursor = alloc_cursor(btree, 0);
prev = malloc(sizeof(*prev) * depth);
memset(prev, 0, sizeof(*prev) * depth);
down_write(&btree->lock);
probe(btree, info->resume, cursor);
leafbuf = level_pop(cursor);
/* leaf walk */
while (1) {
ret = (ops->leaf_chop)(btree, info->key, bufdata(leafbuf));
if (ret) {
mark_buffer_dirty(leafbuf);
if (ret < 0)
goto error_leaf_chop;
}
/* try to merge this leaf with prev */
if (leafprev) {
struct vleaf *this = bufdata(leafbuf);
struct vleaf *that = bufdata(leafprev);
/* try to merge leaf with prev */
if ((ops->leaf_need)(btree, this) <= (ops->leaf_free)(btree, that)) {
trace(">>> can merge leaf %p into leaf %p", leafbuf, leafprev);
(ops->leaf_merge)(btree, that, this);
remove_index(cursor, level);
mark_buffer_dirty(leafprev);
brelse_free(btree, leafbuf);
//dirty_buffer_count_check(sb);
goto keep_prev_leaf;
}
brelse(leafprev);
}
leafprev = leafbuf;
keep_prev_leaf:
//nanosleep(&(struct timespec){ 0, 50 * 1000000 }, NULL);
//printf("time remaining: %Lx\n", deadline - gettime());
// if (deadline && gettime() > deadline)
// suspend = -1;
if (info->blocks && info->freed >= info->blocks)
suspend = -1;
/* pop and try to merge finished nodes */
while (suspend || level_finished(cursor, level)) {
/* try to merge node with prev */
if (prev[level]) {
assert(level); /* node has no prev */
struct bnode *this = cursor_node(cursor, level);
struct bnode *that = bufdata(prev[level]);
trace_off("check node %p against %p", this, that);
trace_off("this count = %i prev count = %i", bcount(this), bcount(that));
/* try to merge with node to left */
if (bcount(this) <= sb->entries_per_node - bcount(that)) {
trace(">>> can merge node %p into node %p", this, that);
merge_nodes(that, this);
remove_index(cursor, level - 1);
mark_buffer_dirty(prev[level]);
brelse_free(btree, level_pop(cursor));
//dirty_buffer_count_check(sb);
goto keep_prev_node;
}
brelse(prev[level]);
}
prev[level] = level_pop(cursor);
keep_prev_node:
/* deepest key in the cursor is the resume address */
if (suspend == -1 && !level_finished(cursor, level)) {
suspend = 1; /* only set resume once */
info->resume = from_be_u64((cursor->path[level].next)->key);
}
if (!level) { /* remove depth if possible */
while (depth > 1 && bcount(bufdata(prev[0])) == 1) {
trace("drop btree level");
btree->root.block = bufindex(prev[1]);
mark_btree_dirty(btree);
brelse_free(btree, prev[0]);
//dirty_buffer_count_check(sb);
depth = --btree->root.depth;
vecmove(prev, prev + 1, depth);
//set_sb_dirty(sb);
}
//sb->snapmask &= ~snapmask; delete_snapshot_from_disk();
//set_sb_dirty(sb);
//save_sb(sb);
ret = suspend;
goto out;
}
level--;
trace_off(printf("pop to level %i, block %Lx, %i of %i nodes\n", level, bufindex(cursor->path[level].buffer), cursor->path[level].next - cursor_node(cursor, level)->entries, bcount(cursor_node(cursor, level))););
}
/* push back down to leaf level */
while (level < depth - 1) {
struct buffer_head *buffer = sb_bread(vfs_sb(sb), from_be_u64(cursor->path[level++].next++->block));
if (!buffer) {
ret = -EIO;
goto out;
}
level_push(cursor, buffer, ((struct bnode *)bufdata(buffer))->entries);
trace_off(printf("push to level %i, block %Lx, %i nodes\n", level, bufindex(buffer), bcount(cursor_node(cursor, level))););
}
