context-switch | Comparison of Rust async and Linux thread context switch time | Reactive Programming library

Basic profilers like gperf or gprof don't work well with MPI programs, but there are many profiling tools specifically designed to work with MPI that collect and report data for each MPI rank. Virtually all of them can collect hardware performance counters for cache misses. Here are a few options:

• HPCToolkit for sampling-based profiling. Works on unmodified binaries.
• TAU and Score-P provide instrumentation-based profiling. Usually requires recompiling.
• TiMemory and Caliper let you mark code regions to measure. TiMemory also has scripts for roofline analysis etc.

Decent HPC centers typically have one or more of them installed. Refer to the manuals to learn how to gather hardware counters.

this is not a good example. the multi and single threaded solutions run simultaneously and on the same counter. so practically you run one multi threaded process with four threads. you need to run one solution until thread is complete and shutdown, then the other. the easiest solution would be to run the single threaded process as a simple loop in the main method and run the multi threaded solution after the loop completes. also, i would have two separate counters, or, you can assign zero to counter after single thread loop completes

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 happens because time is counted per-CPU, as indicated by the 3.430 CPUs utilized. It has, on average, occupied 3.43 CPUs during that time. You can check that dividing 16380/3.43 gives you about the elapsed time.

Yes, you are right. There are three threads that are being executed and it is up to the scheduler of your operating system to schedule the threads and perform context switching. Hence, you may not get the same output each time you run this code

Uncommon traps and deoptimization are HotSpot implementation details. You won't find them in a standard interface like JVM TI (which is designed for a generic virtual machine, not just HotSpot).

As suggested in my previous answer, one possible way to diagnose deoptimization is to add -XX:+UnlockDiagnosticVMOptions -XX:+LogCompilation options and to look for in the compilation log.

Another approach is to trace deoptimization events with async-profiler.
To do so, use -e Deoptimization::uncommon_trap_inner.
This will show you the places in Java code where deoptimization happens, and also timestamps, if using jfr output format.

Since JDK 14, deoptimization events are also reported natively by Flight Recorder (JDK-8216041). Using Event Browser in JMC, you may find all uncommon traps, including method name, bytecode index, deoptimization reason, etc.

The overhead of all the above approaches is small enough. There is usually no problem in using async-profiler in production; JFR is also fine, if the recording settings are not superfluous.

However, there is no much use in profiling deoptimizations, except for very special cases. This is absolutely normal for a typical Java application to recompile methods multiple times, as long as the JVM learns more about the application in runtime. It may sound weird, but uncommon traps is a common technique of the speculative optimization :) As you can see on the above pictures, even basic methods like HashMap.put may cause deoptimization, and this is fine.

The combination of perf record -s and perf report -T should give you the information you need.

To demonstrate, take the following example code using threads with well-defined instruction counts:

"context," in a nutshell, is the collection of values that need to be loaded into the Program Counter register, the Stack Pointer register, and other registers of a CPU in order to make it start or resume execution of a thread.

"Scheduler" is the part of the operating system that decides which thread(s) should run on which CPUs and when.

"context switch" is what we call it when the scheduler saves the context of one thread, and installs the context of some other thread on the same CPU, and lets it run.

"Preemption" is what we call it when the OS switches out some thread for some reason that is not a reaction to something that the thread just did.

"time slice" is the period of time that the scheduler grants to each newly (re)started thread before the scheduler will preempt it in order to let some other waiting thread run.

Finally, (I'm guessing) When you read, "Interference," that probably referred to anything that one thread does which, because of some defect in the program, interferes with the function of some other thread. (E.g., by changing the value of some shared variable, at a time when the other thread was depending on the variable to not change.)

I believe I'm getting the hang of this now. The answer is affirmative:

One can access all of the console functionality (including the cd command, buttons / menus, etc.) through Selenium.

What ultimately got me unstuck was the first comment on this other related question I posted. I will describe two possible ways to go about this in Firefox, matching the two ways one can access a (possibly cross-origin) iframe when working directly with the browser:

• through the console cd command or
• through the drop-down frame-context-switching menu

A script: