nvc | VHDL compiler and simulator | Compiler library

Found them accidentally in a random third-party library https://github.com/fmtlib/fmt/blob/master/include/fmt/core.h

Since the macro is expanded by the pre-processor, which runs before the OpenACC directives are interpreted, I would expect that this will work exactly how you hope. What are you hoping to accomplish here by not writing these loops in a function rather than a macro?

The exact mapping of workers and vectors will depend on the target device and implementation. Specifically when using NVHPC targeting NVIDIA GPUs, a "gang" maps to a CUDA Block, "worker" maps the the y dimension of a thread block, and "vector" to the x-dimension. The value used in "num_workers" or "vector_length" may be reduced given the constrains of the target. CUDA Blocks can contain up to a maximum 1024 threads so the "4096" value will be reduced to what is allowed by the hardware. Secondly, in order to support vector reductions in device routines, a maximum vector_length can be 32. In other words, you're "4096" value is actually "32" due to these constraints.

Note to see the max thread block size on your device, run the "nvaccelinfo" utility and look for the "Maximum Threads per Block" and "Maximum Block Dimensions" fields. Also, setting the environment variable "NV_ACC_TIME=1" will have the runtime produce some basic profiling information, including the actual number of blocks and thread block size used during the run.

In my understanding, a huge amount of threads should lie dormant when there are only as many as 10 iterations in the vector loop.

CUDA threads are grouped into a "warp" of 32 threads where all threads of a warp execute the same instructions concurrently (aka SIMT or single instruction multiple threads). Hence even though only 10 threads are doing useful work, the remaining 12 are not dormant. Plus they still take resources such as registers so adding too many threads for loops with lower trip counts, may actually hurt performance.

In this case setting the vector length to 1 is most likey the best case since the warp can now be comprised of the y-dimension threads. Setting it to 2, will cause a full 32 thread warp in the x-dimension, but only 2 doing useful work.

As to why some combinations give incorrect results, I didn't investigate. Routine worker, especially with reductions, is rarely used so it's possible we have some type of code gen issue, like an off-by one error in the reduction, at these irregular schedule sizes. I'll look into this later and determine if I need to file an issue report.

For #2, How you're determining it's getting run twice? Is just this based on the runtime?

Could those projects be set to compile as an earlier standard of C++?

Some older compilers don't like returns in the middle of code blocks (there are also those that don't like variable identifiers anywhere other than at the start of code blocks).

For those that do complain I just code as:

It's hard to tell from your question whether that cited JSON is how ansible sees it, or you copied that from somewhere else and just assumed that is how ansible sees it

Either way, as best I can tell you're interested in inserting actual_values[0] into the place of the capture group in your regex, which isn't how that process works. In your case, you actually want everything except the capture group carried over, which means you don't care about the capture group's value, which means you shouldn't use a capture group

You also have an unusual .{1,5}? syntax which I'm guessing you mean as "either nothing, or a string of 1 to 5 characters," which in regex is expressed as .{0,5}

For your first problem, you'll want to ensure you and ansible are working with the same understanding about that data; that's what the | type_debug filter is for, since - debug: var=page.json can be misleading with all the jinja2 and stdout callback plugins that touch that data on the way back to your terminal.

Next, and this is kind of related to that, you'll want to know if some process in ansible that has touched that data has introduced escape characters in front of those " in your body.storage.value; my code snipped below works on the assumption they are not present, because your snippet assumed they were not present, but you'll want to verify that for sure. You don't have to leave that assert: in your final playbook, but it can help you ensure you're starting from the right place because if the regex_replace doesn't find any matches, it merely doesn't do anything, which can make it seem like it is silently failing. We want loud failures.

Finally, getting to the part you care about: your process is that you have a bunch of literal text, a variable part, and a bunch of literal text. While it might not be necessary, it is clearest to send that literal text through | regex_escape to let the computer do any regex quoting for you. Then, using that same literal text, tell regex_replace to swap out the variable part with the new bookends

I believe ggtext's geom_textbox() can do what you're looking for. In introduces a seperation of hjust and halign to seperately align the box and the text.

It's illegal OpenACC syntax to use "vector(value)" with a parallel construct. You need to use a "vector_length" clause on the parallel directive to define the vector length. The reason is because "parallel" defines a single compute region to be offloaded and hence all vector loops in this region need to have the same vector length.

You can use "vector(value)" only with a "kernels" construct since the compiler can then split the region into multiple kernels each having a different vector length.

Option 1:

Please find below code by which you can use in the same makefile which will compile all files (.c and .cu) .

The problem here is that you're trying to call a device routine, "Vec1::operator*", that's contained in a shared object from a kernel in the main program. nvc++'s OpenACC implementation uses CUDA to target NVIDIA devices. Since CUDA doesn't have a dynamic linker for device code, at least not yet, this isn't supported.

You'll need to either link this statically, or move the "parallel loop" into the shared object.

Note that the "-ta" flag has been deprecated. Please consider using "-acc -gpu=cuda11.2" instead.