libera/#sicl - IRC Chatlog
Search
19:32:01
moon-child
first atomically exchange the new value with the old one, in the global replica. Then cas it into the nursery replica
19:35:14
moon-child
if a fence has to move everything that's replicated, that's still a win over doing it eagerly; tackle n objects at a time instead of 1. And if you have some atomic-heavy code with a bunch of conses, a bunch of pointing to those new conses from the global heap, and a bunch of fences, the pre-tenurer should learn about that pretty quickly
19:40:38
moon-child
hmm. If you include a generation number, then you don't need a cas loop, just one cas. But you bloat your objects, and have to fight over the generation number, so maybe it's a wash
21:22:08
hayley
@[moon-child]: I don't think a fence has to fix anything, it just has to ensure that there are no replicated writes happening. If we are going lock-free we could use a counter of writes being performed, perhaps.
21:25:55
hayley
Remember that the write occurs to both replicas, so there is no need to fix anything eagerly. The fence just needs to ensure we can't "re-order" around the fence, which is handled by waiting for any writes to finish.
23:12:05
moon-child
hmm. It feels to me that it's better to shunt more work onto the 'owning' thread, since there can only be one of it. Also in the interest of fairness--if other threads are doing extra work only so that the owning thread can see a coherent state, but it never bothers to observe that state, then it's wasted work. But this argument may not hold water: if the overall amount of work done is still less,
23:12:52
moon-child
but something else to consider is that maintaining a counter creates 'false sharing'. If two different threads are diddling replicated objects that happen to come from the same nursery, there should be no issue, but they will have to play pingpong with that nursery's counter
23:14:30
moon-child
another thing: as there are not yet any cl concurrency semantics to adhere to, we don't necessarily have to support fences in the traditional sense. Eg (with-read-barriers ... (fence) ... (fence) ...)
23:18:03
moon-child
(& since the read barrier replaces pointers to the local replica with pointers to the global one, as I think it should, this has effects beyond the with-read-barriers block. That said, I'm not quite sure what a general version of that looks like, as it's rather tailored to this specific mechanism)
0:00:45
hayley
moon-child: If there is much contention on the counter, and thus many writes, it would be better to inform the thread whose nursery is being replicated to just do a minor GC, or pre-tenure harder.
0:01:54
hayley
That's an idea, if we track the probability that objects allocated at some site escape, we can adjust our threshold for directly allocating in the global heap.
0:09:43
moon-child
how would you tell if there is contention on the counter? I guess with hardware xadd, you can rdtsc before and after, and without, just check how many times you have to retry
0:10:32
hayley
To contend, there would have to be a lot of writes. But then we need another counter for that...
4:40:31
contrapunctus
scymtym: thanks for the example. Unfortunately, even after playing with it a fair bit, I'm still pretty perplexed. I tried adapting it for my use (using it to read its own source file and just collecting the output - https://paste.rs/qZf.lisp ), but the output does not contain the comments in the file. 🙁️
5:58:11
hayley
moon-child: How do you go about updating both locations in a lock free way? I know there's a more general double CAS procedure, but it would appear this case is somewhat easier.
5:59:23
hayley
We could also have another thread rewrite references in the local nursery to point into the global heap, but I don't know what we can achieve with that.
6:07:31
moon-child
if there are unsynchronised writes, it's ok if the state is incoherent, until you do something that synchronises with both of them. Then, a write can atomically exchange the new value into the global copy, and do a single attempt to cas it into the nursery copy. If the cas fails, then let the state be incoherent, but add the object to a to-be-cohered list. Then the next time you do something that
6:08:34
moon-child
then the issue is detecting what could synchronise with such writes. Fence is obvious, but I think atomic acq or acqrel does too