k | lightweight npm package to install/update the runtime of k | DevOps library

[temp.names]/5 says that a name prefixed by template must be a template-id, meaning that it must have a template argument list. (Or it can refer to a class/alias template without template argument list, but this is deprecated in the current draft as a result of P1787R6 authored by @DavisHerring.)

There is even an example almost identical to yours under it, identifying your use of template as ill-formed.

The requirement and example comes from CWG defect report 96, in which the possible ambiguity without the requirement is considered.

Open GCC bug report for this is here. I was not able to find a Clang bug report, but searching for it isn't that easy. Its implementation status page for defect reports however does list the defect report as unimplemented.

Here is a sample code to output what you need. I use the formula below to calculate pct change. percentage_change = 100*(new-old)/old

If old is 0 it is changed to 1 to avoid division by zero error.

In order to achieve this goal we need to create permutation of all allowed paths. For example:

At first blush, one would hope this would be enough:

Take a look at the recursive formula for combinations:

Suppose you have a combination space C(n,k). You can divide that space into two subspaces:

• C(n-1,k-1) all combinations, where the first element of the original set (of length n) is present
• C(n-1, k) where first element is not preset

If you have an index X that corresponds to a combination from C(n,k), you can identify whether the first element of your original set belongs to the subset (which corresponds to X), if you check whether X belongs to either subspace:

• X < C(n-1, k-1) : belongs
• X >= C(n-1, k-1): doesn't belong

Then you can recursively apply the same approach for C(n-1, ...) and so on, until you've found the answer for all n elements of the original set.

Python code to illustrate this approach:

The TLDR is that loads which miss all levels of the TLB (and so require a page walk) and which are separated by address unknown stores can't execute in parallel, i.e., the loads are serialized and the memory level parallelism (MLP) factor is capped at 1. Effectively, the stores fence the loads, much as lfence would.

The slow version of your insert function results in this scenario, while the other two don't (the store address is known). For large region sizes the memory access pattern dominates, and the performance is almost directly related to the MLP: the fast versions can overlap load misses and get an MLP of about 3, resulting in a 3x speedup (and the narrower reproduction case we discuss below can show more than a 10x difference on Skylake).

The underlying reason seems to be that the Skylake processor tries to maintain page-table coherence, which is not required by the specification but can work around bugs in software.

For those who are interested, we'll dig into the details of what's going on.

I could reproduce the problem immediately on my Skylake i7-6700HQ machine, and by stripping out extraneous parts we can reduce the original hash insert benchmark to this simple loop, which exhibits the same issue:

a, b = (c, d) unpacks the tuple from left to right and assigns a = c and b = d in that order.

x.items() iterates over key-value pairs in x. E.g. doing list(x.items()) will give [('a', 1), ('b', 2)]

for a, b in x.items() assigns the key to a, and the value to b for each key-value pair in x.

for k, y[k] in x.items() assigns the key to k, and the value to y[k] for each key-value pair in x.

You can use k in y[k] because k has already been assigned since unpacking happens left-right

You don't need to do anything in the loop because whatever you needed is done already.

Because the loop already assigned every value in x to y[k], y is now a shallow copy of x.

As the tweet you reference says, this is indeed a "terse, unintuitive, and confusing" way to do x.copy()

op is only called once before it is destroyed, so calling it as an rvalue permits any && overload on it to reuse any resources it might hold.

The callable object is morally an xvalue - it is "expiring" because it is destroyed immediately after the call. If you specifically designed your callable to only support calling as lvalues, then the library is happy to oblige by preventing this from working.

This is a somewhat confusing trick to save a small amount of time:

We are creating a defaultdict with a factory function that returns a bound append method of a new list instance with [].append. Then we can just do d[key(item)](item) instead of d[key(item)].append(item) like we would have if we create a defaultdict that contains lists. If we don't lookup append everytime, we gain a small amount of time.

But now the dict contains bound methods instead of the lists, so we have to get the original list instance back via __self__.

__self__ is an attribute described for instance methods that returns the original instance. You can verify that with this for example: