class LocklessMailbox
{
public:
	//
	// Construct and initialize the read and write stacks
	//
	LocklessMailbox()
	{
		std::auto_ptr<Node> wh(new Node);
		std::auto_ptr<Node> rh(new Node);

		WriteHead = wh.get();
		WriteHead->Next = NULL;
		WriteHead->Payload = NULL;

		ReadHead = rh.get();
		ReadHead->Next = NULL;
		ReadHead->Payload = NULL;

		wh.release();
		rh.release();
	}

	//
	// Clean up the read, write, and cache stacks, freeing any
	// remaining messages from each stack.
	//
	~LocklessMailbox()
	{
		Release();
	}

public:
	//
	// Register a message from a producer thread. Any number of threads
	// may call this function.
	//
	void AddMessage(MessageInfo* info)
	{
		Node* msgnode = new Node;
		msgnode->Payload = info;

		Node* oldval;
		Node* newval;
		Node* retval;

		do
		{
			msgnode->Next = WriteHead;
			__asm mfence;
			oldval = msgnode->Next;
			newval = msgnode;
			Node** fieldaddr = &(WriteHead);

			_asm
			{
				mfence
				mov eax, oldval
				mov ecx, newval
				mov edx, dword ptr [fieldaddr]

				lock cmpxchg dword ptr[edx], ecx
				mov retval, eax
				mfence
			}
		}
		while(retval != oldval);
	}

	//
	// Retrieve a message from the mailbox.
	// IMPORTANT: only ONE consumer thread (per mailbox) should call this function
	//
	MessageInfo* GetMessage()
	{
		if(!PendingReads.empty())
		{
			Node* readnode = PendingReads.top();
			MessageInfo* payload = readnode->Payload;
			delete readnode;
			PendingReads.pop();
			return payload;
		}

		if(ReadHead->Next == NULL)
			SwapReadAndWrite();

		Node* n = ReadHead;
		while(ReadHead->Next)
		{
			PendingReads.push(n);
			n = n->Next;
			ReadHead = n;
		}

		if(PendingReads.empty())
			return NULL;

		Node* readnode = PendingReads.top();
		MessageInfo* payload = readnode->Payload;
		delete readnode;
		PendingReads.pop();
		return payload;
	}

private:
	//
	// Internal helper for swapping the read/write stacks
	// See class comment for details
	//
	void SwapReadAndWrite()
	{
		Node* oldval;
		Node* newval;
		Node* retval;
		Node* swappedreadhead;

		do
		{
			swappedreadhead = WriteHead;
			__asm mfence;
			oldval = swappedreadhead;
			newval = ReadHead;
			Node** fieldaddr = &(WriteHead);

			_asm
			{
				mfence
				mov eax, oldval
				mov ecx, newval
				mov edx, dword ptr [fieldaddr]

				lock cmpxchg dword ptr[edx], ecx
				mov retval, eax
				mfence
			}
		}
		while(retval != oldval);

		ReadHead = swappedreadhead;
	}

	//
	// Release the mailbox and free any remaining messages
	//
	void Release()
	{
		for(std::stack<Node*>::container_type::iterator iter = PendingReads.c.begin(); iter != PendingReads.c.end(); ++iter)
		{
			delete (*iter)->Payload;
			delete *iter;
		}

		Node* n = WriteHead;
		while(n)
		{
			delete n->Payload;
			Node* nextn = n->Next;
			delete n;
			n = nextn;
		}

		n = ReadHead;
		while(n)
		{
			delete n->Payload;
			Node* nextn = n->Next;
			delete n;
			n = nextn;
		}
 	}

private:
	struct Node
	{
		Node* Next;
		MessageInfo* Payload;
	};

	Node* WriteHead;
	Node* ReadHead;
	std::stack<Node*> PendingReads;
};

//
// TASKS.EPOCH
//
// Demonstration of the multiprocessing capabilities of Epoch
//


entrypoint : () -> ()
{
	task(asyncjob1)
	{
		pi_task()
	}

	task(asyncjob2)
	{
		pi_task()
	}

	task(complexjob)
	{
		acceptmsg
		(
			compute(integer(a), integer(b), integer(c), string(d)) =>
			{
				message(sender(), completed(add(multiply(a, b), c), d))
			}
		)
	}

	message(asyncjob1, calculate("ignored"))
	message(asyncjob1, ignoredmessage("foo", "bar", 42))

	message(asyncjob1, calculate(10000.0))
	message(asyncjob2, calculate(50000.0))

	message(complexjob, compute(5, 4, 2, "Filler"))

	debugwritestring("Please wait, async tasks running...")


	integer(baz, 42)
	debugwritestring(concat("Main task: ", cast(string, baz)))

	responsemap(resulthandler)
	{
		result(real(foo)) => { debugwritestring(concat("Pi result: ", cast(string, foo))) }
		completed(integer(a), string(b)) => { debugwritestring(concat(b, cast(string, a))) }
	}

	acceptmsg(resulthandler)
	acceptmsg(resulthandler)
	acceptmsg(resulthandler)
}


pi_task : () -> ()
{
	acceptmsg(calculate(real(limit)) => { message(sender(), result(pi(limit))) } )
}


pi : (real(denominator_limit)) -> (real(retval, 0.0))
{
	real(denominator, 1.0)
	boolean(isplus, true)

	do
	{
		real(div, 0.0)
		assign(div, divide(4.0, denominator))

		if(equal(isplus, true))
		{
			assign(retval, add(retval, div))
			assign(isplus, false)
		}
		else
		{
			assign(retval, subtract(retval, div))
			assign(isplus, true)
		}

		assign(denominator, add(denominator, 2.0))

	} while(less(denominator, denominator_limit))
}

//
// TASKS.EPOCH
//
// Demonstration of the multiprocessing capabilities of Epoch
//


entrypoint : () -> ()
{
	task(asyncjob1)
	{
		pi_task()
	}

	task(asyncjob2)
	{
		pi_task()
	}

	message(asyncjob1, calculate(10000.0))
	message(asyncjob2, calculate(50000.0))

	debugwritestring("Please wait, async tasks running...")


	integer(baz, 42)
	debugwritestring(concat("Main task: ", cast(string, baz)))


	// Do this twice since we have two results to wait for
	// In a real program we'd do something more robust than
	// just copying/pasting the message handler ;-)

	acceptmsg(result(real(foo)) => { debugwritestring(concat("First result: ", cast(string, foo))) } )
	acceptmsg(result(real(foo)) => { debugwritestring(concat("Second result: ", cast(string, foo))) } )
}


pi_task : () -> ()
{
	acceptmsg(calculate(real(limit)) => { message(caller(), result(pi(limit))) } )
}


pi : (real(denominator_limit)) -> (real(retval, 0.0))
{
	real(denominator, 1.0)
	boolean(isplus, true)

	do
	{
		real(div, 0.0)
		assign(div, divide(4.0, denominator))

		if(equal(isplus, true))
		{
			assign(retval, add(retval, div))
			assign(isplus, false)
		}
		else
		{
			assign(retval, subtract(retval, div))
			assign(isplus, true)
		}

		assign(denominator, add(denominator, 2.0))

	} while(less(denominator, denominator_limit))
}

entrypoint : () -> ()
{

	task(async)
	{
		responsemap(responses)
		{
			some_message(integer(foo)) => { do_stuff(foo) }

			other_message(integer(lots), integer(of), integer(params)) =>
			{
				do()
				lots()
				of()
				stuff()
			}

			exit() => { return() }
		}


		while(true)
		{
			acceptmsg(responses)
		}
	}


	message(async, some_message(42))
	message(async, other_message(1, 2, 3))
	message(async, exit())

	acceptmsg(result(integer(foo)) => { debugwritestring(cast(string, foo)) } )

}

entrypoint : () -> ()
{

	task(async)
	{
		integer(my_foo, 0)

		dispatch initialize : integer(foo)) => { assign(my_foo, foo) }
		
		wait(initialize)

		message(master, result(add(my_foo, 42)))
	}

	dispatch result : (integer(foo)) => { debugwritestring(cast(string, foo)) }

	message(async, initialize(4))
	wait(result)
}

entrypoint : () -> ()
{

	task(async)
	{
		integer(my_foo, 0)

		onmessage(initialize(integer(foo)))
		{
			assign(my_foo, foo);
		}
		
		wait(initialize)

		message(master, result(add(my_foo, 42)))
	}


	message(async, initialize(4))


	onmessage(result(integer(foo)))
	{
		debugwritestring(cast(string, foo))
	}

	wait(result)
}

message sendint :
(
	integer(foo)
)


entrypoint : () -> ()
{

	task(async)
	{
		integer(my_foo, 0)

		onmsg(sendint) { assign(my_foo, foo) }
		wait()

		master(sendint, my_foo)		
	}

	async(sendint, 4)

	onmsg(sendint) { debugwritestring(cast(string, result)) }
	wait()
}

entrypoint : () -> ()
{

	task(async)
	{
		integer(my_foo, 0)

		onmsg sendint : (integer(foo))
		{ assign(my_foo, foo) }

		wait()

		mastertask(sendint(add(my_foo, 42)))
	}

	async(sendint(99))

	onmsg sendint : (integer(foo))
	{ debugwritestring(cast(string, result)) }

	wait()
}

entrypoint : () -> ()
{
	task(async1)
	{
		foobar()
	}
}


foobar : () -> ()
{
	shellfunction(borken)	
}


shellfunction : (function op : () -> ()) -> ()
{
	op()
}


borken : () -> ()
{
	debugwritestring("Oh noes! We borked the task checker!")
}