[anamax]

> In telco networks, once a message is accepted into a system, it is expected to be processed. You should throw away any messages you can't handle (because of overload) at the edge of the system.

That's attractive in general, but is it necessarily possible?

Assume a planar grid with O(N2) nodes of which O(N) edge nodes that can accept a message for a given node somewhere near the center. In other words, that "given node" is O(N) steps away from any edge node.

Suppose that said given node has limited capacity. How can it keep those edge nodes aware of its capacity without wasting capacity or requiring O(N2) queuing at said given node? Remember - it takes O(N) time to get a message from the given node to any edge node and during that time and there are O(N2) places for a message to be in the network at any moment in time.

Now repeat for the other O(N2) interior nodes.

[cmullaparthi]

Yes, it is possible. You have to ensure that every edge node is configured in such a way that it allows only a certain amount of traffic to a "inner" node. And if it finds that the inner node isn't as responsive as it should be, it has to scale back how much traffic it will accept.

For real time traffic, where queuing doesn't make sense, there isn't anything else you can do really.

[anamax]

> You have to ensure that every edge node is configured in such a way that it allows only a certain amount of traffic to a "inner" node.

Let's assume that we have 5 edge nodes and that each is configured to send t traffic. The total amount of traffic that they can send is 5t. If the inner node can handle 5t, you won't need to drop traffic in the network. However, you're likely to drop traffic unnecessarily at an edge node.

Suppose that you have 4t worth of traffic continuously. Clearly the inner node can handle that.

However, consider what happens if all of the traffic during hour n tries to enter the network at edge node n.

For example, during hour 0, node 1-5 see no traffic and node 0 sees 4t worth of traffic. By configuration, node 0 drops 3t and sends t to the inner node. Since none of the other nodes are sending any traffic, the inner node only sees t worth of traffic even though it could handle 5t.

You can try to get around this problem by dynamically configuring the edge nodes, but since they're as much as N apart and they're responding to presented demand, that configuration is always stale.

You can guarantee that you don't overload the inner node, but only if you're willing to waste some of its capability in some circumstances.

[cmullaparthi]

Yes, I agree. There are a few ways around that:

- Some out of band signalling between the edge and the core to indicate current load levels at the core.

- Implement similar form of overload protection at the core. You might now say, "Aha! But you're throwing away messages you've accepted". The answer is no: the edge nodes are typically just relaying messages after some checks, application layer processing is typically done in the core.

This thread is becoming slightly hand-wavy but I hope you get the gist of what I'm saying :)

[anamax]

> Some out of band signalling between the edge and the core to indicate current load levels at the core.

In-band/out-of-band doesn't make any difference - the edge nodes can't communicate fast enough. Remember, they're O(N) from each other. (Yes, two neighbors are adjacent, but there are nodes on the other side of the grid.)

Long wires doesn't help either - distance always matters.

> You might now say, "Aha! But you're throwing away messages you've accepted". The answer is no

Actually the answer is "yes" - The original claim was "In telco networks, once a message is accepted into a system, it is expected to be processed. You should throw away any messages you can't handle (because of overload) at the edge of the system."

> I hope you get the gist of what I'm saying

I get the gist - the problem is that you must either waste capacity, drop in the interior, or both because of distance and the fact that there are more interior nodes than there are edge nodes. (And, you can't have all edge nodes because of distance and fan-in.)

One of the subtle ways to waste capacity is to run the control signals faster than the data signals.