Home | History | Annotate | Download | only in executor 
      1 /*-------------------------------------------------------------------------
      2  * drawElements Quality Program Test Executor
      3  * ------------------------------------------
      4  *
      5  * Copyright 2014 The Android Open Source Project
      6  *
      7  * Licensed under the Apache License, Version 2.0 (the "License");
      8  * you may not use this file except in compliance with the License.
      9  * You may obtain a copy of the License at
     10  *
     11  *      http://www.apache.org/licenses/LICENSE-2.0
     12  *
     13  * Unless required by applicable law or agreed to in writing, software
     14  * distributed under the License is distributed on an "AS IS" BASIS,
     15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     16  * See the License for the specific language governing permissions and
     17  * limitations under the License.
     18  *
     19  *//*!
     20  * \file
     21  * \brief Test batch executor.
     22  *//*--------------------------------------------------------------------*/
     23 
     24 #include "xeBatchExecutor.hpp"
     25 #include "xeTestResultParser.hpp"
     26 
     27 #include <sstream>
     28 #include <cstdio>
     29 
     30 namespace xe
     31 {
     32 
     33 using std::string;
     34 using std::vector;
     35 
     36 enum
     37 {
     38 	TEST_LOG_TMP_BUFFER_SIZE	= 1024,
     39 	INFO_LOG_TMP_BUFFER_SIZE	= 256
     40 };
     41 
     42 // \todo [2012-11-01 pyry] Update execute set in handler.
     43 
     44 static inline bool isExecutedInBatch (const BatchResult* batchResult, const TestCase* testCase)
     45 {
     46 	std::string fullPath;
     47 	testCase->getFullPath(fullPath);
     48 
     49 	if (batchResult->hasTestCaseResult(fullPath.c_str()))
     50 	{
     51 		ConstTestCaseResultPtr data = batchResult->getTestCaseResult(fullPath.c_str());
     52 		return data->getStatusCode() != TESTSTATUSCODE_PENDING && data->getStatusCode() != TESTSTATUSCODE_RUNNING;
     53 	}
     54 	else
     55 		return false;
     56 }
     57 
     58 // \todo [2012-06-19 pyry] These can be optimized using TestSetIterator (once implemented)
     59 
     60 static void computeExecuteSet (TestSet& executeSet, const TestNode* root, const TestSet& testSet, const BatchResult* batchResult)
     61 {
     62 	ConstTestNodeIterator	iter	= ConstTestNodeIterator::begin(root);
     63 	ConstTestNodeIterator	end		= ConstTestNodeIterator::end(root);
     64 
     65 	for (; iter != end; ++iter)
     66 	{
     67 		const TestNode* node = *iter;
     68 
     69 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && testSet.hasNode(node))
     70 		{
     71 			const TestCase* testCase = static_cast<const TestCase*>(node);
     72 
     73 			if (!isExecutedInBatch(batchResult, testCase))
     74 				executeSet.addCase(testCase);
     75 		}
     76 	}
     77 }
     78 
     79 static void computeBatchRequest (TestSet& requestSet, const TestSet& executeSet, const TestNode* root, int maxCasesInSet)
     80 {
     81 	ConstTestNodeIterator	iter		= ConstTestNodeIterator::begin(root);
     82 	ConstTestNodeIterator	end			= ConstTestNodeIterator::end(root);
     83 	int						numCases	= 0;
     84 
     85 	for (; (iter != end) && (numCases < maxCasesInSet); ++iter)
     86 	{
     87 		const TestNode* node = *iter;
     88 
     89 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && executeSet.hasNode(node))
     90 		{
     91 			const TestCase* testCase = static_cast<const TestCase*>(node);
     92 			requestSet.addCase(testCase);
     93 			numCases += 1;
     94 		}
     95 	}
     96 }
     97 
     98 static int removeExecuted (TestSet& set, const TestNode* root, const BatchResult* batchResult)
     99 {
    100 	TestSet					oldSet		(set);
    101 	ConstTestNodeIterator	iter		= ConstTestNodeIterator::begin(root);
    102 	ConstTestNodeIterator	end			= ConstTestNodeIterator::end(root);
    103 	int						numRemoved	= 0;
    104 
    105 	for (; iter != end; ++iter)
    106 	{
    107 		const TestNode* node = *iter;
    108 
    109 		if (node->getNodeType() == TESTNODETYPE_TEST_CASE && oldSet.hasNode(node))
    110 		{
    111 			const TestCase* testCase = static_cast<const TestCase*>(node);
    112 
    113 			if (isExecutedInBatch(batchResult, testCase))
    114 			{
    115 				set.removeCase(testCase);
    116 				numRemoved += 1;
    117 			}
    118 		}
    119 	}
    120 
    121 	return numRemoved;
    122 }
    123 
    124 BatchExecutorLogHandler::BatchExecutorLogHandler (BatchResult* batchResult)
    125 	: m_batchResult(batchResult)
    126 {
    127 }
    128 
    129 BatchExecutorLogHandler::~BatchExecutorLogHandler (void)
    130 {
    131 }
    132 
    133 void BatchExecutorLogHandler::setSessionInfo (const SessionInfo& sessionInfo)
    134 {
    135 	m_batchResult->getSessionInfo() = sessionInfo;
    136 }
    137 
    138 TestCaseResultPtr BatchExecutorLogHandler::startTestCaseResult (const char* casePath)
    139 {
    140 	// \todo [2012-11-01 pyry] What to do with duplicate results?
    141 	if (m_batchResult->hasTestCaseResult(casePath))
    142 		return m_batchResult->getTestCaseResult(casePath);
    143 	else
    144 		return m_batchResult->createTestCaseResult(casePath);
    145 }
    146 
    147 void BatchExecutorLogHandler::testCaseResultUpdated (const TestCaseResultPtr&)
    148 {
    149 }
    150 
    151 void BatchExecutorLogHandler::testCaseResultComplete (const TestCaseResultPtr& result)
    152 {
    153 	// \todo [2012-11-01 pyry] Remove from execute set here instead of updating it between sessions.
    154 	printf("%s\n", result->getTestCasePath());
    155 }
    156 
    157 BatchExecutor::BatchExecutor (const TargetConfiguration& config, CommLink* commLink, const TestNode* root, const TestSet& testSet, BatchResult* batchResult, InfoLog* infoLog)
    158 	: m_config			(config)
    159 	, m_commLink		(commLink)
    160 	, m_root			(root)
    161 	, m_testSet			(testSet)
    162 	, m_logHandler		(batchResult)
    163 	, m_batchResult		(batchResult)
    164 	, m_infoLog			(infoLog)
    165 	, m_state			(STATE_NOT_STARTED)
    166 	, m_testLogParser	(&m_logHandler)
    167 {
    168 }
    169 
    170 BatchExecutor::~BatchExecutor (void)
    171 {
    172 }
    173 
    174 void BatchExecutor::run (void)
    175 {
    176 	XE_CHECK(m_state == STATE_NOT_STARTED);
    177 
    178 	// Check commlink state.
    179 	{
    180 		CommLinkState	commState	= COMMLINKSTATE_LAST;
    181 		std::string		stateStr	= "";
    182 
    183 		commState = m_commLink->getState(stateStr);
    184 
    185 		if (commState == COMMLINKSTATE_ERROR)
    186 		{
    187 			// Report error.
    188 			XE_FAIL((string("CommLink error: '") + stateStr + "'").c_str());
    189 		}
    190 		else if (commState != COMMLINKSTATE_READY)
    191 			XE_FAIL("CommLink is not ready");
    192 	}
    193 
    194 	// Compute initial execute set.
    195 	computeExecuteSet(m_casesToExecute, m_root, m_testSet, m_batchResult);
    196 
    197 	// Register callbacks.
    198 	m_commLink->setCallbacks(enqueueStateChanged, enqueueTestLogData, enqueueInfoLogData, this);
    199 
    200 	try
    201 	{
    202 		if (!m_casesToExecute.empty())
    203 		{
    204 			TestSet batchRequest;
    205 			computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
    206 			launchTestSet(batchRequest);
    207 
    208 			m_state = STATE_STARTED;
    209 		}
    210 		else
    211 			m_state = STATE_FINISHED;
    212 
    213 		// Run handler loop until we are finished.
    214 		while (m_state != STATE_FINISHED)
    215 			m_dispatcher.callNext();
    216 	}
    217 	catch (...)
    218 	{
    219 		m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
    220 		throw;
    221 	}
    222 
    223 	// De-register callbacks.
    224 	m_commLink->setCallbacks(DE_NULL, DE_NULL, DE_NULL, DE_NULL);
    225 }
    226 
    227 void BatchExecutor::onStateChanged (CommLinkState state, const char* message)
    228 {
    229 	switch (state)
    230 	{
    231 		case COMMLINKSTATE_READY:
    232 		case COMMLINKSTATE_TEST_PROCESS_LAUNCHING:
    233 		case COMMLINKSTATE_TEST_PROCESS_RUNNING:
    234 			break; // Ignore.
    235 
    236 		case COMMLINKSTATE_TEST_PROCESS_FINISHED:
    237 		{
    238 			// Feed end of string to parser. This terminates open test case if such exists.
    239 			{
    240 				deUint8 eos = 0;
    241 				onTestLogData(&eos, 1);
    242 			}
    243 
    244 			int numExecuted = removeExecuted(m_casesToExecute, m_root, m_batchResult);
    245 
    246 			// \note No new batch is launched if no cases were executed in last one. Otherwise excutor
    247 			//       could end up in infinite loop.
    248 			if (!m_casesToExecute.empty() && numExecuted > 0)
    249 			{
    250 				// Reset state and start batch.
    251 				m_testLogParser.reset();
    252 
    253 				m_commLink->reset();
    254 				XE_CHECK(m_commLink->getState() == COMMLINKSTATE_READY);
    255 
    256 				TestSet batchRequest;
    257 				computeBatchRequest(batchRequest, m_casesToExecute, m_root, m_config.maxCasesPerSession);
    258 				launchTestSet(batchRequest);
    259 			}
    260 			else
    261 				m_state = STATE_FINISHED;
    262 
    263 			break;
    264 		}
    265 
    266 		case COMMLINKSTATE_TEST_PROCESS_LAUNCH_FAILED:
    267 			printf("Failed to start test process: '%s'\n", message);
    268 			m_state = STATE_FINISHED;
    269 			break;
    270 
    271 		case COMMLINKSTATE_ERROR:
    272 			printf("CommLink error: '%s'\n", message);
    273 			m_state = STATE_FINISHED;
    274 			break;
    275 
    276 		default:
    277 			XE_FAIL("Unknown state");
    278 	}
    279 }
    280 
    281 void BatchExecutor::onTestLogData (const deUint8* bytes, int numBytes)
    282 {
    283 	try
    284 	{
    285 		m_testLogParser.parse(bytes, numBytes);
    286 	}
    287 	catch (const ParseError& e)
    288 	{
    289 		// \todo [2012-07-06 pyry] Log error.
    290 		DE_UNREF(e);
    291 	}
    292 }
    293 
    294 void BatchExecutor::onInfoLogData (const deUint8* bytes, int numBytes)
    295 {
    296 	if (numBytes > 0 && m_infoLog)
    297 		m_infoLog->append(bytes, numBytes);
    298 }
    299 
    300 static void writeCaseListNode (std::ostream& str, const TestNode* node, const TestSet& testSet)
    301 {
    302 	DE_ASSERT(testSet.hasNode(node));
    303 
    304 	TestNodeType nodeType = node->getNodeType();
    305 
    306 	if (nodeType != TESTNODETYPE_ROOT)
    307 		str << node->getName();
    308 
    309 	if (nodeType == TESTNODETYPE_ROOT || nodeType == TESTNODETYPE_GROUP)
    310 	{
    311 		const TestGroup*	group	= static_cast<const TestGroup*>(node);
    312 		bool				isFirst	= true;
    313 
    314 		str << "{";
    315 
    316 		for (int ndx = 0; ndx < group->getNumChildren(); ndx++)
    317 		{
    318 			const TestNode* child = group->getChild(ndx);
    319 
    320 			if (testSet.hasNode(child))
    321 			{
    322 				if (!isFirst)
    323 					str << ",";
    324 
    325 				writeCaseListNode(str, child, testSet);
    326 				isFirst = false;
    327 			}
    328 		}
    329 
    330 		str << "}";
    331 	}
    332 }
    333 
    334 void BatchExecutor::launchTestSet (const TestSet& testSet)
    335 {
    336 	std::ostringstream caseList;
    337 	XE_CHECK(testSet.hasNode(m_root));
    338 	XE_CHECK(m_root->getNodeType() == TESTNODETYPE_ROOT);
    339 	writeCaseListNode(caseList, m_root, testSet);
    340 
    341 	m_commLink->startTestProcess(m_config.binaryName.c_str(), m_config.cmdLineArgs.c_str(), m_config.workingDir.c_str(), caseList.str().c_str());
    342 }
    343 
    344 void BatchExecutor::enqueueStateChanged (void* userPtr, CommLinkState state, const char* message)
    345 {
    346 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
    347 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchStateChanged);
    348 
    349 	writer << executor
    350 		   << state
    351 		   << message;
    352 
    353 	writer.enqueue();
    354 }
    355 
    356 void BatchExecutor::enqueueTestLogData (void* userPtr, const deUint8* bytes, int numBytes)
    357 {
    358 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
    359 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchTestLogData);
    360 
    361 	writer << executor
    362 		   << numBytes;
    363 
    364 	writer.write(bytes, numBytes);
    365 	writer.enqueue();
    366 }
    367 
    368 void BatchExecutor::enqueueInfoLogData (void* userPtr, const deUint8* bytes, int numBytes)
    369 {
    370 	BatchExecutor*	executor	= static_cast<BatchExecutor*>(userPtr);
    371 	CallWriter		writer		(&executor->m_dispatcher, BatchExecutor::dispatchInfoLogData);
    372 
    373 	writer << executor
    374 		   << numBytes;
    375 
    376 	writer.write(bytes, numBytes);
    377 	writer.enqueue();
    378 }
    379 
    380 void BatchExecutor::dispatchStateChanged (CallReader data)
    381 {
    382 	BatchExecutor*	executor	= DE_NULL;
    383 	CommLinkState	state		= COMMLINKSTATE_LAST;
    384 	std::string		message;
    385 
    386 	data >> executor
    387 		 >> state
    388 		 >> message;
    389 
    390 	executor->onStateChanged(state, message.c_str());
    391 }
    392 
    393 void BatchExecutor::dispatchTestLogData (CallReader data)
    394 {
    395 	BatchExecutor*	executor	= DE_NULL;
    396 	int				numBytes;
    397 
    398 	data >> executor
    399 		 >> numBytes;
    400 
    401 	executor->onTestLogData(data.getDataBlock(numBytes), numBytes);
    402 }
    403 
    404 void BatchExecutor::dispatchInfoLogData (CallReader data)
    405 {
    406 	BatchExecutor*	executor	= DE_NULL;
    407 	int				numBytes;
    408 
    409 	data >> executor
    410 		 >> numBytes;
    411 
    412 	executor->onInfoLogData(data.getDataBlock(numBytes), numBytes);
    413 }
    414 
    415 } // xe
    416