Issue #8259 has been updated by Vit Z. > I do atomic operations all the time in C on arbitrary addresses. > Lazy, non-atomic accesses run without speed penalty if I don't need > up-to-date data. Are you talking about Ruby with GVL or C in general? If C in general then I don't understand how barrier-less access to concurrently updatable data does not result in unexpected behaviors for you... > The uncommon case of Array/Hash shrinkage would require RCU or similar > (epoch-based reclamation). But there's no penalty for reads or in-place > modifications other than the cost of the atomic and required memory > barriers. The cost of memory barriers is what I was talking about, right now concurrent Ruby VMs don't need to have any memory barriers on any of the `Array`/`Hash` methods. Adding "atomic" methods to `Array`/`Hash` would force them to put some kind of memory barriers on all of the methods. This will result in a performance penalty that cannot be avoided. What I am worried about, is that this will result in native Ruby `Array`/`Hash` becoming slower for single-threaded usage forever and there will no way to ever get the original performance back. -thedarkone ---------------------------------------- Feature #8259: Atomic attributes accessors https://bugs.ruby-lang.org/issues/8259#change-47136 * Author: Yura Sokolov * Status: Open * Priority: Normal * Assignee: * Category: * Target version: Ruby 2.1.0 ---------------------------------------- =begin Motivated by this gist ((<URL:https://gist.github.com/jstorimer/5298581>)) and atomic gem I propose Class.attr_atomic which will add methods for atomic swap and CAS: class MyNode attr_accessor :item attr_atomic :successor def initialize(item, successor) @item = item @successor = successor end end node = MyNode.new(i, other_node) # attr_atomic ensures at least #{attr} reader method exists. May be, it should # be sure it does volatile access. node.successor # #{attr}_cas(old_value, new_value) do CAS: atomic compare and swap if node.successor_cas(other_node, new_node) print "there were no interleaving with other threads" end # #{attr}_swap atomically swaps value and returns old value. # It ensures that no other thread interleaves getting old value and setting # new one by cas (or other primitive if exists, like in Java 8) node.successor_swap(new_node) It will be very simple for MRI cause of GIL, and it will use atomic primitives for other implementations. Note: both (({#{attr}_swap})) and (({#{attr}_cas})) should raise an error if instance variable were not explicitly set before. Example for nonblocking queue: ((<URL:https://gist.github.com/funny-falcon/5370416>)) Something similar should be proposed for Structs. May be override same method as (({Struct.attr_atomic})) Open question for reader: should (({attr_atomic :my_attr})) ensure that #my_attr reader method exists? Should it guarantee that (({#my_attr})) provides 'volatile' access? May be, (({attr_reader :my_attr})) already ought to provide 'volatile' semantic? May be, semantic of (({@my_attr})) should have volatile semantic (i doubt for that)? =end -- https://bugs.ruby-lang.org/