From 554eca5cf0245d3c3c3cebe6eaf772a098f25aec Mon Sep 17 00:00:00 2001 From: Andreas Jaeger Date: Sat, 3 Jun 2000 08:12:26 +0000 Subject: [PATCH] * sysdeps/sparc/sparc32/pspinlock.c: Implement spinlocks. * sysdeps/sparc/sparc32/sparcv9/pspinlock.c: New. * sysdeps/sparc/sparc64/pspinlock.c: Implement spinlocks. 2000-06-02 Jakub Jelinek * sysdeps/sparc/sparc32/pspinlock.c: Implement spinlocks. * sysdeps/sparc/sparc32/sparcv9/pspinlock.c: New. * sysdeps/sparc/sparc64/pspinlock.c: Implement spinlocks. --- linuxthreads/ChangeLog | 6 ++ .../sysdeps/sparc/sparc32/pspinlock.c | 30 +++++- .../sysdeps/sparc/sparc32/sparcv9/pspinlock.c | 93 +++++++++++++++++++ .../sysdeps/sparc/sparc64/pspinlock.c | 35 ++++++- 4 files changed, 156 insertions(+), 8 deletions(-) create mode 100644 linuxthreads/sysdeps/sparc/sparc32/sparcv9/pspinlock.c diff --git a/linuxthreads/ChangeLog b/linuxthreads/ChangeLog index 00080c8622..c08461ce79 100644 --- a/linuxthreads/ChangeLog +++ b/linuxthreads/ChangeLog @@ -1,3 +1,9 @@ +2000-06-02 Jakub Jelinek + + * sysdeps/sparc/sparc32/pspinlock.c: Implement spinlocks. + * sysdeps/sparc/sparc32/sparcv9/pspinlock.c: New. + * sysdeps/sparc/sparc64/pspinlock.c: Implement spinlocks. + 2000-05-31 Andreas Jaeger * sysdeps/mips/pspinlock.c: Implement spinlocks. diff --git a/linuxthreads/sysdeps/sparc/sparc32/pspinlock.c b/linuxthreads/sysdeps/sparc/sparc32/pspinlock.c index ff72ff0c35..1788d7af33 100644 --- a/linuxthreads/sysdeps/sparc/sparc32/pspinlock.c +++ b/linuxthreads/sysdeps/sparc/sparc32/pspinlock.c @@ -21,10 +21,25 @@ #include +/* This implementation is similar to the one used in the Linux kernel. */ int __pthread_spin_lock (pthread_spinlock_t *lock) { - XXX + asm volatile + ("1: ldstub [%0], %%g2\n" + " orcc %%g2, 0x0, %%g0\n" + " bne,a 2f\n" + " ldub [%0], %%g2\n" + ".subsection 2\n" + "2: orcc %%g2, 0x0, %%g0\n" + " bne,a 2b\n" + " ldub [%0], %%g2\n" + " b,a 1b\n" + ".previous" + : /* no outputs */ + : "r" (lock) + : "g2", "memory", "cc"); + return 0; } weak_alias (__pthread_spin_lock, pthread_spin_lock) @@ -32,7 +47,13 @@ weak_alias (__pthread_spin_lock, pthread_spin_lock) int __pthread_spin_trylock (pthread_spinlock_t *lock) { - XXX + int result; + asm volatile + ("ldstub [%1], %0" + : "=r" (result) + : "r" (lock) + : "memory"); + return result == 0 ? 0 : EBUSY; } weak_alias (__pthread_spin_trylock, pthread_spin_trylock) @@ -40,7 +61,8 @@ weak_alias (__pthread_spin_trylock, pthread_spin_trylock) int __pthread_spin_unlock (pthread_spinlock_t *lock) { - XXX + *lock = 0; + return 0; } weak_alias (__pthread_spin_unlock, pthread_spin_unlock) @@ -51,7 +73,7 @@ __pthread_spin_init (pthread_spinlock_t *lock, int pshared) /* We can ignore the `pshared' parameter. Since we are busy-waiting all processes which can access the memory location `lock' points to can use the spinlock. */ - XXX + *lock = 0; return 0; } weak_alias (__pthread_spin_init, pthread_spin_init) diff --git a/linuxthreads/sysdeps/sparc/sparc32/sparcv9/pspinlock.c b/linuxthreads/sysdeps/sparc/sparc32/sparcv9/pspinlock.c new file mode 100644 index 0000000000..06050d3fec --- /dev/null +++ b/linuxthreads/sysdeps/sparc/sparc32/sparcv9/pspinlock.c @@ -0,0 +1,93 @@ +/* POSIX spinlock implementation. SPARC v9 version. + Copyright (C) 2000 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ + +#include +#include + + +/* This implementation is similar to the one used in the Linux kernel. */ +int +__pthread_spin_lock (pthread_spinlock_t *lock) +{ + asm volatile + ("1: ldstub [%0], %%g2\n" + " brnz,pn %%g2, 2f\n" + " membar #StoreLoad | #StoreStore\n" + ".subsection 2\n" + "2: ldub [%0], %%g2\n" + " brnz,pt 2b\n" + " membar #LoadLoad\n" + " b,a,pt %%xcc, 1b\n" + ".previous" + : /* no outputs */ + : "r" (lock) + : "g2", "memory"); + return 0; +} +weak_alias (__pthread_spin_lock, pthread_spin_lock) + + +int +__pthread_spin_trylock (pthread_spinlock_t *lock) +{ + int result; + asm volatile + ("ldstub [%1], %0\n" + "membar #StoreLoad | #StoreStore" + : "=r" (result) + : "r" (lock) + : "memory"); + return result == 0 ? 0 : EBUSY; +} +weak_alias (__pthread_spin_trylock, pthread_spin_trylock) + + +int +__pthread_spin_unlock (pthread_spinlock_t *lock) +{ + asm volatile + ("membar #StoreStore | #LoadStore\n" + "stb %%g0, [%0]" + : + : "r" (lock) + : "memory"); + return 0; +} +weak_alias (__pthread_spin_unlock, pthread_spin_unlock) + + +int +__pthread_spin_init (pthread_spinlock_t *lock, int pshared) +{ + /* We can ignore the `pshared' parameter. Since we are busy-waiting + all processes which can access the memory location `lock' points + to can use the spinlock. */ + *lock = 0; + return 0; +} +weak_alias (__pthread_spin_init, pthread_spin_init) + + +int +__pthread_spin_destroy (pthread_spinlock_t *lock) +{ + /* Nothing to do. */ + return 0; +} +weak_alias (__pthread_spin_destroy, pthread_spin_destroy) diff --git a/linuxthreads/sysdeps/sparc/sparc64/pspinlock.c b/linuxthreads/sysdeps/sparc/sparc64/pspinlock.c index 83edb08bba..e793b5c65c 100644 --- a/linuxthreads/sysdeps/sparc/sparc64/pspinlock.c +++ b/linuxthreads/sysdeps/sparc/sparc64/pspinlock.c @@ -21,10 +21,24 @@ #include +/* This implementation is similar to the one used in the Linux kernel. */ int __pthread_spin_lock (pthread_spinlock_t *lock) { - XXX + asm volatile + ("1: ldstub [%0], %%g5\n" + " brnz,pn %%g5, 2f\n" + " membar #StoreLoad | #StoreStore\n" + ".subsection 2\n" + "2: ldub [%0], %%g5\n" + " brnz,pt 2b\n" + " membar #LoadLoad\n" + " b,a,pt %%xcc, 1b\n" + ".previous" + : /* no outputs */ + : "r" (lock) + : "g5", "memory"); + return 0; } weak_alias (__pthread_spin_lock, pthread_spin_lock) @@ -32,7 +46,14 @@ weak_alias (__pthread_spin_lock, pthread_spin_lock) int __pthread_spin_trylock (pthread_spinlock_t *lock) { - XXX + int result; + asm volatile + ("ldstub [%1], %0\n" + "membar #StoreLoad | #StoreStore" + : "=r" (result) + : "r" (lock) + : "memory"); + return result == 0 ? 0 : EBUSY; } weak_alias (__pthread_spin_trylock, pthread_spin_trylock) @@ -40,7 +61,13 @@ weak_alias (__pthread_spin_trylock, pthread_spin_trylock) int __pthread_spin_unlock (pthread_spinlock_t *lock) { - XXX + asm volatile + ("membar #StoreStore | #LoadStore\n" + "stb %%g0, [%0]" + : + : "r" (lock) + : "memory"); + return 0; } weak_alias (__pthread_spin_unlock, pthread_spin_unlock) @@ -51,7 +78,7 @@ __pthread_spin_init (pthread_spinlock_t *lock, int pshared) /* We can ignore the `pshared' parameter. Since we are busy-waiting all processes which can access the memory location `lock' points to can use the spinlock. */ - XXX + *lock = 0; return 0; } weak_alias (__pthread_spin_init, pthread_spin_init)