Skip to contentSkip to conversation

2.6.9-rc1-mm4 sparc reiser4 build broken - undefined atomic_sub_and_test

DISCUSSION Martin Schwidefsky 2 participants 2 messages Sep 13, 2004 Atomic infrastructure

lore
Share & tools
lore
#0 lore raw
Quoted 9 lines
Quoted 6 lines

Review

Quoted 4 lines

But Bill already said he doesn't want it, [...]

(quoted diff) +1 -1
-		 		 if (atomic_sub_and_test(bio->bi_vcnt, &fq->nr_submitted))
+		 		 if (atomic_sub_return(bio->bi_vcnt, &fq->nr_submitted) == 0)

And that is more portable how?

It's more portable in that all but s390 already provide it (and I expect Martin will be happy to add it).

Well, adding the missing s390 atomic operations is easy (see patch). But I really doubt that it will make a measurable difference in performance on ANY architecture. You could do this with a (atomic_add_return(-x, &v) == 0) ...

blue skies,
Martin.

---

From: Martin Schwidefsky <[email protected]>

Add atomic[64]_add_and_test, atomic[64]_sub_return and atomic[64]_sub_and_test primitives.

diffstat:

 include/asm-s390/atomic.h |   24 ++++++++++++++++++++++++
 1 files changed, 24 insertions(+)
include/asm-s390/atomic.h +24 -0
diff -urN linux-2.6/include/asm-s390/atomic.h linux-2.6-s390/include/asm-s390/atomic.h
@@ -53,6 +53,10 @@
 {
 	return __CS_LOOP(v, i, "ar");
 }
+static __inline__ int atomic_add_and_test(int i, atomic_t * v)
+{
+	return __CS_LOOP(v, i, "ar") == 0;
+}
 static __inline__ int atomic_add_negative(int i, atomic_t * v)
 {
 	return __CS_LOOP(v, i, "ar") < 0;
@@ -61,6 +65,14 @@
 {
 	       __CS_LOOP(v, i, "sr");
 }
+static __inline__ int atomic_sub_return(int i, atomic_t * v)
+{
+	return __CS_LOOP(v, i, "sr");
+}
+static __inline__ int atomic_sub_and_test(int i, atomic_t * v)
+{
+	return __CS_LOOP(v, i, "sr") == 0;
+}
 static __inline__ void atomic_inc(volatile atomic_t * v)
 {
 	       __CS_LOOP(v, 1, "ar");
@@ -127,6 +139,10 @@
 {
 	return __CSG_LOOP(v, i, "agr");
 }
+static __inline__ long long atomic64_add_and_test(int i, atomic64_t * v)
+{
+	return __CSG_LOOP(v, i, "agr") == 0;
+}
 static __inline__ long long atomic64_add_negative(int i, atomic64_t * v)
 {
 	return __CSG_LOOP(v, i, "agr") < 0;
@@ -135,6 +151,14 @@
 {
 	       __CSG_LOOP(v, i, "sgr");
 }
+static __inline__ long long atomic64_sub_return(int i, atomic64_t * v)
+{
+	return __CSG_LOOP(v, i, "sgr");
+}
+static __inline__ long long atomic64_sub_and_test(int i, atomic64_t * v)
+{
+	return __CSG_LOOP(v, i, "agr") == 0;
+}
 static __inline__ void atomic64_inc(volatile atomic64_t * v)
 {
 	       __CSG_LOOP(v, 1, "agr");
#1 lore raw

Hi,

Quoted 3 lines · Martin Schwidefsky

Well, adding the missing s390 atomic operations is easy (see patch). But I really doubt that it will make a measurable difference in performance on ANY architecture.

On some archs atomic_sub_return is more complex than atomic_sub_and_test and there it does make a difference.

bye, Roman