tequilaOS/platform_bionic
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Implement pthread spin.

Browse source 
In order to run tsan unit tests, we need to support pthread spin APIs.

Bug: 18623621
Bug: 25392375
Change-Id: Icbb4a74e72e467824b3715982a01600031868e29
This commit is contained in:
Yabin Cui 2015-11-17 16:03:18 -08:00
parent b804b9d67b
commit fe3a83a934
12 changed files with 149 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
libc/Android.mk
View file

@ -584,6 +584,7 @@ libc_pthread_src_files := \
bionic/pthread_setname_np.cpp \
bionic/pthread_setschedparam.cpp \
bionic/pthread_sigmask.cpp \
bionic/pthread_spinlock.cpp \
libc_thread_atexit_impl_src_files := \
bionic/__cxa_thread_atexit_impl.cpp \

81
libc/bionic/pthread_spinlock.cpp Normal file
View file

@ -0,0 +1,81 @@
/*
* Copyright (C) 2015 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <pthread.h>
#include "private/bionic_lock.h"
// User-level spinlocks can be hazardous to battery life on Android.
// We implement a simple compromise that behaves mostly like a spinlock,
// but prevents excessively long spinning.
struct pthread_spinlock_internal_t {
Lock lock;
};
static_assert(sizeof(pthread_spinlock_t) == sizeof(pthread_spinlock_internal_t),
"pthread_spinlock_t should actually be pthread_spinlock_internal_t.");
static_assert(alignof(pthread_spinlock_t) >= 4,
"pthread_spinlock_t should fulfill the alignment of pthread_spinlock_internal_t.");
static inline pthread_spinlock_internal_t* __get_internal_spinlock(pthread_spinlock_t* lock) {
return reinterpret_cast<pthread_spinlock_internal_t*>(lock);
}
int pthread_spin_init(pthread_spinlock_t* lock_interface, int pshared) {
pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
lock->lock.init(pshared);
return 0;
}
int pthread_spin_destroy(pthread_spinlock_t* lock_interface) {
pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
return lock->lock.trylock() ? 0 : EBUSY;
}
int pthread_spin_trylock(pthread_spinlock_t* lock_interface) {
pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
return lock->lock.trylock() ? 0 : EBUSY;
}
int pthread_spin_lock(pthread_spinlock_t* lock_interface) {
pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
for (int i = 0; i < 10000; ++i) {
if (lock->lock.trylock()) {
return 0;
}
}
lock->lock.lock();
return 0;
}
int pthread_spin_unlock(pthread_spinlock_t* lock_interface) {
pthread_spinlock_internal_t* lock = __get_internal_spinlock(lock_interface);
lock->lock.unlock();
return 0;
}

14
libc/include/pthread.h
View file

@ -108,6 +108,14 @@ typedef int pthread_barrierattr_t;
#define PTHREAD_BARRIER_SERIAL_THREAD -1
typedef struct {
#if defined(__LP64__)
int64_t __private;
#else
int32_t __private[2];
#endif
} pthread_spinlock_t;
#if defined(__LP64__)
#define PTHREAD_STACK_MIN (4 * PAGE_SIZE)
#else
@ -229,6 +237,12 @@ int pthread_barrier_init(pthread_barrier_t*, const pthread_barrierattr_t*, unsig
int pthread_barrier_destroy(pthread_barrier_t*) __nonnull((1));
int pthread_barrier_wait(pthread_barrier_t*) __nonnull((1));
int pthread_spin_destroy(pthread_spinlock_t*) __nonnull((1));
int pthread_spin_init(pthread_spinlock_t*, int) __nonnull((1));
int pthread_spin_lock(pthread_spinlock_t*) __nonnull((1));
int pthread_spin_trylock(pthread_spinlock_t*) __nonnull((1));
int pthread_spin_unlock(pthread_spinlock_t*) __nonnull((1));
pthread_t pthread_self(void) __pure2;
int pthread_setname_np(pthread_t, const char*) __nonnull((2));

5
libc/libc.arm.map
View file

@ -1323,6 +1323,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.arm64.map
View file

@ -1168,6 +1168,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.map.txt
View file

@ -1350,6 +1350,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.mips.map
View file

@ -1286,6 +1286,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.mips64.map
View file

@ -1168,6 +1168,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.x86.map
View file

@ -1284,6 +1284,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

5
libc/libc.x86_64.map
View file

@ -1168,6 +1168,11 @@ LIBC_N {
pthread_barrier_destroy;
pthread_barrier_init;
pthread_barrier_wait;
pthread_spin_destroy;
pthread_spin_init;
pthread_spin_lock;
pthread_spin_trylock;
pthread_spin_unlock;
pwritev;
pwritev64;
scandirat;

7
libc/private/bionic_lock.h
View file

@ -30,6 +30,7 @@
#include <stdatomic.h>
#include "private/bionic_futex.h"
#include "private/bionic_macros.h"
// Lock is used in places like pthread_rwlock_t, which can be initialized without calling
// an initialization function. So make sure Lock can be initialized by setting its memory to 0.
@ -49,6 +50,12 @@ class Lock {
this->process_shared = process_shared;
}
bool trylock() {
LockState old_state = Unlocked;
return __predict_true(atomic_compare_exchange_strong_explicit(&state, &old_state,
LockedWithoutWaiter, memory_order_acquire, memory_order_relaxed));
}
void lock() {
LockState old_state = Unlocked;
if (__predict_true(atomic_compare_exchange_strong_explicit(&state, &old_state,

11
tests/pthread_test.cpp
View file

@ -1779,3 +1779,14 @@ TEST(pthread, pthread_barrier_check_ordering) {
ASSERT_EQ(0, pthread_join(threads[i], nullptr));
}
}
TEST(pthread, pthread_spinlock_smoke) {
pthread_spinlock_t lock;
ASSERT_EQ(0, pthread_spin_init(&lock, 0));
ASSERT_EQ(0, pthread_spin_trylock(&lock));
ASSERT_EQ(0, pthread_spin_unlock(&lock));
ASSERT_EQ(0, pthread_spin_lock(&lock));
ASSERT_EQ(EBUSY, pthread_spin_trylock(&lock));
ASSERT_EQ(0, pthread_spin_unlock(&lock));
ASSERT_EQ(0, pthread_spin_destroy(&lock));
}