4-way intersections: Throughput and deadlocks [image heavy]

[TRUEpicness]

in my map i have an omnistation that gets all ore except uranium
what i want to do is give the iron trains priority over the others using circuit networks (which i want to start experimenting after never using it because its complex depending on what you want to do)
i have a stacker going into the omnistation and the 2 stacker 'lanes' that are the closest to the omnistation have a trainstop where only and all iron trains go to make them prioritized
they immediately leave that station and go through a signal and then waits at the signal after that (which is in the usual place in a stacker)
the first signal has wire on it that connects to the other signals is the stacker which turn red if an iron train is in the priority part of the stacker
is there any ways i can improve it? (im sure there are lots of ways.)

[aaargha]

Allright, I've completed the automated setup, and run some tests on the Windcross version. Six tests to be precise, all the same (set 1), each averaged over the course of 5 minutes.
My numbers: 57.6, 57.6, 60, 61.6, 58.8 and 56.6
There is a difference of 5 trains a minute between the highest and lowest measurements, which imo is pretty big.

Then I did a 30 minute test, and got 57 trains a minute...
Could it be that all these variations are caused by the randomness of train destinations, so a lucky set will have better use of the buffers, and trains will arrive in a pattern so they can always make use of the maximum number of available turns? This may be made even worse by the seemingly random way trains get priority? I know it is deterministic, but I think it is so sensitive to small details, and has very little consideration of giving priority in a way that allows for maximal throughput, it is virtually random.

The random destination selection is probably the biggest cause of the variations and it seems like the 5min test is too short for useful comparisons in many cases. At 15min the variation seems to be about +-1, I probably won't increase the duration of the tests beyond that to increase the accuracy, the large 8-lane ones take long enough as it is (I can only maintain about 90-100 UPS for them).

I'd really love to know the rules that control which trains get access to a certain block, it could probably be exploited for some neat designs. I've done a bit of testing on that but while some of my theories work for my test setups they do not hold up in the throughput tester. It's probably dependant on the train update order which may involve anything from which chunk the trains are in to the build order of the trains.

So this made me curious. I set out to eliminate the random factor from the tests. There are two setups I came up with, one where I seperated the input buffers, each having its own train generator and a single destinaction. The throughput bottleneck this way is pretty much how many trains a single line (the output line) can carry. This way it achieved around 93 trains a minute.
Then I hooked up the three train generators to merge into a single line, and controlled which one is released via circuits, I set them into a repeating pattern of left -> straight -> right, so at any time, four trains arrived at the junction, each doing the same turn (all left / straight / right). I only did one such test, as I dont think the throughput will be any different due to the highly controlled nature of this test and that the intesection never backed up. The throughput was 91.2 trains a minute.

That seems perfectly reasonable, a large part of why I implemented the random destinations was that I felt that controlling it like that would make the results too "artificial". It's fun to see the big numbers, but the conditions are a bit far from reality to make the results all that useful

Watching the trains in this second test reassured my suspicion that this intersection actually likes left turns over trains going straight, as it can let four left turns happen in parralel, while only two trains can go straight at any time. Most probably that is why this intersection (and some other) report a higher score in set1 than in set2. The take from this is that the general assumption that left turns (in RHD systems, or, right turns in LHD systems) are bad for throughput is false. It seems, it mostly depends on the type of intersection used.

I agree that the intersection type, mainly buffer placement, will heavily influence this. Still, for the vast majority of the intersections tested set 2 performs better than set 1. For most of the designs where set 1 performs better than set 2 the "bad" turn actually has better buffering than the straight path, best example are probably the multi-cross designs.

Armed with this knowledge I started building intersections... The entire day passed, and I did not even get to benchmarking the 8-car Windcross which was the whole point, but at least I got three designs, each sort of iterating on the other. A day wasted well spent.
Here is the BP book: https://pastebin.com/e46k2Ncn
And the pics: https://imgur.com/a/qxpaT

The first one I call Braid, because that is what the lines going straight remind me in the middle, also, that one has pretty bad performance (I dont think its worth benchmarking in its current form), it is more of a proof of concept. I may try improving on it tomorrow.

The second one kinda reminds me of a boat prop... I have not tested it, but it ought to be better than the Braid Mostly due to more buffers. But I'm curious wether the left turning lane cutting straight across two other lanes will work out or not.

Speaking of more buffers, the third one is full of them. The only thing that is not fully buffered is the left turning lane, but that worked out pretty well for the Windcross. On the straight lines, there are two buffer zones where two 2-4 trains can fit... Although, it would be a real pain to extend the buffers that need extending... I have high hopes for this one. And the best thing is, all those buffers barely increased its size.

Ps.: feel free to change the names

Added as Braid, Propeller and Pasta I did muck about with the signals a bit, there was some misplaced signal in one of them, but mostly to enforce 6-car output blocks. Over all, they're three solid designs.

The output block size is something that I probably should have mentioned, and been a bit better with myself (redid the tests for Inscribed square without the train size optimized output blocks), but I think the designs will probably be more useful if they're not locked to one train length. I'll instead add a section with some links to general optimizations that can be applied to most intersections. I'm currently looking to include optimizing output blocks (once I get around to making that posts), the merge-o-matic that tallinu made, and probably something on circuit controlled traffic-lights (once someone manages to design a easer to use system that is not a deadlock waiting to happen).

in my map i have an omnistation that gets all ore except uranium
what i want to do is give the iron trains priority over the others using circuit networks (which i want to start experimenting after never using it because its complex depending on what you want to do)
i have a stacker going into the omnistation and the 2 stacker 'lanes' that are the closest to the omnistation have a trainstop where only and all iron trains go to make them prioritized
they immediately leave that station and go through a signal and then waits at the signal after that (which is in the usual place in a stacker)
the first signal has wire on it that connects to the other signals is the stacker which turn red if an iron train is in the priority part of the stacker
is there any ways i can improve it? (im sure there are lots of ways.)

That sounds like it should work so I'm not sure what you're looking for? The only think I can think of is doing the same thing with a regular priority merge instead of circuits, how that is achieved is mentioned a few times in this thread.

You'll probably get better results by making a topic in the "gameplay help" subforum, especially if you include some pictures of you current setup. In this thread it's a bit off-topic.

[Zijkhal]

Pasta

I'm kinda surprised by the Braid's performance, in the controlled test it got backed up.
And yes, the controlled test is not really representative of a "real-life" scenario.

As for the buffer signalling, what governs where you put the extra signals?

Oh, and I think the Braid should not be A rated, if a train wants to go straight or left, but does a repath, after the first split but before the second, there could be a scenario where they can not fit, and block the output trains. If, for example, two straight lanes going the opposite direction block each other, they could cause a deadlock requiring player intervention.

For left turning vs strainght, true, but both cross four other train tracks, so in a way they are exactly as bad.

[aaargha]

Pasta

I'm kinda surprised by the Braid's performance, in the controlled test it got backed up.
And yes, the controlled test is not really representative of a "real-life" scenario.

As for the buffer signalling, what governs where you put the extra signals?

It's mostly that the block after a crossing needs to be as long as the longest train that will use the intersection, at least if it's going to be used by trains of different lengths. Once we've passed that distance signals can safely be placed anywhere. If we'd design for a fixed train length then we can cheat a bit on that as long as we're aware where the trains will stop.

Oh, and I think the Braid should not be A rated, if a train wants to go straight or left, but does a repath, after the first split but before the second, there could be a scenario where they can not fit, and block the output trains. If, for example, two straight lanes going the opposite direction block each other, they could cause a deadlock requiring player intervention.

Heh, I didn't actually even look for that, most with that kind of performance tend to be A rated, so thanks for pointing that out. From what I can see it would require 8 trains going straight on opposing lanes, to fill the buffers, and another from each direction that switches from left to straight while on the crossing. I've got to say that is one of the less likely ones Oh well, it is by far the leading B rated 2-lane intersection at least.

For left turning vs strainght, true, but both cross four other train tracks, so in a way they are exactly as bad.

And if the intersection is input- and output-dependant the left turn should even be better as it allows for some trains to turn right at the same time. I think that the reason why this is not too visible in the results may be that it is not the left turn in itself that is problematic, what becomes an issue is when you mix trains going left with trains going straight. A train turning left will block all other paths if the other trains want to go straight (the other way around is also true). It does not seem too far fetched that doing a set that is 50% left, 15% straight, and 35% right would perform better for many intersections, at least as long as the left turns do not intersect.

I wonder if the reason the left turn got labelled as bad is that in most "real" scenarios it's mainly trains going straight through with only a few turning left/right to get to certain offshoots.

[Tallinu]

... A day wasted well spent.

I hear you there! Some interesting looking designs, too. Some of those remind me of a cross between Aaargha's "inscribed square" and the MultiCross layout.

is it ok that i have changed the 4 lane multicross intersection into a 2 lane (by removing the outer rail) or should have kept it 4 lane (as in prep for 4 lane system)?
just wondering

I had actually been working on optimized versions of both the 4 lane and 2 lane MultiCross but I got busy with life and distracted by other things before actually posting them (I kept wanting to finish creating rescaled versions for longer trains first). I think I'll go ahead and do that now, since people are active here again.

It's okay to do whatever you want with them, of course, but you'll get better performance with an intersection specifically designed for the number of lanes you're using. Leaving enough room for a future upgrade to four lanes may be a smart move, or you can just build a full 4 lane junction and only use the inner two lanes at first but that's a bit wasteful of track, unless you're absolutely certain you'll be upgrading and don't want to bother with setting up a two lane junction and then just tearing it down and replacing it later. But if materials or maximum efficiency for the current system are the main concern, definitely stick with one designed for two lanes until you're ready to upgrade.

I'll edit them in or make a new post here once I have blueprint books published for the optimized two lane MultiCross variants I have finished. It's a really interesting design, I think, because there are several versions each with different length and performance. And with the way I've set up the blueprints, each holding just one of the four arms of the junction which you rotate and assemble, you can actually have different parts of the same junction use different versions of it, so that the entrance/exit tracks with the most traffic use a longer, high-performance layout while the tracks with lower traffic use smaller layouts with less buffers (or even a universal piece with no buffers -- for example, if you know the station(s) down that track are only ever going to have one train assigned to each).

I wonder if the reason the left turn got labelled as bad is that in most "real" scenarios it's mainly trains going straight through with only a few turning left/right to get to certain offshoots.

You're almost certainly on the money there. Except for a situation where most traffic is turning toward or coming back from a direction at a right-angle, and the "branches" are going straight and turning the other direction, but I doubt that happens too often. I suspect four-ways are most often used where most of the traffic is going straight through to reach destinations further down a continuing main line.

---

Here are the two-lane MultiCross blueprint strings I'd been working on. There are versions for both LHD and RHD in 6, 8, 10, and 14 car scaling, although not all versions are included at the longer scales. Partly because beyond a certain length the expanded versions just don't make a lot of sense, and partly because the TurboCross's merge manager takes a lot of tweaking to get it to handle a new train length reliably.

https://drive.google.com/drive/folders/ ... mJ0NDdVMjQ

Let me know if there are any problems accessing those.

[TRUEpicness]

i can access them just fine
i have saved the lhd versions of them into a blueprint book called 'keep for future bases'. i do really like how you have just a quarter of the whole thing and you then put it together though.
i went on xterminators website and got his 4 lane blueprint book which doesnt include a 4 way intersection for some reason

[noodlebox]

I've been working on a new BP book for a different rail gauge, and that meant making some new intersections. Then I found your benchmarking map and got lost in that for a while, until I finally decided to post here with my results.

Here's a set of "Celtic Knot"-style intersections for 2-, 4-, and 8-lane RHD, but signaled a little differently for improved throughput. Trains are much more optimistic about entering the junction to move as far forward as they can without risking a deadlock, and often don't end up needing to stop. The 4- and 8-lane versions perform very well, considering their size. These should be deadlock safe regardless of train length or repathing, though there could be something I've missed. At worst, a perfect storm of repathing events could lead to trains ending up in a slow-to-resolve jumble, but an automatically resolvable one at least., [edit] but I've found some cases where they can deadlock if multiple trains repath. I eliminated a C-level deadlock possible in the original version if two trains repath by chain signaling a few more blocks (throughput numbers below should drop by around 5-10%), but the 4- and 8-lane versions are still at least vulnerable to a B-level deadlock if four trains repath inconveniently. I also have some buffered versions that I can post after I work out a couple small bugs if everything else is alright with these.

Potential B-level deadlock setup in 4- or 8-lane version:
- Train A enters on outer lane from South, intending to exit North, recalculates path after first chain signal and stops because Train B has reserved a block ahead of it.
- Train B enters on outer lane from East, intending to exit West, recalculates path after first chain signal and stops because Train C has reserved a block ahead of it.
- Train C enters on outer lane from North, intending to exit South, recalculates path after first chain signal and stops because Train D has reserved a block ahead of it.
- Train D enters on outer lane from West, intending to exit North, repaths to exit East after first chain signal and stops because Train A is inside a block ahead of it.
- Deadlock resolves if any of these trains repaths again to exit to its own left.

I don't think the deadlock rating can be improved to A simply by adjusting signals. So, I think that would be an "A" rating for the 2-lane version, and a "B" for the 4- and 8- lane versions.

"Greedy" Celtic Knot Junctions
BP Book (2017.10.09) (revised, with A/B-level deadlock ratings)
BP Book (2017.10.08) (original, with C-level deadlock ratings)
Images: https://imgur.com/a/Fmstv

I did some testing and these are the trains per minute I got for profiles 1 and 2:
Dual Celtic Knot - 42/48
Quad Celtic Knot - 72/78
Octo Celtic Knot - 110/110

Edit: found some repathing deadlocks

[sillyfly]

Very interesting thread and ideas, I'm surprised I have only just now come across it (maybe its because I've taken a break from Factorio )

If I might suggest a more "systematic" categorizing scheme. Sometimes it is more important to have lower probability of deadlock (if 100% safe / Cat A is not possible for some reason), while other times you may decide an occasional deadlock is fine, so long as it can be resolved automatically - so the straight linear order is not always accurate for all cases.

I suggest a three-metric categorization scheme, because well - we all like to play Factorio, so I assume we all like things that are neat and concise. Namely, I suggest labeling intersections "STE", where

• S stands for Safety, and can be one of:
  • S for Safe, meaning no deadlocks possible
  • P for Problematic/Potential-deadlock, meaning deadlocks are possible in rare cases where two or more trains re-path inside the intersection
  • D for Dangerous, meaning deadlocks are possible in cases where even just one train re-pathes inside the intersection
  • U for Unsafe, meaning deadlocks may occur even with no re-pathing occuring
• T stands for Troubleshooting, and can be one of:
  • A for Automatic, meaning all possible deadlocks may be automatically resolved if a block clears.
  • M for Manual, meaning deadlocks which require manual intervention for solving may occur.
• E stands for Efficiency, and is a number between 0 and 100 signifying the percentage of the maximum theoretical efficiency. In practice, since a single lane can support almost exactly 30 trains per minute, a 4-way n-lane intersection has a maximum theoretical throughput of

  Code: Select all

   30 * 4 * n / 2 = 60 * n 

  
  trains per minute (half of the lanes are incoming, half outgoing). This is very convenient, as it means 100% efficiency is exactly 1 train per lane per second. So to convert from TPS to Efficiency you simply divide by the number of lanes and multiply by 100.

As an example, here is the conversion from the original categories to this scheme (with efficiency omitted):

A -> SA
B -> PA
C -> PM
D -> DA
E -> DM
F -> UM

Note that SM and UA are not possible categorizations, as a Safe intersection will never require player intervention by definition, and an Unsafe intersection (presumably) always fails in a way that requires player intervention.

As for the efficiency, I think it can be extremely interesting to see the law of diminishing returns, and how it applies to intersection - presumably, the higher-lane version of an intersection will have a lower efficiency, but does it scale the same way for all types?


(Note: I may have been over-thinking and over-complicating this... )

[ERJHolton]

Thank you for this thread! Excellent information, and the test-bench map is lots of fun for experimentation. I have one quick question about the test methodology. Do you reset the counters as soon as you start the trains, or do you let the trains run for a few minutes first to let it settle into a steady flow before starting the counter?

Finally, I'd like to offer my own small contribution to the 2-lane four-way canon. On a whim I decided to try to design a junction loosely based on the magic roundabout; that is, a series of roundabouts feeding into a central contradirectional roundabout. It took a few iterations and refinements, but eventually I came up with a layout that seems quite stable under the three provided major profiles (equal, planned RHD, planned LHD), and has reasonable throughput. There are potential deadlock scenarios, but I think actual deadlocks would be quite rare.

Blueprint string:

Magic Roundabout v4r4

Code: Select all

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

Picture

[TRUEpicness]

thats the biggest roundabout ive ever seen

[mrvn]

At the start there was the simple round about and crossing and then things got bigger and bigger. With buffers before, after and even inside the constructs all to imporve throughput. The designs allow multiple trains to take a left (or right) or multiple trains to go straight at the same time and the buffers are there so hopefully the game will pick the right trains to move at the same time.

Now I wonder if that choice should be left to the game at all. Why not build a real traffic light? Split each track into left turn, right turn and straight and then have buffers. Use circuits to enable combinations of trains to pass through the junction, e.g. all left turns at the same time, for a while. Buffers that threaten to overflow should be allowed to drain first or most often but also no train should be held back forever. For advanced circuit use: Try to control the signals leaving the buffer zones to interleave the trains. Give them enough tracks to get up to speed so they race across the actual junction. Start the next set of trains so that it arives at the junction as it clears.

[Jap2.0]

At the start there was the simple round about and crossing and then things got bigger and bigger. With buffers before, after and even inside the constructs all to imporve throughput. The designs allow multiple trains to take a left (or right) or multiple trains to go straight at the same time and the buffers are there so hopefully the game will pick the right trains to move at the same time.

Now I wonder if that choice should be left to the game at all. Why not build a real traffic light? Split each track into left turn, right turn and straight and then have buffers. Use circuits to enable combinations of trains to pass through the junction, e.g. all left turns at the same time, for a while. Buffers that threaten to overflow should be allowed to drain first or most often but also no train should be held back forever. For advanced circuit use: Try to control the signals leaving the buffer zones to interleave the trains. Give them enough tracks to get up to speed so they race across the actual junction. Start the next set of trains so that it arives at the junction as it clears.

I've been thinking about making something like that with a lot of buffer and circuits esssentially being traffic lights for some time now, but I haven't gotten around to it yet. Maybe this weekend.

[ERJHolton]

When it comes to roundabouts, at least, circuits would be needed to force respect for the offside priority rule (ie, traffic within the roundabout has priority over traffic waiting to enter it). If I get time this evening I might test a simple roundabout with quadrants of a full train length that has signalling for such implemented, and see how it behaves.

Edit: Done. It's a bit bigger than I said above, but it flows quite well. If it can deadlock with fewer than 12 trains in the circle I'd be surprised, and that's a scenario that seems unlikely at best.

String below, plus a picture, and a close-up of the combinator setup.

Offside priority roundabout v1r4, RHD

Code: Select all

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

Overview picture

Combinator setup

The rail at the bottom is part of the roundabout, while the rail coming in from the top is one of the entrance legs.The rail signal on the right is read and the signals input into the right-hand arithmetic combinator. It adds the red and yellow signals together and outputs that as cyan. The other combinator adds together the value of the cyan signal and the value of the red signal from the rail signal at the exit of the junction, and outputs the result on the pink signal. Finally, the rail signal that controls the top rail's access to the junction is set to be closed if the pink signal is greater than zero.

The upshot is that if a train on the roundabout is either within three wagon lengths of the junction or is moving fast enough that it reserves the block, it stops trains from entering the roundabout. Even if it is clear for a train to enter, it won't unless it can move through the junction. This setup is replicated at all four entrance junctions.

[mrvn]

The rail at the bottom is part of the roundabout, while the rail coming in from the top is one of the entrance legs.The rail signal on the right is read and the signals input into the right-hand arithmetic combinator. It adds the red and yellow signals together and outputs that as cyan. The other combinator adds together the value of the cyan signal and the value of the red signal from the rail signal at the exit of the junction, and outputs the result on the pink signal. Finally, the rail signal that controls the top rail's access to the junction is set to be closed if the pink signal is greater than zero.

The upshot is that if a train on the roundabout is either within three wagon lengths of the junction or is moving fast enough that it reserves the block, it stops trains from entering the roundabout. Even if it is clear for a train to enter, it won't unless it can move through the junction. This setup is replicated at all four entrance junctions.

I would like to take this a step further. Move the buffers further away from the roundabout so they can accelerate before entering it and then time the signals in such a way that the entering train will slot right between trains already on the roundabout. Same on the output side. There should be enough tracks for the train to slow down if the output is congested. Trains should also only be allowed to enter when their destinations output buffer has space for them. The idea would be that trains inside the roundabout are always at (near) full speed.

[ERJHolton]

I like the idea, but there are some challenges to implementation. Firstly, you want trains moving swiftly through junctions, but not so fast they speed-reserve blocks too far ahead. Secondly, if a train's path has multiple branches, it becomes problematic to detect their overall path through the junction. Finally, if you have different train types on your network (eg bulk trains are 2-4, with some 1-2 legacy/small volume item trains, and 1-1 fluid wagon trains; perhaps some trains are fuelled with coal rather than solid fuel or rocket fuel), you'll have trains with different acceleration rates.

There is a mod with a potential answer to the first challenge, called Train Speed Limit. The second challenge is one I currently do not have the know-how to solve, and the third would have to be solved by completely standardizing on one train type (including having to barrel / unbarrel fluids rather than using the heavier fluid wagons).

[Jap2.0]

Sorry everyone. I tried to make an intersection using the traffic light principle and combinators, but I've never been much good at them, so I don't really have anything to show for it. Someone else feel free to try - I still think it would be a really cool intersection, if it was done by someone more adept at circuits than me.

[hansjoachim]

Jap2.0 i am working on one. And it works pretty well, but I have to fix a couple things before posting it. You can se an earlier version from me if you want.
There is a save file attached to that older post
viewtopic.php?f=194&t=46855&start=240

[mrvn]

I like the idea, but there are some challenges to implementation. Firstly, you want trains moving swiftly through junctions, but not so fast they speed-reserve blocks too far ahead. Secondly, if a train's path has multiple branches, it becomes problematic to detect their overall path through the junction. Finally, if you have different train types on your network (eg bulk trains are 2-4, with some 1-2 legacy/small volume item trains, and 1-1 fluid wagon trains; perhaps some trains are fuelled with coal rather than solid fuel or rocket fuel), you'll have trains with different acceleration rates.

There is a mod with a potential answer to the first challenge, called Train Speed Limit. The second challenge is one I currently do not have the know-how to solve, and the third would have to be solved by completely standardizing on one train type (including having to barrel / unbarrel fluids rather than using the heavier fluid wagons).

I think you do want the trains at full speed for maximum throughput. Make the junction large enough that their reservation stays inside it. I'm talking humongous.

I don't get your comment about multiple branches. In my suggestion each input would split right at the start into as many branches as there are outputs. Then you have buffer area for each. So the trains path gets decided before it enters the input buffer.

Your comment about different speeds is a problem. I have no problem standardizing on one kind of fuel and one type of train length. But fluid wagons are just so damn useful. I wouldn't want to do without them. On the other hand, at least in vanilla, you probably won't have many liquid trains. So maybe they can just be ignored.

[Tallinu]

I don't get your comment about multiple branches. In my suggestion each input would split right at the start into as many branches as there are outputs. Then you have buffer area for each. So the trains path gets decided before it enters the input buffer.

This is exactly what's done in most of the really high throughput junction designs. That concept was present even my old "Cross" design from before I had access to these great testing tools, and by now it's been pretty well refined, although there's certainly room for more innovation!

I'm not sure how well that idea would work in regards to a roundabout though, considering that they tend to put all traffic on the same circular path regardless of which exit a train is heading for. Having multiple paths onto the roundabout per entrance would be functionally equivalent to a stacker, as in an input buffer with multiple parking slots side by side, and all trains waiting at that entrance would be trying to use, or at least start out using, the same path through the roundabout. There's no way to know which train is heading for which exit unless there's a one to one correspondence between input buffers and accessible output buffers, and if all of a given set of input buffers merge onto the same roundabout track, then that's not the case. I don't think it's possible to make something for which that's true and which also qualifies as a roundabout (and not just something that resembles a roundabout visually, but can't actually be traversed in a full circle).

On the other hand, the idea of having a really huge roundabout with circuitry to help a train merge into the gaps might work, although detecting a gap large enough for an entire train and its track reservation to fit in might be difficult, and I can tell you from experience that it's also difficult to get trains to travel at a consistent speed and reliably do what you want them to do, even with some serious circuitry. But if you want to, you're welcome to have a look at the merge managers on a few of the MultiCross blueprints I posted recently for some circuitry that you might be able to modify to always prioritize one lane (the main roundabout path) over another (the entrance), or at least for an example idea of how I handled some of that detection and lane control.

[ERJHolton]

I've been messing around a bit with the offside priority roundabout I posted earlier, trying to work out ways to where when train A exits a roundabout, train B can enter the roundabout without forcing train C to stop at the chain signal. Ideally, train C would be forced to slow down for just long enough for train B to clear the merge. The mod I linked to earlier, Train Speed Limits, would probably be the easiest way to set the speeds, but I expect some creative flashing of red signals ahead of train C would do something similar.