xcp | Also contains | Infrastructure Automation library

The main problem is, you've multiple duplicate keys on your JSON i.e x (check it here) So when you try this

Using the very last example in the link you provide in your comment, something like the below - using xpath - should get you the admin info:

If nothing is found you get an empty array back. You have to do something like that:

I was able to figure out what I was doing wrong - posting it here so that it can help others.

I was allowing users to filter out items in the tree view using other controls in the form, and I had implemented it such a way that on a node, I generate the list of children of a node when the bound property was accessed.

This meant that I returned a new list of children each time the bound property was accessed, and the framework expects the list of children to be stable between immediate calls.

The solution was to cache the list of children of a node so that I only generate a new list when something actually changed.

First check perf counters for arith.divider_active being ~= core clock cycles.

98% of the function runtime can be explained by taking the number of square roots and the operation throughput.

Or that works too.

If that's the case, you're saturating the (not fully pipelined) divider throughput and there's not much left to gain from just exposing more ILP.

Algorithmic changes are your only real chance to gain anything, e.g avoid some sqrt operations or use single-precision.

Single-precision gives you 2x as much work per vector for free. But for sqrt-heavy workloads there's an additional gain: vsqrtps throughput per vector is usually better than vsqrtpd. That's the case on Skylake: one per 6 cycles vs. vsqrtpd at one per 9 to 12 cycles. That could move the bottleneck away from the sqrt/divide unit, perhaps to the front-end or the FMA unit.

vrsqrtps has been suggested in comments. That would be worth considering (if single-precision is an option), but it's not a clear win when you need a Newton Raphson iteration to get enough precision. Bare x * rsqrtps(x) without Newton Raphson is probably too inaccurate (and needs a cmp/AND to work around x==0.0), but an NR iteration can take too many extra FMA uops to be worth it.

(AVX512 with vrsqrt14ps/pd has more precision in the approximation, but usually still not enough to use without Newton. But interestingly it does exist for double-precision. Of course if you're on Xeon Phi, sqrt is very slow and you're intended to use AVX512ER vrsqrt28pd + Newton, or just vrsqrt28ps on its own.)

Last time I tuned a function including a sqrt of a polynomial-approximation for Skylake, fast-approx reciprocals weren't worth it. Hardware single-precision sqrt was the best choice that gave us the required precision (and we weren't even considering needing double). There was more work than yours between sqrt operations, though.

Add a graphics window to your measurement setup. In the graphics window you configure your signals and XCP readings the way you want.

During testing, you can use the CAPL call TestReportAddWindowCapture(...) to generate a screenshot of this window and add it to your report.

Have a look at following sample:

CANoe creates a system variable for each .XCP parameter.

You setup the parameters in the XCP/CCP window.

In CAPL you can read and write the value of the parameters by accessing the corresponding system variables. Just check the symbol explorer. The system variables should all be in namespace XCP.

So changing the parameter a0 of device XcpSim in CAPL would be something like

The formula for the (total) padding is explained here:

In your case, n mod s = 4 mod 2 = 0 so