woken | orchestration platform for Docker containers running data | Machine Learning library

In order to be able to decrease the player's stats while he is playing you can use the while loop in a different thread/task.

Using threads with python is very simple:

First, you have to import threading:

It looks like it can.

Of course there is no documentation, it's not the Apple way to write a documentation.

But fortunatelly, we can check it with apple opensource xnu kernel: https://opensource.apple.com/source/xnu/xnu-7195.81.3/

I would say we are interesting in the file xnu-7195.50.7.100.1\osfmk\kern\clock.c There is a trap that implements mach_wait_until with such call:

Mobile operating systems such as Android and iOS have a different scheduling strategies for background processes compared to traditional *nix operating systems. The mobile OS tends to starve the background processes in order to preserve the battery time. This is know as background process optimization and will be applied to the processes/threads of the application the moment application enters in background.

As of Android 7, the background processes are no longer informed about the network events with the CONNECTIVITY_ACTION broadcasts unless they register in the manifest that they want to receive the events.

Although the lobcurl is used in android native code, the threads created from the native library will be subject of the entitlements that the application declared in the manifest (which need to be granted).

I know how frustrating a blocking issue can be so I can offer you a quick workaround to try until the problem is resolved.

curl_multi_poll() can receive a timeout that in your code is set to a very_large_number. In addition, the last parameter of the function call is a pointer to an integer numfds that will be populated with the number of file descriptors on which an event occurred while the curl_multi_pool() was pooling.

You can use this in your favor to construct a workaround in the following way:

1. Make the very_large_number a reasonably_small_number
2. replace the nullptr with &numfds
3. Surround the curl_multi_poll with a do ... while loop

So you will have something like this:

It is recommended you have general working idea of software systems before you proceed with Java concurrency. You will gain more insight on solving your problem once you understand how semaphores, mutex locks, etc work, concepts of deadlock conditions, avoidance & prevention, etc.

I recommend you read up to Chapter 6 of William Stalling's Operating Systems: Design & Principles.

You can use pthread_cond_wait() to wait for a signal from the main thread that the condition was met and the work can resume (ex. wait for the subscriptionChangeNeeded to change). This will remove the need to use sleep, however once the thread is suspended on this call, the only way to resume it is to call the pthread_cond_signal().

If your worker thread's loop has other tasks to do and you depend on periodical wake-ups, you can use the pthread_cond_timedwait() to wait for the subscriptionChangeNeeded to change; or for a timeout to be reached; whatever happens first.

The main thread will have a task to identify the change in the condition and once it has identified that there is need for the update, main thread will call pthread_cond_signal() to inform the writer thread that he needs to wakeup. If the signal is not received in the time specified as a timeout, the thread will resume (wake up), even if the condition was met, so this is similar to sleep

Regardless on which one occurs first (the time-out or the condition change), the thread will be resumed and he can perform the changeSubscription();.

You can check more details and examples here

This are POSIX functions defined in pthread.h

You should initialize all elements of the built-in array:

You are passing the same Context (and thus Waker) to the poll() method of the Future returned by new_inner_task, which passes it down the chain to the poll() of the Future returned by UnboundedReceiverStream::next(). The implementation of that arranges to call wake() on this Waker at the appropriate time (when new elements appear in the channel). When that is done, Tokio polls the top-level future associated with this Waker - the join!() of the three futures.

If you omitted the line that polls the inner task and just returned Poll::Pending instead, you would get the expected situation, where your Future would be polled once and then "hang" forever, as nothing would wake it again.

Not exactly "memory" bound, but bound on latency of store-forwarding. i9-9900K and i7-7700 have exactly the same microarchitecture for each core so that's not surprising :P https://en.wikichip.org/wiki/intel/microarchitectures/coffee_lake#Key_changes_from_Kaby_Lake. (Except possibly for improvement in hardware mitigation of Meltdown, and possibly fixing the loop buffer (LSD).)

Remember that when a perf event counter overflows and triggers a sample, the out-of-order superscalar CPU has to choose exactly one of the in-flight instructions to "blame" for this cycles event. Often this is the oldest un-retired instruction in the ROB, or the one after. Be very suspicious of cycles event samples over very small scales.

Perf never blames a load that was slow to produce a result, usually the instruction that was waiting for it. (In this case an xor or add). Here, sometimes the store consuming the result of that xor. These aren't cache-miss loads; store-forwarding latency is only about 3 to 5 cycles on Skylake (variable, and shorter if you don't try too soon: Loop with function call faster than an empty loop) so you do have loads completing at about 2 per 3 to 5 cycles.

You have two dependency chains through memory

• The longest one involving two RMWs of b. This is twice as long and will be the overall bottleneck for the loop.
• The other involving one RMW of a (with an extra read each iteration which can happen in parallel with the read that's part of the next a ^= i;).

The dep chain for i only involves registers and can run far ahead of the others; it's no surprise that add $0x1,%rax has no counts. Its execution cost is totally hidden in the shadow of waiting for loads.

I'm a bit surprised there are significant counts for mov %edx,a. Perhaps it sometimes has to wait for the older store uops involving b to run on the CPUs single store-data port. (Uops are dispatched to ports according to oldest-ready first. How are x86 uops scheduled, exactly?)

Uops can't retire until all previous uops have executed, so it could just be getting some skew from the store at the bottom of the loop. Uops retire in groups of 4, so if the mov %edx,b does retire, the already-executed cmp/jcc, the mov load of a, and the xor %eax,%edx can retire with it. Those are not part of the dep chain that waits for b, so they're always going to be sitting in the ROB waiting to retire whenever the b store is ready to retire. (This is guesswork about how mov %edx,a could be getting counts, despite not being part of a real bottleneck.)

The store-address uops should all run far ahead of the loop because they don't have to wait for previous iterations: RIP-relative addressing¹ is ready right away. And they can run on port 7, or compete with loads for ports 2 or 3. Same for the loads: they can execute right away and detect what store they're waiting for, with the load buffer monitoring it and ready to report when the data becomes ready after the store-data uop does eventually run.

Presumably the front-end will eventually bottleneck on allocating load buffer entries, and that's what will limit how many uops can be in the back-end, not ROB or RS size.

Footnote 1: Your annotated output only shows a not a(%rip) so that's odd; doesn't matter if somehow you did get it to use 32-bit absolute, or if it's just a disassembly quirk failing to show RIP-relative.

This line is wrong: