1

/* $Id$ */

     2

     3

/** @file ai_threads.cpp handles the threading of AIs */

     4

     5

#include "../stdafx.h"

     6

#include "../openttd.h"

     7

#include "../variables.h"

     8

#include "../debug.h"

     9

#include "../thread.h"

    10

#include "../vehicle_func.h"

    11

#include "../player_func.h"

    12

#include "ai.h"

    13

#include "ai_threads.h"

    14

#include "api/ai_controller.hpp"

    15

#include "api/ai_object.hpp"

    16

#include "../misc/autoptr.hpp"

    17

#include "../misc/countedptr.hpp"

    18

#include <map>

    19

    20

class AIThread : public SimpleCountedObject {

    21

public:

    22

	/** Different states of the AI thread. */

    23

	enum ThreadState {

    24

		INITIALIZED, ///< The mutex and conditions are initialized

    25

		STARTING,    ///< The thread is just started

    26

		RUNNING,     ///< We are inside the main AI

    27

		SUSPENDED,   ///< We are suspended (either by sleep or block)

    28

		STOPPING,    ///< We are being stopped

    29

		STOPPED,     ///< The main AI has stopped

    30

	};

    31

    32

	static const int MAIN_THREAD = -1;

    33

    34

protected:

    35

	typedef std::map<int, CCountedPtr<AIThread> > Threads;

    36

    37

	static Threads s_threads;        ///< collection of active fibers

    38

    39

	int            fiber_id;         ///< id of this fiber (or MAIN_THREAD for the main) - equal to the ID of the current player

    40

	ThreadState    state;            ///< The current state of the AI

    41

	int            ticks_to_sleep;   ///< Sleep this many runticks

    42

	AIController   *controller;      ///< Controller of this AI

    43

    44

	/**

    45

	 * Initialize this AI Thread base class for the given controller.

    46

	 * @param player the player ID of this AI (used as fiber_id)

    47

	 * @param controller the AI have to run

    48

	 * @note this constructor is protected. It should be called only by

    49

	 * subclass (OS specific thread implementation).

    50

	 */

    51

protected:

    52

	AIThread(PlayerID player, AIController *controller)

    53

	{

    54

		assert(s_threads[player] == NULL);

    55

		/* Register new thread */

    56

		s_threads[player] = this;

    57

    58

		/* Ensure that main thread has its wrapper too */

    59

		if (player != MAIN_THREAD) stFind(MAIN_THREAD);

    60

    61

		this->state = INITIALIZED;

    62

		this->fiber_id = player;

    63

		this->ticks_to_sleep = 0;

    64

		this->controller = controller;

    65

	}

    66

    67

public:

    68

	virtual ~AIThread()

    69

	{

    70

		/* At this point we should be already removed from the thread collection */

    71

		assert(this->fiber_id == MAIN_THREAD || stFind(this->fiber_id) == NULL);

    72

	}

    73

    74

	/**

    75

	 * Start the AI thread and return once the AI calls Sleep or

    76

	 *  any other suspending command.

    77

	 * @note should be called after Initialize, but before any other function.

    78

	 */

    79

public:

    80

	virtual bool Start() = 0;

    81

    82

	/**

    83

	 * The method that runs in the new Thread.

    84

	 * @note should be called by the newly spawned thread in Start.

    85

	 */

    86

protected:

    87

	void ThreadProc()

    88

	{

    89

		assert(this->state == STARTING);

    90

		this->state = RUNNING;

    91

    92

		/* Run the AI. If this function ever returns, the AI is dead */

    93

		this->controller->Start();

    94

    95

		if (this->state != STOPPING) {

    96

			DEBUG(ai, 1, "We've got a suicidal AI for player %d", this->fiber_id);

    97

			/* The AI stopped on it's own */

    98

			this->state = STOPPED;

    99

			AI_PlayerDied((PlayerID)this->fiber_id);

   100

		} else {

   101

			this->state = STOPPED;

   102

		}

   103

	}

   104

   105

	/**

   106

	 * Suspend this AI.

   107

	 * @param timeout time to suspend. < 0 means infinite (MultiPlayer only!)

   108

	 * @note should be called from the AI thread.

   109

	 */

   110

public:

   111

	void Suspend(int timeout)

   112

	{

   113

		/* Should not attempt to suspend main fiber */

   114

		assert(this->fiber_id != MAIN_THREAD);

   115

		/* AI fiber should be running */

   116

		assert(this->state == RUNNING);

   117

		/* We can only suspend ourself */

   118

		assert(this->CurrentThread() == this);

   119

   120

		this->ticks_to_sleep = timeout;

   121

   122

		/* When AI thread gets suspended, it always switches back to main thread */

   123

		AIThread *main = stFind(MAIN_THREAD);

   124

		main->SwitchToThis(RUNNING);

   125

   126

		/* The AI is told to die by the main thread */

   127

		if (this->state == STOPPING) {

   128

			this->controller->Stop();

   129

			OnStop();

   130

			/* XXX -- It might be nice to throw an exception, as it is easier to handle */

   131

			//throw std::exception();

   132

			//NOT_REACHED();

   133

   134

			main->SwitchToThis(RUNNING);

   135

			return;

   136

		}

   137

		assert(this->state == RUNNING);

   138

	}

   139

   140

	/**

   141

	 * Set the AI thread to resume at the next call of RunTick.

   142

	 * @note should NOT be called from the AI thread.

   143

	 */

   144

public:

   145

	void Resume()

   146

	{

   147

		/* Should be called from main fiber only */

   148

		assert(CurrentThread() == stFind(MAIN_THREAD));

   149

		/* AI fiber should be suspended */

   150

		assert(this->state == SUSPENDED);

   151

		/* Normally the ticks_to_sleep hangs at -1 for MP. Possible the MP is

   152

		 * faster then the delay requested by the user. In this case the value

   153

		 * is lower. To let the normal delay system kick in, we reverse the value

   154

		 * of ticks_to_sleep. But now it doesn't directly continue when the value

   155

		 * was 'hanging', so we subtract 1 and it all works fine. */

   156

		this->ticks_to_sleep = -this->ticks_to_sleep - 1;

   157

	}

   158

   159

	/**

   160

	 * Let the AI thread run for a while and return when it is done.

   161

	 * However, when the thread is suspended and the suspend timeout

   162

	 * has not yet passed, nothing happens except decrementing the

   163

	 * before mentioned timeout.

   164

	 * @note should NOT be called from the AI thread.

   165

	 */

   166

public:

   167

	void RunTick()

   168

	{

   169

		/* Should be called from main fiber only */

   170

		assert(CurrentThread() == stFind(MAIN_THREAD));

   171

		/* Only AI fibers should be resumed this way */

   172

		assert(this != stFind(MAIN_THREAD));

   173

		/* AI fiber should be still suspended */

   174

		assert(this->state == SUSPENDED);

   175

   176

		this->controller->IncreaseTick();

   177

   178

		/* If the value is < -1, the user wants a delay which might exceed the delay

   179

		 *  of the MP. Therefor we keep adding value to ticks_to_sleep till it

   180

		 *  reaches -1, and we 'hang' it there infinitely, until the MP commands

   181

		 *  comes in. In the case it happens sooner, the Resume() codes handles it

   182

		 *  nicely and makes the value positive with the remaining ticks to wait. */

   183

		if (this->ticks_to_sleep < -1)  this->ticks_to_sleep++;

   184

		if (this->ticks_to_sleep < 0)   return; // We have to wait infinitely

   185

		if (--this->ticks_to_sleep > 0) return; // We have to wait a little longer

   186

   187

		/* Make the thread running again */

   188

		this->SwitchToThis(RUNNING);

   189

	}

   190

   191

	/**

   192

	 * Stop the AI thread and wait till it is stopped.

   193

	 * @note should NOT be called from the AI thread.

   194

	 */

   195

public:

   196

	virtual void Stop() = 0;

   197

   198

	/**

   199

	 * Called before the AI thread finishes. Should wakeup the main thread.

   200

	 */

   201

public:

   202

	virtual void OnStop() {};

   203

   204

	/**

   205

	 * Called in the context of thread that wants to yield execution and switch

   206

	 *  to 'this' thread. One of those threads should be always the main thread

   207

	 *  (fiber_id == MAIN_THREAD).

   208

	 */

   209

public:

   210

	virtual void SwitchToThis(ThreadState new_state) = 0;

   211

   212

	/**

   213

	 * Find and return the thread object by its 'id' (player_id or MAIN_THREAD).

   214

	 *  Returns NULL if such thread object doesn't exist. If

   215

	 *  (fiber_id == MAIN_THREAD) and the thread object with this id doesn't

   216

	 *  exist, the new one is created and attached to the current (main) thread.

   217

	 */

   218

public:

   219

	static AIThread *stFind(int fiber_id)

   220

	{

   221

		Threads::iterator it = s_threads.find(fiber_id);

   222

		if (it == s_threads.end()) {

   223

			if (fiber_id != MAIN_THREAD) return NULL;

   224

			/* main thread doesn't have its own thread object, create it */

   225

			return stNew((PlayerID)MAIN_THREAD, NULL);

   226

		}

   227

		return (*it).second;

   228

	}

   229

   230

	/**

   231

	 * Remove thread object from the collection by its 'id' and destroy it.

   232

	 */

   233

public:

   234

	static void stRelease(int fiber_id)

   235

	{

   236

		Threads::iterator it = s_threads.find(fiber_id);

   237

		if (it != s_threads.end()) s_threads.erase(it);

   238

	}

   239

   240

	/**

   241

	 * Find the thread object that belongs to the currently running thread (caller).

   242

	 */

   243

public:

   244

	static AIThread *stCurrentThread()

   245

	{

   246

		AIThread *main = stFind(MAIN_THREAD);

   247

		AIThread *cur = main->CurrentThread();

   248

		return cur;

   249

	}

   250

   251

	/**

   252

	 * Find the thread object that belongs to the currently running thread (caller).

   253

	 */

   254

public:

   255

	virtual AIThread *CurrentThread() = 0;

   256

   257

	/**

   258

	 * Create new AI thread object for given player and add it into thread collection.

   259

	 */

   260

public:

   261

	static AIThread *stNew(PlayerID player, AIController *controller);

   262

};

   263

   264

/**

   265

 * Collection of all AI Thread objects.

   266

 */

   267

/* static */ AIThread::Threads AIThread::s_threads;

   268

   269

/**

   270

 * AI thread implementation using Win32 thread API. This should be used only on Win95

   271

 * where Fiber API is not supported. Main OTTD thread has assigned the first object

   272

 * in collection (AIThread::s_threads[MAIN_THREAD]). Other threads created by this main

   273

 * thread have assigned higher slots [PlayerID]. This implementation is supposed to emulate

   274

 * Win32 fibers using normal Win32 threads. Synchronisation is done using simple event

   275

 * object (kind of bi-state semaphore gate - 0/1 - which is reset to 0 when thread passes

   276

 * the wait function and must be set back to 1 in order to fire another thread).

   277

 * Each thread from the collection (except one) is wating on its own event object. So the

   278

 * thread that wants to yeald execution must set the event object of the target thread

   279

 * and then enter its own wait state.

   280

 */

   281

class AIThread_MT : public AIThread {

   282

	static int s_current;     ///< currently executed thread

   283

   284

	AutoPtrT<AutoResetEvent> evt_go;       ///< Win32 event handle that signals the thread can go

   285

	ThreadState              next_state;   ///< Next state after wakeup

   286

	AutoPtrT<ThreadObject>   thr;          ///< Thread Object associated with this AI thread

   287

   288

	/**

   289

	 * Initialize this AI Thread Object for the given controller.

   290

	 * @param player the player ID of this AI (used as fiber_id) or MAIN_THREAD if attaching to the main game thread

   291

	 * @param controller the AI have to run

   292

	 */

   293

public:

   294

	AIThread_MT(PlayerID player, AIController *controller)

   295

		: AIThread(player, controller)

   296

	{

   297

		DEBUG(ai, 3, "+AIThread_MT(%d) from thr %d", player, ThreadObject::CurrentId());

   298

		this->evt_go = AutoResetEvent::New();

   299

		this->next_state = STOPPED;

   300

   301

		/* Handle main thread differently. When AIThread::AIThread() calls stFind() the new Thread Object

   302

		 * is created for the main thread. In this case we will not create new system thread but rather

   303

		 * attach to the curent one. */

   304

		if (player == MAIN_THREAD) {

   305

			/* also main thread needs to know own win32 thread id */

   306

			this->thr = ThreadObject::Current();

   307

		} else {

   308

			/* create new Thread Object */

   309

			this->thr = ThreadObject::New();

   310

		}

   311

	}

   312

   313

	/**

   314

	 * Destructor (AI Thread Object cleanup).

   315

	 */

   316

public:

   317

	/*virtual*/ ~AIThread_MT()

   318

	{

   319

		DEBUG(ai, 3, "-AIThread_MT(%d) from thr %u", this->fiber_id, ThreadObject::CurrentId());

   320

   321

		/* Flush stdout and stderr, as killing the thread doesn't allow the thread

   322

		 *  to do that (in case there still is something to print) */

   323

		fflush(stdout);

   324

		fflush(stderr);

   325

   326

		this->evt_go.Detach();

   327

	}

   328

   329

	/**

   330

	 * Implementation specific Start() routine.

   331

	 * @see AIThread::Start()

   332

	 */

   333

public:

   334

	virtual bool Start()

   335

	{

   336

		AIThread_MT *cur = stCurrentFiber();

   337

		assert(cur != this); // target fiber is not active already

   338

		assert(!this->thr->IsRunning()); // not yet started

   339

		assert(fiber_id != MAIN_THREAD); // main fiber can't be started this way

   340

   341

		cur->state = SUSPENDED;

   342

		this->next_state = STARTING;

   343

   344

		{

   345

			/* Protect the AI Thread Object against sudden death in the case when

   346

			 * AI decides to stop itself by calling AI_StopPlayer(). Technically there

   347

			 * is no problem deleting the the AI Thread Object from its thread, but for

   348

			 * the code robustness there is assert(m_attached || !IsRunning()); to avoid

   349

			 * that. */

   350

			CCountedPtr<AIThread> protect_this = this;

   351

			if (!this->thr->Begin(&stThreadProc, this)) return false; // unable to create thread

   352

			cur->EnterWaitState();

   353

		} // end of 'protection area'

   354

   355

		return true;

   356

	}

   357

   358

	/**

   359

	 * Function that is started as process of the new AI thread (fiber).

   360

	 * @param fiber AIThread_Fiber* to the fiber that starts

   361

	 */

   362

protected:

   363

	static void CDECL stThreadProc(void *thr)

   364

	{

   365

		AIThread_MT *cur = (AIThread_MT*)thr;

   366

		cur->FiberProc();

   367

	}

   368

   369

	/**

   370

	 * The method that runs in the context of new thread (virtual fiber) when started.

   371

	 */

   372

protected:

   373

	void FiberProc()

   374

	{

   375

		try

   376

		{

   377

			s_current = this->fiber_id;

   378

			this->state = this->next_state;

   379

			AIThread::ThreadProc();

   380

		}

   381

		catch (std::exception &e)

   382

		{

   383

			DEBUG(ai, 0, "%s", e.what());

   384

		}

   385

		DEBUG(ai, 3, "thread %d finished", this->fiber_id);

   386

   387

		/* Tell the main thread that we are stopping */

   388

		this->OnStop();

   389

	}

   390

   391

	/**

   392

	 * Implementation specific way how to stop execution of the AI thread.

   393

	 * @see AIThread::Stop()

   394

	 */

   395

public:

   396

	/*virtual*/ void Stop()

   397

	{

   398

		AIThread_MT *cur = stCurrentFiber();

   399

		/* The AI stopping itself */

   400

		if (cur == this) {

   401

			/* must be AI fiber */

   402

			assert(this->fiber_id != MAIN_THREAD);

   403

   404

			DEBUG(ai, 3, "this->OnStop(%d) from thr %d", this->fiber_id, ThreadObject::CurrentId());

   405

			this->state = STOPPED;

   406

			this->controller->Stop();

   407

			//throw std::exception();

   408

			//NOT_REACHED();

   409

			return;

   410

		}

   411

   412

		assert(cur->fiber_id == MAIN_THREAD);

   413

		assert(this->state == SUSPENDED);

   414

		this->SwitchToThis(STOPPING);

   415

		assert(this->state == SUSPENDED);

   416

		this->state = STOPPED;

   417

	}

   418

   419

	/**

   420

	 * This routine should notify main thread that AI thread finished (stopped

   421

	 * forever).

   422

	 */

   423

protected:

   424

	/*virtual*/ void OnStop()

   425

	{

   426

		AIThread_MT *main = (AIThread_MT*)stFind(MAIN_THREAD);

   427

		main->evt_go->Set();

   428

	}

   429

   430

	/**

   431

	 * Implementation specific way how to yield execution to the other thread (virtual fiber).

   432

	 * @see AIThread::SwitchToThis()

   433

	 */

   434

protected:

   435

	void SwitchToThis(ThreadState new_state)

   436

	{

   437

		AIThread_MT *cur = stCurrentFiber();

   438

		assert(cur != this); // target fiber is not active already

   439

		assert(this->state == SUSPENDED); // target fiber is in proper state

   440

		assert(this->thr->IsRunning() || this->fiber_id == MAIN_THREAD); // target fiber is created

   441

   442

		cur->state = SUSPENDED;

   443

		this->next_state = new_state;

   444

   445

		{

   446

			/* Protect the AI Thread Object against sudden death in the case when

   447

			 * AI decides to stop itself by calling AI_StopPlayer(). Technically there

   448

			 * is no problem deleting the the AI Thread Object from its thread, but for

   449

			 * the code robustness there is assert(m_attached || !IsRunning()); to avoid

   450

			 * that. */

   451

			CCountedPtr<AIThread> protect_this = this;

   452

			this->evt_go->Set();

   453

			cur->EnterWaitState();

   454

		} // end of 'protection area'

   455

	}

   456

   457

	/**

   458

	 * Wait for the 'GO' signal. This way all thread except one are waiting on their own

   459

	 * event object in order to emulate cooperative multithreading (fibers).

   460

	 */

   461

protected:

   462

	void EnterWaitState()

   463

	{

   464

		assert(this->thr->IsCurrent()); // can wait on own event only

   465

		this->evt_go->Wait();

   466

		s_current = this->fiber_id;

   467

		assert(this->state == SUSPENDED);

   468

		this->state = this->next_state;

   469

		assert(this->state != SUSPENDED);

   470

	}

   471

   472

	/**

   473

	 * Ugly way how to get AI Thread object that belongs to the currently executed

   474

	 * (calling) thread.

   475

	 * @todo consider using TLS API or thread map to make it less ugly

   476

	 */

   477

protected:

   478

	AIThread_MT* stCurrentFiber()

   479

	{

   480

		AIThread_MT *cur = (AIThread_MT*)stFind(s_current);

   481

		assert(cur != NULL);

   482

		assert(cur->thr->IsCurrent());

   483

		return cur;

   484

	}

   485

   486

	/**

   487

	 * Ugly way how to provide stCurrentFiber() functionality for the base class.

   488

	 */

   489

protected:

   490

	/*virtual*/ AIThread *CurrentThread()