Replace void* with std::byte* in AsyncRuntime

[yijia1212]

Summary

Replace void* with std::byte* in AsyncRuntime to make it clear that these pointers point to a memory region.

[ezhulenev]

mlir/include/mlir/ExecutionEngine/AsyncRuntime.h

18

Build is failing, looks like it's missing <cstddef>

[yijia1212]

Add cstddef header include

mlir/include/mlir/ExecutionEngine/AsyncRuntime.h

 // to LLVM dialect lowering.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 #define MLIR_EXECUTIONENGINE_ASYNCRUNTIME_H_
 
 #include <stdint.h>
+#include <utility>
 
 #ifdef mlir_async_runtime_EXPORTS
 // We are building this library
 #define MLIR_ASYNCRUNTIME_DEFINE_FUNCTIONS
 #endif // mlir_async_runtime_EXPORTS
 
 namespace mlir {
 namespace runtime {
 
 //===----------------------------------------------------------------------===//
 // Async runtime API.
 //===----------------------------------------------------------------------===//
 
 // Runtime implementation of `async.token` data type.
 using AsyncToken = struct AsyncToken;
 
 // Runtime implementation of `async.group` data type.
 using AsyncGroup = struct AsyncGroup;
 
 // Runtime implementation of `async.value` data type.
 using AsyncValue = struct AsyncValue;
 
 // Async value payload stored in a memory owned by the async.value.
-using ValueStorage = void *;
+using ValueStorage = std::byte *;
 
 // Async runtime uses LLVM coroutines to represent asynchronous tasks. Task
 // function is a coroutine handle and a resume function that continue coroutine
 // execution from a suspension point.
 using CoroHandle = void *;           // coroutine handle
 using CoroResume = void (*)(void *); // coroutine resume function
 
 // Async runtime uses reference counting to manage the lifetime of async values

mlir/lib/ExecutionEngine/AsyncRuntime.cpp

struct AsyncValue : public RefCounted {
   // AsyncValue similar to an AsyncToken created with a reference count of 2.
   AsyncValue(AsyncRuntime *runtime, int64_t size)
       : RefCounted(runtime, /*refCount=*/2), state(State::kUnavailable),
         storage(size) {}
 
   std::atomic<State::StateEnum> state;
 
   // Use vector of bytes to store async value payload.
-  std::vector<int8_t> storage;
+  std::vector<std::byte> storage;
 
   // Pending awaiters are guarded by a mutex.
   std::mutex mu;
   std::condition_variable cv;
   std::vector<std::function<void()>> awaiters;
 };
 
 // Async group provides a mechanism to group together multiple async tokens or