LATCH | Fastest CPU implementation of the LATCH | GPU library

You can achieve this a few different ways e.g. subquery, cte etc. Here is a cte example:

Nevermind, I think I've figured out what you're trying to do based on the comments in your edit. You can set the scrollLeft property programmatically to keep the cursor right-aligned:

Why int temp = count; wait(100); count = temp + 1; is not thread-safe? One possible flow:

• First thread reads count (0), save it in temp for later, and waits, allowing second thread to run (lock released);
  
• second thread reads count (also 0), saved in temp, and waits, eventually allowing first thread to continue;
  
• first thread increments value from temp and saves in count (1);
  
• but second thread still holds the old value of count (0) in temp - eventually it will run and store temp+1 (1) into count, not incrementing its new value.

^{very simplified, just considering 2 threads}

In short: wait() releases the lock allowing other (synchronized) method to run.

As has been stated in the comments, you don't assign a value to all your output signals from the Case statement for each case. As the extract from the language standard can use language that is bit technical and opaque, I will try to write an explanation that is beginner friendly.

You case statement has seven outputs, Z(0..2) and Znot(0..3). Your process is of a type known as combinatorial (i.e. it is not clocked). The standard description of this structure would be to assign all outputs, for all cases. If you look at your first evaluation (when = "000") you can see that you are only assigning values to Z. This implies that you want Znot to retain its previous value, which implies a memory element. A non-clocked memory element is called a Latch.

The reason you get a warning is that Latches violate synchronous design practices. FPGAs are designed to work synchronously. The tools know this, and since in 99% of cases a latch is unintended, will raise a warning. The reason they don't raise an error is that there are some corner cases where a latch is intended, but this is for expert use only.

The correct way to imply a memory element is to use a register. In this case, to imply this would be to drive your process with a clock. If that is not desirable then explicitly state the desired value for every output in every case.

The OP said that my comment concerning security manager helped him find the root cause, so I am converting it into an answer:

As is documented, System.exit() will not shut down the JVM if there is a security manager stopping it from doing so. In that case you should see a SecurityException, though.

A discussion in Gradle issue #11195 mentions a problem that Kafka sporadically exits unexpectedly and suggests a security manager policy for Spring-Kafka stopping it from doing so. This was committed to Spring-Kafka, but - if I understand correctly - not to Gradle.

Another edge case is shutdown hooks: The thread invoking System.exit() blocks until the JVM terminates. If a shutdown hook submits a task to this thread, it leads to a deadlock.

So I got the blue light to go off. Instead of pinMode(D4,INPUT); and digitalWrite(D4,LOW); D4 is pin 16 which is the wake pin. So I had to define it thus #define LED3 16 and then pinMode(LED3,INPUT); and digitalWrite(LED3,LOW); I will change my original code to reflect these changes.

I'm not sure I can say anything specific about your timings, since it's still not clear how did you measure/calculate the numbers exactly, but you are right, "multithreading does not give a linear speedup to the number of threads...1/n" in most of the cases. Why?

I'm sure you have heard about Amdahl's law (https://en.wikipedia.org/wiki/Amdahl%27s_law). You can achieve "1/n" only if you don't have any sequential part of the program, a portion of the program that cannot be parallelized. But even if your own code/business logic/algorithm (or its portion to be parallelized) doesn't have such part, there are the underlying software and hardware layers that execute your code and these layers can introduce some sequential parts because of contention on some resources. For example, you can pass only one Ethernet packet at a time over a single-mode fiber or over a single twisted pair; your HDD can write data in only one position of its magnetic heads at a time; you have sequential access to the main memory because of the front-side bus and the memory bus; L2/L3 cache invalidation takes additional work to be done to be synchronized; a translation lookaside buffer (TLB) miss leads to walking to the main memory (see above about the front-side bus and the memory bus); to allocate a new object in JVM in the heap (when Thread-local allocation buffers (TLABs) is full) some internal synchronization required; you can get stop-the-world pauses on GC while compaction, which looks like a sequential portion of your code; classloading and JIT's activity add their sequential-like parts to the application; a 3rd party library may have some synchronization on a static value; etc., etc.

So, you can see "1/n" only in very very simple cases when not your application code, nor the underlying levels have any shared resources used. Here is an example

We've finally understood the mechanism that leads to the issue.

A -> Traefik -> B

1. B returns a list of objects with a ZonedDateTime field ("validFrom":"2021-12-24 23:59:57+01:00") and the header Transfer-Encoding: chunked.
2. Traefik replaces the Transfer-Encoding: chunked with a Content-Length, computed from the body of the request.
3. A receives the response, deserializes the objects, then reserializes them but in the UTC timezone ("validFrom":"2021-12-24 22:59:57Z"), but it reuses the Content-Length from Traefik without recalculating it.

As a consequence, the body from is shorter than the announced Content-Length (each ZonedDateTime takes five bytes less when A sends it than when Traefik computes the content length).

The client however has been announced a Content-Length and is waiting for the missing bytes.

The solution we have in mind right now is to tell Feign and its calling controller that it returns a ResponseEntity instead of a ResponseEntity>.

Pros:

• B's response is returned as-is, so no more problem due to a varying content length.
• A does not spend CPU-time deserializing then immediately reserializing the response.

Cons:

• The OpenApi doc of A won't show the type of return (unless the Open API annotation allow to specify the return model). That's what I'll test later today.

It appears from the example from here that get_stop_token is actually not meant to be used by the client code. It is called behind the scenes by the std::jthread and passed to the function called by std::jthread. It appears it is the way it's got to be done