executor/xeBatchExecutor.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program Test Executor
  * ------------------------------------------
  *
  * Copyright 2014 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Test batch executor.
  *//*--------------------------------------------------------------------*/

 #include "xeBatchExecutor.hpp"
 #include "xeTestResultParser.hpp"

 #include <sstream>
 #include <cstdio>

 namespace xe
 {

 using std::string;
 using std::vector;

 enum
 {
 	TEST_LOG_TMP_BUFFER_SIZE	= 1024,
 	INFO_LOG_TMP_BUFFER_SIZE	= 256
 };

 // \todo [2012-11-01 pyry] Update execute set in handler.

 static inline bool isExecutedInBatch (const BatchResult* batchResult, const TestCase* testCase)
 {
 	std::string fullPath;
 	testCase->getFullPath(fullPath);

 	if (batchResult->hasTestCaseResult(fullPath.c_str()))
 	{
 		ConstTestCaseResultPtr data = batchResult->getTestCaseResult(fullPath.c_str());
 		return data->getStatusCode() != TESTSTATUSCODE_PENDING && data->getStatusCode() != TESTSTATUSCODE_RUNNING;
 	}
 	else
 		return false;
 }

 // \todo [2012-06-19 pyry] These can be optimized using TestSetIterator (once implemented)

 static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult)
 {
 	ConstTestNodeIterator	iter	= ConstTestNodeIterator::begin(root);
 	ConstTestNodeIterator	end		= ConstTestNodeIterator::end(root);

 	for (; iter != end; ++iter)
 	{
 		const TestNode* node = *iter;

 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node))
 		{
 			const TestCase* testCase = static_cast<const TestCase*>(node);

 			if (!isExecutedInBatch(batchResult, testCase))
 				executeSet.addCase(testCase);
 		}
 	}
 }

 static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet)
 {
 	ConstTestNodeIterator	iter		= ConstTestNodeIterator::begin(root);
 	ConstTestNodeIterator	end			= ConstTestNodeIterator::end(root);
 	int						numCases	= 0;

 	for (; (iter != end) && (numCases < maxCasesInSet); ++iter)
 	{
 		const TestNode* node = *iter;

 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node))
 		{
 			const TestCase* testCase = static_cast<const TestCase*>(node);
 			requestSet.addCase(testCase);
 			numCases += 1;
 		}
 	}
 }

 static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult)
 {
 	TestSet					oldSet		(set);
 	ConstTestNodeIterator	iter		= ConstTestNodeIterator::begin(root);
 	ConstTestNodeIterator	end			= ConstTestNodeIterator::end(root);
 	int						numRemoved	= 0;

 	for (; iter != end; ++iter)
 	{
 		const TestNode* node = *iter;

 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node))
 		{
 			const TestCase* testCase = static_cast<const TestCase*>(node);

 			if (isExecutedInBatch(batchResult, testCase))
 			{
 				set.removeCase(testCase);
 				numRemoved += 1;
 			}
 		}
 	}

 	return numRemoved;
 }

 BatchExecutorLogHandler::BatchExecutorLogHandler (BatchResult* batchResult)
 	: m_batchResult(batchResult)
 {
 }

 BatchExecutorLogHandler::~BatchExecutorLogHandler (void)
 {
 }

 void BatchExecutorLogHandler::setSessionInfo (const SessionInfo& sessionInfo)
 {
 	m_batchResult->getSessionInfo() = sessionInfo;
 }

 TestCaseResultPtr BatchExecutorLogHandler::startTestCaseResult (const char* casePath)
 {
 	// \todo [2012-11-01 pyry] What to do with duplicate results?
 	if (m_batchResult->hasTestCaseResult(casePath))
 		return m_batchResult->getTestCaseResult(casePath);
 	else
 		return m_batchResult->createTestCaseResult(casePath);
 }

 void BatchExecutorLogHandler::testCaseResultUpdated (const TestCaseResultPtr&)
 {
 }

 void BatchExecutorLogHandler::testCaseResultComplete (const TestCaseResultPtr& result)
 {
 	// \todo [2012-11-01 pyry] Remove from execute set here instead of updating it between sessions.
 	printf("%s\n", result->getTestCasePath());
 }

 BatchExecutor::BatchExecutor (const TargetConfiguration& config, CommLink* commLink, const TestNode* root, const TestSet& testSet, BatchResult* batchResult, InfoLog* infoLog)
 	: m_config			(config)
 	, m_commLink		(commLink)
 	, m_root			(root)
 	, m_testSet			(testSet)
 	, m_logHandler		(batchResult)
 	, m_batchResult		(batchResult)
 	, m_infoLog			(infoLog)
 	, m_state			(STATE_NOT_STARTED)
 	, m_testLogParser	(&m_logHandler)
 {
 }

 BatchExecutor::~BatchExecutor (void)
 {
 }

 void BatchExecutor::run (void)
 {
 	XE_CHECK(m_state == STATE_NOT_STARTED);

 	// Check commlink state.
 	{
 		CommLinkState	commState	= COMMLINKSTATE_LAST;
 		std::string		stateStr	= "";

 		commState = m_commLink->getState(stateStr);

 		if (commState == COMMLINKSTATE_ERROR)
 		{
 			// Report error.
 			XE_FAIL((string("CommLink error: '") + stateStr + "'").c_str());
 		}
 		else if (commState != COMMLINKSTATE_READY)
 			XE_FAIL("CommLink is not ready");
 	}

 	// Compute initial execute set.
 	computeExecuteSet(m_casesToExecute, m_root, m_testSet, m_batchResult);

 	// Register callbacks.
 	m_commLink->setCallbacks(enqueueStateChanged, enqueueTestLogData, enqueueInfoLogData, this);

 	try
 	{
 		if (!m_casesToExecute.empty())
 		{
 			TestSet batchRequest;
 			computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
 			launchTestSet(batchRequest);

 			m_state = STATE_STARTED;
 		}
 		else
 			m_state = STATE_FINISHED;

 		// Run handler loop until we are finished.
 		while (m_state != STATE_FINISHED)
 			m_dispatcher.callNext();
 	}
 	catch (...)
 	{
 		m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
 		throw;
 	}

 	// De-register callbacks.
 	m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
 }

 void BatchExecutor::cancel (void)
 {
 	m_state = STATE_FINISHED;
 	m_dispatcher.cancel();
 }

 void BatchExecutor::onStateChanged (CommLinkState state, const char* message)
 {
 	switch (state)
 	{
 		case COMMLINKSTATE_READY:
 		case COMMLINKSTATE_TEST_PROCESS_LAUNCHING:
 		case COMMLINKSTATE_TEST_PROCESS_RUNNING:
 			break; // Ignore.

 		case COMMLINKSTATE_TEST_PROCESS_FINISHED:
 		{
 			// Feed end of string to parser. This terminates open test case if such exists.
 			{
 				deUint8 eos = 0;
 				onTestLogData(&eos, 1);
 			}

 			int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult);

 			// \note No new batch is launched if no cases were executed in last one. Otherwise excutor
 			//       could end up in infinite loop.
 			if (!m_casesToExecute.empty() && numExecuted > 0)
 			{
 				// Reset state and start batch.
 				m_testLogParser.reset();

 				m_commLink->reset();
 				XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY);

 				TestSet batchRequest;
 				computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
 				launchTestSet(batchRequest);
 			}
 			else
 				m_state = STATE_FINISHED;

 			break;
 		}

 		case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED:
 			printf("Failed to start test process: '%s'\n", message);
 			m_state = STATE_FINISHED;
 			break;

 		case COMMLINKSTATE_ERROR:
 			printf("CommLink error: '%s'\n", message);
 			m_state = STATE_FINISHED;
 			break;

 		default:
 			XE_FAIL("Unknown state");
 	}
 }

 void BatchExecutor::onTestLogData (const deUint8* bytes, size_t numBytes)
 {
 	try
 	{
 		m_testLogParser.parse(bytes, numBytes);
 	}
 	catch (const ParseError& e)
 	{
 		// \todo [2012-07-06 pyry] Log error.
 		DE_UNREF(e);
 	}
 }

 void BatchExecutor::onInfoLogData (const deUint8* bytes, size_t numBytes)
 {
 	if (numBytes > 0 && m_infoLog)
 		m_infoLog->append(bytes, numBytes);
 }

 static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet)
 {
 	DE_ASSERT(testSet.hasNode(node));

 	TestNodeType nodeType = node->getNodeType();

 	if (nodeType != TESTNODETYPE_ROOT)
 		str << node->getName();

 	if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP)
 	{
 		const TestGroup*	group	= static_cast<const TestGroup*>(node);
 		bool				isFirst	= true;

 		str << "{";

 		for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
 		{
 			const TestNode* child = group->getChild(ndx);

 			if (testSet.hasNode(child))
 			{
 				if (!isFirst)
 					str << ",";

 				writeCaseListNode(str, child, testSet);
 				isFirst = false;
 			}
 		}

 		str << "}";
 	}
 }

 void BatchExecutor::launchTestSet (const TestSet& testSet)
 {
 	std::ostringstream caseList;
 	XE_CHECK(testSet.hasNode(m_root));
 	XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT);
 	writeCaseListNode(caseList, m_root, testSet);

 	m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str());
 }

 void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message)
 {
 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchStateChanged);

 	writer << executor
 		   << state
 		   << message;

 	writer.enqueue();
 }

 void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
 {
 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchTestLogData);

 	writer << executor
 		   << numBytes;

 	writer.write(bytes, numBytes);
 	writer.enqueue();
 }

 void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
 {
 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData);

 	writer << executor
 		   << numBytes;

 	writer.write(bytes, numBytes);
 	writer.enqueue();
 }

 void BatchExecutor::dispatchStateChanged (CallReader& data)
 {
 	BatchExecutor*	executor	= DE_NULL;
 	CommLinkState	state		= COMMLINKSTATE_LAST;
 	std::string		message;

 	data >> executor
 		 >> state
 		 >> message;

 	executor->onStateChanged(state, message.c_str());
 }

 void BatchExecutor::dispatchTestLogData (CallReader& data)
 {
 	BatchExecutor*	executor	= DE_NULL;
 	size_t			numBytes;

 	data >> executor
 		 >> numBytes;

 	executor->onTestLogData(data.getDataBlock(numBytes), numBytes);
 }

 void BatchExecutor::dispatchInfoLogData (CallReader& data)
 {
 	BatchExecutor*	executor	= DE_NULL;
 	size_t			numBytes;

 	data >> executor
 		 >> numBytes;

 	executor->onInfoLogData(data.getDataBlock(numBytes), numBytes);
 }

 } // xe
	/*-------------------------------------------------------------------------
	* drawElements Quality Program Test Executor
	* ------------------------------------------
	*
	* Copyright 2014 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Test batch executor.
	//--------------------------------------------------------------------*/

	#include "xeBatchExecutor.hpp"
	#include "xeTestResultParser.hpp"

	#include <sstream>
	#include <cstdio>

	namespace xe
	{

	using std::string;
	using std::vector;

	enum
	{
	TEST_LOG_TMP_BUFFER_SIZE = 1024,
	INFO_LOG_TMP_BUFFER_SIZE = 256
	};

	// \todo [2012-11-01 pyry] Update execute set in handler.

	static inline bool isExecutedInBatch (const BatchResult* batchResult, const TestCase* testCase)
	{
	std::string fullPath;
	testCase->getFullPath(fullPath);

	if (batchResult->hasTestCaseResult(fullPath.c_str()))
	{
	ConstTestCaseResultPtr data = batchResult->getTestCaseResult(fullPath.c_str());
	return data->getStatusCode() != TESTSTATUSCODE_PENDING && data->getStatusCode() != TESTSTATUSCODE_RUNNING;
	}
	else
	return false;
	}

	// \todo [2012-06-19 pyry] These can be optimized using TestSetIterator (once implemented)

	static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult)
	{
	ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
	ConstTestNodeIterator end = ConstTestNodeIterator::end(root);

	for (; iter != end; ++iter)
	{
	const TestNode* node = *iter;

	if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node))
	{
	const TestCase* testCase = static_cast<const TestCase*>(node);

	if (!isExecutedInBatch(batchResult, testCase))
	executeSet.addCase(testCase);
	}
	}
	}

	static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet)
	{
	ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
	ConstTestNodeIterator end = ConstTestNodeIterator::end(root);
	int numCases = 0;

	for (; (iter != end) && (numCases < maxCasesInSet); ++iter)
	{
	const TestNode* node = *iter;

	if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node))
	{
	const TestCase* testCase = static_cast<const TestCase*>(node);
	requestSet.addCase(testCase);
	numCases += 1;
	}
	}
	}

	static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult)
	{
	TestSet oldSet (set);
	ConstTestNodeIterator iter = ConstTestNodeIterator::begin(root);
	ConstTestNodeIterator end = ConstTestNodeIterator::end(root);
	int numRemoved = 0;

	for (; iter != end; ++iter)
	{
	const TestNode* node = *iter;

	if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node))
	{
	const TestCase* testCase = static_cast<const TestCase*>(node);

	if (isExecutedInBatch(batchResult, testCase))
	{
	set.removeCase(testCase);
	numRemoved += 1;
	}
	}
	}

	return numRemoved;
	}

	BatchExecutorLogHandler::BatchExecutorLogHandler (BatchResult* batchResult)
	: m_batchResult(batchResult)
	{
	}

	BatchExecutorLogHandler::~BatchExecutorLogHandler (void)
	{
	}

	void BatchExecutorLogHandler::setSessionInfo (const SessionInfo& sessionInfo)
	{
	m_batchResult->getSessionInfo() = sessionInfo;
	}

	TestCaseResultPtr BatchExecutorLogHandler::startTestCaseResult (const char* casePath)
	{
	// \todo [2012-11-01 pyry] What to do with duplicate results?
	if (m_batchResult->hasTestCaseResult(casePath))
	return m_batchResult->getTestCaseResult(casePath);
	else
	return m_batchResult->createTestCaseResult(casePath);
	}

	void BatchExecutorLogHandler::testCaseResultUpdated (const TestCaseResultPtr&)
	{
	}

	void BatchExecutorLogHandler::testCaseResultComplete (const TestCaseResultPtr& result)
	{
	// \todo [2012-11-01 pyry] Remove from execute set here instead of updating it between sessions.
	printf("%s\n", result->getTestCasePath());
	}

	BatchExecutor::BatchExecutor (const TargetConfiguration& config, CommLink* commLink, const TestNode* root, const TestSet& testSet, BatchResult* batchResult, InfoLog* infoLog)
	: m_config (config)
	, m_commLink (commLink)
	, m_root (root)
	, m_testSet (testSet)
	, m_logHandler (batchResult)
	, m_batchResult (batchResult)
	, m_infoLog (infoLog)
	, m_state (STATE_NOT_STARTED)
	, m_testLogParser (&m_logHandler)
	{
	}

	BatchExecutor::~BatchExecutor (void)
	{
	}

	void BatchExecutor::run (void)
	{
	XE_CHECK(m_state == STATE_NOT_STARTED);

	// Check commlink state.
	{
	CommLinkState commState = COMMLINKSTATE_LAST;
	std::string stateStr = "";

	commState = m_commLink->getState(stateStr);

	if (commState == COMMLINKSTATE_ERROR)
	{
	// Report error.
	XE_FAIL((string("CommLink error: '") + stateStr + "'").c_str());
	}
	else if (commState != COMMLINKSTATE_READY)
	XE_FAIL("CommLink is not ready");
	}

	// Compute initial execute set.
	computeExecuteSet(m_casesToExecute, m_root, m_testSet, m_batchResult);

	// Register callbacks.
	m_commLink->setCallbacks(enqueueStateChanged, enqueueTestLogData, enqueueInfoLogData, this);

	try
	{
	if (!m_casesToExecute.empty())
	{
	TestSet batchRequest;
	computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
	launchTestSet(batchRequest);

	m_state = STATE_STARTED;
	}
	else
	m_state = STATE_FINISHED;

	// Run handler loop until we are finished.
	while (m_state != STATE_FINISHED)
	m_dispatcher.callNext();
	}
	catch (...)
	{
	m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
	throw;
	}

	// De-register callbacks.
	m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
	}

	void BatchExecutor::cancel (void)
	{
	m_state = STATE_FINISHED;
	m_dispatcher.cancel();
	}

	void BatchExecutor::onStateChanged (CommLinkState state, const char* message)
	{
	switch (state)
	{
	case COMMLINKSTATE_READY:
	case COMMLINKSTATE_TEST_PROCESS_LAUNCHING:
	case COMMLINKSTATE_TEST_PROCESS_RUNNING:
	break; // Ignore.

	case COMMLINKSTATE_TEST_PROCESS_FINISHED:
	{
	// Feed end of string to parser. This terminates open test case if such exists.
	{
	deUint8 eos = 0;
	onTestLogData(&eos, 1);
	}

	int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult);

	// \note No new batch is launched if no cases were executed in last one. Otherwise excutor
	// could end up in infinite loop.
	if (!m_casesToExecute.empty() && numExecuted > 0)
	{
	// Reset state and start batch.
	m_testLogParser.reset();

	m_commLink->reset();
	XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY);

	TestSet batchRequest;
	computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
	launchTestSet(batchRequest);
	}
	else
	m_state = STATE_FINISHED;

	break;
	}

	case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED:
	printf("Failed to start test process: '%s'\n", message);
	m_state = STATE_FINISHED;
	break;

	case COMMLINKSTATE_ERROR:
	printf("CommLink error: '%s'\n", message);
	m_state = STATE_FINISHED;
	break;

	default:
	XE_FAIL("Unknown state");
	}
	}

	void BatchExecutor::onTestLogData (const deUint8* bytes, size_t numBytes)
	{
	try
	{
	m_testLogParser.parse(bytes, numBytes);
	}
	catch (const ParseError& e)
	{
	// \todo [2012-07-06 pyry] Log error.
	DE_UNREF(e);
	}
	}

	void BatchExecutor::onInfoLogData (const deUint8* bytes, size_t numBytes)
	{
	if (numBytes > 0 && m_infoLog)
	m_infoLog->append(bytes, numBytes);
	}

	static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet)
	{
	DE_ASSERT(testSet.hasNode(node));

	TestNodeType nodeType = node->getNodeType();

	if (nodeType != TESTNODETYPE_ROOT)
	str << node->getName();

	if (nodeType == TESTNODETYPE_ROOT \|\| nodeType == TESTNODETYPE_GROUP)
	{
	const TestGroup* group = static_cast<const TestGroup*>(node);
	bool isFirst = true;

	str << "{";

	for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
	{
	const TestNode* child = group->getChild(ndx);

	if (testSet.hasNode(child))
	{
	if (!isFirst)
	str << ",";

	writeCaseListNode(str, child, testSet);
	isFirst = false;
	}
	}

	str << "}";
	}
	}

	void BatchExecutor::launchTestSet (const TestSet& testSet)
	{
	std::ostringstream caseList;
	XE_CHECK(testSet.hasNode(m_root));
	XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT);
	writeCaseListNode(caseList, m_root, testSet);

	m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str());
	}

	void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message)
	{
	BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
	CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchStateChanged);

	writer << executor
	<< state
	<< message;

	writer.enqueue();
	}

	void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
	{
	BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
	CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchTestLogData);

	writer << executor
	<< numBytes;

	writer.write(bytes, numBytes);
	writer.enqueue();
	}

	void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, size_t numBytes)
	{
	BatchExecutor* executor = static_cast<BatchExecutor*>(userPtr);
	CallWriter writer (&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData);

	writer << executor
	<< numBytes;

	writer.write(bytes, numBytes);
	writer.enqueue();
	}

	void BatchExecutor::dispatchStateChanged (CallReader& data)
	{
	BatchExecutor* executor = DE_NULL;
	CommLinkState state = COMMLINKSTATE_LAST;
	std::string message;

	data >> executor
	>> state
	>> message;

	executor->onStateChanged(state, message.c_str());
	}

	void BatchExecutor::dispatchTestLogData (CallReader& data)
	{
	BatchExecutor* executor = DE_NULL;
	size_t numBytes;

	data >> executor
	>> numBytes;

	executor->onTestLogData(data.getDataBlock(numBytes), numBytes);
	}

	void BatchExecutor::dispatchInfoLogData (CallReader& data)
	{
	BatchExecutor* executor = DE_NULL;
	size_t numBytes;

	data >> executor
	>> numBytes;

	executor->onInfoLogData(data.getDataBlock(numBytes), numBytes);
	}

	} // xe