[Mirror] Introduction of Kokkos::Event interface (based on and includes 9122)

[csiefer2]

Automated mirror of upstream PR kokkos#9245 This is a follow on to this PR: kokkos#9122 introducing a better fallback implementation.

[gemini-code-assist]

Code Review

This pull request introduces an experimental Event API (Kokkos::Experimental::Event) to support fine-grained stream dependencies, providing a native implementation for the CUDA backend and a portable fallback for other backends. The review comments identify several critical issues that need to be addressed: a compilation error in the CUDA event resource due to mismatched member variable names, potential infinite loops in the fallback implementation due to a lack of volatile qualifiers on the flag view, incorrect usage of default-constructed execution spaces instead of the passed arguments, and a side effect in the CUDA backend where the active device is changed without being restored.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The member variable is declared as label, but the constructor initializes m_label and the label() method returns m_handle->m_label. This will cause a compilation error because m_label is undeclared. It should be renamed to m_label.

Suggested change

	std::string label = "unknown";
	std::string m_label = "unknown";

[gemini-code-assist]

The flag view is used for busy-waiting on the host in fence(). Without declaring the view's value type as volatile (or using volatile memory traits), the compiler is free to cache the value of flag() in a register during the loop, leading to an infinite loop/hang in optimized builds. Changing the value type to volatile int ensures that a volatile load is performed on every iteration.

                const Kokkos::View<volatile int, Kokkos::SharedHostPinnedSpace>& flag_,
                const ExecutionSpace& exec_)
      : label(label_), flag(flag_), exec(exec_) {}
  std::string label;
  Kokkos::View<volatile int, Kokkos::SharedHostPinnedSpace> flag;

[gemini-code-assist]

Change the value type of flag_t to volatile int to ensure volatile reads/writes are used, preventing compiler optimization from caching the flag value in a register during busy-waiting.

  using flag_t     = Kokkos::View<volatile int, Kokkos::SharedHostPinnedSpace>;

[gemini-code-assist]

There are two issues here:

1. The constructor default-constructs the execution space (execution_space()) instead of using the passed exec_space parameter, which breaks instance-specific behavior.
2. It repeats the Kokkos::View type instead of using the defined flag_t alias.

Using flag_t and passing exec_space correctly resolves both issues.

  Event(const std::string& label_, const execution_space& exec_space)
      : m_handle(std::make_shared<resource_t>(
            label_,
            flag_t(std::string("Kokkos::Event::flag:") + label_),
            exec_space)) {
    record(exec_space);
  };

[gemini-code-assist]

The record function default-constructs the execution space (execution_space()) and assigns it to m_handle->exec instead of using the passed exec_space parameter. This discards the specific execution space instance passed by the caller.

  void record(const execution_space& exec_space) {
    m_handle->flag() = 0;
    m_handle->exec   = exec_space;

[gemini-code-assist]

Calling cudaSetDevice has the side effect of permanently changing the active CUDA device of the calling thread, which is not restored. This can lead to subtle bugs in subsequent CUDA operations in the same thread. It is safer to query the current device and restore it after creating the event.

  explicit EventResource(const std::string& label,
                         const Kokkos::Cuda& exec_space)
      : m_label(label), m_cudaDev(exec_space.cuda_device()) {
    int current_dev = -1;
    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaGetDevice(&current_dev));
    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(m_cudaDev));
    KOKKOS_IMPL_CUDA_SAFE_CALL(
        cudaEventCreateWithFlags(&m_event, cudaEventDisableTiming));
    KOKKOS_IMPL_CUDA_SAFE_CALL(cudaSetDevice(current_dev));
  }