Home | History | Annotate | Download | only in utils 
      1 /*
      2  * Copyright (C) 2007 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef _LIBS_UTILS_ANDROID_THREADS_H
     18 #define _LIBS_UTILS_ANDROID_THREADS_H
     19 
     20 #include <stdint.h>
     21 #include <sys/types.h>
     22 
     23 #if defined(HAVE_PTHREADS)
     24 # include <pthread.h>
     25 #endif
     26 
     27 #include <utils/ThreadDefs.h>
     28 
     29 // ---------------------------------------------------------------------------
     30 // C API
     31 
     32 #ifdef __cplusplus
     33 extern "C" {
     34 #endif
     35 
     36 // Create and run a new thread.
     37 extern int androidCreateThread(android_thread_func_t, void *);
     38 
     39 // Create thread with lots of parameters
     40 extern int androidCreateThreadEtc(android_thread_func_t entryFunction,
     41                                   void *userData,
     42                                   const char* threadName,
     43                                   int32_t threadPriority,
     44                                   size_t threadStackSize,
     45                                   android_thread_id_t *threadId);
     46 
     47 // Get some sort of unique identifier for the current thread.
     48 extern android_thread_id_t androidGetThreadId();
     49 
     50 // Low-level thread creation -- never creates threads that can
     51 // interact with the Java VM.
     52 extern int androidCreateRawThreadEtc(android_thread_func_t entryFunction,
     53                                      void *userData,
     54                                      const char* threadName,
     55                                      int32_t threadPriority,
     56                                      size_t threadStackSize,
     57                                      android_thread_id_t *threadId);
     58 
     59 // set the same of the running thread
     60 extern void androidSetThreadName(const char* name);
     61 
     62 // Used by the Java Runtime to control how threads are created, so that
     63 // they can be proper and lovely Java threads.
     64 typedef int (*android_create_thread_fn)(android_thread_func_t entryFunction,
     65                                         void *userData,
     66                                         const char* threadName,
     67                                         int32_t threadPriority,
     68                                         size_t threadStackSize,
     69                                         android_thread_id_t *threadId);
     70 
     71 extern void androidSetCreateThreadFunc(android_create_thread_fn func);
     72 
     73 // ------------------------------------------------------------------
     74 // Extra functions working with raw pids.
     75 
     76 // Get pid for the current thread.
     77 extern pid_t androidGetTid();
     78 
     79 #ifdef HAVE_ANDROID_OS
     80 // Change the priority AND scheduling group of a particular thread.  The priority
     81 // should be one of the ANDROID_PRIORITY constants.  Returns INVALID_OPERATION
     82 // if the priority set failed, else another value if just the group set failed;
     83 // in either case errno is set.  Thread ID zero means current thread.
     84 extern int androidSetThreadPriority(pid_t tid, int prio);
     85 
     86 // Get the current priority of a particular thread. Returns one of the
     87 // ANDROID_PRIORITY constants or a negative result in case of error.
     88 extern int androidGetThreadPriority(pid_t tid);
     89 #endif
     90 
     91 #ifdef __cplusplus
     92 } // extern "C"
     93 #endif
     94 
     95 // ----------------------------------------------------------------------------
     96 // C++ API
     97 #ifdef __cplusplus
     98 namespace android {
     99 // ----------------------------------------------------------------------------
    100 
    101 // Create and run a new thread.
    102 inline bool createThread(thread_func_t f, void *a) {
    103     return androidCreateThread(f, a) ? true : false;
    104 }
    105 
    106 // Create thread with lots of parameters
    107 inline bool createThreadEtc(thread_func_t entryFunction,
    108                             void *userData,
    109                             const char* threadName = "android:unnamed_thread",
    110                             int32_t threadPriority = PRIORITY_DEFAULT,
    111                             size_t threadStackSize = 0,
    112                             thread_id_t *threadId = 0)
    113 {
    114     return androidCreateThreadEtc(entryFunction, userData, threadName,
    115         threadPriority, threadStackSize, threadId) ? true : false;
    116 }
    117 
    118 // Get some sort of unique identifier for the current thread.
    119 inline thread_id_t getThreadId() {
    120     return androidGetThreadId();
    121 }
    122 
    123 // ----------------------------------------------------------------------------
    124 }; // namespace android
    125 #endif  // __cplusplus
    126 // ----------------------------------------------------------------------------
    127 
    128 #endif // _LIBS_UTILS_ANDROID_THREADS_H
    129