serpentine | Boost Windows RAT | Security Testing library

This piece of code gives exactly the same result as your code... But without the column loop.

double decimalsPwr = pow(10.0, 15.0), serpentine2Pwr = pow(2.0, (*serpentineR));

serpentineR is used as scalar so pass it as scalar not via global memory which is much slower. But here I would go even further and do not do above calculations on GPU side. Just pre-calculate them in CPU and pass to the kernel. Imagine that every this calculation has to be performed 4096 x 4096 times - what a waste of resources!

unsigned int decimals = floor(decimalsPwr * fabs(*nonce)); - same here, pre-calculate on CPU and pass as parameter to the kernel. It needs to be calculated only once.

Another suggestion would be to avoid using 64 bit types in the kernel as much as possible. In most cases they are much slower in compare to 32 bit types on GPU. Let's check for example GeForce RTX 2060. Wikipedia states that the processing power for single fp precision is 5241.60 GFLOPS but for double fp precision is just 163.80 GFLOPS. That is 32x difference! If reducing precision is not an option then many times is worth to perform the 64 bit calculations in CPU and pass the results to GPU for the remaining calculations.

You need an additional guard so:

1. The call to seq is not redundant because rnf x needs to be evaluated (to WHNF) to evaluate x to NF, and that's seq's job.

2. Yes, I believe so: just

Here is one possibility to either create an iterator or the entire array at once:

The answer to what I wanted to know is no. The primary key is not required in the projection list, the UPDATE's effect is the same even if o.order_id is not selected in the sub-query. However, this doesn't mean the primary key is unused, thanks to the declarative technique. Whatever including or excluding the primary key, the same execution plan is created to fetch the records which will be updated:

Projection doesn't change much here, the DBMS could identify each rows after the hash join operation, see krokodilko's answer.

If you don't select anything from the table (like you type SELECT 1 FROM ...), you can't execute the update command, the sub-query's result is just a normal set of some data, it can't be mapped to a table.

I think we should always include the primary key to make it clear to the reader how is the sub-query's result used in the inner-query, which table we plan to update.

very cool idea. I think you're more restrictive than necessary

You can add a type signature to testFunction where you pass it to nf. Something like:

nf (testFunction :: [[Int]] -> ExampleDataType3 Double Int) [[1,0,1,1],[0,0,0,1],[1,1,1,0],[0,1,0,1]]

I picked the type Double; you may pick some other type. Since there are several options, GHC gives the Ambiguous type variable error rather than arbitrarily picking one.