/* Copyright (c) 2001, Stanford University
 * All rights reserved
 *
 * See the file LICENSE.txt for information on redistributing this software.
 */

#include "server_dispatch.h"
#include "server.h"
#include "cr_error.h"
#include "cr_mem.h"
#include "state/cr_statetypes.h"

#define DEBUG_BARRIERS 1

void SERVER_DISPATCH_APIENTRY glStubDispatchBarrierCreateCR( GLuint name, GLuint count )
{
	GLStubBarrier *barrier;
#if DEBUG_BARRIERS
	char debug_buf[4096];
#endif

	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.BarrierCreateCR( name, count );
		return;
	}

	barrier = (GLStubBarrier *) crHashtableSearch( cr_server.barriers, name );

#if DEBUG_BARRIERS
	sprintf( debug_buf, "BarrierCreateCR( %d, %d )", name, count );
	cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif
	if (count == 0)
	{
		count = cr_server.numClients;
#if DEBUG_BARRIERS
		sprintf( debug_buf, "changing count to %d", count );
		cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif
	}


	/* we use maxBarrierCount in Clear() and SwapBuffers() and also use it
	 * in __getNextClient() for deadlock detection.  The issue is that all
	 * the existing clients may be blocked, but we might soon get another
	 * client connection to break the apparent deadlock.
	 */
	if (count > cr_server.maxBarrierCount)
		cr_server.maxBarrierCount = count;

	if ( barrier == NULL )
	{
		barrier = (GLStubBarrier *) crAlloc( sizeof(*barrier) );
		barrier->count = count;
		barrier->num_waiting = 0;
		barrier->waiting = (RunQueue **) 
			crAlloc( count * sizeof(*(barrier->waiting)) );

		crHashtableAdd( cr_server.barriers, name, barrier );
#if DEBUG_BARRIERS
		sprintf( debug_buf, "This was a new barrier!" );
		cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif
	}
	else
	{
		/* HACK -- this allows everybody to create a barrier, and all
           but the first creation are ignored, assuming the count
           match. */
#if DEBUG_BARRIERS
		sprintf( debug_buf, "I already knew about this barrier." );
		cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif
		if ( barrier->count != count )
		{
#if DEBUG_BARRIERS
			sprintf( debug_buf, "And someone messed up the count!." );
			cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif
			crError( "Barrier name=%u created with count=%u, but already "
						 "exists with count=%u", name, count, barrier->count );
		}
	}

	if (cr_server.debug_barriers)
		crDebug("BarrierCreate(id=%d, count=%d)", name, barrier->count);
}

void SERVER_DISPATCH_APIENTRY glStubDispatchBarrierDestroyCR( GLuint name )
{
	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.BarrierDestroyCR( name );
		return;
	}

	crError( "NO BARRIER DESTROY FOR YOU!  (name=%u)", name );
}

void SERVER_DISPATCH_APIENTRY glStubDispatchBarrierExecCR( GLuint name )
{
	GLStubBarrier *barrier;
#if DEBUG_BARRIERS
	char debug_buf[4096];
#endif

	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.BarrierExecCR( name );
		return;
	}

	barrier = (GLStubBarrier *) crHashtableSearch( cr_server.barriers, name );
	if ( barrier == NULL )
	{
		crError( "glStubDispatchBarrierExec: No such barrier: %d", name );
	}

#if DEBUG_BARRIERS
	sprintf( debug_buf, "BarrierExec( %d )", name );
	cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
	sprintf( debug_buf, "num_waiting = %d", barrier->num_waiting );
	cr_server.head_spu->dispatch_table.ChromiumParametervCR( GL_PRINT_STRING_CR, GL_UNSIGNED_BYTE, sizeof(debug_buf), debug_buf );
#endif

	barrier->waiting[barrier->num_waiting++] = cr_server.run_queue;

	cr_server.run_queue->blocked = 1;

	if ( barrier->num_waiting == barrier->count )
	{
		GLuint i;

		if (cr_server.debug_barriers)
			crDebug("BarrierExec(client=%p, id=%d, num_waiting=%d/%d) - release",
							cr_server.curClient, name, barrier->num_waiting,
							barrier->count);

		for ( i = 0; i < barrier->count; i++ )
		{
			barrier->waiting[i]->blocked = 0;
		}
		barrier->num_waiting = 0;
	}
	else if (cr_server.debug_barriers)
		crDebug("BarrierExec(client=%p, id=%d, num_waiting=%d/%d) - block",
						cr_server.curClient, name, barrier->num_waiting,
						barrier->count);

}

void SERVER_DISPATCH_APIENTRY glStubDispatchSemaphoreCreateCR( GLuint name, GLuint count )
{
	GLStubSemaphore *sema;

	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.SemaphoreCreateCR( name, count );
		return;
	}

	sema = crHashtableSearch(cr_server.semaphores, name);
	if (sema)
		return; /* already created */

	sema = (GLStubSemaphore *) crAlloc( sizeof( *sema ) );
	crHashtableAdd( cr_server.semaphores, name, sema );
	sema->count = count;
	sema->waiting = sema->tail = NULL;
	if (cr_server.debug_barriers)
		crDebug("SemaphoreCreate(id=%d, count=%d)", name, count);
}

void SERVER_DISPATCH_APIENTRY glStubDispatchSemaphoreDestroyCR( GLuint name )
{
	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.SemaphoreDestroyCR( name );
		return;
	}

	crError( "NO DESTROY FOR YOU! (name=%u)", name );
}

/* Semaphore wait */
void SERVER_DISPATCH_APIENTRY glStubDispatchSemaphorePCR( GLuint name )
{
	GLStubSemaphore *sema;

	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.SemaphorePCR( name );
		return;
	}

	sema = (GLStubSemaphore *) crHashtableSearch( cr_server.semaphores, name );
	if (!sema)
	{
		crError( "No such semaphore: %d", name );
	}
	if (sema->count)
	{
		/* go */
		if (cr_server.debug_barriers)
			crDebug("SemaphoreP(client=%p, id=%d, count=%d) decrement to %d",
							cr_server.curClient, name, sema->count, sema->count - 1);
		sema->count--;
	}
	else
	{
		/* block */
		wqnode *node;
		if (cr_server.debug_barriers)
			crDebug("SemaphoreP(client=%p, id=%d, count=%d) - block.",
							cr_server.curClient, name, sema->count);
		cr_server.run_queue->blocked = 1;
		node = (wqnode *) crAlloc( sizeof( *node ) );
		node->q = cr_server.run_queue;
		node->next = NULL;
		if (sema->tail)
		{
			sema->tail->next = node;
		}
		else
		{
			sema->waiting = node;
		}
		sema->tail = node;
	}
}

/* Semaphore signal */
void SERVER_DISPATCH_APIENTRY glStubDispatchSemaphoreVCR( GLuint name )
{
	GLStubSemaphore *sema;

	if (cr_server.ignore_papi)
	{
		cr_server.head_spu->dispatch_table.SemaphoreVCR( name );
		return;
	}

	sema = (GLStubSemaphore *) crHashtableSearch( cr_server.semaphores, name );
	if (!sema)
	{
		crError( "No such semaphore: %d", name );
	}
	if (sema->waiting)
	{
		wqnode *temp = sema->waiting;
		if (cr_server.debug_barriers)
			crDebug("SemaphoreV(client=%p, id=%d, count=%d) - unblock.",
							cr_server.curClient, name, sema->count);
		/* unblock one waiter */
		temp->q->blocked = 0;
		sema->waiting = temp->next;
		crFree( temp );
		if (!sema->waiting)
		{
			sema->tail = NULL;
		}
	}
	else
	{
		/* nobody's waiting */
		if (cr_server.debug_barriers)
			crDebug("SemaphoreV(client=%p, id=%d, count=%d) - increment to %d",
							cr_server.curClient, name, sema->count, sema->count + 1);
		sema->count++;
	}
}
