framework/platform/android/tcuAndroidExecService.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * drawElements Quality Program Tester Core
  * ----------------------------------------
  *
  * 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 Android ExecServer.
  *//*--------------------------------------------------------------------*/

 #include "tcuAndroidExecService.hpp"
 #include "deFile.h"
 #include "deClock.h"

 #if 0
 #define DBG_PRINT(ARGS) print ARGS
 #else
 #define DBG_PRINT(ARGS)
 #endif

 namespace tcu
 {
 namespace Android
 {

 static const char *LOG_FILE_NAME = "/sdcard/dEQP-log.qpa";

 enum
 {
     PROCESS_START_TIMEOUT  = 5000 * 1000, //!< Timeout in usec.
     PROCESS_QUERY_INTERVAL = 1000 * 1000  //!< Running query interval limit in usec.
 };

 static void checkJniException(JNIEnv *env, const char *file, int line)
 {
     if (env->ExceptionOccurred())
     {
         env->ExceptionDescribe();
         env->ExceptionClear();
         throw InternalError("JNI Exception", DE_NULL, file, line);
     }
 }

 #define JNI_CHECK(EXPR)                             \
     do                                              \
     {                                               \
         checkJniException(env, __FILE__, __LINE__); \
         TCU_CHECK_INTERNAL(EXPR);                   \
     } while (false)

 // TestProcess

 TestProcess::TestProcess(JavaVM *vm, jobject context)
     : m_vm(vm)
     , m_remoteCls(0)
     , m_remote(0)
     , m_start(0)
     , m_kill(0)
     , m_isRunning(0)
     , m_launchTime(0)
     , m_lastQueryTime(0)
     , m_lastRunningStatus(false)
     , m_logReader(xs::LOG_BUFFER_BLOCK_SIZE, xs::LOG_BUFFER_NUM_BLOCKS)
 {
     DBG_PRINT(("TestProcess::TestProcess(%p, %p)", vm, context));

     JNIEnv *env         = getCurrentThreadEnv();
     jobject remote      = 0;
     jstring logFileName = 0;

     try
     {
         jclass remoteCls = 0;
         jmethodID ctorId = 0;

         remoteCls = env->FindClass("com/drawelements/deqp/testercore/RemoteAPI");
         JNI_CHECK(remoteCls);

         // Acquire global reference to RemoteAPI class.
         m_remoteCls = reinterpret_cast<jclass>(env->NewGlobalRef(remoteCls));
         JNI_CHECK(m_remoteCls);
         env->DeleteLocalRef(remoteCls);
         remoteCls = 0;

         ctorId = env->GetMethodID(m_remoteCls, "<init>", "(Landroid/content/Context;Ljava/lang/String;)V");
         JNI_CHECK(ctorId);

         logFileName = env->NewStringUTF(LOG_FILE_NAME);
         JNI_CHECK(logFileName);

         // Create RemoteAPI instance.
         remote = env->NewObject(m_remoteCls, ctorId, context, logFileName);
         JNI_CHECK(remote);

         env->DeleteLocalRef(logFileName);
         logFileName = 0;

         // Acquire global reference to remote.
         m_remote = env->NewGlobalRef(remote);
         JNI_CHECK(m_remote);
         env->DeleteLocalRef(remote);
         remote = 0;

         m_start = env->GetMethodID(m_remoteCls, "start", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z");
         JNI_CHECK(m_start);

         m_kill = env->GetMethodID(m_remoteCls, "kill", "()Z");
         JNI_CHECK(m_kill);

         m_isRunning = env->GetMethodID(m_remoteCls, "isRunning", "()Z");
         JNI_CHECK(m_isRunning);
     }
     catch (...)
     {
         if (logFileName)
             env->DeleteLocalRef(logFileName);
         if (remote)
             env->DeleteLocalRef(remote);
         if (m_remoteCls)
             env->DeleteGlobalRef(reinterpret_cast<jobject>(m_remoteCls));
         if (m_remote)
             env->DeleteGlobalRef(m_remote);
         throw;
     }
 }

 TestProcess::~TestProcess(void)
 {
     DBG_PRINT(("TestProcess::~TestProcess()"));

     try
     {
         JNIEnv *env = getCurrentThreadEnv();
         env->DeleteGlobalRef(m_remote);
         env->DeleteGlobalRef(m_remoteCls);
     }
     catch (...)
     {
     }
 }

 void TestProcess::start(const char *name, const char *params, const char *workingDir, const char *caseList)
 {
     DBG_PRINT(("TestProcess::start(%s, %s, %s, ...)", name, params, workingDir));

     JNIEnv *env         = getCurrentThreadEnv();
     jstring nameStr     = 0;
     jstring paramsStr   = 0;
     jstring caseListStr = 0;

     DE_UNREF(workingDir);

     // Remove old log file if such exists.
     if (deFileExists(LOG_FILE_NAME))
     {
         if (!deDeleteFile(LOG_FILE_NAME) || deFileExists(LOG_FILE_NAME))
             throw xs::TestProcessException(std::string("Failed to remove '") + LOG_FILE_NAME + "'");
     }

     try
     {
         nameStr = env->NewStringUTF(name);
         JNI_CHECK(nameStr);

         paramsStr = env->NewStringUTF(params);
         JNI_CHECK(paramsStr);

         caseListStr = env->NewStringUTF(caseList);
         JNI_CHECK(caseListStr);

         jboolean res = env->CallBooleanMethod(m_remote, m_start, nameStr, paramsStr, caseListStr);
         checkJniException(env, __FILE__, __LINE__);

         if (res == JNI_FALSE)
             throw xs::TestProcessException("Failed to launch activity");

         m_launchTime        = deGetMicroseconds();
         m_lastQueryTime     = m_launchTime;
         m_lastRunningStatus = true;
     }
     catch (...)
     {
         if (nameStr)
             env->DeleteLocalRef(nameStr);
         if (paramsStr)
             env->DeleteLocalRef(paramsStr);
         if (caseListStr)
             env->DeleteLocalRef(caseListStr);
         throw;
     }

     env->DeleteLocalRef(nameStr);
     env->DeleteLocalRef(paramsStr);
     env->DeleteLocalRef(caseListStr);
 }

 void TestProcess::terminate(void)
 {
     DBG_PRINT(("TestProcess::terminate()"));

     JNIEnv *env  = getCurrentThreadEnv();
     jboolean res = env->CallBooleanMethod(m_remote, m_kill);
     checkJniException(env, __FILE__, __LINE__);
     DE_UNREF(res); // Failure to kill process is ignored.
 }

 void TestProcess::cleanup(void)
 {
     DBG_PRINT(("TestProcess::cleanup()"));

     terminate();
     m_logReader.stop();
 }

 bool TestProcess::isRunning(void)
 {
     uint64_t curTime = deGetMicroseconds();

     // On Android process launch is asynchronous so we don't want to poll for process until after some time.
     if (curTime - m_launchTime < PROCESS_START_TIMEOUT || curTime - m_lastQueryTime < PROCESS_QUERY_INTERVAL)
         return m_lastRunningStatus;

     JNIEnv *env  = getCurrentThreadEnv();
     jboolean res = env->CallBooleanMethod(m_remote, m_isRunning);
     checkJniException(env, __FILE__, __LINE__);

     DBG_PRINT(("TestProcess::isRunning(): %s", res == JNI_TRUE ? "true" : "false"));
     m_lastQueryTime     = curTime;
     m_lastRunningStatus = res == JNI_TRUE;

     return m_lastRunningStatus;
 }

 JNIEnv *TestProcess::getCurrentThreadEnv(void)
 {
     JNIEnv *env = DE_NULL;
     jint ret    = m_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);

     if (ret == JNI_OK)
         return env;
     else
         throw InternalError("GetEnv() failed");
 }

 int TestProcess::readTestLog(uint8_t *dst, int numBytes)
 {
     if (!m_logReader.isRunning())
     {
         if (deGetMicroseconds() - m_launchTime > xs::LOG_FILE_TIMEOUT * 1000)
         {
             // Timeout, kill process.
             terminate();
             DBG_PRINT(("TestProcess:readTestLog(): Log file timeout occurred!"));
             return 0; // \todo [2013-08-13 pyry] Throw exception?
         }

         if (!deFileExists(LOG_FILE_NAME))
             return 0;

         // Start reader.
         m_logReader.start(LOG_FILE_NAME);
     }

     DE_ASSERT(m_logReader.isRunning());
     return m_logReader.read(dst, numBytes);
 }

 int TestProcess::getExitCode(void) const
 {
     return 0;
 }

 int TestProcess::readInfoLog(uint8_t *dst, int numBytes)
 {
     // \todo [2012-11-12 pyry] Read device log.
     DE_UNREF(dst && numBytes);
     return 0;
 }

 // ExecutionServer

 ExecutionServer::ExecutionServer(JavaVM *vm, xs::TestProcess *testProcess, deSocketFamily family, int port,
                                  RunMode runMode)
     : xs::ExecutionServer(testProcess, family, port, runMode)
     , m_vm(vm)
 {
 }

 xs::ConnectionHandler *ExecutionServer::createHandler(de::Socket *socket, const de::SocketAddress &clientAddress)
 {
     DE_UNREF(clientAddress);
     return new ConnectionHandler(m_vm, this, socket);
 }

 // ConnectionHandler

 ConnectionHandler::ConnectionHandler(JavaVM *vm, xs::ExecutionServer *server, de::Socket *socket)
     : xs::ExecutionRequestHandler(server, socket)
     , m_vm(vm)
 {
 }

 void ConnectionHandler::run(void)
 {
     JNIEnv *env = DE_NULL;
     if (m_vm->AttachCurrentThread(&env, DE_NULL) != 0)
     {
         print("AttachCurrentThread() failed");
         return;
     }

     xs::ExecutionRequestHandler::run();

     if (m_vm->DetachCurrentThread() != 0)
         print("DetachCurrentThread() failed");
 }

 // ServerThread

 ServerThread::ServerThread(JavaVM *vm, xs::TestProcess *process, deSocketFamily family, int port)
     : m_server(vm, process, family, port, xs::ExecutionServer::RUNMODE_FOREVER)
 {
 }

 void ServerThread::run(void)
 {
     try
     {
         m_server.runServer();
     }
     catch (const std::exception &e)
     {
         die("ServerThread::run(): %s", e.what());
     }
 }

 void ServerThread::stop(void)
 {
     m_server.stopServer();
     join();
 }

 // ExecService

 ExecService::ExecService(JavaVM *vm, jobject context, int port, deSocketFamily family)
     : m_process(vm, context)
     , m_thread(vm, &m_process, family, port)
 {
 }

 ExecService::~ExecService(void)
 {
 }

 void ExecService::start(void)
 {
     m_thread.start();
 }

 void ExecService::stop(void)
 {
     m_thread.stop();
 }

 } // namespace Android
 } // namespace tcu
	/*-------------------------------------------------------------------------
	* drawElements Quality Program Tester Core
	* ----------------------------------------
	*
	* 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 Android ExecServer.
	//--------------------------------------------------------------------*/

	#include "tcuAndroidExecService.hpp"
	#include "deFile.h"
	#include "deClock.h"

	#if 0
	#define DBG_PRINT(ARGS) print ARGS
	#else
	#define DBG_PRINT(ARGS)
	#endif

	namespace tcu
	{
	namespace Android
	{

	static const char *LOG_FILE_NAME = "/sdcard/dEQP-log.qpa";

	enum
	{
	PROCESS_START_TIMEOUT = 5000 * 1000, //!< Timeout in usec.
	PROCESS_QUERY_INTERVAL = 1000 * 1000 //!< Running query interval limit in usec.
	};

	static void checkJniException(JNIEnv env, const char file, int line)
	{
	if (env->ExceptionOccurred())
	{
	env->ExceptionDescribe();
	env->ExceptionClear();
	throw InternalError("JNI Exception", DE_NULL, file, line);
	}
	}

	#define JNI_CHECK(EXPR) \
	do \
	{ \
	checkJniException(env, __FILE__, __LINE__); \
	TCU_CHECK_INTERNAL(EXPR); \
	} while (false)

	// TestProcess

	TestProcess::TestProcess(JavaVM *vm, jobject context)
	: m_vm(vm)
	, m_remoteCls(0)
	, m_remote(0)
	, m_start(0)
	, m_kill(0)
	, m_isRunning(0)
	, m_launchTime(0)
	, m_lastQueryTime(0)
	, m_lastRunningStatus(false)
	, m_logReader(xs::LOG_BUFFER_BLOCK_SIZE, xs::LOG_BUFFER_NUM_BLOCKS)
	{
	DBG_PRINT(("TestProcess::TestProcess(%p, %p)", vm, context));

	JNIEnv *env = getCurrentThreadEnv();
	jobject remote = 0;
	jstring logFileName = 0;

	try
	{
	jclass remoteCls = 0;
	jmethodID ctorId = 0;

	remoteCls = env->FindClass("com/drawelements/deqp/testercore/RemoteAPI");
	JNI_CHECK(remoteCls);

	// Acquire global reference to RemoteAPI class.
	m_remoteCls = reinterpret_cast<jclass>(env->NewGlobalRef(remoteCls));
	JNI_CHECK(m_remoteCls);
	env->DeleteLocalRef(remoteCls);
	remoteCls = 0;

	ctorId = env->GetMethodID(m_remoteCls, "<init>", "(Landroid/content/Context;Ljava/lang/String;)V");
	JNI_CHECK(ctorId);

	logFileName = env->NewStringUTF(LOG_FILE_NAME);
	JNI_CHECK(logFileName);

	// Create RemoteAPI instance.
	remote = env->NewObject(m_remoteCls, ctorId, context, logFileName);
	JNI_CHECK(remote);

	env->DeleteLocalRef(logFileName);
	logFileName = 0;

	// Acquire global reference to remote.
	m_remote = env->NewGlobalRef(remote);
	JNI_CHECK(m_remote);
	env->DeleteLocalRef(remote);
	remote = 0;

	m_start = env->GetMethodID(m_remoteCls, "start", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z");
	JNI_CHECK(m_start);

	m_kill = env->GetMethodID(m_remoteCls, "kill", "()Z");
	JNI_CHECK(m_kill);

	m_isRunning = env->GetMethodID(m_remoteCls, "isRunning", "()Z");
	JNI_CHECK(m_isRunning);
	}
	catch (...)
	{
	if (logFileName)
	env->DeleteLocalRef(logFileName);
	if (remote)
	env->DeleteLocalRef(remote);
	if (m_remoteCls)
	env->DeleteGlobalRef(reinterpret_cast<jobject>(m_remoteCls));
	if (m_remote)
	env->DeleteGlobalRef(m_remote);
	throw;
	}
	}

	TestProcess::~TestProcess(void)
	{
	DBG_PRINT(("TestProcess::~TestProcess()"));

	try
	{
	JNIEnv *env = getCurrentThreadEnv();
	env->DeleteGlobalRef(m_remote);
	env->DeleteGlobalRef(m_remoteCls);
	}
	catch (...)
	{
	}
	}

	void TestProcess::start(const char name, const char params, const char workingDir, const char caseList)
	{
	DBG_PRINT(("TestProcess::start(%s, %s, %s, ...)", name, params, workingDir));

	JNIEnv *env = getCurrentThreadEnv();
	jstring nameStr = 0;
	jstring paramsStr = 0;
	jstring caseListStr = 0;

	DE_UNREF(workingDir);

	// Remove old log file if such exists.
	if (deFileExists(LOG_FILE_NAME))
	{
	if (!deDeleteFile(LOG_FILE_NAME) \|\| deFileExists(LOG_FILE_NAME))
	throw xs::TestProcessException(std::string("Failed to remove '") + LOG_FILE_NAME + "'");
	}

	try
	{
	nameStr = env->NewStringUTF(name);
	JNI_CHECK(nameStr);

	paramsStr = env->NewStringUTF(params);
	JNI_CHECK(paramsStr);

	caseListStr = env->NewStringUTF(caseList);
	JNI_CHECK(caseListStr);

	jboolean res = env->CallBooleanMethod(m_remote, m_start, nameStr, paramsStr, caseListStr);
	checkJniException(env, __FILE__, __LINE__);

	if (res == JNI_FALSE)
	throw xs::TestProcessException("Failed to launch activity");

	m_launchTime = deGetMicroseconds();
	m_lastQueryTime = m_launchTime;
	m_lastRunningStatus = true;
	}
	catch (...)
	{
	if (nameStr)
	env->DeleteLocalRef(nameStr);
	if (paramsStr)
	env->DeleteLocalRef(paramsStr);
	if (caseListStr)
	env->DeleteLocalRef(caseListStr);
	throw;
	}

	env->DeleteLocalRef(nameStr);
	env->DeleteLocalRef(paramsStr);
	env->DeleteLocalRef(caseListStr);
	}

	void TestProcess::terminate(void)
	{
	DBG_PRINT(("TestProcess::terminate()"));

	JNIEnv *env = getCurrentThreadEnv();
	jboolean res = env->CallBooleanMethod(m_remote, m_kill);
	checkJniException(env, __FILE__, __LINE__);
	DE_UNREF(res); // Failure to kill process is ignored.
	}

	void TestProcess::cleanup(void)
	{
	DBG_PRINT(("TestProcess::cleanup()"));

	terminate();
	m_logReader.stop();
	}

	bool TestProcess::isRunning(void)
	{
	uint64_t curTime = deGetMicroseconds();

	// On Android process launch is asynchronous so we don't want to poll for process until after some time.
	if (curTime - m_launchTime < PROCESS_START_TIMEOUT \|\| curTime - m_lastQueryTime < PROCESS_QUERY_INTERVAL)
	return m_lastRunningStatus;

	JNIEnv *env = getCurrentThreadEnv();
	jboolean res = env->CallBooleanMethod(m_remote, m_isRunning);
	checkJniException(env, __FILE__, __LINE__);

	DBG_PRINT(("TestProcess::isRunning(): %s", res == JNI_TRUE ? "true" : "false"));
	m_lastQueryTime = curTime;
	m_lastRunningStatus = res == JNI_TRUE;

	return m_lastRunningStatus;
	}

	JNIEnv *TestProcess::getCurrentThreadEnv(void)
	{
	JNIEnv *env = DE_NULL;
	jint ret = m_vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6);

	if (ret == JNI_OK)
	return env;
	else
	throw InternalError("GetEnv() failed");
	}

	int TestProcess::readTestLog(uint8_t *dst, int numBytes)
	{
	if (!m_logReader.isRunning())
	{
	if (deGetMicroseconds() - m_launchTime > xs::LOG_FILE_TIMEOUT * 1000)
	{
	// Timeout, kill process.
	terminate();
	DBG_PRINT(("TestProcess:readTestLog(): Log file timeout occurred!"));
	return 0; // \todo [2013-08-13 pyry] Throw exception?
	}

	if (!deFileExists(LOG_FILE_NAME))
	return 0;

	// Start reader.
	m_logReader.start(LOG_FILE_NAME);
	}

	DE_ASSERT(m_logReader.isRunning());
	return m_logReader.read(dst, numBytes);
	}

	int TestProcess::getExitCode(void) const
	{
	return 0;
	}

	int TestProcess::readInfoLog(uint8_t *dst, int numBytes)
	{
	// \todo [2012-11-12 pyry] Read device log.
	DE_UNREF(dst && numBytes);
	return 0;
	}

	// ExecutionServer

	ExecutionServer::ExecutionServer(JavaVM vm, xs::TestProcess testProcess, deSocketFamily family, int port,
	RunMode runMode)
	: xs::ExecutionServer(testProcess, family, port, runMode)
	, m_vm(vm)
	{
	}

	xs::ConnectionHandler ExecutionServer::createHandler(de::Socket socket, const de::SocketAddress &clientAddress)
	{
	DE_UNREF(clientAddress);
	return new ConnectionHandler(m_vm, this, socket);
	}

	// ConnectionHandler

	ConnectionHandler::ConnectionHandler(JavaVM vm, xs::ExecutionServer server, de::Socket *socket)
	: xs::ExecutionRequestHandler(server, socket)
	, m_vm(vm)
	{
	}

	void ConnectionHandler::run(void)
	{
	JNIEnv *env = DE_NULL;
	if (m_vm->AttachCurrentThread(&env, DE_NULL) != 0)
	{
	print("AttachCurrentThread() failed");
	return;
	}

	xs::ExecutionRequestHandler::run();

	if (m_vm->DetachCurrentThread() != 0)
	print("DetachCurrentThread() failed");
	}

	// ServerThread

	ServerThread::ServerThread(JavaVM vm, xs::TestProcess process, deSocketFamily family, int port)
	: m_server(vm, process, family, port, xs::ExecutionServer::RUNMODE_FOREVER)
	{
	}

	void ServerThread::run(void)
	{
	try
	{
	m_server.runServer();
	}
	catch (const std::exception &e)
	{
	die("ServerThread::run(): %s", e.what());
	}
	}

	void ServerThread::stop(void)
	{
	m_server.stopServer();
	join();
	}

	// ExecService

	ExecService::ExecService(JavaVM *vm, jobject context, int port, deSocketFamily family)
	: m_process(vm, context)
	, m_thread(vm, &m_process, family, port)
	{
	}

	ExecService::~ExecService(void)
	{
	}

	void ExecService::start(void)
	{
	m_thread.start();
	}

	void ExecService::stop(void)
	{
	m_thread.stop();
	}

	} // namespace Android
	} // namespace tcu