Clarify that recent AdaptiveCpp versions do not require compilation t…

…argets to be provided (codeplaysoftware#337)

Clarify that recent AdaptiveCpp versions do not require targets to be provided

Code_Exercises/Coalesced_Global_Memory/README.md

@@ -72,8 +72,11 @@ icpx -fsycl -o Coalesced_Global_Memory_source -I../External/Catch2/single_includ
 For AdaptiveCpp:
 ```sh
 # <target specification> is a list of backends and devices to target, for example
-# "omp;generic" compiles for CPUs with the OpenMP backend and GPUs using the generic single-pass compiler.
-# The simplest target specification is "omp" which compiles for CPUs using the OpenMP backend.
+# "generic" compiles for CPUs and GPUs using the generic single-pass compiler.
+# When in doubt, use "generic" as it usually generates the fastest binaries.
+#
+# Recent, full installations of AdaptiveCpp may not need targets to be provided,
+# compiling for "generic" by default.
 cmake -DSYCL_ACADEMY_USE_ADAPTIVECPP=ON -DSYCL_ACADEMY_INSTALL_ROOT=/insert/path/to/adaptivecpp -DACPP_TARGETS="<target specification>" ..
 make Coalesced_Global_Memory_source
 ```

Code_Exercises/Compiling_with_SYCL/README.md

@@ -124,8 +124,11 @@ icpx -fsycl -o Compiling_with_SYCL_source -I../External/Catch2/single_include ..
 For AdaptiveCpp:
 ```sh
 # <target specification> is a list of backends and devices to target, for example
-# "omp;generic" compiles for CPUs with the OpenMP backend and GPUs using the generic single-pass compiler.
-# The simplest target specification is "omp" which compiles for CPUs using the OpenMP backend.
+# "generic" compiles for CPUs and GPUs using the generic single-pass compiler.
+# When in doubt, use "generic" as it usually generates the fastest binaries.
+#
+# Recent, full installations of AdaptiveCpp may not need targets to be provided,
+# compiling for "generic" by default.
 cmake -DSYCL_ACADEMY_USE_ADAPTIVECPP=ON -DSYCL_ACADEMY_INSTALL_ROOT=/insert/path/to/AdaptiveCpp -DACPP_TARGETS="<target specification>" ..
 make Compiling_with_SYCL_source
 ```

Code_Exercises/Image_Convolution/README.md

@@ -102,8 +102,11 @@ icpx -fsycl -o Image_Convolution_reference -I../../Utilities/include/ -I../../Ex
 For AdaptiveCpp:
 ```sh
 # <target specification> is a list of backends and devices to target, for example
-# "omp;generic" compiles for CPUs with the OpenMP backend and GPUs using the generic single-pass compiler.
-# The simplest target specification is "omp" which compiles for CPUs using the OpenMP backend.
+# "generic" compiles for CPUs and GPUs using the generic single-pass compiler.
+# When in doubt, use "generic" as it usually generates the fastest binaries.
+#
+# Recent, full installations of AdaptiveCpp may not need targets to be provided,
+# compiling for "generic" by default.
 cmake -DSYCL_ACADEMY_USE_ADAPTIVECPP=ON -DSYCL_ACADEMY_INSTALL_ROOT=/insert/path/to/adaptivecpp -DACPP_TARGETS="<target specification>" ..
 make Image_Convolution_reference
 ```

Code_Exercises/adaptivecpp.md

@@ -1,8 +1,11 @@
 If you haven't done so already, use CMake to configure then build the exercises:
 ```sh
 # <target specification> is a list of backends and devices to target, for example
-# "omp;generic" compiles for CPUs with the OpenMP backend and GPUs using the generic single-pass compiler.
-# The simplest target specification is "omp" which compiles for CPUs using the OpenMP backend.
+# "generic" compiles for CPUs and GPUs using the generic single-pass compiler.
+# When in doubt, use "generic" as it usually generates the fastest binaries.
+#
+# Recent, full installations of AdaptiveCpp may not need targets to be provided,
+# compiling for "generic" by default.
 cmake -DSYCL_ACADEMY_USE_ADAPTIVECPP=ON -DSYCL_ACADEMY_ENABLE_SOLUTIONS=OFF
 -DSYCL_ACADEMY_INSTALL_ROOT=/insert/path/to/adaptivecpp -DACPP_TARGETS="<target specification>" ..
 ```

README.md

@@ -234,18 +234,23 @@ or CUDA SDKs, respectively.
 
 #### Additional cmake arguments for AdaptiveCpp
 
-When building with AdaptiveCpp, cmake will additionally require you to specify the
-target platform using `-DACPP_TARGETS=<target specification>`.
+Sufficiently new (>= 24.02.0), full installations of AdaptiveCpp do not require specifying compilation targets.
+In this case, targets may still be provided optionally. 
+
+For older AdaptiveCpp versions, CMake will require you to specify the compilation targets using `-DACPP_TARGETS=<target specification>`. 
+
 `<target specification>` is a list of compilation flows to enable and devices to target, for example
 `-DACPP_TARGETS="omp;generic"` compiles for CPUs using OpenMP and GPUs using the generic single-pass compiler.
 
+If your AdaptiveCpp installation does not force a compilation target to be provided, but it was built with the generic single-pass compiler disabled (it is enabled by default in all AdaptiveCpp installations built against LLVM >= 14), it is compiling for a default set of targets provided at installation time. If you cannot run the binary on the hardware of your choice, this default set may not be the right one for your hardware and you may have to specify the right targets explicitly.
+
 Available compilation flows are:
 * `omp` - OpenMP CPU backend
-* `generic` - Generic single-pass compiler. Generates a binary that runs on AMD, NVIDIA and Intel GPUs using runtime compilation
-* `cuda` - CUDA backend for NVIDIA GPUs. Requires specification of targets of the form sm_XY, e.g. sm_70 for Volta, sm_60 for Pascal
-* `hip`  - HIP backend for AMD GPUs. Requires specification of targets of the form gfxXYZ, e.g. gfx906 for Vega 20, gfx900 for Vega 10
+* `generic` - Generic single-pass compiler. Generates a binary that runs on host CPU, AMD, NVIDIA and Intel GPUs using runtime compilation
+* `cuda` - CUDA backend for NVIDIA GPUs. Requires specification of targets of the form sm_XY, e.g. sm_70 for Volta, sm_60 for Pascal. E.g: `cuda:sm_70`.
+* `hip`  - HIP backend for AMD GPUs. Requires specification of targets of the form gfxXYZ, e.g. gfx906 for Vega 20, gfx900 for Vega 10. E.g.: `hip:gfx906`.
 
-When in doubt, use `-DACPP_TARGETS=omp;generic`.
+When in doubt, use `-DACPP_TARGETS=generic` as it compiles the fastest, usually generates the fastest binaries, and generates portable binaries.
 
 #### CMake usage example