diff options
Diffstat (limited to 'emulator/opengl/shared')
19 files changed, 829 insertions, 907 deletions
diff --git a/emulator/opengl/shared/OpenglCodecCommon/Android.mk b/emulator/opengl/shared/OpenglCodecCommon/Android.mk index 83090d8..0c3f827 100644 --- a/emulator/opengl/shared/OpenglCodecCommon/Android.mk +++ b/emulator/opengl/shared/OpenglCodecCommon/Android.mk @@ -13,8 +13,11 @@ commonSources := \ host_commonSources := $(commonSources) +host_commonLdLibs := -lstdc++ + ifeq ($(HOST_OS),windows) host_commonSources += Win32PipeStream.cpp + host_commonLdLibs += -lws2_32 -lpsapi else host_commonSources += UnixStream.cpp endif @@ -26,7 +29,7 @@ $(call emugl-begin-host-static-library,libOpenglCodecCommon) LOCAL_SRC_FILES := $(host_commonSources) $(call emugl-import, libemugl_common) $(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include/libOpenglRender $(LOCAL_PATH)) -$(call emugl-export,LDLIBS,-lstdc++) +$(call emugl-export,LDLIBS,$(host_commonLdLibs)) $(call emugl-end-module) @@ -39,6 +42,6 @@ ifdef EMUGL_BUILD_64BITS $(call emugl-import, lib64emugl_common) $(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/host/include/libOpenglRender $(LOCAL_PATH)) $(call emugl-export,CFLAGS,-m64 -fPIC) - $(call emugl-export,LDLIBS,-lstdc++) + $(call emugl-export,LDLIBS,$(host_commonLdLibs)) $(call emugl-end-module) endif diff --git a/emulator/opengl/shared/OpenglOsUtils/Android.mk b/emulator/opengl/shared/OpenglOsUtils/Android.mk deleted file mode 100644 index f9673fc..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/Android.mk +++ /dev/null @@ -1,48 +0,0 @@ -# This build script corresponds to a small library containing -# OS-specific support functions for: -# - thread-local storage -# - dynamic library loading -# - child process creation and wait (probably not needed in guest) -# -LOCAL_PATH := $(call my-dir) - -### Host library ############################################## - -host_common_SRC_FILES := osDynLibrary.cpp -host_common_LDLIBS := -host_common_INCLUDES := $(LOCAL_PATH) - -ifeq ($(HOST_OS),windows) - host_common_SRC_FILES += \ - osProcessWin.cpp \ - osThreadWin.cpp - host_common_LDLIBS += -lws2_32 -lpsapi -else - host_common_SRC_FILES += \ - osProcessUnix.cpp \ - osThreadUnix.cpp - host_common_LDLIBS += -ldl -endif - -ifeq ($(HOST_OS),linux) - host_common_LDLIBS += -lpthread -lrt -lX11 -endif - -### 32-bit host library #### -$(call emugl-begin-host-static-library,libOpenglOsUtils) - $(call emugl-export,C_INCLUDES,$(host_common_INCLUDES)) - LOCAL_SRC_FILES = $(host_common_SRC_FILES) - $(call emugl-export,LDLIBS,$(host_common_LDLIBS)) - $(call emugl-import,libemugl_common) -$(call emugl-end-module) - -### 64-bit host library #### -ifdef EMUGL_BUILD_64BITS - $(call emugl-begin-host64-static-library,lib64OpenglOsUtils) - $(call emugl-export,C_INCLUDES,$(host_common_INCLUDES)) - LOCAL_SRC_FILES = $(host_common_SRC_FILES) - $(call emugl-export,LDLIBS,$(host_common_LDLIBS)) - $(call emugl-import,lib64emugl_common) - $(call emugl-export,CFLAGS,-m64 -fPIC) - $(call emugl-end-module) -endif diff --git a/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.cpp b/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.cpp deleted file mode 100644 index e8e6ab7..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.cpp +++ /dev/null @@ -1,79 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#include "osDynLibrary.h" - -#ifndef _WIN32 -#include <dlfcn.h> -#endif -#include <stdio.h> - -namespace osUtils { - -dynLibrary *dynLibrary::open(const char *p_libName) -{ - dynLibrary *lib = new dynLibrary(); - if (!lib) { - return NULL; - } - -#ifdef _WIN32 - lib->m_lib = LoadLibrary(p_libName); -#else // !WIN32 - lib->m_lib = dlopen(p_libName, RTLD_NOW); -#endif - - if (lib->m_lib == NULL) { - printf("Failed to load %s\n", p_libName); -#ifndef _WIN32 - printf("error %s\n", dlerror()); //only on linux -#endif - delete lib; - return NULL; - } - - return lib; -} - -dynLibrary::dynLibrary() : - m_lib(NULL) -{ -} - -dynLibrary::~dynLibrary() -{ - if (NULL != m_lib) { -#ifdef _WIN32 - FreeLibrary(m_lib); -#else // !WIN32 - dlclose(m_lib); -#endif - } -} - -dynFuncPtr dynLibrary::findSymbol(const char *p_symName) -{ - if (NULL == m_lib) { - return NULL; - } - -#ifdef _WIN32 - return (dynFuncPtr) GetProcAddress(m_lib, p_symName); -#else // !WIN32 - return (dynFuncPtr) dlsym(m_lib, p_symName); -#endif -} - -} // of namespace osUtils diff --git a/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.h b/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.h deleted file mode 100644 index c83fbf3..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osDynLibrary.h +++ /dev/null @@ -1,71 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#ifndef _OSUTILS_DYN_LIBRARY_H -#define _OSUTILS_DYN_LIBRARY_H - -#ifdef _WIN32 -#include <windows.h> -#endif - -namespace osUtils { - -typedef void (*dynFuncPtr)(void); - -class dynLibrary -{ -public: - static dynLibrary *open(const char *p_libName); - ~dynLibrary(); - - dynFuncPtr findSymbol(const char *p_symName); - -private: - dynLibrary(); - -private: -#ifdef _WIN32 - HMODULE m_lib; -#else - void *m_lib; -#endif -}; - -} // of namespace osUtils - - - -// Macro to compose emugl shared library name under various OS and bitness -// eg. -// on x86_64, EMUGL_LIBNAME("foo") --> "lib64foo.so" - -#ifdef _WIN32 -# define DLL_EXTENSION "" // _WIN32 LoadLibrary only accept name w/o .dll extension -#elif defined(__APPLE__) -# define DLL_EXTENSION ".dylib" -#else -# define DLL_EXTENSION ".so" -#endif - -#if defined(__x86_64__) -# define EMUGL_LIBNAME(name) "lib64" name DLL_EXTENSION -#elif defined(__i386__) -# define EMUGL_LIBNAME(name) "lib" name DLL_EXTENSION -#else -/* This header is included by target w/o using EMUGL_LIBNAME(). Don't #error, leave it undefined */ -#endif - - -#endif diff --git a/emulator/opengl/shared/OpenglOsUtils/osProcess.h b/emulator/opengl/shared/OpenglOsUtils/osProcess.h deleted file mode 100644 index 82b31b3..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osProcess.h +++ /dev/null @@ -1,62 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#ifndef _OSUTILS_PROCESS_H -#define _OSUTILS_PROCESS_H - -#ifdef _WIN32 -#include <windows.h> -#endif - -namespace osUtils { - -class childProcess -{ -public: - static childProcess *create(const char *p_cmdLine, const char *p_startdir); - ~childProcess(); - - int getPID() - { -#ifdef _WIN32 - return m_proc.dwProcessId; -#else - return(m_pid); -#endif - } - - int tryWait(bool& isAlive); - bool wait(int *exitStatus); - -private: - childProcess() {}; - -private: -#ifdef _WIN32 - PROCESS_INFORMATION m_proc; -#else - int m_pid; -#endif -}; - -int ProcessGetPID(); -int ProcessGetTID(); -bool ProcessGetName(char *p_outName, int p_outNameLen); -int KillProcess(int pid, bool wait); -bool isProcessRunning(int pid); - -} // of namespace osUtils - -#endif diff --git a/emulator/opengl/shared/OpenglOsUtils/osProcessUnix.cpp b/emulator/opengl/shared/OpenglOsUtils/osProcessUnix.cpp deleted file mode 100644 index c97ff58..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osProcessUnix.cpp +++ /dev/null @@ -1,210 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#include "osProcess.h" -#include <stdio.h> -#include <stdlib.h> -#include <sys/wait.h> -#include <sys/types.h> -#include <poll.h> -#include <pthread.h> -#include <string.h> -#include <pwd.h> -#include <paths.h> -#include <errno.h> -#include <signal.h> -#include <unistd.h> -#include <assert.h> - -namespace osUtils { - -// -// buildArgList converts a command line into null terminated argument list. -// to be used with execv or execvp. -// each argument is seperated by space or tab, to specify multiple words -// at the same argument place it inside single-quoted or double-quoted string. -// -static char **buildArgList(const char *command) -{ - char **argv = NULL; - int argvSize = 0; - int nArgs = 0; - char *tmpcmd = strdup(command); - char *t = tmpcmd; - char *strStart = NULL; - int i = 0; - - #define ADD_ARG \ - { \ - nArgs++; \ - if (!argv) { \ - argvSize = 12; \ - argv = (char **)malloc(argvSize * sizeof(char *)); \ - } \ - else if (nArgs > argvSize) { \ - argvSize += 12; \ - argv = (char **)realloc(argv, argvSize * sizeof(char *)); \ - } \ - argv[nArgs-1] = t; \ - t = NULL; \ - } - - while( tmpcmd[i] != '\0' ) { - if (!strStart) { - if (tmpcmd[i] == '"' || tmpcmd[i] == '\'') { - strStart = &tmpcmd[i]; - } - else if (tmpcmd[i] == ' ' || tmpcmd[i] == '\t') { - tmpcmd[i] = '\0'; - if (t) ADD_ARG; - } - else if (!t) { - t = &tmpcmd[i]; - } - } - else if (tmpcmd[i] == *strStart) { - t = strStart; - strStart = NULL; - } - - i++; - } - if (t) { - ADD_ARG; - } - if (nArgs > 0) { - ADD_ARG; // for NULL terminating list - } - - return argv; -} - -static pid_t start_process(const char *command,const char *startDir) -{ - pid_t pid; - - pid = fork(); - - if (pid < 0) { - return pid; - } - else if (pid == 0) { - // - // Close all opened file descriptors - // - for (int i=3; i<256; i++) { - close(i); - } - - if (startDir) { - chdir(startDir); - } - - char **argv = buildArgList(command); - if (!argv) { - return -1; - } - execvp(argv[0], argv); - - perror("execl"); - exit(-101); - } - - return pid; -} - -childProcess * -childProcess::create(const char *p_cmdLine, const char *p_startdir) -{ - childProcess *child = new childProcess(); - if (!child) { - return NULL; - } - - child->m_pid = start_process(p_cmdLine, p_startdir); - if (child->m_pid < 0) { - delete child; - return NULL; - } - - return child; -} - -childProcess::~childProcess() -{ -} - -bool -childProcess::wait(int *exitStatus) -{ - int ret=0; - if (m_pid>0) { - pid_t pid = waitpid(m_pid,&ret,0); - if (pid != -1) { - m_pid=-1; - if (exitStatus) { - *exitStatus = ret; - } - return true; - } - } - return false; -} - -int -childProcess::tryWait(bool &isAlive) -{ - int ret=0; - isAlive = false; - if (m_pid>0) { - pid_t pid = waitpid(m_pid,&ret,WNOHANG); - if (pid == 0) { - isAlive = true; - } - } - - return ((char)WEXITSTATUS(ret)); -} - -int ProcessGetPID() -{ - return getpid(); -} - -int KillProcess(int pid, bool wait) -{ - if (pid<1) { - return false; - } - - if (0!=kill(pid,SIGTERM)) { - return false; - } - - if (wait) { - if (waitpid(pid,NULL,0)<0) { - return false; - } - } - - return true; -} - -bool isProcessRunning(int pid) -{ - return (kill(pid,0) == 0); -} - -} // of namespace osUtils diff --git a/emulator/opengl/shared/OpenglOsUtils/osProcessWin.cpp b/emulator/opengl/shared/OpenglOsUtils/osProcessWin.cpp deleted file mode 100644 index 6ff0fdf..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osProcessWin.cpp +++ /dev/null @@ -1,171 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#include "osProcess.h" -#include <windows.h> -#include <string> -#include <stdlib.h> -#include <psapi.h> - -namespace osUtils { - -childProcess * -childProcess::create(const char *p_cmdLine, const char *p_startdir) -{ - childProcess *child = new childProcess(); - if (!child) { - return NULL; - } - - STARTUPINFOA si; - ZeroMemory(&si, sizeof(si)); - - ZeroMemory(&child->m_proc, sizeof(child->m_proc)); - BOOL ret = CreateProcessA( - NULL , - (LPSTR)p_cmdLine, - NULL, - NULL, - FALSE, - CREATE_DEFAULT_ERROR_MODE, - NULL, - (p_startdir != NULL ? p_startdir : ".\\"), - &si, - &child->m_proc); - if (ret == 0) { - delete child; - return NULL; - } - - // close the thread handle we do not need it, - // keep the process handle for wait/trywait operations, will - // be closed on destruction - CloseHandle(child->m_proc.hThread); - - return child; -} - -childProcess::~childProcess() -{ - if (m_proc.hProcess) { - CloseHandle(m_proc.hProcess); - } -} - -bool -childProcess::wait(int *exitStatus) -{ -DWORD _exitStatus; - - if (WaitForSingleObject(m_proc.hProcess, INFINITE) == WAIT_FAILED) { - return false; - } - - if (!GetExitCodeProcess(m_proc.hProcess, &_exitStatus)) - { - return false; - } - - if (exitStatus) { - *exitStatus = _exitStatus; - } - - return true; -} - -int -childProcess::tryWait(bool& isAlive) -{ - DWORD status = WaitForSingleObject(m_proc.hProcess, 0); - - if(status == WAIT_OBJECT_0) - { - // process has exited - isAlive = false; - GetExitCodeProcess(m_proc.hProcess, &status); - } - else if (status == WAIT_TIMEOUT) - { - isAlive = true; - status = 0; - } - - return status; - -} - -int ProcessGetPID() -{ - return GetCurrentProcessId(); -} - -int ProcessGetTID() -{ - return GetCurrentThreadId(); -} - -bool ProcessGetName(char *p_outName, int p_outNameLen) -{ - return 0 != GetModuleFileNameEx( GetCurrentProcess(), NULL, p_outName, p_outNameLen); -} - -int KillProcess(int pid, bool wait) -{ - DWORD exitStatus = 1; - HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid); - - if (NULL == hProc) { - return 0; - } - - // - // Terminate the process - // - TerminateProcess(hProc, 0x55); - - if (wait) { - // - // Wait for it to be terminated - // - if(WaitForSingleObject(hProc, INFINITE) == WAIT_FAILED) { - CloseHandle(hProc); - return 0; - } - - if (!GetExitCodeProcess(hProc, &exitStatus)) { - CloseHandle(hProc); - return 0; - } - } - - CloseHandle(hProc); - - return exitStatus; -} - -bool isProcessRunning(int pid) -{ - bool isRunning = false; - - HANDLE process = OpenProcess(SYNCHRONIZE, FALSE, pid); - if (NULL != process) { - DWORD ret = WaitForSingleObject(process, 0); - CloseHandle(process); - isRunning = (ret == WAIT_TIMEOUT); - } - return isRunning; -} - -} // of namespace osUtils diff --git a/emulator/opengl/shared/OpenglOsUtils/osThread.h b/emulator/opengl/shared/OpenglOsUtils/osThread.h deleted file mode 100644 index 970396d..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osThread.h +++ /dev/null @@ -1,60 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#ifndef _OSUTILS_THREAD_H -#define _OSUTILS_THREAD_H - -#ifdef _WIN32 -#include <windows.h> -#else // !WIN32 -#include <pthread.h> -#endif - -namespace osUtils { - -class Thread -{ -public: - Thread(); - virtual ~Thread(); - - virtual int Main() = 0; - - bool start(); - bool wait(int *exitStatus); - bool trywait(int *exitStatus); - -private: -#ifdef _WIN32 - static DWORD WINAPI thread_main(void *p_arg); -#else // !WIN32 - static void* thread_main(void *p_arg); -#endif - -private: -#ifdef _WIN32 - HANDLE m_thread; - DWORD m_threadId; -#else // !WIN32 - pthread_t m_thread; - int m_exitStatus; - pthread_mutex_t m_lock; -#endif - bool m_isRunning; -}; - -} // of namespace osUtils - -#endif diff --git a/emulator/opengl/shared/OpenglOsUtils/osThreadUnix.cpp b/emulator/opengl/shared/OpenglOsUtils/osThreadUnix.cpp deleted file mode 100644 index ef2bebc..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osThreadUnix.cpp +++ /dev/null @@ -1,98 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#include "osThread.h" - -#include "emugl/common/thread_store.h" - -#include <stdint.h> - -namespace osUtils { - -Thread::Thread() : - m_thread((pthread_t)NULL), - m_exitStatus(0), - m_isRunning(false) -{ - pthread_mutex_init(&m_lock, NULL); -} - -Thread::~Thread() -{ - pthread_mutex_destroy(&m_lock); -} - -bool -Thread::start() -{ - pthread_mutex_lock(&m_lock); - m_isRunning = true; - int ret = pthread_create(&m_thread, NULL, Thread::thread_main, this); - if(ret) { - m_isRunning = false; - } - pthread_mutex_unlock(&m_lock); - return m_isRunning; -} - -bool -Thread::wait(int *exitStatus) -{ - if (!m_isRunning) { - return false; - } - - void *retval; - if (pthread_join(m_thread,&retval)) { - return false; - } - - if (exitStatus) { - *exitStatus = (int)(uintptr_t)retval; - } - return true; -} - -bool -Thread::trywait(int *exitStatus) -{ - bool ret = false; - - pthread_mutex_lock(&m_lock); - if (!m_isRunning) { - *exitStatus = m_exitStatus; - ret = true; - } - pthread_mutex_unlock(&m_lock); - return ret; -} - -void * -Thread::thread_main(void *p_arg) -{ - Thread *self = (Thread *)p_arg; - int ret = self->Main(); - - pthread_mutex_lock(&self->m_lock); - self->m_isRunning = false; - self->m_exitStatus = ret; - pthread_mutex_unlock(&self->m_lock); - - ::emugl::ThreadStore::OnThreadExit(); - return (void*)(uintptr_t)ret; -} - -} // of namespace osUtils - diff --git a/emulator/opengl/shared/OpenglOsUtils/osThreadWin.cpp b/emulator/opengl/shared/OpenglOsUtils/osThreadWin.cpp deleted file mode 100644 index 1a30b97..0000000 --- a/emulator/opengl/shared/OpenglOsUtils/osThreadWin.cpp +++ /dev/null @@ -1,104 +0,0 @@ -/* -* Copyright (C) 2011 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. -*/ -#include "osThread.h" - -#include "emugl/common/thread_store.h" - -namespace osUtils { - -Thread::Thread() : - m_thread(NULL), - m_threadId(0), - m_isRunning(false) -{ -} - -Thread::~Thread() -{ - if(m_thread) { - CloseHandle(m_thread); - } -} - -bool -Thread::start() -{ - m_isRunning = true; - m_thread = CreateThread(NULL, 0, &Thread::thread_main, this, 0, &m_threadId); - if(!m_thread) { - m_isRunning = false; - } - return m_isRunning; -} - -bool -Thread::wait(int *exitStatus) -{ - if (!m_isRunning) { - return false; - } - - if(WaitForSingleObject(m_thread, INFINITE) == WAIT_FAILED) { - return false; - } - - DWORD retval; - if (!GetExitCodeThread(m_thread,&retval)) { - return false; - } - - m_isRunning = 0; - - if (exitStatus) { - *exitStatus = retval; - } - return true; -} - -bool -Thread::trywait(int *exitStatus) -{ - if (!m_isRunning) { - return false; - } - - if(WaitForSingleObject(m_thread, 0) == WAIT_OBJECT_0) { - - DWORD retval; - if (!GetExitCodeThread(m_thread,&retval)) { - return true; - } - - if (exitStatus) { - *exitStatus = retval; - } - return true; - } - - return false; -} - -DWORD WINAPI -Thread::thread_main(void *p_arg) -{ - Thread *self = (Thread *)p_arg; - int ret = self->Main(); - self->m_isRunning = false; - ::emugl::ThreadStore::OnThreadExit(); - return ret; -} - -} // of namespace osUtils diff --git a/emulator/opengl/shared/emugl/common/Android.mk b/emulator/opengl/shared/emugl/common/Android.mk index 58dd6da..fb9ab57 100644 --- a/emulator/opengl/shared/emugl/common/Android.mk +++ b/emulator/opengl/shared/emugl/common/Android.mk @@ -9,16 +9,26 @@ commonSources := \ id_to_object_map.cpp \ lazy_instance.cpp \ pod_vector.cpp \ + shared_library.cpp \ smart_ptr.cpp \ sockets.cpp \ thread_store.cpp \ host_commonSources := $(commonSources) +host_commonLdLibs := -lstdc++ + +ifneq (windows,$(HOST_OS)) + host_commonSources += thread_pthread.cpp + host_commonLdLibs += -ldl -lpthread +else + host_commonSources += thread_win32.cpp +endif + $(call emugl-begin-host-static-library,libemugl_common) LOCAL_SRC_FILES := $(host_commonSources) $(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/shared) -$(call emugl-export,LDLIBS,-lstdc++) +$(call emugl-export,LDLIBS,$(host_commonLdLibs)) $(call emugl-end-module) ifdef EMUGL_BUILD_64BITS @@ -26,7 +36,7 @@ ifdef EMUGL_BUILD_64BITS LOCAL_SRC_FILES := $(host_commonSources) $(call emugl-export,CFLAGS,-m64 -fPIC) $(call emugl-export,C_INCLUDES,$(EMUGL_PATH)/shared) - $(call emugl-export,LDLIBS,-lstdc++) + $(call emugl-export,LDLIBS,$(host_commonLdLibs)) $(call emugl-end-module) endif @@ -38,8 +48,10 @@ host_commonSources := \ lazy_instance_unittest.cpp \ pod_vector_unittest.cpp \ mutex_unittest.cpp \ + shared_library_unittest.cpp \ smart_ptr_unittest.cpp \ thread_store_unittest.cpp \ + thread_unittest.cpp \ $(call emugl-begin-host-executable,emugl_common_host_unittests) LOCAL_SRC_FILES := $(host_commonSources) @@ -52,3 +64,13 @@ ifdef EMUGL_BUILD_64BITS $(call emugl-import,lib64emugl_common lib64emugl_gtest) $(call emugl-end-module) endif + +$(call emugl-begin-host-shared-library,libemugl_test_shared_library) +LOCAL_SRC_FILES := testing/test_shared_library.cpp +$(call emugl-end-module) + +ifdef EMUGL_BUILD_64BITS + $(call emugl-begin-host64-shared-library,lib64emugl_test_shared_library) + LOCAL_SRC_FILES := testing/test_shared_library.cpp + $(call emugl-end-module) +endif diff --git a/emulator/opengl/shared/emugl/common/shared_library.cpp b/emulator/opengl/shared/emugl/common/shared_library.cpp new file mode 100644 index 0000000..db1c75c --- /dev/null +++ b/emulator/opengl/shared/emugl/common/shared_library.cpp @@ -0,0 +1,105 @@ +// Copyright (C) 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. + +#include "emugl/common/shared_library.h" + +#include <stddef.h> +#include <string.h> +#include <stdio.h> + +#ifndef _WIN32 +#include <dlfcn.h> +#include <stdlib.h> +#endif + +namespace emugl { + +#ifdef _WIN32 + +// static +SharedLibrary* SharedLibrary::open(const char* libraryName) { + HMODULE lib = LoadLibrary(libraryName); + return lib ? new SharedLibrary(lib) : NULL; +} + +SharedLibrary::SharedLibrary(HandleType lib) : mLib(lib) {} + +SharedLibrary::~SharedLibrary() { + if (mLib) { + FreeLibrary(mLib); + } +} + +SharedLibrary::FunctionPtr SharedLibrary::findSymbol( + const char* symbolName) { + if (!mLib || !symbolName) { + return NULL; + } + return reinterpret_cast<FunctionPtr>( + GetProcAddress(mLib, symbolName)); +} + +#else // !_WIN32 + +// static +SharedLibrary* SharedLibrary::open(const char* libraryName) { + const char* libPath = libraryName; + char* path = NULL; + + const char* libBaseName = strrchr(libraryName, '/'); + if (!libBaseName) { + libBaseName = libraryName; + } + + if (!strchr(libBaseName, '.')) { + // There is no extension in this library name, so append one. +#ifdef __APPLE__ + static const char kDllExtension[] = ".dylib"; +#else + static const char kDllExtension[] = ".so"; +#endif + size_t pathLen = strlen(libraryName) + sizeof(kDllExtension); + path = static_cast<char*>(malloc(pathLen)); + snprintf(path, pathLen, "%s%s", libraryName, kDllExtension); + libPath = path; + } + + void* lib = dlopen(libPath, RTLD_NOW); + + if (path) { + free(path); + } + + return lib ? new SharedLibrary(lib) : NULL; +} + +SharedLibrary::SharedLibrary(HandleType lib) : mLib(lib) {} + +SharedLibrary::~SharedLibrary() { + if (mLib) { + dlclose(mLib); + } +} + +SharedLibrary::FunctionPtr SharedLibrary::findSymbol( + const char* symbolName) { + if (!mLib || !symbolName) { + return NULL; + } + return reinterpret_cast<FunctionPtr>(dlsym(mLib, symbolName)); +} + +#endif // !_WIN32 + +} // namespace emugl diff --git a/emulator/opengl/shared/emugl/common/shared_library.h b/emulator/opengl/shared/emugl/common/shared_library.h new file mode 100644 index 0000000..38d25bd --- /dev/null +++ b/emulator/opengl/shared/emugl/common/shared_library.h @@ -0,0 +1,85 @@ +// Copyright (C) 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. + +#ifndef EMUGL_COMMON_SHARED_LIBRARY_H +#define EMUGL_COMMON_SHARED_LIBRARY_H + +#ifdef _WIN32 +#include <windows.h> +#endif + +namespace emugl { + +// A class used to open a platform-specific shared library, and probe +// it for symbols. Usage is the following: +// +// // Open the library. +// SharedLibrary* library = SharedLibrary::open("libFoo"); +// if (!library) { +// ... could not find / open library! +// } +// +// //Probe for function symbol. +// FunctionPtr my_func = library->findSymbol("my_func"); +// +// // Closes library/ +// delete library; +// +class SharedLibrary { +public: + // Open a given library. |libraryName| can be either a full library + // path, or a simple name without an extension. On success, returns + // a new SharedLibrary instance that must be deleted by the caller. + static SharedLibrary* open(const char* libraryName); + + // Closes an existing SharedLibrary instance. + ~SharedLibrary(); + + // Generic function pointer type, for values returned by the + // findSymbol() method. + typedef void (*FunctionPtr)(void); + + // Probe a given SharedLibrary instance to find a symbol named + // |symbolName| in it. Return its address as a FunctionPtr, or + // NULL if the symbol is not found. + FunctionPtr findSymbol(const char* symbolName); + +private: +#ifdef _WIN32 + typedef HMODULE HandleType; +#else + typedef void* HandleType; +#endif + + // Constructor intentionally hidden. + SharedLibrary(HandleType); + + HandleType mLib; +}; + +// Macro to compose emugl shared library name under various OS and bitness +// eg. +// on x86_64, EMUGL_LIBNAME("foo") --> "lib64foo" + +#if defined(__x86_64__) +# define EMUGL_LIBNAME(name) "lib64" name +#elif defined(__i386__) +# define EMUGL_LIBNAME(name) "lib" name +#else +/* This header is included by target w/o using EMUGL_LIBNAME(). Don't #error, leave it undefined */ +#endif + +} // namespace emugl + +#endif // EMUGL_COMMON_SHARED_LIBRARY_H diff --git a/emulator/opengl/shared/emugl/common/shared_library_unittest.cpp b/emulator/opengl/shared/emugl/common/shared_library_unittest.cpp new file mode 100644 index 0000000..cec4c73 --- /dev/null +++ b/emulator/opengl/shared/emugl/common/shared_library_unittest.cpp @@ -0,0 +1,141 @@ +// Copyright (C) 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. + +#include "emugl/common/shared_library.h" + +#include <gtest/gtest.h> + +#include <string> + +#include <limits.h> +#include <string.h> + +// Hack to get the current executable's full path. +namespace testing { +namespace internal { + +extern std::string g_executable_path; + +} // namespace internal +} // namespace testing + +namespace emugl { + +namespace { + +// Return the name/path of the test shared library to load. +// Note that this doesn't include a platform-specific extension. +// This assumes that the test shared library is under the lib/ sub-directory +// of the current executable's path! +std::string GetTestLibraryName() { + static const char kSubDir[] = "lib/"; +#ifdef __x86_64__ + static const char kLibraryPrefix[] = "lib64"; +#else + static const char kLibraryPrefix[] = "lib"; +#endif + static const char kTestLibrarySuffix[] = "emugl_test_shared_library"; + + const char* exec_path = testing::internal::g_executable_path.c_str(); + +#ifdef _WIN32 + const char* p = strrchr(exec_path, '/'); + const char* p2 = strrchr(exec_path, '\\'); + if (p2) { + if (!p || p2 > p) { + p = p2; + } + } +#else + const char* p = strrchr(exec_path, '/'); +#endif + + std::string path; + + if (!p) { + path = "./"; + } else { + path = std::string(exec_path, p - exec_path + 1U); + } + path += kSubDir; + path += kLibraryPrefix; + path += kTestLibrarySuffix; + printf("Library path: %s\n", path.c_str()); + return path; +} + +class SharedLibraryTest : public testing::Test { +public: + SharedLibraryTest() { + // Locate the shared library + mLibraryPath = GetTestLibraryName(); + } + + ~SharedLibraryTest() {} + + const char* library_path() const { return mLibraryPath.c_str(); } + +private: + std::string mLibraryPath; +}; + +class ScopedSharedLibrary { +public: + explicit ScopedSharedLibrary(SharedLibrary* lib) : mLib(lib) {} + ~ScopedSharedLibrary() { + delete mLib; + } + SharedLibrary* get() const { return mLib; } + + SharedLibrary* operator->() { return mLib; } + +private: + SharedLibrary* mLib; +}; + +} // namespace + +TEST_F(SharedLibraryTest, Open) { + ScopedSharedLibrary lib(SharedLibrary::open(library_path())); + EXPECT_TRUE(lib.get()); +} + +TEST_F(SharedLibraryTest, OpenWithExtension) { + std::string path = library_path(); +#ifdef _WIN32 + path += ".dll"; +#elif defined(__APPLE__) + path += ".dylib"; +#else + path += ".so"; +#endif + ScopedSharedLibrary lib(SharedLibrary::open(path.c_str())); + EXPECT_TRUE(lib.get()); +} + +TEST_F(SharedLibraryTest, FindSymbol) { + ScopedSharedLibrary lib(SharedLibrary::open(library_path())); + EXPECT_TRUE(lib.get()); + + if (lib.get()) { + typedef int (*FooFunction)(void); + + FooFunction foo_func = reinterpret_cast<FooFunction>( + lib->findSymbol("foo_function")); + EXPECT_TRUE(foo_func); + EXPECT_EQ(42, (*foo_func)()); + } +} + +} // namespace emugl diff --git a/emulator/opengl/shared/emugl/common/testing/test_shared_library.cpp b/emulator/opengl/shared/emugl/common/testing/test_shared_library.cpp new file mode 100644 index 0000000..598a963 --- /dev/null +++ b/emulator/opengl/shared/emugl/common/testing/test_shared_library.cpp @@ -0,0 +1,22 @@ +// Copyright (C) 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. + +// This source file must be compiled into a simple shared library which +// will be used by shared_library_unittest.cpp to verify that the +// emugl::SharedLibrary class works properly. + + +extern "C" int foo_function(void) { + return 42; +} diff --git a/emulator/opengl/shared/emugl/common/thread.h b/emulator/opengl/shared/emugl/common/thread.h new file mode 100644 index 0000000..d0f7d20 --- /dev/null +++ b/emulator/opengl/shared/emugl/common/thread.h @@ -0,0 +1,102 @@ +// Copyright (C) 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. + +#ifndef EMUGL_COMMON_THREAD_H +#define EMUGL_COMMON_THREAD_H + +#ifdef _WIN32 +#include <windows.h> +#else +#include <pthread.h> +#endif + +#include <stdint.h> + +namespace emugl { + +// Wrapper class for platform-specific threads. +// To create your own thread, define a sub-class of emugl::Thread +// and override its main() method. +// +// For example: +// +// class MyThread : public emugl::Thread { +// public: +// MyThread() : Thread() {} +// +// virtual intptr_t main() { +// ... main thread loop implementation +// return 0; +// } +// }; +// +// ... +// +// // Create new instance, but does not start it. +// MyThread* thread = new MyThread(); +// +// // Start the thread. +// thread->start(); +// +// // Wait for thread completion, and gets result into |exitStatus|. +// int exitStatus; +// thread->wait(&exitStatus); +// +class Thread { +public: + // Public constructor. + Thread(); + + // Virtual destructor. + virtual ~Thread(); + + // Override this method in your own thread sub-classes. This will + // be called when start() is invoked on the Thread instance. + virtual intptr_t main() = 0; + + // Start a thread instance. Return true on success, false otherwise + // (e.g. if the thread was already started or terminated). + bool start(); + + // Wait for thread termination and retrieve exist status into + // |*exitStatus|. Return true on success, false otherwise. + // NOTE: |exitStatus| can be NULL. + bool wait(intptr_t *exitStatus); + + // Check whether a thread has terminated. On success, return true + // and sets |*exitStatus|. On failure, return false. + // NOTE: |exitStatus| can be NULL. + bool tryWait(intptr_t *exitStatus); + +private: +#ifdef _WIN32 + static DWORD WINAPI thread_main(void* arg); + + HANDLE mThread; + DWORD mThreadId; + CRITICAL_SECTION mLock; +#else // !WIN32 + static void* thread_main(void* arg); + + pthread_t mThread; + pthread_mutex_t mLock; +#endif + intptr_t mExitStatus; + bool mIsRunning; +}; + +} // namespace emugl + +#endif // EMUGL_COMMON_THREAD_H + diff --git a/emulator/opengl/shared/emugl/common/thread_pthread.cpp b/emulator/opengl/shared/emugl/common/thread_pthread.cpp new file mode 100644 index 0000000..5dbc3ab --- /dev/null +++ b/emulator/opengl/shared/emugl/common/thread_pthread.cpp @@ -0,0 +1,114 @@ +// Copyright (C) 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. + +#include "emugl/common/thread.h" + +#include "emugl/common/thread_store.h" + +#include <stdio.h> + +namespace emugl { + +namespace { + +class ScopedLocker { +public: + ScopedLocker(pthread_mutex_t* mutex) : mMutex(mutex) { + pthread_mutex_lock(mMutex); + } + + ~ScopedLocker() { + pthread_mutex_unlock(mMutex); + } +private: + pthread_mutex_t* mMutex; +}; + +} // namespace + +Thread::Thread() : + mThread((pthread_t)NULL), + mExitStatus(0), + mIsRunning(false) { + pthread_mutex_init(&mLock, NULL); +} + +Thread::~Thread() { + pthread_mutex_destroy(&mLock); +} + +bool Thread::start() { + bool ret = true; + pthread_mutex_lock(&mLock); + mIsRunning = true; + if (pthread_create(&mThread, NULL, thread_main, this)) { + ret = false; + mIsRunning = false; + } + pthread_mutex_unlock(&mLock); + return ret; +} + +bool Thread::wait(intptr_t *exitStatus) { + { + ScopedLocker locker(&mLock); + if (!mIsRunning) { + // Thread already stopped. + if (exitStatus) { + *exitStatus = mExitStatus; + } + return true; + } + } + + // NOTE: Do not hold the lock when waiting for the thread to ensure + // it can update mIsRunning and mExitStatus properly in thread_main + // without blocking. + void *retval; + if (pthread_join(mThread, &retval)) { + return false; + } + if (exitStatus) { + *exitStatus = (intptr_t)retval; + } + return true; +} + +bool Thread::tryWait(intptr_t *exitStatus) { + ScopedLocker locker(&mLock); + if (!mIsRunning) { + return false; + } + if (exitStatus) { + *exitStatus = mExitStatus; + } + return true; +} + +// static +void* Thread::thread_main(void *arg) { + Thread* self = reinterpret_cast<Thread*>(arg); + intptr_t ret = self->main(); + + pthread_mutex_lock(&self->mLock); + self->mIsRunning = false; + self->mExitStatus = ret; + pthread_mutex_unlock(&self->mLock); + + ::emugl::ThreadStore::OnThreadExit(); + + return (void*)ret; +} + +} // namespace emugl diff --git a/emulator/opengl/shared/emugl/common/thread_unittest.cpp b/emulator/opengl/shared/emugl/common/thread_unittest.cpp new file mode 100644 index 0000000..db1931f --- /dev/null +++ b/emulator/opengl/shared/emugl/common/thread_unittest.cpp @@ -0,0 +1,109 @@ +// Copyright (C) 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. + +#include "emugl/common/thread.h" + +#include "emugl/common/mutex.h" + +#include <gtest/gtest.h> + +namespace emugl { + +namespace { + +// A simple thread instance that does nothing at all and exits immediately. +class EmptyThread : public ::emugl::Thread { +public: + intptr_t main() { return 42; } +}; + +class CountingThread : public ::emugl::Thread { +public: + class State { + public: + State() : mLock(), mCount(0) {} + ~State() {} + + void increment() { + mLock.lock(); + mCount++; + mLock.unlock(); + } + + int count() const { + int ret; + mLock.lock(); + ret = mCount; + mLock.unlock(); + return ret; + } + + private: + mutable Mutex mLock; + int mCount; + }; + + CountingThread(State* state) : mState(state) {} + + intptr_t main() { + mState->increment(); + return 0; + } + +private: + State* mState; +}; + +} // namespace + +TEST(ThreadTest, SimpleThread) { + Thread* thread = new EmptyThread(); + EXPECT_TRUE(thread); + EXPECT_TRUE(thread->start()); + intptr_t status; + EXPECT_TRUE(thread->wait(&status)); + EXPECT_EQ(42, status); +} + +TEST(ThreadTest, MultipleThreads) { + CountingThread::State state; + const size_t kMaxThreads = 100; + Thread* threads[kMaxThreads]; + + // Create all threads. + for (size_t n = 0; n < kMaxThreads; ++n) { + threads[n] = new CountingThread(&state); + EXPECT_TRUE(threads[n]) << "thread " << n; + } + + // Start them all. + for (size_t n = 0; n < kMaxThreads; ++n) { + EXPECT_TRUE(threads[n]->start()) << "thread " << n; + } + + // Wait for them all. + for (size_t n = 0; n < kMaxThreads; ++n) { + EXPECT_TRUE(threads[n]->wait(NULL)) << "thread " << n; + } + + // Check state. + EXPECT_EQ((int)kMaxThreads, state.count()); + + // Delete them all. + for (size_t n = 0; n < kMaxThreads; ++n) { + delete threads[n]; + } +} + +} // namespace emugl diff --git a/emulator/opengl/shared/emugl/common/thread_win32.cpp b/emulator/opengl/shared/emugl/common/thread_win32.cpp new file mode 100644 index 0000000..f348ca8 --- /dev/null +++ b/emulator/opengl/shared/emugl/common/thread_win32.cpp @@ -0,0 +1,122 @@ +// Copyright (C) 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. + +#include "emugl/common/thread.h" + +#include "emugl/common/thread_store.h" + +namespace emugl { + +namespace { + +class ScopedLocker { +public: + ScopedLocker(CRITICAL_SECTION* section) : mSection(section) { + EnterCriticalSection(mSection); + } + + ~ScopedLocker() { + LeaveCriticalSection(mSection); + } +private: + CRITICAL_SECTION* mSection; +}; + +} // namespace + +Thread::Thread() : + mThread(INVALID_HANDLE_VALUE), + mThreadId(0), + mExitStatus(0), + mIsRunning(false) { + InitializeCriticalSection(&mLock); +} + +Thread::~Thread() { + if(mThread != INVALID_HANDLE_VALUE) { + CloseHandle(mThread); + } + DeleteCriticalSection(&mLock); +} + +bool Thread::start() { + ScopedLocker locker(&mLock); + + bool ret = true; + mIsRunning = true; + mThread = CreateThread(NULL, 0, &Thread::thread_main, this, 0, &mThreadId); + if (!mThread) { + ret = false; + mIsRunning = false; + } + return ret; +} + +bool Thread::wait(intptr_t* exitStatus) { + { + ScopedLocker locker(&mLock); + if (!mIsRunning) { + // Thread already stopped. + if (exitStatus) { + *exitStatus = mExitStatus; + } + return true; + } + } + + // NOTE: Do not hold lock during wait to aloow thread_main to + // properly update mIsRunning and mExitStatus on thread exit. + if (WaitForSingleObject(mThread, INFINITE) == WAIT_FAILED) { + return false; + } + + if (exitStatus) { + ScopedLocker locker(&mLock); + *exitStatus = mExitStatus; + } + return true; +} + +bool Thread::tryWait(intptr_t* exitStatus) { + ScopedLocker locker(&mLock); + + if (!mIsRunning || + WaitForSingleObject(mThread, 0) != WAIT_OBJECT_0) { + return false; + } + + if (exitStatus) { + *exitStatus = mExitStatus; + } + return true; +} + +// static +DWORD WINAPI Thread::thread_main(void *arg) +{ + Thread* self = reinterpret_cast<Thread*>(arg); + intptr_t ret = self->main(); + + EnterCriticalSection(&self->mLock); + self->mIsRunning = false; + self->mExitStatus = ret; + LeaveCriticalSection(&self->mLock); + + // Ensure all thread-local values are released for this thread. + ::emugl::ThreadStore::OnThreadExit(); + + return static_cast<DWORD>(ret); +} + +} // namespace emugl |