Skip to contentSkip to conversation

atomic test and set

DISCUSSION Tobin C. Harding 3 participants 6 messages Oct 18, 2017 – Oct 22, 2017

lore
Share & tools
lore
#0 lore raw

Hi,

Do we have an atomic test and set function in the kernel. I have tried

const int KEY_FLAG_BIT = 1;

...

	static siphash_key_t ptr_secret __read_mostly;
	static unsigned long have_key = 0;

	if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
		get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

I looked in include/linux/atomic.h and thought about using

	static atomic_t have_key = ATOMIC_INIT(0);

        if (atomic_xchg(&have_key, 1) == 0)
        	get_random_bytes(&ptr_secret, sizeof(ptr_secret));

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

(Is this whole discussion just premature optimization?)

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

#define  atomic_xchg(...)						\
	__atomic_op_fence(atomic_xchg, __VA_ARGS__)

#define __atomic_op_fence(op, args...) \

({									\
	typeof(op##_relaxed(args)) __ret;				\
	smp_mb__before_atomic();					\
	__ret = op##_relaxed(args);					\
	smp_mb__after_atomic();						\
	__ret;								\
})
#define  atomic_xchg_release(...)					\
	__atomic_op_release(atomic_xchg, __VA_ARGS__)

#define __atomic_op_release(op, args...) \

({									\
	smp_mb__before_atomic();					\
	op##_relaxed(args);						\
})

#define atomic_xchg_relaxed atomic_xchg

thanks,
Tobin.

#1 lore raw
Quoted 7 lines · Tobin C. Harding

Hi,

Do we have an atomic test and set function in the kernel. I have tried

Yes and it is used very much inside the kernel.

Quoted 5 lines

const int KEY_FLAG_BIT = 1;

...

Quoted 8 lines
   static siphash_key_t ptr_secret __read_mostly;
   static unsigned long have_key = 0;

   if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
       get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

What doesn't work? What you expected and how is the result different?

Quoted 5 lines

I looked in include/linux/atomic.h and thought about using

   static atomic_t have_key = ATOMIC_INIT(0);
Quoted 7 lines
       if (atomic_xchg(&have_key, 1) == 0)
           get_random_bytes(&ptr_secret, sizeof(ptr_secret));

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

Did you read this https://www.mjmwired.net/kernel/Documentation/atomic_ops.txt ?

Quoted 1 line

(Is this whole discussion just premature optimization?)

This has nothing to do with optimization but rather the requirement. In kernel atomic variables are used to avoid race conditions generally.

Quoted 3 lines

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

Implementation would differ based on the architecture. In some architectures it would be a single instruction and in others it may not be the case.

Quoted 25 lines

#define  atomic_xchg(...)                        \
   __atomic_op_fence(atomic_xchg, __VA_ARGS__)

#define __atomic_op_fence(op, args...) \

({                                    \
   typeof(op##_relaxed(args)) __ret;                \
   smp_mb__before_atomic();                    \
   __ret = op##_relaxed(args);                    \
   smp_mb__after_atomic();                        \
   __ret;                                \
})
#define  atomic_xchg_release(...)                    \
   __atomic_op_release(atomic_xchg, __VA_ARGS__)

#define __atomic_op_release(op, args...) \

({                                    \
   smp_mb__before_atomic();                    \
   op##_relaxed(args);                        \
})

#define atomic_xchg_relaxed atomic_xchg

Quoted 7 lines

thanks,
Tobin.

_______________________________________________
Kernelnewbies mailing list
Kernelnewbies at kernelnewbies.org
https://lists.kernelnewbies.org/mailman/listinfo/kernelnewbies

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.kernelnewbies.org/pipermail/kernelnewbies/attachments/20171017/0fc28498/attachment.html

#2 lore raw
In reply to Tobin C. Harding
Quoted 25 lines · Tobin C. Harding

Hi,

Do we have an atomic test and set function in the kernel. I have tried

const int KEY_FLAG_BIT = 1;

...

	static siphash_key_t ptr_secret __read_mostly;
	static unsigned long have_key = 0;

	if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
		get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

I looked in include/linux/atomic.h and thought about using

	static atomic_t have_key = ATOMIC_INIT(0);

        if (atomic_xchg(&have_key, 1) == 0)
        	get_random_bytes(&ptr_secret, sizeof(ptr_secret));
Quoted 3 lines

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

Yes it stores at every call. To check before load, you should use cmpxchg

Quoted 4 lines

(Is this whole discussion just premature optimization?)

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

I think those macros look loverly ;-)
Maybe you should look into `Documentation/atomic_ops.txt' for help. Also, I think see how xchg() and cmpxchg() is implemented in the kernel, e.g., at here:

https://elixir.free-electrons.com/linux/latest/source/arch/x86/include/asm/cmpxchg.h

Yubin

#3 lore raw
Quoted 30 lines · Yubin Ruan
Quoted 25 lines · Tobin C. Harding

Hi,

Do we have an atomic test and set function in the kernel. I have tried

const int KEY_FLAG_BIT = 1;

...

	static siphash_key_t ptr_secret __read_mostly;
	static unsigned long have_key = 0;

	if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
		get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

I looked in include/linux/atomic.h and thought about using

	static atomic_t have_key = ATOMIC_INIT(0);

        if (atomic_xchg(&have_key, 1) == 0)
        	get_random_bytes(&ptr_secret, sizeof(ptr_secret));
Quoted 3 lines

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

Quoted 8 lines

Yes it stores at every call. To check before load, you should use cmpxchg

Quoted 4 lines

(Is this whole discussion just premature optimization?)

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

I think those macros look loverly ;-)

Thanks Yubin, guess I need to work on my macro-foo

Quoted 4 lines

Maybe you should look into `Documentation/atomic_ops.txt' for help. Also, I think see how xchg() and cmpxchg() is implemented in the kernel, e.g., at here:

https://elixir.free-electrons.com/linux/latest/source/arch/x86/include/asm/cmpxchg.h

thanks,
Tobin.

#4 lore raw

2017-10-20 16:55 GMT+08:00 Tobin C. Harding <[email protected]>:

Quoted 27 lines · Yubin Ruan
Quoted 26 lines · Tobin C. Harding
Quoted 25 lines

Hi,

Do we have an atomic test and set function in the kernel. I have tried

const int KEY_FLAG_BIT = 1;

...

    static siphash_key_t ptr_secret __read_mostly;
    static unsigned long have_key = 0;

    if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
            get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

I looked in include/linux/atomic.h and thought about using

    static atomic_t have_key = ATOMIC_INIT(0);

        if (atomic_xchg(&have_key, 1) == 0)
            get_random_bytes(&ptr_secret, sizeof(ptr_secret));
Quoted 5 lines
Quoted 5 lines
Quoted 3 lines

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

Yes it stores at every call. To check before load, you should use cmpxchg

sorry this should be "check before store" ...

Quoted 14 lines
Quoted 7 lines
Quoted 5 lines

(Is this whole discussion just premature optimization?)

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

I think those macros look loverly ;-)

Thanks Yubin, guess I need to work on my macro-foo

Quoted 4 lines

Maybe you should look into `Documentation/atomic_ops.txt' for help. Also, I think see how xchg() and cmpxchg() is implemented in the kernel, e.g., at here:

https://elixir.free-electrons.com/linux/latest/source/arch/x86/include/asm/cmpxchg.h

I really think the `cmpxchg.h' is valuable for learning. Please do take a look at it.

And sorry again for so many typos.

Yubin

#5 lore raw
Quoted 46 lines · Yubin Ruan

2017-10-20 16:55 GMT+08:00 Tobin C. Harding <[email protected]>:

Quoted 27 lines · Yubin Ruan
Quoted 26 lines · Tobin C. Harding
Quoted 25 lines

Hi,

Do we have an atomic test and set function in the kernel. I have tried

const int KEY_FLAG_BIT = 1;

...

    static siphash_key_t ptr_secret __read_mostly;
    static unsigned long have_key = 0;

    if (test_and_set_bit(KEY_FLAG_BIT, &have_key))
            get_random_bytes(&ptr_secret, sizeof(ptr_secret));

But that doesn't work.

I looked in include/linux/atomic.h and thought about using

    static atomic_t have_key = ATOMIC_INIT(0);

        if (atomic_xchg(&have_key, 1) == 0)
            get_random_bytes(&ptr_secret, sizeof(ptr_secret));
Quoted 5 lines
Quoted 5 lines
Quoted 3 lines

This works. My question is; does this code LOAD the value at have_key and STORE the argument on every call? Or does it LOAD the value, check if it is the same as the argument, and STORE _only_ if it is different?

Yes it stores at every call. To check before load, you should use cmpxchg

sorry this should be "check before store" ...

Quoted 10 lines
Quoted 7 lines
Quoted 5 lines

(Is this whole discussion just premature optimization?)

I cannot grok the macros in atomic.h, they seem circular. Here is the macro definitions in call chain order starting with atomic_xchg()

I think those macros look loverly ;-)

Thanks Yubin, guess I need to work on my macro-foo

Quoted 7 lines
Quoted 4 lines
Quoted 4 lines

Maybe you should look into `Documentation/atomic_ops.txt' for help. Also, I think see how xchg() and cmpxchg() is implemented in the kernel, e.g., at here:

https://elixir.free-electrons.com/linux/latest/source/arch/x86/include/asm/cmpxchg.h

I really think the `cmpxchg.h' is valuable for learning. Please do take a look at it.

I read atomic_ops.txt, thanks. Also I used cmpxchg() like this

static atomic_t foo = ATOMIC_INIT(0);

...

        if (atomic_cmpxchg(&foo, 0, 1) == 0) {
                do_this();
        }

With the intent that only a single caller will ever call do_this().

thanks,
Tobin.