Subversion Repositories connect-6

/*

connectk -- a program to play the connect-k family of games

Copyright (C) 2007 Michael Levin

This program is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License

as published by the Free Software Foundation; either version 2

of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#include "config.h"

#include <glib.h>

#include "../shared.h"

#include "../connectk.h"

/* FIXME: The AI thread function busy waits on Windows. For some reason, it fails to

   deadlock itself on mutex1! */

int ai_stop = 0;

static GMutex *ai_mutex1, *ai_mutex2;

static guint ai_done_source = 0;

static AIMove ai_move;

static GThread *ai_thread;

static int ai_halt = 0;

static gboolean ai_done(gpointer user_data)

{

        if (opt_debug_thread)

                g_debug("ai_done(): making AI move");

        make_move(ai_move.x, ai_move.y);

        return FALSE;

}

AIMoves *run_ai(Player *player)

{

        AIMoves *moves;

        AIFunc func;

        if (opt_debug_thread)

                g_debug("run_ai(): running AI function");

        ai_stop = FALSE;

        func = ai(player->ai)->func;

        if (!func)

                return NULL;

        moves = func(board);

        if (player->search)

                search(board, moves, player);

        ai_stop = FALSE;

        return moves;

}

static gpointer ai_thread_func(gpointer user_data)

{

        for (;;) {

                AIMoves *moves;

                if (opt_debug_thread)

                        g_debug("ai_thread_func(): locking mutex1");

                g_mutex_lock(ai_mutex1);

                if (opt_debug_thread)

                        g_debug("ai_thread_func(): mutex1 locked");

                if (ai_halt) {

                        ai_halt = FALSE;

                        g_mutex_unlock(ai_mutex1);

                        return NULL;

                }

                if (opt_debug_thread)

                        g_debug("ai_thread_func(): locking mutex2");

                g_mutex_lock(ai_mutex2);

                if (opt_debug_thread)

                        g_debug("ai_thread_func(): mutex2 locked");

                if (ai(players[board->turn].ai)->func && !opt_pause_ai &&

                    !board->won) {

                        ai_move.x = -1;

                        ai_move.y = -1;

                        moves = run_ai(players + board->turn);

                        /* Choose an adjacent move if the AI returns nothing */

                        if (!aimoves_choose(moves, &ai_move)) {

                                aimoves_free(moves);

                                moves = ai_adjacent(board);

                                aimoves_choose(moves, &ai_move);

                        }

                        /* Print the move list utility */

                        if (opt_print_u)

                                g_debug("AI %s utility %d (0x%x)",

                                        ai(players[board->turn].ai)->s_desc,

                                        moves->utility, moves->utility);

                        ai_done_source = g_timeout_add(0, ai_done, NULL);

                        aimoves_free(moves);

                }

                g_mutex_unlock(ai_mutex2);

                if (opt_debug_thread)

                        g_debug("ai_thread_func(): mutex2 unlocked");

                g_thread_yield();

        }

        return NULL;

}

void stop_ai(void)

{

        ai_stop = TRUE;

#ifndef NO_TRYLOCK

        if (opt_debug_thread)

                g_debug("stop_ai(): trylocking mutex1");

        g_mutex_trylock(ai_mutex1);

#endif

        if (opt_debug_thread)

                g_debug("stop_ai(): locking mutex2");

        g_mutex_lock(ai_mutex2);

        if (opt_debug_thread)

                g_debug("stop_ai(): mutex2 locked");

        if (ai_done_source) {

                g_source_remove(ai_done_source);

                ai_done_source = 0;

        }

        g_mutex_unlock(ai_mutex2);

        if (opt_debug_thread)

                g_debug("stop_ai(): mutex2 unlocked");

}

void start_ai(void)

{

        if (players[board->turn].ai == PLAYER_HUMAN)

                return;

#ifndef NO_TRYLOCK

        if (opt_debug_thread)

                g_debug("start_ai(): trylocking mutex1");

        g_mutex_trylock(ai_mutex1);

#endif

        g_mutex_unlock(ai_mutex1);

        if (opt_debug_thread)

                g_debug("stop_ai(): mutex1 unlocked");

}

void halt_ai_thread(void)

{

        if (opt_debug_thread)

                g_debug("halt_ai_thread(): unlocking mutex1, joining thread");

        ai_stop = TRUE;

        ai_halt = TRUE;

        g_mutex_unlock(ai_mutex1);

        g_thread_join(ai_thread);

        if (opt_debug_thread)

                g_debug("halt_ai_thread(): mutex1 unlocked");

}

void start_ai_thread(void)

{

        GError *error = NULL;

        g_thread_init(NULL);

        ai_mutex1 = g_mutex_new();

        ai_mutex2 = g_mutex_new();

        g_mutex_lock(ai_mutex1);

        if (opt_debug_thread)

                g_debug("start_ai_thread(): mutex1, mutex2 locked");

        ai_thread = g_thread_create_full(ai_thread_func, NULL, 0, TRUE, TRUE,

                                         G_THREAD_PRIORITY_NORMAL, &error);

        if (error)

                g_error("Failed to spawn AI thread");

}