gunicorn_thrift | Thrift app and worker for gunicorn | Performance Testing library

1 FP operation per core clock cycle would be pathetic for a modern superscalar CPU. Your Skylake-derived CPU can actually do 2x 4-wide SIMD double-precision FMA operations per core per clock, and each FMA counts as two FLOPs, so theoretical max = 16 double-precision FLOPs per core clock, so 24 * 16 = 384 GFLOP/S. (Using vectors of 4 doubles, i.e. 256-bit wide AVX). See FLOPS per cycle for sandy-bridge and haswell SSE2/AVX/AVX2

There is a a function call inside the timed region, callq 403c0b <_Z12do_timed_runRKmRd+0x1eb> (as well as the __kmpc_end_serialized_parallel stuff).

There's no symbol associated with that call target, so I guess you didn't compile with debug info enabled. (That's separate from optimization level, e.g. gcc -g -O3 -march=native -fopenmp should run the same asm, just have more debug metadata.) Even a function invented by OpenMP should have a symbol name associated at some point.

As far as benchmark validity, a good litmus test is whether it scales reasonably with problem size. Unless you exceed L3 cache size or not with a smaller or larger problem, the time should change in some reasonable way. If not, then you'd worry about it optimizing away, or clock speed warm-up effects (Idiomatic way of performance evaluation? for that and more, like page-faults.)

1. Why are there non-conditional jumps in code (at 403ad3, 403b53, 403d78 and 403d8f)?

Once you're already in an if block, you unconditionally know the else block should not run, so you jmp over it instead of jcc (even if FLAGS were still set so you didn't have to test the condition again). Or you put one or the other block out-of-line (like at the end of the function, or before the entry point) and jcc to it, then it jmps back to after the other side. That allows the fast path to be contiguous with no taken branches.

1. Why are there 3 retq instances in the same function with only one return path (at 403c0a, 403ca4 and 403d26)?

Duplicate ret comes from "tail duplication" optimization, where multiple paths of execution that all return can just get their own ret instead of jumping to a ret. (And copies of any cleanup necessary, like restoring regs and stack pointer.)

1. Virtual user which is "idle" (doing nothing) has minimal resources footprint (mainly thread stack size) so I don't think you will need to have more machines

2. Well-behaved load test must represent real life usage of the application with 100% accuracy, if you're testing a website each JMeter thread (virtual user) must mimic a real user using a real browser with all related features like

   • handling embedded resources (image, scripts, styles, fonts, sounds, etc.)
   • using caching properly
   • getting and sending back cookies
   • sending appropriate headers
   • processing AJAX requests like browser does

   the most straightforward example of the difference between 400 users without think times and 4000 users with think times will be that 4000 users will open 4000 connections and keep them open and 400 users will open only 400 connections.

It is possible to:

1. Download the playlist using HTTP Request sampler and Save Responses to a file listener so it would be saved to your local drive. See Performance Testing: Upload and Download Scenarios with Apache JMeter article for more comprehensive instructions if needed

2. Amend the playlist as needed using JSR223 Sampler or OS Process Sampler

3. In the bzm - Streaming Sampler use local URL via file URI scheme i.e.

By the way, I have to wait first post issue before the second post issue should be run...I know there is no await operator in k6

K6 currently has only blocking calls so each post will finish fully before the next one starts.

On the loop question you have two(three) problems:

• createdISCompleted is unitialized, so the while loop will never be run as it's not false.
• you have big S in the declaration but then you have small s in the while loop.
• you have break at the end of the loop which means it will always exit after the first iteration.

Here is my attempt at measuring fork-join overhead:

Just add JSON JMESPath Extractor as a child of the request which returns the above response and configure it like:

• Names of created variables: anything meaningful, i.e. clientTransactionId
• JMESPath Expressions: clientTransactionId
• Match No: 1

Once done you will be able to refer extracted value as ${clientTransactionId} JMeter Variable where required

applicationTransactionId can be handled in exactly the same manner

More information:

• The JMeter JSON JMESPath Extractor and Assertion: A Guide
• JMESPath Tutorial

From the workload point of view the approach is exactly the same, my understanding is:

• Stress test is about finding the first bottleneck, it's normally applied before deployment or even at early stages of development (see shift-left concept)
• Breakpoint (sometimes also called Capacity) test is about checking how much load the overall integrated environment can handle without issues and what is the slowest component which is a subject for scaling up/optimization.

More information:

• Software Performance Testing Types
• Performance Testing vs. Load Testing vs. Stress Testing
• What Is Performance Testing: Reviewing Load, Stress, & Capacity Testing

LONGTEXT columns are stored separately from the rest of the columns. Extra disk fetches are used to load the value.

When you separated the LONGTEXT columns out, did you then fetch the value? And that was slow, anyway?

Do you have INDEX(shop_id)?

Did Laravel do something dumb like preload the entire table?

What will you do with the PDF? If you will only be writing them to a web page, it would be more efficient in multiple ways to store it as a file, then have HTML reference it. This would probably be done via .

It sounds like you are not executing the scenarios in parallel (as I would expect from k6 scenarios), but rather in sequence.

There isn't anything builtin in k6, but why not have a simple shell script which performs the following steps in order: