Interesting!Your suggestion would in fact do pri select in the special case 1. below:
- Poll highPri first (take it if it's ready), if highPri not ready then take lowPri (provided highPri has not become ready since the first poll)
- However, if highPri has become ready between the first and the second, then it would be taken (provided lowPri is not also ready)
- If both have become ready when the second select is entered they would be taken 50% of the time on the average
I fail to see that this is the general pri select that I am quering about whether it has "appeared" in go over the last years.
I have a stomach feeling that it can not be implemented by polling. In the semantics of a select the whole select is evaluated before it is entered to se if there is/are any guard(s) ready. If not, pick randomly. If not, set alle guards up in some wait state.The default case I have always used like "since no event ready (polling) then do something else than listening again on the same events". occam has deafult (although it's called TRUE & SKIP), xC does not.torsdag 29. april 2021 kl. 11:36:45 UTC+2 skrev Jan Mercl:On Thu, Apr 29, 2021 at 11:24 AM Øyvind Teig <oyvin...@teigfam.net> wrote:
> This is not solved with a default clause, which transforms the selective choice waiting for some event to happen into busy polling. It's nice yo have some times, but that is something orthogonal to pri/ordered.
Not sure if I would call it busy polling, but I meant schematically this:
select {
case x := <-highPriority:
handle(x)
default:
select {
case x := <-highPriority:
handle(x)
case x := <-lowPriority:
handle(x)
}
}
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/47051a51-f040-4b51-a792-24a0f96c50f4n%40googlegroups.com.
On Apr 29, 2021, at 8:10 AM, Øyvind Teig <oyvin...@teigfam.net> wrote:
I agree with you.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/cf43611c-599f-46d9-98ac-60ede00daea9n%40googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/cf43611c-599f-46d9-98ac-60ede00daea9n%40googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/ac6eecc4-ee82-4a21-9001-b2c704e74e8cn%40googlegroups.com.
I will give you the pseudo code:{ // step #1 do select on bothselect highselect low}if high read:return highelse:// we read a low so do a high poll{select high:default:}if high read:enqueue low and return highelse:if queue empty:return lowelse:use queue and enqueue low from step #1 // FIFO order on low readsThe above code will always return high values over low values (if high available), and return low values in order of events
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/2460a16f-af1b-4613-ba4a-72b13e816a2bn%40googlegroups.com.
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/f26ee7f2-a518-433f-89d4-d55aa0a9b07d%40www.fastmail.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/00218548-6E27-4E16-A75F-88B6E30195E5%40ix.netcom.com.
They could still both have become ready (not in the same "cycle") between the two selects. Even if that probability is low, it would need knowledge like yours to show that this may in fact be zero. There could be a descheduling in between, one of those in my opinion, not relevant arguments.
torsdag 29. april 2021 kl. 15:47:42 UTC+2 skrev Jan Mercl:On Thu, Apr 29, 2021 at 3:23 PM Øyvind Teig <oyvin...@teigfam.net> wrote:
> 4c is not "correct" as I want it. In the pri select case, if more than one is ready, then they shall not be randomly chosen. Never. They should be selected according to priority.
That's not what 4c says. Instead of "more than one ready" it says
"both high and low _get ready at the same time_".
Note that in the first approximation the probability of 4c happening
is approaching zero. If we consider time "ticks" in discrete quanta,
the probability is proportional to the size of the quantum. And
depending on a particular implementation of the scheduler the
probability of 4c can still be exactly zero. For example, the OS
kernel may deliver only one signal at a time to the process etc.
So the "Never" case may quite well never happen at all.
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/2460a16f-af1b-4613-ba4a-72b13e816a2bn%40googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/CAEkBMfFC1gtxbWZsy88gM4ymPncCjs6Q3YJpTcXym8bT1Ev6Kw%40mail.gmail.com.
I agree with Axel's take here. It seems, Øyvind, that you are concerned more with principle than practice here. Can you give an example of a real world case where you think that this might actually matter?
On Apr 29, 2021, at 2:05 PM, Øyvind Teig <oyvin...@teigfam.net> wrote:
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/20c0a14c-5e4e-47a3-a198-808f207980c4n%40googlegroups.com.
- I'm sorry I didn't follow up on your answer where you had got to the length of spelling out some code right before my eyes. I got lost in the other points (I actually started a response..)
- I trust you
- But to do more than trusting, understanding would be much better. I'm sorry: to understand I would need more than pseudo code
- But I was really after whether the "pri" keyword (or whatever) in front of "select" had been introduced over the last years. The answer seems to be "no"
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/7ae6ae45-c341-4998-9229-74b133ac213fn%40googlegroups.com.
torsdag 29. april 2021 kl. 20:22:32 UTC+2 skrev rog:I agree with Axel's take here. It seems, Øyvind, that you are concerned more with principle than practice here. Can you give an example of a real world case where you think that this might actually matter?Thanks, yes. I have written some about that in the Nondeterminsim blog note, referred to at the top. I admit I indicated that seeing some code might be interesting, but it was the principle I was after. In the end a "yes" or "no".Some from the chapter "-Nondeterministic selective choice in implementations is not good": (Preceeding the quote I have been telling about CSP's external nondeterministic choice in the specfications ("implement this any way you want") but in the implementation part we have to take decisions (deterministic, inner choice: "we do it this way"). I was thinking this is relevant because Why build concurrency on the ideas of CSP? Here's the quote:"The statement was that with the non-deterministic guarded choice in Go, what happens is up to the run-time, which is “not good”. This is implementation, not specification. With occam there is ALT or PRI ALT, always coded as PRI ALT. For a server to be “fair” I have to code it myself, it’s up to me, at the application level to find the best algorithm. Which, during my years as occam programmer was “new starting channel index in the ALT-set is the channel index of the served channel + 1 modulo-divided by number of channels”. Channels are clients[0..4] (five) ALT‘ed in set [4,0,1,2,3] served index 4, then 4+1 rem 5 == 0 yields next ALT set [0,1,2,3,4]. Just served 4 and you’re at the back of the set."The example here is a server with N clients where it is essential that none of clients will starve and none jam the server.
I have needed to do this coding several times. Go has random select which in theory may mean starving and jamming. I worked with safety critical fire detection, and it was necessary to ensure this. Or at least we didn't dare to take the chance. We could not just add another machine.To use select when that's fair enough (pun 1) - "fair enough" (pun 2). But If I want to be certain of no starving or jamming I need to code the fairness algorithm. I can then promise a client that may have been ready but wasn't served to come in before I take the previous clients that were allowed. This is at best very difficult if all we have is select. Having pri select as the starting point is, in this case, easier.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/20c0a14c-5e4e-47a3-a198-808f207980c4n%40googlegroups.com.
On Thu, 29 Apr 2021, 20:05 Øyvind Teig, <oyvin...@teigfam.net> wrote:torsdag 29. april 2021 kl. 20:22:32 UTC+2 skrev rog:I agree with Axel's take here. It seems, Øyvind, that you are concerned more with principle than practice here. Can you give an example of a real world case where you think that this might actually matter?Thanks, yes. I have written some about that in the Nondeterminsim blog note, referred to at the top. I admit I indicated that seeing some code might be interesting, but it was the principle I was after. In the end a "yes" or "no".Some from the chapter "-Nondeterministic selective choice in implementations is not good": (Preceeding the quote I have been telling about CSP's external nondeterministic choice in the specfications ("implement this any way you want") but in the implementation part we have to take decisions (deterministic, inner choice: "we do it this way"). I was thinking this is relevant because Why build concurrency on the ideas of CSP? Here's the quote:"The statement was that with the non-deterministic guarded choice in Go, what happens is up to the run-time, which is “not good”. This is implementation, not specification. With occam there is ALT or PRI ALT, always coded as PRI ALT. For a server to be “fair” I have to code it myself, it’s up to me, at the application level to find the best algorithm. Which, during my years as occam programmer was “new starting channel index in the ALT-set is the channel index of the served channel + 1 modulo-divided by number of channels”. Channels are clients[0..4] (five) ALT‘ed in set [4,0,1,2,3] served index 4, then 4+1 rem 5 == 0 yields next ALT set [0,1,2,3,4]. Just served 4 and you’re at the back of the set."The example here is a server with N clients where it is essential that none of clients will starve and none jam the server.I have needed to do this coding several times. Go has random select which in theory may mean starving and jamming. I worked with safety critical fire detection, and it was necessary to ensure this. Or at least we didn't dare to take the chance. We could not just add another machine.To use select when that's fair enough (pun 1) - "fair enough" (pun 2). But If I want to be certain of no starving or jamming I need to code the fairness algorithm. I can then promise a client that may have been ready but wasn't served to come in before I take the previous clients that were allowed. This is at best very difficult if all we have is select. Having pri select as the starting point is, in this case, easier.To start with, if you've got N clients where N isn't known in advance, it's not possible to use Go's select statement directly because it doesn't provide support for reading from a slice.You can do it with reflection though. It's not too hard to code something quite similar to your algorithm above.For example: https://go2goplay.golang.org/p/S_5WFkpqMP_H
On Thu, Apr 29, 2021 at 12:05 PM Øyvind Teig <oyvin...@teigfam.net> wrote:
>
> The example here is a server with N clients where it is essential that none of clients will starve and none jam the server. I have needed to do this coding several times. Go has random select which in theory may mean starving and jamming. I worked with safety critical fire detection, and it was necessary to ensure this. Or at least we didn't dare to take the chance. We could not just add another machine.
>
> To use select when that's fair enough (pun 1) - "fair enough" (pun 2). But If I want to be certain of no starving or jamming I need to code the fairness algorithm. I can then promise a client that may have been ready but wasn't served to come in before I take the previous clients that were allowed. This is at best very difficult if all we have is select. Having pri select as the starting point is, in this case, easier.
When there are multiple ready results, the select statement in Go is
guaranteed to use a uniform pseudo-random selection
(https://golang.org/ref/spec#Select_statements). The fact that cases
are selected using a uniform distribution ensures that executing a
select statement in a loop can't lead to starving (I'm not sure what
jamming is).
As several people have said, it's meaningless to say "I want to ensure
that if both case A and case B are available then the select statement
will choose case A." It's meaningless because it relies on a notion
of simultaneity that literally doesn't exist.
There will always be a
period of time after the select statement chooses B, but before it
actually executes the case, that case A may become ready. That will
be true for any possible implementation of select, because select is
not an atomic operation.
Therefore, this code using a hypothetical priority case
select {
case pri <-c1:
case <-c2:
}
can always be rewritten as
select {
case <-c1:
default:
select {
case <-c1:
case <-c2:
}
}
The rewritten select is exactly equivalent to the first. The only way
that they could not be equivalent would be if select were atomic.
Ian
If there is no notion of simultaneity why all the effort to describe the random distribution?
The select is first set up, at which time the code decides on which one to take if more than one guard is ready. If the clients were only sending, then nowhere in the system is this noted on "the other" side of the channel (in the server) before it enters the select. The channel would have noted the first contender, yes, but the servre have yet no idea. If none is ready, then the server was first on all the ends, and when a sender arrives it will match the guard set in the server and tear down the select. In due time the server is scheduled with that one event.This is how I have seen it in several systems. I wonder what might be so different with go.
Ok, so this is a pattern that Go people would use if they needed to do pri select. Then, why go to the lengths of the other code shown above? Is it because I have kind of "pressed" you to come up with code and then of course, one thing may be solved several ways?
Will your Go code examples stand the test of formal verification? Of course, when it's not formally verified you probaby could not answer such a question. But the stomach feeling?
Another angle: Go does not have the expression before the select that evaluates to true or false. Nothing likeselect {case (do_this) => val1 <-c1:
case val2 <-c2:
}Instead, the chan is set to nil to exclude it from the set. What might happen if we had a set of 100 clients and they were switched on and off internally in the server (that's their purpose) - when will the uniform distribution be reset? What's the life span of the distribution? With a psudorandom sequence any one value is only visited once on a round.
We still want this to be fair. Could those having been served be served again (before the others) after a reset of the distribution, and this introduce a notion of unfairness?
(I gues that jamming is that only one client alone gets to the server, whereas starving is that a client never gets to the server).
Øyvind
Ian
--
You received this message because you are subscribed to the Google Groups "golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email to golang-nuts...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/ec5e5c0f-c5bf-4efb-b1c4-dc056720ba5cn%40googlegroups.com.
Axel, it is impolite not to try to comment and discuss each and every point above.
I have tried to expand on Jan's code (https://go2goplay.golang.org/p/7xDzP6Jvyl8), here: https://go2goplay.golang.org/p/vhmo_Vw6OQy. I have added a mediumPriority channel. (Hope it's right..)
Ian said that select is not an atomic operation. I assume (but everyone here seems to tell me the opposite), that at each default there are starts of new, unique selects?Here is one of the comments I wrote to one of Axel's points above, and it could be iterated over three priorities as well:I think this is where I need to understand Go a little better, because it might be different from occam's default (TRUE & SKIP). Actually, this may be the reason why this thread is still not closed. To me it is very strange that between the first polling of the highPri and the default, why that outer select is not torn down. Then enter a new select, which would have two guards: high and low pri. In my head when setting up the new select there would be a decision of which one to select. It would select from the set of ready guards right there. They could both have become ready.
Remember in my head these two may be hw pins. (If the first high pri poll was done at 0 ns and the second select's decision could be 10 ns later, then both hw pins could have become ready at 5 ns). If so the decision needs to be on one of them. With "only random" (yes, I think think this is so, on a general basis, but I accept that Go doesn't have the other option) to chose from, then it may chose the low pri, even if the high pri also was, hw wise, ready.
If these two (or three) cannot be hardware pins (as in Go), then I reason (by induction(?)) that all of the code must be atomic with no descheduling in between, for me to understand that the scheme is 100% as intended: meaning that there is not any state where random select is ever used.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/9186c34b-1088-4ae0-8076-6c5cd0cdde38n%40googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/dc3898ea-032e-4b28-acd4-65e1b7cef21fn%40googlegroups.com.
On Sun, May 2, 2021 at 9:23 PM Øyvind Teig <oyvin...@teigfam.net> wrote:
I have tried to expand on Jan's code (https://go2goplay.golang.org/p/7xDzP6Jvyl8), here: https://go2goplay.golang.org/p/vhmo_Vw6OQy. I have added a mediumPriority channel. (Hope it's right..)That code is missing a case in the innermost select. This one seems correct:
Ian said that select is not an atomic operation. I assume (but everyone here seems to tell me the opposite), that at each default there are starts of new, unique selects?Here is one of the comments I wrote to one of Axel's points above, and it could be iterated over three priorities as well:I think this is where I need to understand Go a little better, because it might be different from occam's default (TRUE & SKIP). Actually, this may be the reason why this thread is still not closed. To me it is very strange that between the first polling of the highPri and the default, why that outer select is not torn down. Then enter a new select, which would have two guards: high and low pri. In my head when setting up the new select there would be a decision of which one to select. It would select from the set of ready guards right there. They could both have become ready.This description sounds correct. This is how Go behaves.
Remember in my head these two may be hw pins. (If the first high pri poll was done at 0 ns and the second select's decision could be 10 ns later, then both hw pins could have become ready at 5 ns). If so the decision needs to be on one of them. With "only random" (yes, I think think this is so, on a general basis, but I accept that Go doesn't have the other option) to chose from, then it may chose the low pri, even if the high pri also was, hw wise, ready.This is fundamentally correct (though I'm not sure what you mean by "hw pin").
If these two (or three) cannot be hardware pins (as in Go), then I reason (by induction(?)) that all of the code must be atomic with no descheduling in between, for me to understand that the scheme is 100% as intended: meaning that there is not any state where random select is ever used.It is.
Again: Your understanding is correct. But the resulting situation is still equivalent to a priority select. There is no observable behavior in difference between the two.So let me repeat my question:Assume a read happened from lowPriority, even though highPriority was ready to read as well. That's, AIUI, the outcome you are concerned about.In that situation, how would you know that highPriority was ready to read as well?I believe you'll find that the answer is "you can't".
meaning that there is not any state where random select is ever used.It is.
Trouble A: If random select is never used […]
If so, maybe a constructive point is to try to write some runnable Go code that uses this pri select pattern. I have thought about it, but I don't know how to check whether it would ever enter one of the selects
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/cda2055a-8024-4ab1-87ca-18a177aa1cb2n%40googlegroups.com.
On May 3, 2021, at 1:23 PM, 'Axel Wagner' via golang-nuts <golan...@googlegroups.com> wrote:
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/CAEkBMfFOUfDQJSpFQCOUAs%2BtKEATNO8K3pj0ZA%3DvRmNXDMokDg%40mail.gmail.com.
On Mon, May 3, 2021 at 6:34 PM Øyvind Teig <oyvin...@teigfam.net> wrote:meaning that there is not any state where random select is ever used.It is.Trouble A: If random select is never used […]I was unclear: When I said "It is", I meant "it is used". Your understanding of what select does is correct. There will be cases, where both channels are ready when the inner `select` is entered and thus, there will be a pseudorandom choice over which will proceed.
The argument put forward is that that's exactly how a priority select would have to behave as well. As least as I imagine it and as well as I understand the implementation of `select` (which is, admittedly, not *super* well).
If so, maybe a constructive point is to try to write some runnable Go code that uses this pri select pattern. I have thought about it, but I don't know how to check whether it would ever enter one of the selectsThis is precisely what my question was getting at. FWIW, it's ultimately pretty straight forward to demonstrate this behavior:
This program exits if and only if the inner select choses `lo`. Given that we know that `hi` is being closed before `lo` ("Within a single goroutine, the happens-before order is the order expressed by the program."), `lo` being ready implies `hi` being ready as well. Thus, by seeing that the program exits, we can show that the inner select sometimes chooses the `lo` case, even though the `hi` is ready as well.
Crucially, however, we needed to know that `close(hi)` happens before `close(lo)` to prove this case was taken - thus, the communications are not concurrent. That's what I meant by "external synchronization primitives".
I think my question was flawed, because really, the issue isn't about how the `select` with `default` construct we showed works - the question is how a priority `select` could work. That is, could we implement a priority `select` such that this code terminates: https://play.golang.org/p/4G8CY36L0Qy
I don't think we can - and based on that assumption I extrapolated how a priority select would actually behave - but I have to admit that I really don't understand `select` or the underlying hardware primitives enough to make a solid case either way here. Maybe you can provide an equivalent program in a language of your choice that terminates - that would certainly prove that it's at least possible (though to be clear: I don't understand your xC code, so I can't promise that I'd understand whatever you send here, personally :) ).All of that being said: I really think that in the cases where a priority select is needed, this construct is good enough to hold up.
In most “select” implementations a set of “ready” endpoints is returned. So it is trivial for the reader to prioritize some endpoints over others.
Because of the way Go select works it is more difficult - requiring nested selects - and it is more easily implemented using multiple readers and queues once it moves beyond a few producers.
I don't see where hi and lo are being sent to?
But then, "happens before" is "within a single gorotine". When it comes to several and concurrent goroutines there is no other order than those forced on them by synchronisation over nonbuffered channels (or the join you had in the code example).
I think my question was flawed, because really, the issue isn't about how the `select` with `default` construct we showed works - the question is how a priority `select` could work. That is, could we implement a priority `select` such that this code terminates: https://play.golang.org/p/4G8CY36L0Qy
But wouldn't this be 50% on each, like in https://play.golang.org/INacl7a-BU? (Taken from my note https://www.teigfam.net/oyvind/home/technology/049-nondeterminism/#go_or_go_or_golang)
I don't think we can - and based on that assumption I extrapolated how a priority select would actually behave - but I have to admit that I really don't understand `select` or the underlying hardware primitives enough to make a solid case either way here. Maybe you can provide an equivalent program in a language of your choice that terminates - that would certainly prove that it's at least possible (though to be clear: I don't understand your xC code, so I can't promise that I'd understand whatever you send here, personally :) ).All of that being said: I really think that in the cases where a priority select is needed, this construct is good enough to hold up.Hmm.. I must admit I smile here. I kind of like that we come to different conclusions. Would you you send your daughter with a fly by wire airplane that has some "good enough" sw?
There is a rather good explanation of PRI ALT (=pri select) of occam, where the TRUE & SKIP (=default) is also seen at page 72 of http://www.transputer.net/obooks/isbn-013629312-3/oc20refman.pdf.
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/944ccecd-6a70-46de-a09f-7742eab9e2a1n%40googlegroups.com.
On May 3, 2021, at 2:24 PM, Øyvind Teig <oyvin...@teigfam.net> wrote:
To view this discussion on the web visit https://groups.google.com/d/msgid/golang-nuts/c5566e71-befb-4912-8004-91538f940b25n%40googlegroups.com.
On Mon, May 3, 2021 at 9:16 PM Øyvind Teig <oyvin...@teigfam.net> wrote:I don't see where hi and lo are being sent to?They are being `close`d. Reading from a closed channel immediately succeeds, yielding the zero value.I chose to use `close` because it's a non-blocking way to make a channel readable. You could get the same demonstration by making the channels buffered and writing to them.But then, "happens before" is "within a single gorotine". When it comes to several and concurrent goroutines there is no other order than those forced on them by synchronisation over nonbuffered channels (or the join you had in the code example).Exactly. It is only *because* we use a single goroutine and we thus know that there is a happens-before edge.For example, this program *also* exits (i.e. line 16 is executed), but you can no longer conclude that `hi` was ready when it does.This is how most practical cases would likely happen.I think my question was flawed, because really, the issue isn't about how the `select` with `default` construct we showed works - the question is how a priority `select` could work. That is, could we implement a priority `select` such that this code terminates: https://play.golang.org/p/4G8CY36L0QyBut wouldn't this be 50% on each, like in https://play.golang.org/INacl7a-BU? (Taken from my note https://www.teigfam.net/oyvind/home/technology/049-nondeterminism/#go_or_go_or_golang)I don't understand this question. Though I also see that my question is wrong - it should be "could we implement a priority `select` such that this code *never* terminates.If we suppose a perfect priority select, which never chooses the `lo` case if the `hi` case is ready, the program I linked would never terminate. Because `lo` is never ready unless `hi` is ready too. This, AIUI, is the priority `select` you'd want. Note, in particular, the made up `pri` keyword in the example.So, no, in that scenario we wouldn't have a pseudo-random choice. The question I was begging is if we could actually implement a select like you want. If you can write this program in another language, and that program ends up not terminating, that would demonstrate that it's indeed possible to write a `select` as you are requesting.I don't think we can - and based on that assumption I extrapolated how a priority select would actually behave - but I have to admit that I really don't understand `select` or the underlying hardware primitives enough to make a solid case either way here. Maybe you can provide an equivalent program in a language of your choice that terminates - that would certainly prove that it's at least possible (though to be clear: I don't understand your xC code, so I can't promise that I'd understand whatever you send here, personally :) ).All of that being said: I really think that in the cases where a priority select is needed, this construct is good enough to hold up.Hmm.. I must admit I smile here. I kind of like that we come to different conclusions. Would you you send your daughter with a fly by wire airplane that has some "good enough" sw?This is… a strange question. I'm not saying "the software might be buggy, but it will be buggy software that is good enough". I'm saying "the construct is good enough to implement non-buggy software with it". Of course you need to know what the construct does and take it into account when writing your code - if you assume it works differently than it does, you'll introduce bugs, yes. That is true in any language.There is a rather good explanation of PRI ALT (=pri select) of occam, where the TRUE & SKIP (=default) is also seen at page 72 of http://www.transputer.net/obooks/isbn-013629312-3/oc20refman.pdf.Can you translate the example into that language? And demonstrate that it doesn't terminate?It's not practical for me to learn a different language and scour its reference manual, to try and figure out how their select works, if that is compatible with how Go's select works and thus if and how lessons learned from that language are transferable to Go.You seem to be convinced that their priority select is superior to Go's select construct and can map semantics that Go can't.
I see that, which is great. But I still don't understand why https://go2goplay.golang.org/p/S_5WFkpqMP_H (By rog, 29Apr2021 23:52:05) seems not to print "Client 2".
mandag 3. mai 2021 kl. 21:44:49 UTC+2 skrev axel.wa...@googlemail.com:On Mon, May 3, 2021 at 9:16 PM Øyvind Teig <oyvin...@teigfam.net> wrote:I don't see where hi and lo are being sent to?They are being `close`d. Reading from a closed channel immediately succeeds, yielding the zero value.I chose to use `close` because it's a non-blocking way to make a channel readable. You could get the same demonstration by making the channels buffered and writing to them.
But then, "happens before" is "within a single gorotine". When it comes to several and concurrent goroutines there is no other order than those forced on them by synchronisation over nonbuffered channels (or the join you had in the code example).Exactly. It is only *because* we use a single goroutine and we thus know that there is a happens-before edge.For example, this program *also* exits (i.e. line 16 is executed), but you can no longer conclude that `hi` was ready when it does.This is how most practical cases would likely happen.I think my question was flawed, because really, the issue isn't about how the `select` with `default` construct we showed works - the question is how a priority `select` could work. That is, could we implement a priority `select` such that this code terminates: https://play.golang.org/p/4G8CY36L0QyBut wouldn't this be 50% on each, like in https://play.golang.org/INacl7a-BU? (Taken from my note https://www.teigfam.net/oyvind/home/technology/049-nondeterminism/#go_or_go_or_golang)I don't understand this question. Though I also see that my question is wrong - it should be "could we implement a priority `select` such that this code *never* terminates.
If we suppose a perfect priority select, which never chooses the `lo` case if the `hi` case is ready, the program I linked would never terminate.
Because `lo` is never ready unless `hi` is ready too. This, AIUI, is the priority `select` you'd want. Note, in particular, the made up `pri` keyword in the example.
So, no, in that scenario we wouldn't have a pseudo-random choice. The question I was begging is if we could actually implement a select like you want. If you can write this program in another language, and that program ends up not terminating, that would demonstrate that it's indeed possible to write a `select` as you are requesting.
I don't think we can - and based on that assumption I extrapolated how a priority select would actually behave - but I have to admit that I really don't understand `select` or the underlying hardware primitives enough to make a solid case either way here. Maybe you can provide an equivalent program in a language of your choice that terminates - that would certainly prove that it's at least possible (though to be clear: I don't understand your xC code, so I can't promise that I'd understand whatever you send here, personally :) ).All of that being said: I really think that in the cases where a priority select is needed, this construct is good enough to hold up.Hmm.. I must admit I smile here. I kind of like that we come to different conclusions. Would you you send your daughter with a fly by wire airplane that has some "good enough" sw?This is… a strange question. I'm not saying "the software might be buggy, but it will be buggy software that is good enough". I'm saying "the construct is good enough to implement non-buggy software with it". Of course you need to know what the construct does and take it into account when writing your code - if you assume it works differently than it does, you'll introduce bugs, yes. That is true in any language.
There is a rather good explanation of PRI ALT (=pri select) of occam, where the TRUE & SKIP (=default) is also seen at page 72 of http://www.transputer.net/obooks/isbn-013629312-3/oc20refman.pdf.Can you translate the example into that language? And demonstrate that it doesn't terminate?