Add sycl quick refs

Code_Exercises/Exercise_02_Hello_World/source.cpp

@@ -6,7 +6,37 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
-*/
+
+ *
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Include SYCL header
+ * #if __has_include(<SYCL/sycl.hpp>)
+ * #include <SYCL/sycl.hpp>
+ * #else
+ * #include <CL/sycl.hpp>
+ * #endif
+ *
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Submit work to the queue
+ * q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ * // Within the command group you can
+ * //    1. Enqueue a command:
+ *          cgh.single_task<class mykernel>([=] {
+ *              // Do something
+ *          });
+ *
+ *       2. Declare a sycl::stream for printing from device:
+ *          auto os = sycl::stream{buf_size, wi_size, cgh};
+ *
+ */
 
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>

Code_Exercises/Exercise_05_Device_Selection/source.cpp

@@ -6,6 +6,46 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+ *
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Make a child class of sycl::device_selector
+ * class my_functor_selector : public sycl::device_selector {
+ *   // Overload operator() for sycl::device.
+ *   int operator()(const sycl::device& dev) const override {
+ *   ...
+ *   }
+ * }
+ * ...
+ * auto q = sycl::queue{my_functor_selector{}};
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Or use a function selector
+ * int my_function_selector(const sycl::device &d) {
+ *  ...
+ * }
+ * ...
+ * auto q = sycl::queue{my_function_selector};
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Or use a lambda selector
+ * auto my_lambda_selector = [](const sycl::device &d) {
+ *  ...
+ * };
+ * ...
+ * auto q = sycl::queue{my_lambda_selector};
+ *
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Query a device for some things:
+ * std::string vendor = dev.get_info<sycl::info::device::vendor>();
+ * std::string dev_name = dev.get_info<sycl::info::device::name>();
+ * std::string dev_driver_ver = dev.get_info<sycl::info::device::driver_version>();
+ *
+ *
 */
 
 #define CATCH_CONFIG_MAIN

Code_Exercises/Exercise_06_Vector_Add/source.cpp

@@ -6,6 +6,36 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Submit work to the queue
+ * q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a single task:
+ *          cgh.single_task<class mykernel>([=]() {
+ *              // Do something
+ *          });
+ * //    3. Enqueue a parallel for:
+ *          cgh.parallel_for<class mykernel>(sycl::range{n}, [=](sycl::id<1> i) {
+ *              // Do something
+ *          });
+ *
 */
 
 #define CATCH_CONFIG_MAIN

Code_Exercises/Exercise_09_Synchronization/source.cpp

@@ -6,12 +6,53 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Do a USM malloc_device
+ * auto ptr = sycl::malloc_device<T>(n, q);
+ *
+ * // Do a USM memcpy
+ * q.memcpy(dst_ptr, src_ptr, sizeof(T)*n);
+ *
+ * // Wait on a queue
+ * q.wait();
+ *
+ * // Submit work to the queue
+ * q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a parallel for:
+ *              cgh.parallel_for<class mykernel>(sycl::range{n}, 
+ *                    [=](sycl::id<1> i) { // Do something });
+ *
+ *
 */
 
 #define CATCH_CONFIG_MAIN
 #include <catch2/catch.hpp>
 
-TEST_CASE("synchronization", "synchronization_source") {
-  // Use your code from Exercises 6 and 8 to start
+TEST_CASE("synchronization_usm", "synchronization_source") {
+  // Use your code from Exercise 3 to start
+  REQUIRE(true);
+}
+
+TEST_CASE("synchronization_buffer_acc", "synchronization_source") {
+  // Use your code from Exercise 3 to start
   REQUIRE(true);
 }

Code_Exercises/Exercise_10_Managing_Dependencies/source.cpp

@@ -6,6 +6,49 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Do a USM memcpy
+ * auto event = q.memcpy(dst_ptr, src_ptr, sizeof(T)*n);
+ * // Do a USM memcpy with dependent events
+ * auto event = q.memcpy(dst_ptr, src_ptr, sizeof(T)*n, {event1, event2});
+ *
+ * // Wait on an event
+ * event.wait();
+ *
+ * // Wait on a queue
+ * q.wait();
+ *
+ * // Submit work to the queue
+ * auto event = q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a parallel for:
+ * //             i: Without dependent events
+ *                    cgh.parallel_for<class mykernel>(sycl::range{n}, 
+ *                    [=](sycl::id<1> i) { // Do something });
+ * //             ii: With dependent events
+ *                    cgh.parallel_for<class mykernel>(sycl::range{n}, 
+ *                    {event1, event2}, [=](sycl::id<1> i) { 
+ *                        // Do something
+ *                      });
+ *
 */
 
 #define CATCH_CONFIG_MAIN

Code_Exercises/Exercise_11_In_Order_Queue/source.cpp

@@ -6,6 +6,53 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Construct an in-order queue
+ * auto q = sycl::queue{sycl::default_selector{}, 
+ *        {sycl::property::queue::in_order{}}};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Do a USM memcpy
+ * auto event = q.memcpy(dst_ptr, src_ptr, sizeof(T)*n);
+ * // Do a USM memcpy with dependent events
+ * auto event = q.memcpy(dst_ptr, src_ptr, sizeof(T)*n, {event1, event2});
+ *
+ * // Wait on an event
+ * event.wait();
+ *
+ * // Wait on a queue
+ * q.wait();
+ *
+ * // Submit work to the queue
+ * auto event = q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a parallel for:
+ * //             i: Without dependent events
+ *                    cgh.parallel_for<class mykernel>(sycl::range{n}, 
+ *                    [=](sycl::id<1> i) { // Do something });
+ * //             ii: With dependent events
+ *                    cgh.parallel_for<class mykernel>(sycl::range{n}, 
+ *                    {event1, event2}, [=](sycl::id<1> i) { 
+ *                        // Do something
+ *                      });
+
 */
 
 #define CATCH_CONFIG_MAIN

Code_Exercises/Exercise_12_Temporary_Data/source.cpp

@@ -6,6 +6,45 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Default construct a queue
+ * auto q = sycl::queue{};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Declare a buffer using host ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}, 
+ *                 {sycl::property::buffer::use_host_ptr{}}};
+ *
+ * // Declare a buffer relating to no host memory
+ * auto buf = sycl::buffer{sycl::range{n}};
+ *
+ * // Set final data of a buffer
+ * buf.set_final_data(host_ptr);
+ *
+ * // Set final data of a buffer to nullptr
+ * buf.set_final_data(nullptr);
+ *
+ * // Submit work to the queue
+ * q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a parallel for:
+ *          cgh.parallel_for<class mykernel>(sycl::range{n}, [=](sycl::id<1> i) {
+ *              // Do something
+ *          });
+ *
 */
 
 #define CATCH_CONFIG_MAIN

Code_Exercises/Exercise_13_Load_Balancing/source.cpp

@@ -6,6 +6,40 @@
 
  You should have received a copy of the license along with this
  work.  If not, see <http://creativecommons.org/licenses/by-sa/4.0/>.
+
+ * SYCL Quick Reference
+ * ~~~~~~~~~~~~~~~~~~~~
+ *
+ * // Get all available devices
+ * auto devs = sycl::device::get_devices();
+ *
+ * // Construct a queue with a device
+ * auto q = sycl::queue{my_device};
+ *
+ * // Declare a buffer pointing to ptr
+ * auto buf = sycl::buffer{ptr, sycl::range{n}};
+ *
+ * // Submit work to the queue
+ * q.submit([&](sycl::handler &cgh) {
+ *   // COMMAND GROUP
+ * });
+ *
+ * // Within the command group you can
+ * //    1. Declare an accessor to a buffer
+ *          auto read_write_acc = sycl::accessor{buf, cgh};
+ *          auto read_acc = sycl::accessor{buf, cgh, sycl::read_only};
+ *          auto write_acc = sycl::accessor{buf, cgh, sycl::write_only};
+ *          auto no_init_acc = sycl::accessor{buf, cgh, sycl::no_init};
+ * //    2. Enqueue a single task:
+ *          cgh.single_task<class mykernel>([=]() {
+ *              // Do something
+ *          });
+ * //    3. Enqueue a parallel for:
+ *          cgh.parallel_for<class mykernel>(sycl::range{n}, [=](sycl::id<1> i) {
+ *              // Do something
+ *          });
+ *
+
 */
 
 #define CATCH_CONFIG_MAIN