sal | 🚀 Performance focused , lightweight scroll animation | Animation library

It's because the lats and lons are vectors with different size...

I usually do this if using WGS84 or degrees as unit:

You need a main dict to group by the Name, then update the value to merge all dict, finally keep only the values of it (the merged dict)

You can try to use two queries with UNION ALL one is for name which value is null, another one writes MIN aggregate function by name with name isn't NULL.

Query #1

A subquery should do the job:

Use a RANGE window in the analytic function:

Yes, you are right, it has to do with order.

In the first case, Calc tries to take records that meet the condition

grade = 1 or (grade=2 and sal >= 10000 and sal<=20000)

(All records for grade = 1 and additionally records for grade = 2 with sal between 10000 and 20000)

And in the second case, this condition

sal >= 10000 and sal<=20000 and (grade = 1 or grade=2)

That is exactly what you wanted to get.

You can read more details, for example, in Wikipedia

Try this:

Try this:

You can see the cost of instructions on most mainstream architecture here and there. Based on that and assuming you use for example an Intel Skylake processor, you can see that one 32-bit imul instruction can be computed per cycle but with a latency of 3 cycles. In the optimized code, 2 lea instructions (which are very cheap) can be executed per cycle with a 1 cycle latency. The same thing apply for the sal instruction (2 per cycle and 1 cycle of latency).

This means that the optimized version can be executed with only 2 cycle of latency while the first one takes 3 cycle of latency (not taking into account load/store instructions that are the same). Moreover, the second version can be better pipelined since the two instructions can be executed for two different input data in parallel thanks to a superscalar out-of-order execution. Note that two loads can be executed in parallel too although only one store can be executed in parallel per cycle. This means that the execution is bounded by the throughput of store instructions. Overall, only 1 value can only computed per cycle. AFAIK, recent Intel Icelake processors can do two stores in parallel like new AMD Ryzen processors. The second one is expected to be as fast or possibly faster on the chosen use-case (Intel Skylake processors). It should be significantly faster on very recent x86-64 processors.

Note that the lea instruction is very fast because the multiply-add is done on a dedicated CPU unit (hard-wired shifters) and it only supports some specific constant for the multiplication (supported factors are 1, 2, 4 and 8, which mean that lea can be used to multiply an integer by the constants 2, 3, 4, 5, 8 and 9). This is why lea is faster than imul/mul.

I can reproduce the slower execution with -O2 using GCC 11.2 (on Linux with a i5-9600KF processor).

The main source of source of slowdown comes from the higher number of micro-operations (uops) to be executed in the -O2 version certainly combined with the saturation of some execution ports certainly due to a bad micro-operation scheduling.

Here is the assembly of the loop with -Os: