[aot] C-API breaking changes!

.github/workflows/scripts/aot-demo.sh

@@ -4,11 +4,11 @@ set -ex
 export TI_SKIP_VERSION_CHECK=ON
 export TI_CI=1
 
-export TAICHI_AOT_DEMO_URL=https://github.com/taichi-dev/taichi-aot-demo
-export TAICHI_AOT_DEMO_BRANCH=master
+export TAICHI_AOT_DEMO_URL=https://github.com/PENGUINLIONG/taichi-aot-demo
+export TAICHI_AOT_DEMO_BRANCH=fix-cgraph-demo
 
 export TAICHI_UNITY2_URL=https://github.com/taichi-dev/taichi-unity2
-export TAICHI_UNITY2_BRANCH=main
+export TAICHI_UNITY2_BRANCH=fix-include
 
 export TAICHI_UNITY_EXAMPLE_URL=https://github.com/taichi-dev/Taichi-UnityExample
 export TAICHI_UNITY_EXAMPLE_BRANCH=main

c_api/docs/taichi/taichi_core.h.md

@@ -35,7 +35,7 @@ The following section provides a brief introduction to the Taichi C-API.
 You *must* create a runtime instance before working with Taichi, and *only* one runtime per thread. Currently, we do not officially claim that multiple runtime instances can coexist in a process, but please feel free to [file an issue with us](https://github.com/taichi-dev/taichi/issues) if you run into any problem with runtime instance coexistence.
 
 ```cpp
-TiRuntime runtime = ti_create_runtime(TI_ARCH_VULKAN);
+TiRuntime runtime = ti_create_runtime(TI_ARCH_VULKAN, 0);
 ```
 
 When your program runs to the end, ensure that:
@@ -116,7 +116,7 @@ TiAotModule aot_module = ti_load_aot_module(runtime, "/path/to/aot/module");
 
 `/path/to/aot/module` should point to the directory that contains a `metadata.tcb`.
 
-You can destroy an unused AOT module, but please ensure that there is no kernel or compute graph related to it pending to [`ti_submit`](#function-ti_submit).
+You can destroy an unused AOT module, but please ensure that there is no kernel or compute graph related to it pending to [`ti_flush`](#function-ti_flush).
 
 ```cpp
 ti_destroy_aot_module(aot_module);
@@ -177,10 +177,10 @@ named_arg2.argument = args[2];
 ti_launch_compute_graph(runtime, compute_graph, named_args.size(), named_args.data());
 ```
 
-When you have launched all kernels and compute graphs for this batch, you should `function.submit` and `function.wait` for the execution to finish.
+When you have launched all kernels and compute graphs for this batch, you should `function.flush` and `function.wait` for the execution to finish.
 
 ```cpp
-ti_submit(runtime);
+ti_flush(runtime);
 ti_wait(runtime);
 ```
 
@@ -502,14 +502,6 @@ Allocates a device image with provided parameters.
 
 Frees an image allocation.
 
-`function.create_event`
-
-Creates an event primitive.
-
-`function.destroy_event`
-
-Destroys an event primitive.
-
 `function.copy_memory_device_to_device`
 
 Copies the data in a contiguous subsection of the device memory to another subsection. The two subsections *must not* overlap.
@@ -534,19 +526,7 @@ Launches a Taichi kernel with the provided arguments. The arguments *must* have
 
 Launches a Taichi compute graph with provided named arguments. The named arguments *must* have the same count, names, and types as in the source code.
 
-`function.signal_event`
-
-Sets an event primitive to a signaled state so that the queues waiting for it can go on execution. If the event has been signaled, you *must* call `function.reset_event` to reset it; otherwise, an undefined behavior would occur.
-
-`function.reset_event`
-
-Sets a signaled event primitive back to an unsignaled state.
-
-`function.wait_event`
-
-Waits until an event primitive transitions to a signaled state. The awaited event *must* be signaled by an external procedure or a previous invocation to `function.reset_event`; otherwise, an undefined behavior would occur.
-
-`function.submit`
+`function.flush`
 
 Submits all previously invoked device commands to the offload device for execution.
 

c_api/include/taichi/cpp/taichi.hpp

@@ -685,60 +685,6 @@ class AotModule {
   }
 };
 
-class Event {
-  TiRuntime runtime_{TI_NULL_HANDLE};
-  TiEvent event_{TI_NULL_HANDLE};
-  bool should_destroy_{false};
-
- public:
-  constexpr bool is_valid() const {
-    return event_ != nullptr;
-  }
-  inline void destroy() {
-    if (should_destroy_) {
-      ti_destroy_event(event_);
-      event_ = TI_NULL_HANDLE;
-      should_destroy_ = false;
-    }
-  }
-
-  Event() {
-  }
-  Event(const Event &) = delete;
-  Event(Event &&b) : event_(b.event_), should_destroy_(b.should_destroy_) {
-  }
-  Event(TiRuntime runtime, TiEvent event, bool should_destroy)
-      : runtime_(runtime), event_(event), should_destroy_(should_destroy) {
-  }
-  ~Event() {
-    destroy();
-  }
-
-  Event &operator=(const Event &) = delete;
-  Event &operator=(Event &&b) {
-    event_ = detail::move_handle(b.event_);
-    should_destroy_ = std::exchange(b.should_destroy_, false);
-    return *this;
-  }
-
-  void reset(TiEvent event_) {
-    ti_reset_event(runtime_, event_);
-  }
-  void signal(TiEvent event_) {
-    ti_signal_event(runtime_, event_);
-  }
-  void wait(TiEvent event_) {
-    ti_wait_event(runtime_, event_);
-  }
-
-  constexpr TiEvent event() const {
-    return event_;
-  }
-  constexpr operator TiEvent() const {
-    return event_;
-  }
-};
-
 class CapabilityLevelConfigBuilder;
 class CapabilityLevelConfig {
  public:
@@ -937,8 +883,10 @@ class Runtime {
         runtime_(detail::move_handle(b.runtime_)),
         should_destroy_(std::exchange(b.should_destroy_, false)) {
   }
-  Runtime(TiArch arch)
-      : arch_(arch), runtime_(ti_create_runtime(arch)), should_destroy_(true) {
+  Runtime(TiArch arch, uint32_t device_index = 0)
+      : arch_(arch),
+        runtime_(ti_create_runtime(arch, device_index)),
+        should_destroy_(true) {
   }
   Runtime(TiArch arch, TiRuntime runtime, bool should_destroy)
       : arch_(arch), runtime_(runtime), should_destroy_(should_destroy) {
@@ -1071,8 +1019,8 @@ class Runtime {
     ti_transition_image(runtime_, image, layout);
   }
 
-  void submit() {
-    ti_submit(runtime_);
+  void flush() {
+    ti_flush(runtime_);
   }
   void wait() {
     ti_wait(runtime_);

c_api/include/taichi/taichi.h

@@ -5,28 +5,14 @@
 #include "taichi/taichi_core.h"
 
 #ifdef TI_WITH_VULKAN
-#ifndef TI_NO_VULKAN_INCLUDES
-#include <vulkan/vulkan.h>
-#endif  // TI_NO_VULKAN_INCLUDES
-
 #include "taichi/taichi_vulkan.h"
 #endif  // TI_WITH_VULKAN
 
 #ifdef TI_WITH_OPENGL
-#ifndef TI_NO_OPENGL_INCLUDES
-#include <GL/gl.h>
-#endif  // TI_NO_OPENGL_INCLUDES
-
 #include "taichi/taichi_opengl.h"
 #endif  // TI_WITH_OPENGL
 
 #ifdef TI_WITH_CUDA
-#ifndef TI_NO_CUDA_INCLUDES
-// Only a few CUDA types is needed, including the entire <cuda.h> is overkill
-// for this
-typedef void *CUdeviceptr;
-#endif  // TI_NO_CUDA_INCLUDES
-
 #include "taichi/taichi_cuda.h"
 #endif  // TI_WITH_CUDA
 

c_api/include/taichi/taichi_core.h

@@ -48,7 +48,7 @@
 // any problem with runtime instance coexistence.
 //
 // ```cpp
-// TiRuntime runtime = ti_create_runtime(TI_ARCH_VULKAN);
+// TiRuntime runtime = ti_create_runtime(TI_ARCH_VULKAN, 0);
 // ```
 //
 // When your program runs to the end, ensure that:
@@ -144,7 +144,7 @@
 //
 // You can destroy an unused AOT module, but please ensure that there is no
 // kernel or compute graph related to it pending to
-// [`ti_submit`](#function-ti_submit).
+// [`ti_flush`](#function-ti_flush).
 //
 // ```cpp
 // ti_destroy_aot_module(aot_module);
@@ -211,11 +211,11 @@
 // ```
 //
 // When you have launched all kernels and compute graphs for this batch, you
-// should [`ti_submit`](#function-ti_submit) and [`ti_wait`](#function-ti_wait)
+// should [`ti_flush`](#function-ti_flush) and [`ti_wait`](#function-ti_wait)
 // for the execution to finish.
 //
 // ```cpp
-// ti_submit(runtime);
+// ti_flush(runtime);
 // ti_wait(runtime);
 // ```
 //
@@ -281,12 +281,6 @@ typedef struct TiRuntime_t *TiRuntime;
 // kernels and compute graphs.
 typedef struct TiAotModule_t *TiAotModule;
 
-// Handle `TiEvent`
-//
-// A synchronization primitive to manage device execution flows in multiple
-// queues.
-typedef struct TiEvent_t *TiEvent;
-
 // Handle `TiMemory`
 //
 // A contiguous allocation of device memory.
@@ -845,7 +839,8 @@ TI_DLL_EXPORT void TI_API_CALL ti_set_last_error(
 // Function `ti_create_runtime`
 //
 // Creates a Taichi Runtime with the specified [`TiArch`](#enumeration-tiarch).
-TI_DLL_EXPORT TiRuntime TI_API_CALL ti_create_runtime(TiArch arch);
+TI_DLL_EXPORT TiRuntime TI_API_CALL ti_create_runtime(TiArch arch,
+                                                      uint32_t device_index);
 
 // Function `ti_destroy_runtime`
 //
@@ -915,16 +910,6 @@ ti_create_sampler(TiRuntime runtime, const TiSamplerCreateInfo *create_info);
 TI_DLL_EXPORT void TI_API_CALL ti_destroy_sampler(TiRuntime runtime,
                                                   TiSampler sampler);
 
-// Function `ti_create_event`
-//
-// Creates an event primitive.
-TI_DLL_EXPORT TiEvent TI_API_CALL ti_create_event(TiRuntime runtime);
-
-// Function `ti_destroy_event`
-//
-// Destroys an event primitive.
-TI_DLL_EXPORT void TI_API_CALL ti_destroy_event(TiEvent event);
-
 // Function `ti_copy_memory_device_to_device` (Device Command)
 //
 // Copies the data in a contiguous subsection of the device memory to another
@@ -980,33 +965,11 @@ ti_launch_compute_graph(TiRuntime runtime,
                         uint32_t arg_count,
                         const TiNamedArgument *args);
 
-// Function `ti_signal_event` (Device Command)
-//
-// Sets an event primitive to a signaled state so that the queues waiting for it
-// can go on execution. If the event has been signaled, you *must* call
-// [`ti_reset_event`](#function-ti_reset_event-device-command) to reset it;
-// otherwise, an undefined behavior would occur.
-TI_DLL_EXPORT void TI_API_CALL ti_signal_event(TiRuntime runtime,
-                                               TiEvent event);
-
-// Function `ti_reset_event` (Device Command)
-//
-// Sets a signaled event primitive back to an unsignaled state.
-TI_DLL_EXPORT void TI_API_CALL ti_reset_event(TiRuntime runtime, TiEvent event);
-
-// Function `ti_wait_event` (Device Command)
-//
-// Waits until an event primitive transitions to a signaled state. The awaited
-// event *must* be signaled by an external procedure or a previous invocation to
-// [`ti_reset_event`](#function-ti_reset_event-device-command); otherwise, an
-// undefined behavior would occur.
-TI_DLL_EXPORT void TI_API_CALL ti_wait_event(TiRuntime runtime, TiEvent event);
-
-// Function `ti_submit`
+// Function `ti_flush`
 //
 // Submits all previously invoked device commands to the offload device for
 // execution.
-TI_DLL_EXPORT void TI_API_CALL ti_submit(TiRuntime runtime);
+TI_DLL_EXPORT void TI_API_CALL ti_flush(TiRuntime runtime);
 
 // Function `ti_wait`
 //

c_api/include/taichi/taichi_vulkan.h

@@ -89,15 +89,6 @@ typedef struct TiVulkanImageInteropInfo {
   VkImageUsageFlags usage;
 } TiVulkanImageInteropInfo;
 
-// Structure `TiVulkanEventInteropInfo`
-//
-// Necessary detail to share the same Vulkan event synchronization primitive
-// between Taichi and the user application.
-typedef struct TiVulkanEventInteropInfo {
-  // Vulkan event handle.
-  VkEvent event;
-} TiVulkanEventInteropInfo;
-
 // Function `ti_create_vulkan_runtime_ext`
 //
 // Creates a Vulkan Taichi runtime with user-controlled capability settings.
@@ -153,21 +144,6 @@ ti_export_vulkan_image(TiRuntime runtime,
                        TiImage image,
                        TiVulkanImageInteropInfo *interop_info);
 
-// Function `ti_import_vulkan_event`
-//
-// Imports the Vulkan event owned by Taichi to external procedures.
-TI_DLL_EXPORT TiEvent TI_API_CALL
-ti_import_vulkan_event(TiRuntime runtime,
-                       const TiVulkanEventInteropInfo *interop_info);
-
-// Function `ti_export_vulkan_event`
-//
-// Exports a Vulkan event from external procedures to Taichi.
-TI_DLL_EXPORT void TI_API_CALL
-ti_export_vulkan_event(TiRuntime runtime,
-                       TiEvent event,
-                       TiVulkanEventInteropInfo *interop_info);
-
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus