Support standalone executable builds on Android

Only building dEQP as an app on Android is supported. This change allows
building dEQP as a standalone executable on Android that can be run from
adb shell. This is more convenient for iterative testing during driver
development as the command and corresponding output are in one place.

VK-GL-CTS issue: 5320

Components: Framework

Change-Id: Ibeac5160e058b96f9ece30e0eafb991bef570164

Author: PixelyIon

CMakeLists.txt

@@ -5,6 +5,7 @@
 cmake_minimum_required(VERSION 3.20.0)
 
 option(GLES_ALLOW_DIRECT_LINK "Allow direct linking to GLES libraries" OFF)
+option(DEQP_ANDROID_EXE "Build dEQP modules as executables rather than a library on Android" OFF)
 
 # Target selection:
 # SELECTED_BUILD_TARGETS is a CMake option that can be set to a list of targets
@@ -204,6 +205,22 @@ if (DEFINED DEQP_EGL_LIBRARIES AND GLES_ALLOW_DIRECT_LINK)
 	add_definitions(-DDEQP_EGL_DIRECT_LINK=1)
 endif ()
 
+# Android build variants
+if (DE_OS_IS_ANDROID)
+	if (DEQP_ANDROID_EXE)
+		message(STATUS "DEQP_ANDROID_BUILD      = EXE")
+		set(DEQP_ANDROID_APP OFF)
+	else ()
+		message(STATUS "DEQP_ANDROID_BUILD      = APP")
+		set(DEQP_ANDROID_APP ON)
+
+		add_definitions(-DDEQP_IS_ANDROID_APP=1)
+	endif ()
+else ()
+	set(DEQP_ANDROID_EXE OFF)
+	set(DEQP_ANDROID_APP OFF)
+endif ()
+
 # Legacy APIs that don't support run-time loading
 if (DEQP_SUPPORT_GLES1)
 	add_definitions(-DDEQP_SUPPORT_GLES1=1)
@@ -275,7 +292,7 @@ include_directories(
 	external/vulkancts/framework/vulkan
 	)
 
-if (DE_OS_IS_ANDROID OR DE_OS_IS_IOS)
+if (DEQP_ANDROID_APP OR DE_OS_IS_IOS)
 	# On Android deqp modules are compiled as libraries and linked into final .so
 	set(DEQP_MODULE_LIBRARIES )
 	set(DEQP_MODULE_ENTRY_POINTS )
@@ -319,7 +336,7 @@ macro (add_deqp_module MODULE_NAME SRCS LIBS EXECLIBS ENTRY)
 	set(DEQP_MODULE_LIBRARIES		${DEQP_MODULE_LIBRARIES} PARENT_SCOPE)
 	set(DEQP_MODULE_ENTRY_POINTS	${DEQP_MODULE_ENTRY_POINTS} PARENT_SCOPE)
 
-	if (NOT DE_OS_IS_ANDROID AND NOT DE_OS_IS_IOS)
+	if (NOT DEQP_ANDROID_APP AND NOT DE_OS_IS_IOS)
 		# Executable target
 		add_executable(${MODULE_NAME} ${PROJECT_SOURCE_DIR}/framework/platform/tcuMain.cpp ${ENTRY})
 		target_link_libraries(${MODULE_NAME} PUBLIC "${EXECLIBS}" "${MODULE_NAME}${MODULE_LIB_TARGET_POSTFIX}")
@@ -341,7 +358,7 @@ macro (add_deqp_module_skip_android MODULE_NAME SRCS LIBS EXECLIBS ENTRY)
 	add_library("${MODULE_NAME}${MODULE_LIB_TARGET_POSTFIX}" STATIC ${SRCS})
 	target_link_libraries("${MODULE_NAME}${MODULE_LIB_TARGET_POSTFIX}" ${LIBS})
 
-	if (NOT DE_OS_IS_ANDROID AND NOT DE_OS_IS_IOS)
+	if (NOT DEQP_ANDROID_APP AND NOT DE_OS_IS_IOS)
 		# Executable target
 		add_executable(${MODULE_NAME} ${PROJECT_SOURCE_DIR}/framework/platform/tcuMain.cpp ${ENTRY})
 		target_link_libraries(${MODULE_NAME} PUBLIC "${EXECLIBS}" "${MODULE_NAME}${MODULE_LIB_TARGET_POSTFIX}")
@@ -355,10 +372,10 @@ endmacro (add_deqp_module_skip_android)
 
 # Macro for adding data dirs to module
 macro (add_data_dir MODULE_NAME SRC_DIR DST_DIR)
-	if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX OR DE_OS_IS_QNX)
+	if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX OR DE_OS_IS_QNX OR DEQP_ANDROID_EXE)
 		add_custom_command(TARGET "${MODULE_NAME}${MODULE_DATA_TARGET_POSTFIX}" POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/${SRC_DIR} ${CMAKE_CURRENT_BINARY_DIR}/${DST_DIR})
 
-	elseif (DE_OS_IS_ANDROID)
+	elseif (DEQP_ANDROID_APP)
 		add_custom_command(TARGET "${MODULE_NAME}${MODULE_DATA_TARGET_POSTFIX}" POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/${SRC_DIR} ${CMAKE_BINARY_DIR}/assets/${DST_DIR})
 
 	elseif (DE_OS_IS_IOS)
@@ -368,10 +385,10 @@ endmacro (add_data_dir)
 
 # Macro for adding individual data files to module
 macro (add_data_file MODULE_NAME SRC_FILE DST_FILE)
-	if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX OR DE_OS_IS_QNX)
+	if (DE_OS_IS_WIN32 OR DE_OS_IS_UNIX OR DE_OS_IS_OSX OR DE_OS_IS_QNX OR DEQP_ANDROID_EXE)
 		add_custom_command(TARGET "${MODULE_NAME}${MODULE_DATA_TARGET_POSTFIX}" POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FILE} ${CMAKE_CURRENT_BINARY_DIR}/${DST_FILE})
 
-	elseif (DE_OS_IS_ANDROID)
+	elseif (DEQP_ANDROID_APP)
 		add_custom_command(TARGET "${MODULE_NAME}${MODULE_DATA_TARGET_POSTFIX}" POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different ${CMAKE_CURRENT_SOURCE_DIR}/${SRC_FILE} ${CMAKE_BINARY_DIR}/assets/${DST_FILE})
 
 	elseif (DE_OS_IS_IOS)
@@ -393,7 +410,7 @@ add_subdirectory(external/vulkancts/vkscpc ${MAYBE_EXCLUDE_FROM_ALL})
 add_subdirectory(external/openglcts ${MAYBE_EXCLUDE_FROM_ALL})
 
 # Single-binary targets
-if (DE_OS_IS_ANDROID)
+if (DEQP_ANDROID_APP)
 	include_directories(executor)
 	include_directories(${PROJECT_BINARY_DIR}/external/vulkancts/framework/vulkan)
 

external/vulkancts/README.md

@@ -107,6 +107,14 @@ If building for 32-bit x86 with GCC, you probably also want to add `-msse2
 
 ### Android
 
+There's two types of builds for Android:
+
+#### App
+
+This builds an APK that needs to be invoked via `adb shell` and the output needs
+to be read via `adb logcat`, it's the preferred way for long-running invocations
+on Android since it doesn't depend on an active connection from the host PC.
+
 Following command will build dEQP.apk:
 
 	python3 scripts/android/build_apk.py --sdk <path to Android SDK> --ndk <path to Android NDK>
@@ -126,6 +134,28 @@ To pick which ABI to use at _install time_, use the following command instead:
 
 	adb install -g --abi <ABI name> <build-root>/package/dEQP.apk
 
+#### Executable
+
+This is identical to the builds on other platforms and is better for iterative
+runs of headless tests as CTS can be invoked and the output can be checked from
+a single interactive terminal.
+
+This build doesn't support WSI tests and shouldn't be used for conformance
+submissions, it also isn't recommended for longer running tests since Android
+will terminate this process as soon as the `adb shell` session ends which may
+happen due to an unintentional device disconnection.
+
+	cmake <path to vulkancts> -GNinja -DCMAKE_BUILD_TYPE=Debug \
+	      -DCMAKE_TOOLCHAIN_FILE=<NDK path>/build/cmake/android.toolchain.cmake \
+	      -DCMAKE_ANDROID_NDK=<NDK path> -DANDROID_ABI=<ABI to build eg: arm64-v8a> \
+	      -DDE_ANDROID_API=<API level> -DDEQP_TARGET_TOOLCHAIN=ndk-modern \
+	      -DDEQP_TARGET=android -DDEQP_ANDROID_EXE=ON
+	ninja all
+
+The build needs to be transferred to the device via `adb push` to a directory
+under `/data/` on the device, such as `/data/local/tmp/` which should be writeable
+for non-rooted devices. It should be noted that anywhere on `/sdcard/` won't work
+since it's mounted as `noexec`.
 
 Building Mustpass
 -----------------
@@ -311,6 +341,8 @@ Test log will be written into TestResults.qpa
 
 ### Android
 
+#### App
+
 For Android build using SDK 29 or greater, it is recommended to use `/sdcard/Documents/` instead of `/sdcard/` due to scoped storage.
 
 	adb push <vulkancts>/external/vulkancts/mustpass/main/vk-default.txt /sdcard/vk-default.txt
@@ -326,6 +358,13 @@ Test progress will be written to device log and can be displayed with:
 
 Test log will be written into `/sdcard/TestResults.qpa`.
 
+#### Executable
+
+Identical to [Linux](#linux-1), but within `adb shell` instead:
+
+	adb shell
+	> cd <pushed build directory>/external/vulkancts/modules/vulkan
+	> ./deqp-vk --deqp-caselist-file=...
 
 Conformance Submission Package Requirements
 -------------------------------------------

framework/delibs/debase/CMakeLists.txt

@@ -38,3 +38,7 @@ endif ()
 if (DE_OS_IS_SYMBIAN)
     target_link_libraries(debase gcc)
 endif()
+
+if (DE_OS_IS_ANDROID)
+	target_link_libraries(debase log)
+endif()

framework/platform/android/tcuAndroidPlatform.cpp

@@ -33,6 +33,8 @@
 #include "tcuFunctionLibrary.hpp"
 #include "vkWsiPlatform.hpp"
 
+#include <sys/utsname.h>
+
 // Assume no call translation is needed
 #include <android/native_window.h>
 struct egl_native_pixmap_t;
@@ -313,38 +315,45 @@ class VulkanDisplay : public vk::wsi::Display
     WindowRegistry &m_windowRegistry;
 };
 
-static size_t getTotalSystemMemory(ANativeActivity *activity)
+static size_t getTotalSystemMemory(NativeActivity *activity)
 {
     const size_t MiB = (size_t)(1 << 20);
+    // Use relatively high fallback size to encourage CDD-compliant behavior
+    const size_t fallbackSize = (sizeof(void *) == sizeof(uint64_t)) ? 2048 * MiB : 1024 * MiB;
 
-    try
+    if (activity)
     {
-        const size_t totalMemory = getTotalAndroidSystemMemory(activity);
-        print("Device has %.2f MiB of system memory\n", static_cast<double>(totalMemory) / static_cast<double>(MiB));
-        return totalMemory;
+        try
+        {
+            const size_t totalMemory = getTotalAndroidSystemMemory(activity->getNativeActivity());
+            print("Device has %.2f MiB of system memory\n",
+                  static_cast<double>(totalMemory) / static_cast<double>(MiB));
+            return totalMemory;
+        }
+        catch (const std::exception &e)
+        {
+            print("WARNING: Failed to determine system memory size required by CDD: %s\n", e.what());
+            print("WARNING: Using fall-back size of %.2f MiB\n", double(fallbackSize) / double(MiB));
+        }
     }
-    catch (const std::exception &e)
-    {
-        // Use relatively high fallback size to encourage CDD-compliant behavior
-        const size_t fallbackSize = (sizeof(void *) == sizeof(uint64_t)) ? 2048 * MiB : 1024 * MiB;
 
-        print("WARNING: Failed to determine system memory size required by CDD: %s\n", e.what());
-        print("WARNING: Using fall-back size of %.2f MiB\n", double(fallbackSize) / double(MiB));
-
-        return fallbackSize;
-    }
+    return fallbackSize;
 }
 
 // Platform
 
 Platform::Platform(NativeActivity &activity)
-    : m_activity(activity)
-    , m_totalSystemMemory(getTotalSystemMemory(activity.getNativeActivity()))
+    : m_activity(&activity)
+    , m_totalSystemMemory(getTotalSystemMemory(&activity))
 {
     m_nativeDisplayFactoryRegistry.registerFactory(new NativeDisplayFactory(m_windowRegistry));
     m_contextFactoryRegistry.registerFactory(new eglu::GLContextFactory(m_nativeDisplayFactoryRegistry));
 }
 
+Platform::Platform() : m_activity(nullptr), m_totalSystemMemory(getTotalSystemMemory(nullptr))
+{
+}
+
 Platform::~Platform(void)
 {
 }
@@ -362,7 +371,22 @@ vk::Library *Platform::createLibrary(const char *libraryPath) const
 
 void Platform::describePlatform(std::ostream &dst) const
 {
-    tcu::Android::describePlatform(m_activity.getNativeActivity(), dst);
+    if (m_activity)
+    {
+        tcu::Android::describePlatform(m_activity->getNativeActivity(), dst);
+    }
+    else
+    {
+        utsname sysInfo{};
+        if (uname(&sysInfo) != 0)
+        {
+            dst << "OS: Android (Unknown)\n";
+            return;
+        }
+
+        dst << "OS: Android " << sysInfo.release << " " << sysInfo.version << "\n";
+        dst << "CPU: " << sysInfo.machine << "\n";
+    }
 }
 
 void Platform::getMemoryLimits(tcu::PlatformMemoryLimits &limits) const
@@ -416,3 +440,8 @@ bool Platform::hasDisplay(vk::wsi::Type wsiType) const
 
 } // namespace Android
 } // namespace tcu
+
+tcu::Platform *createPlatform(void)
+{
+    return new tcu::Android::Platform();
+}

framework/platform/android/tcuAndroidPlatform.hpp

@@ -40,6 +40,7 @@ class Platform : public tcu::Platform, private eglu::Platform, private glu::Plat
 {
 public:
     Platform(NativeActivity &activity);
+    Platform(void);
     virtual ~Platform(void);
 
     virtual bool processEvents(void);
@@ -70,7 +71,7 @@ class Platform : public tcu::Platform, private eglu::Platform, private glu::Plat
     bool hasDisplay(vk::wsi::Type wsiType) const;
 
 private:
-    NativeActivity &m_activity;
+    NativeActivity *m_activity;
     WindowRegistry m_windowRegistry;
     const size_t m_totalSystemMemory;
 };

framework/qphelper/qpDebugOut.c

@@ -98,7 +98,7 @@ void qpDiev(const char *format, va_list args)
 }
 
 /* print() implementation. */
-#if (DE_OS == DE_OS_ANDROID)
+#if defined(DEQP_IS_ANDROID_APP)
 
 #include <android/log.h>