syncd | open source code deployment tool | Continuous Deployment library

If you have configured core:default_timezone airflow configuration, environment health status is just a metric and it will not have any impact on the actual job/tasks execution.

You can ignore the health status or you can remove the configuration to accept default UTC timezone.

This is because Composer runs a liveness DAG named airflow_monitoring every 5 minutes and reports environment health as follow:

• When the DAG run finishes successfully the health status is True.
• If the DAG run fails, the health status is False.
• If the DAG does not finish, Composer polls the DAG’s status every 5 minutes and reports False if the one-hour timeout occurs.

First of all, it is important to understand the synchronization guarantees that SYCL makes. Like many other heterogeneous models (e.g. OpenCL), SYCL only allows synchronization within a work group, not with work items from other work groups. The background here is that the hardware, driver, or SYCL implementation is not required to execute the work groups in parallel such that they make independent forward progress. Instead, the stack is free to execute the work groups in any order - in an extreme case, it could execute the work groups sequentially, one by one. A simple example is if you are e.g. on a single-core CPU. In that case, the backend thread pool of the SYCL implementation is probably just of size 1, and so the SYCL implementation might just iterate across all your work groups sequentially.

This means that it is very difficult to formulate producer-consumer algorithms [where one work item produces a value that another work items waits for] that span multiple work groups because it could always happen that the producer work group is scheduled to run after the consumer work group, potentially leading to a dead lock if available hardware resources prevent both from running simultaneously.

The canonical way to achieve synchronization across all work items of a kernel is therefore to split the kernel in two kernels, as you have done.

I'm not sure if you did this just for the code example or if it's also in your production code, but I'd like to point out that the q.wait() calls between and after the kernels seem unnecessary. queue::wait() causes the host thread to wait for completion of submitted operations, but for this use case it's sufficient if you know that the kernels run in-order. The SYCL buffer-accessor model would automatically guarantee this because the SYCL implementation would detect that both kernels read-write vec_star, therefore a dependency edge is inserted in the SYCL task graph. In general, for performance you want to avoid host synchronization unless absolutely necessary, and let the device work through all enqueued work asynchronously.

Tricks you can try

In principle, in some special cases you can maybe try other approaches. However, I don't expect them to be a better choice for most use cases than just using two kernels.

• group_barrier: If you somehow manage to formulate the problem such that producer-consumer dependencies don't cross boundaries between two work groups, you can use group_barrier() for synchronization
• atomic_ref: If you somehow know that your SYCL implementation/driver/hardware all guarantee that your producer work groups execute before or during the consumer work groups, you could have an atomic flag in global memory to store whether the value was already updated. You can use atomic_ref store/load to implement something like a spin lock in global memory.
• Multiple buffers: It might be possible to combine the two kernels if at the end of the second kernel you store your updated vec in a temporary buffer instead of the original one. After the two kernels have completed, you flip the original and temporary buffers for the next iteration.