ghz | Simple gRPC benchmarking and load testing tool | Testing library

There's quite a bit I don't understand in your code. So instead I'll just give you code that works ;-)

• I'm baffled by how your code can run at all. A .gz file is compressed binary data (gzip compression). You should need to open it with Python's gzip.open(). As is, I expect it to die with an encoding exception, as it does when I try it.

• temp[2] is not an integer. It's a string. You're not adding integers here, you're catenating strings with +. int() needs to be applied first.

• I don't believe I've ever seen asyncio mixed with concurrent.futures before. There's no need for it. asyncio is aimed at fine-grained pseudo-concurrency in a single thread; concurrent.futures is aimed at coarse-grained genuine concurrency across processes. You want the latter here. The code is easier, simpler, and faster without asyncio.

• While concurrent.futures is fine, I'm old enough that I invested a whole lot into learning the older multiprocessing first, and so I'm using that here.

• These ngram files are big enough that I'm "chunking" the reads regardless of whether running the serial or parallel version.

• collections.Counter is much better suited to your task than a plain dict.

• While I'm on a faster machine than you, some of the changes alluded to above have a lot do with my faster times.

• I do get a speedup using 3 worker processes, but, really, all 3 were hardly ever being utilized. There's very little computation being done per line of input, and I expect that it's more memory-bound than CPU-bound. All the processes are fighting for cache space too, and cache misses are expensive. An "ideal" candidate for coarse-grained parallelism does a whole lot of computation per byte that needs to be transferred between processes, and not need much inter-process communication at all. Neither are true of this problem.

To enforce operation on a single core, you can use the following options

--extra-config=kubeadm.ignore-preflight-errors=NumCPU --force --cpus=1

Please note that docker and minikube were designed to run on at least two cores. If available, please consider enabling hyperthreading.

Thank you to @Slaw for providing a solution to my problem. To solve my issue, I created a deletionQueue ArrayList which would hold the paths to the files I would like to delete. Once .dispose() is used on the MediaPlayer, after a certain amount of time has passed, those files would be automatically deleted.

I have run a single thread matrix multiplication

But then you counted system-wide across all 4 cores for the time when it was running. That's what perf -a does, and why you got Performance counter stats for 'system wide': in your ouput.

So the kernel's task-clock "event" was counting time across all 4 cores whenever your process was active:

68,701.90 msec task-clock # 4.000 CPUs utilized

That's 68.7 CPU-seconds, almost exactly 4x 17.17 s, which makes sense.

I also don't know why 0.462 GHz is written in front of cpu-cycles.

That's the average cycles/time across all 4 cores during the time your code was active. The clock doesn't tick for CPUs that are asleep, so it seems the load average was 4 * 462/800 = 2.31 CPUs not asleep during the time your code was keeping 1 core busy.

So you were benchmarking while your system was running another 1.3 threads on average. (Including CPU time waking up for interrupts)

I'm assuming your measurements were not limited to user-space-only (excluding ticks spent in kernel mode); that's another possible effect.

If you hadn't used -a, a lower frequency than the HW was running at can still happen if you count only user-space cycles, not cycles spent in the kernel. (e.g. perf stat --all-user, or with your kernel.perf_event_paranoid setting high enough to not let you profile HW events in the kernel which effectively applies :u to HW events but without printing them as cycles:u.)

If you change your kernel.perf_event_paranoid sysctl setting to 0, or run perf as root, you should see exactly 800 MHz as cycles / task-clock, since that's the speed the CPU was running when your threads were running.

Spending a lot of cycles not in user-space would indicate that your code is spending a lot of time in the kernel, probably handling page faults if you're using a big array.

Compare your two loops from the original and improved versions.

Original:

I could not reproduce your issue.

Your issue is environmental, exactly what it is I could not say.

I advise creating a new project in idea and following the same steps I did and it should work as long as you have the file path correct.

These are the steps I followed to get allow the media to play with your sample app:

1. Created a new JavaFX project in Idea with OpenJDK 17.0.2 and JavaFX 17.0.2 on Windows 11.

2. Copy-and-pasted your JavaFX sample code into the new project.

3. Followed the instructions to add media handling to the project:

   • Can not work with MediaPlayer class, javafx.media is not found

4. Downloaded your mp3 and wav files.

5. Set the file path to each in turn.

6. Ran the app and hit the play button for each file.

Both the MP3 and WAV files played without problem.

Your lie in april is nice, I will try to learn it.

A frequency 1 MHz higher than the maximum frequency of the CPU indicates the Intel(R) Turbo Boost(TM) feature.

xlwings declares appscript as a dependency but it doesn't limit version; appscript doesn't properly declare Python version compatibility (xlwings does it properly) so pip is trying to install the latest version which is not compatible with Python 2.7. Try to limit versions this way:

Assuming that you are using an Intel® AVX-512 instruction-supported processor, try installing the Intel® Optimization for TensorFlow Wheel via PIP specifically build for AVX512. These packages are available as *.whl on the Intel® website for specific Python versions or can be installed using the following command for Python versions 3.7, 3.8, and 3.9 (Linux Only).