| /frameworks/wilhelm/src/ |
| ThreadPool.h | 50 /** \brief ThreadPool manages a pool of worker threads that execute Closures */
58 unsigned mWaitingNotFull; ///< Number of client threads waiting to enqueue
59 unsigned mWaitingNotEmpty; ///< Number of worker threads waiting to dequeue
61 unsigned mMaxThreads; ///< Number of worker threads
67 pthread_t *mThreadArray; ///< The worker threads
|
| /libcore/luni/src/main/java/java/util/concurrent/ |
| CyclicBarrier.java | 11 * A synchronization aid that allows a set of threads to all wait for
13 * useful in programs involving a fixed sized party of threads that
15 * <em>cyclic</em> because it can be re-used after the waiting threads
20 * arrives, but before any threads are released.
74 * it is executed, then any of the threads in the party could execute that
86 * other threads waiting at that barrier point will also leave
96 * corresponding {@code await()} in other threads.
107 * is reset. There can be many generations associated with threads
109 * may be allocated to waiting threads - but only one of these
231 * given number of parties (threads) are waiting upon it, and whic
[all...] |
| /libcore/luni/src/main/native/ |
| AsynchronousSocketCloseMonitor.cpp | 27 * We use an intrusive doubly-linked list to keep track of blocked threads.
30 * Waking potentially-blocked threads when a socket is closed is O(n) in the total number of
31 * blocked threads (not the number of threads actually blocked on the socket in question).
47 // Ensure that the signal we send interrupts system calls but doesn't kill threads.
|
| /external/chromium/base/synchronization/ |
| condition_variable.h | 7 // several threads wait for an event, as is common with a thread pool managed
10 // used in Chrome in the DNS prefetching system to notify worker threads that
34 // USAGE NOTE 2: Broadcast() frees up all waiting threads at once,
37 // approach to getting a lot of threads out of Wait() is to have each
43 // done, and leaves no sleeping threads... and performance is less
47 // threads that were waiting when the request was made will indeed
50 // a while while waiting threads come around). This implementation
52 // that all threads get signaled by Broadcast().
97 // Broadcast() revives all waiting threads.
165 // Events that threads are blocked on
[all...] |
| /external/chromium/testing/gtest/test/ |
| gtest_stress_test.cc | 33 // used in a large number of threads concurrently.
62 // How many threads to create?
105 // RecordProperty() should interact safely with other threads as well.
126 // Tests using SCOPED_TRACE() and Google Test assertions in many threads
130 scoped_ptr<ThreadWithParam<int> > threads[kThreadCount]; local
133 threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
139 // Blocks until all the threads are done.
141 threads[i]->Join();
206 // This statement should succeed, because failures in all threads are
225 // This statement should succeed, because failures in all threads ar
[all...] |
| /external/gtest/test/ |
| gtest_stress_test.cc | 33 // used in a large number of threads concurrently.
62 // How many threads to create?
105 // RecordProperty() should interact safely with other threads as well.
126 // Tests using SCOPED_TRACE() and Google Test assertions in many threads
130 scoped_ptr<ThreadWithParam<int> > threads[kThreadCount]; local
133 threads[i].reset(new ThreadWithParam<int>(&ManyAsserts,
139 // Blocks until all the threads are done.
141 threads[i]->Join();
206 // This statement should succeed, because failures in all threads are
225 // This statement should succeed, because failures in all threads ar
[all...] |
| /frameworks/base/core/java/android/content/ |
| ContentProvider.java | 74 * {@link #update}) may be called from many threads at once, and must be thread-safe.
422 * threads, as described in
423 * <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#Threads">Processes
424 * and Threads</a>.
444 * threads, as described in
445 * <a href="{@docRoot}guide/topics/fundamentals/processes-and-threads.html#Threads">Processes
446 * and Threads</a>.
466 * threads, as described i
[all...] |
| /external/chromium/base/ |
| tracked_objects.h | 34 // threads had a slight impact on this approach, and required use of some locks
35 // when accessing data from the worker threads.
71 // threads there are, and how many Locations of construction there are.
100 // To provide a mechanism for iterating over all "known threads," which means
101 // threads that have recorded a birth or a death, we create a singly linked list
121 // structures that are asynchronously changing on various threads. For display
133 // instances are thread safe containers which are passed to various threads to
137 // need to be sorted, and possibly aggregated (example: how many threads are in
208 // birthplace (fixed Location). Used both on specific threads, and also used
217 // threads, we create DeathData stats that tally the number of births withou
[all...] |
| /external/linux-tools-perf/ |
| builtin-test.c | 267 struct thread_map *threads; local
278 threads = thread_map__new(-1, getpid());
279 if (threads == NULL) {
293 if (perf_evsel__open_per_thread(evsel, threads, false) < 0) {
318 perf_evsel__close_fd(evsel, 1, threads->nr);
322 thread_map__delete(threads);
331 struct thread_map *threads; local
344 threads = thread_map__new(-1, getpid());
345 if (threads == NULL) {
368 if (perf_evsel__open(evsel, cpus, threads, false) < 0)
[all...] |
| /external/chromium/base/metrics/ |
| stats_table_unittest.cc | 51 slot_id = table.RegisterThread("too many threads");
69 // CounterMixed will be incremented by odd numbered threads and
70 // decremented by even threads.
108 // Create a few threads and have them poke on their counters.
121 // Spin up a set of threads to go bang on the various counters.
122 // After we join the threads, we'll make sure the counters
124 StatsTableThread* threads[kMaxThreads]; local
126 // Spawn the threads.
128 threads[index] = new StatsTableThread("MultipleThreadsTest", index);
129 threads[index]->Start()
[all...] |
| /external/linux-tools-perf/util/ |
| evsel.c | 204 struct thread_map *threads, bool group)
213 perf_evsel__alloc_fd(evsel, cpus->nr, threads->nr) < 0)
224 for (thread = 0; thread < threads->nr; thread++) {
227 pid = threads->map[thread];
249 thread = threads->nr;
268 int threads[1]; member in struct:__anon8638
271 .threads = { -1, },
275 struct thread_map *threads, bool group)
282 if (threads == NULL)
283 threads = &empty_thread_map.map
[all...] |
| /external/protobuf/src/google/protobuf/stubs/ |
| once_unittest.cc | 209 scoped_ptr<TestThread> threads[4]; local
212 threads[i].reset(RunInitOnceInNewThread());
215 threads[i]->Join();
226 scoped_ptr<TestThread> threads[8]; local
231 threads[i].reset(RunInitOnceInNewThread());
234 threads[i].reset(RunInitRecursiveOnceInNewThread());
246 threads[i]->Join();
|
| /external/valgrind/main/drd/tests/ |
| circular_buffer.c | 180 #define THREADS (10)
184 pthread_t producers[THREADS];
185 pthread_t consumers[THREADS];
186 int thread_arg[THREADS];
207 for (i = 0; i < THREADS; ++i)
214 for (i = 0; i < THREADS; ++i)
218 for (i = 0; i < THREADS; ++i)
|
| /frameworks/wilhelm/tests/sandbox/ |
| multithread.c | 17 // Multiple threads create and destroy objects
37 pthread_t threads[MAX_THREAD]; variable
128 // create threads
155 ok = pthread_create(&threads[i], (const pthread_attr_t *) NULL, thread_start,
171 // signal threads that they should exit
183 // now wait for the threads to actually exit
185 ok = pthread_join(threads[i], NULL);
|
| /external/valgrind/main/helgrind/tests/ |
| tc17_sembar.c | 59 /* Before destroying, make sure all threads have left the barrier. */
95 // all other threads arriving at the barrier
98 // now let all the other threads past the barrier, giving them
108 obvious (Thrcheck-visible) dependency on all other threads
111 Transitively, the result is that all threads leaving the
112 barrier have a a Thrcheck-visible dependency on all threads
119 // first N-1 threads wind up waiting here
133 understand that bar->arrived is protected by mutex1 whilst threads
143 writes memory in all threads and cause Thrcheck to (correctly)
|
| /external/valgrind/main/coregrind/ |
| m_machine.c | 49 return INSTR_PTR( VG_(threads)[tid].arch );
52 return STACK_PTR( VG_(threads)[tid].arch );
55 return FRAME_PTR( VG_(threads)[tid].arch );
59 INSTR_PTR( VG_(threads)[tid].arch ) = ip;
62 STACK_PTR( VG_(threads)[tid].arch ) = sp;
69 regs->r_pc = (ULong)VG_(threads)[tid].arch.vex.guest_EIP;
70 regs->r_sp = (ULong)VG_(threads)[tid].arch.vex.guest_ESP;
72 = VG_(threads)[tid].arch.vex.guest_EBP;
74 regs->r_pc = VG_(threads)[tid].arch.vex.guest_RIP;
75 regs->r_sp = VG_(threads)[tid].arch.vex.guest_RSP
[all...] |
| /external/dbus/test/name-test/ |
| run-test.sh | 42 echo "running test-threads-init"
43 ${DBUS_TOP_BUILDDIR}/libtool --mode=execute $DEBUG $DBUS_TOP_BUILDDIR/test/name-test/test-threads-init || die "test-threads-init failed"
|
| /external/webkit/Source/WebCore/platform/audio/ |
| ReverbInputBuffer.h | 36 // ReverbInputBuffer is used to buffer input samples for deferred processing by the background threads.
46 // Background threads can call this to check if there's anything to read...
49 // The individual background threads read here (and hope that they can keep up with the buffer writing).
|
| /frameworks/av/libvideoeditor/vss/stagefrightshells/src/ |
| MediaBufferPuller.h | 20 #include <utils/threads.h>
77 bool mAskToStart; // Asks the threads to start
78 bool mAskToStop; // Asks the threads to stop
|
| /frameworks/base/services/input/ |
| InputManager.h | 41 * The input manager uses two threads.
63 /* Starts the input manager threads. */
66 /* Stops the input manager threads and waits for them to exit. */
|
| /libcore/luni/src/main/java/java/util/concurrent/locks/ |
| ReentrantLock.java | 30 * access order. Programs using fair locks accessed by many threads
35 * fairness of thread scheduling. Thus, one of many threads using a
37 * active threads are not progressing and not currently holding the
41 * is available even if other threads are waiting.
323 * other threads are currently waiting for the lock.
352 * an available lock <em>will not</em> be acquired if any other threads
461 * <li> Waiting threads are signalled in FIFO order.
463 * <li>The ordering of lock reacquisition for threads returning
464 * from waiting methods is the same as for threads initially
466 * but for <em>fair</em> locks favors those threads that have bee
[all...] |
| /libcore/luni/src/test/java/tests/support/ |
| ThreadPool.java | 79 Thread[] threads = new Thread[activeCount()]; local
80 int count = enumerate(threads);
83 threads[i].join();
|
| /system/extras/tests/bionic/libc/common/ |
| test_pthread_getcpuclockid.c | 73 pthread_t threads[MAX_THREADS]; local
79 pthread_create( &threads[nn], &attr, thread_func, (void*)nn );
83 pthread_join( threads[nn], &dummy );
|
| test_pthread_once.c | 65 pthread_t threads[N_THREADS]; local
69 if (pthread_create( &threads[nn], NULL, thread_function, (void*)(long int)nn) < 0) {
76 if (pthread_join(threads[nn], NULL)) {
|
| /external/icu4c/test/threadtest/ |
| threadtest.cpp | 32 // Windows specific code for starting threads
77 // UNIX specific code for starting threads
147 // that is shared by all threads.
149 // During the test, the threads will access this info without
172 // The main program monitors the threads by looking
198 UMTX gStopMutex; // Lets main thread suspend test threads.
200 // worker threads and the main thread
235 else if (strcmp(argv[argnum], "-threads") == 0)
288 fprintf(stderr, "usage: threadtest [-threads nnn] [-time nnn] [-quiet] [-verbose] test-name\n"
291 " -threads nnn Number of threads. Default is 2. \n
[all...] |
