flow-control | Examples of flow control | Code Inspection library

Yes it can and there are a couple of ways to do it:

A. Set the NON_PERSISTENT message delivery flag on your MessageProducer or directly on the send operation:

Meaning if my window size is n bytes, the stream won't send any data until it's accumulated at least n bytes?

No. The sender can send any number of bytes less than or equal to n.

More generally, how do I maximize the performance of my stream if I maintain only one stream?

For just one stream, just use the max possible value, 2^31-1.
Furthermore, you want to configure the receiver to send WINDOW_UPDATE frames soon enough, so that the sender always has a large enough flow control window that allows it to never stop sending.

One important thing to note is that the configuration of the max flow control window is related to the memory capacity of the receiver.

Since HTTP/2 is multiplexed, the implementation must continue to read data until the flow control window is exhausted.
Using the max flow control window, 2 GiB, means that the receiver needs to be prepared to buffer at least up to 2 GiB of data, until the application decides to consume that data.

In other words: reading the data from the network by the implementation, and consuming that data by the application may happen at different speeds; if reading is faster than consuming, the implementation must read the data and accumulate it aside until the application can consume it.

When the application consumes the data, it tells the implementation how many bytes were consumed, and the implementation may send a WINDOW_UPDATE frame to the sender, to enlarge the flow control window again, so the sender can continue to send.

Note that implementations really want to apply backpressure, i.e. wait for applications to consume the data before sending WINDOW_UPDATEs back to the sender.
If the implementation (wrongly) acknowledges consumption of data before passing it to the application, then it is open to memory blow-up, as the sender will continue to send, but the receiver is forced to accumulate it aside until the host memory of the receiver is exhausted (assuming the application is slower to consume data than the implementation to read data from the network).

Given the above, a single connection, for the max flow control window, may require up to 2 GiB of memory. Imagine 1024 connections (not that many for a server), and you need 2 TiB of memory.

Also consider that for such large flow control windows, you may hit TCP congestion (head of line blocking) before the flow control window is exhausted.
If this happens, you are basically back to the TCP connection capacity, meaning that HTTP/2 flow control limits never trigger because the TCP limits trigger before (or you are otherwise limited by bandwidth, etc.).

Another consideration to make is that you want to avoid that the sender exhausts the flow control window and therefore is forced to stall and stop sending.

For a flow control window of 1 MiB, you don't want to receive 1 MiB of data, consume it and then send back a WINDOW_UPDATE of 1 MiB, because otherwise the client will send 1 MiB, stall, receive the WINDOW_UPDATE, send another 1 MiB, stall again, etc. (see also how to use Multiplexing http2 feature when uploading).

Historically, small flow control windows (as the one suggested in the specification of 64 KiB) were causing super-slow downloads in browsers, that quickly realized that they needed to tell servers that their flow control window was large enough so that the server would not stall the downloads. Currently, Firefox and Chrome set it at 16 MiB.

You want to feed the sender with WINDOW_UPDATEs so it never stalls.

This is a combination of how fast the application consumes the received data, how much you want to "accumulate" the number of consumed bytes before sending the WINDOW_UPDATE (to avoid sending WINDOW_UPDATE too frequently), and how long it takes for the WINDOW_UPDATE to go from receiver to sender.

You could do the selecting of the correct group/row with adding the .mat-tab-group class to your selector and combine it with a :nth-child, :first-child, etc. It depends on which group/row you want to select. Here are two examples:

This will only adjust the styling of the first group:

I think you most likely will have to go with the below installation option :

• with your standalone Prometheus (not using Prometheus Operator)

Can you check and paste the output of kubectl get prometheus. If you see any running prometheus, you can run kubectl describe prometheus $prometheus_resource_name and check the labels to verify if it is deployed by the operator or it is a standalone prometheus.

In case it is deployed by Prometheus operator, you can use either of these approaches:

• side by side with your existing Prometheus Operator
• update your existing Prometheus Operator

I've just tried this approach locally using spring-geode-starter:1.3.0.RELEASE and it seems to be working just fine:

Hey, I had the same issue this morning but found a fix.

1) Keep the analysis_options.yaml in your root folder with this code:

Workflows start in the Pending state and then are moved through their steps by the workflow-controller pod (which is installed in the cluster as part of Argo).

The workflow-controller pod is stuck in ContainerCreating. kc describe po {workflow-controller pod} reveals a Calico-related network error.

As mentioned in the comments, it looks like a common Calico error. Once you clear that up, your hello-world workflow should execute just fine.

Note from OP: Further debugging confirms the Calico problem (Calico nodes are not in the running state):

Yes, there is a 'simpler' / shorter / more terse syntax to returning an empty result set in SQL Server that does not require first creating a derived table.

Not an expert in Rx, but let me take a stab at it.. observeOn(...) has its own default buffer size of 128. So, right from the start it's going to request more from upstream than your buffer can hold.

observeOn(...) accepts an optional buffer size override, but even if you supply it, the ParallelFlowable is going to be invoking your flatMap(...) method more frequently than you want. I'm not 100% sure why, maybe it has its own internal buffering it performs when merging the rails back to sequential.

I think you can get closer to your desired behavior by using flatMap(...) instead of parralel(...), supplying a maxConcurrency argument.

One other thing to keep in mind is that you don't want to call subscribeOn(...) - it's meant to affect the upstream Flowable in its entirety. So if you're already calling parallel(...).runOn(...), it has no effect or the effect will be unexpected.

Armed with the above, I think this gets you closer to what you're looking for: