Introduce PAL function table (#10675)

Summary:

This is the implementation of the PAL changes described in #10432. This PR introduces a struct (`pal_table`) to hold function pointers to the PAL function implementations. There is a singleton instance of this struct, which is initialized with the weak/strong et_pal_ functions - maintaining backwards compatibility with the existing override mechanism.

I've then added wrapper functions for the PAL into the executorch::runtime namespace which dispatch through the function table. It is intended that callers use these functions instead of the "raw" et_pal_ methods in order to correctly dispatch through the function table. I also update ET callers to do this.

Differential Revision: D74121895

Author: GregoryComer

backends/xnnpack/runtime/profiling/XNNProfiler.cpp

@@ -62,7 +62,7 @@ Error XNNProfiler::start(EventTracer* event_tracer) {
   state_ = XNNProfilerState::Running;
 
   // Log the start of execution timestamp.
-  start_time_ = et_pal_current_ticks();
+  start_time_ = runtime::pal_current_ticks();
 
   return Error::Ok;
 }
@@ -187,7 +187,7 @@ void XNNProfiler::log_operator_timings() {
 
 void XNNProfiler::submit_trace() {
   // Retrieve the system tick rate (ratio between ticks and nanoseconds).
-  auto tick_ns_conv_multiplier = et_pal_ticks_to_ns_multiplier();
+  auto tick_ns_conv_multiplier = runtime::pal_ticks_to_ns_multiplier();
 
   ET_CHECK(op_timings_.size() == op_count_);
   size_t name_len = 0;

devtools/etdump/etdump_flatcc.cpp

@@ -224,7 +224,7 @@ EventTracerEntry ETDumpGen::start_profiling(
     prof_entry.chain_id = chain_id;
     prof_entry.debug_handle = debug_handle;
   }
-  prof_entry.start_time = et_pal_current_ticks();
+  prof_entry.start_time = runtime::pal_current_ticks();
   return prof_entry;
 }
 
@@ -246,15 +246,15 @@ EventTracerEntry ETDumpGen::start_profiling_delegate(
   prof_entry.event_id = delegate_debug_index == kUnsetDelegateDebugIntId
       ? create_string_entry(name)
       : delegate_debug_index;
-  prof_entry.start_time = et_pal_current_ticks();
+  prof_entry.start_time = runtime::pal_current_ticks();
   return prof_entry;
 }
 
 void ETDumpGen::end_profiling_delegate(
     EventTracerEntry event_tracer_entry,
     const void* metadata,
     size_t metadata_len) {
-  et_timestamp_t end_time = et_pal_current_ticks();
+  et_timestamp_t end_time = runtime::pal_current_ticks();
   check_ready_to_add_events();
 
   // Start building the ProfileEvent entry.
@@ -463,7 +463,7 @@ Result<bool> ETDumpGen::log_intermediate_output_delegate_helper(
 }
 
 void ETDumpGen::end_profiling(EventTracerEntry prof_entry) {
-  et_timestamp_t end_time = et_pal_current_ticks();
+  et_timestamp_t end_time = runtime::pal_current_ticks();
   ET_CHECK_MSG(
       prof_entry.delegate_event_id_type == DelegateDebugIdType::kNone,
       "Delegate events must use end_profiling_delegate to mark the end of a delegate profiling event.");

examples/portable/executor_runner/executor_runner.cpp

@@ -269,9 +269,11 @@ int main(int argc, char** argv) {
         (uint32_t)inputs.error());
     ET_LOG(Debug, "Inputs prepared.");
 
-    const et_timestamp_t before_execute = et_pal_current_ticks();
+    const et_timestamp_t before_execute =
+        executorch::runtime::pal_current_ticks();
     Error status = method->execute();
-    const et_timestamp_t after_execute = et_pal_current_ticks();
+    const et_timestamp_t after_execute =
+        executorch::runtime::pal_current_ticks();
     time_spent_executing += after_execute - before_execute;
     ET_CHECK_MSG(
         status == Error::Ok,

runtime/executor/platform_memory_allocator.h

@@ -48,7 +48,7 @@ class PlatformMemoryAllocator final : public MemoryAllocator {
 
     // Allocate enough memory for the node, the data and the alignment bump.
     size_t alloc_size = sizeof(AllocationNode) + size + alignment;
-    void* node_memory = et_pal_allocate(alloc_size);
+    void* node_memory = runtime::pal_allocate(alloc_size);
 
     // If allocation failed, log message and return nullptr.
     if (node_memory == nullptr) {
@@ -87,7 +87,7 @@ class PlatformMemoryAllocator final : public MemoryAllocator {
     AllocationNode* current = head_;
     while (current != nullptr) {
       AllocationNode* next = current->next;
-      et_pal_free(current);
+      runtime::pal_free(current);
       current = next;
     }
     head_ = nullptr;

runtime/platform/abort.cpp

@@ -17,7 +17,7 @@ namespace runtime {
  * up, and set an abnormal exit status (platform-defined).
  */
 ET_NORETURN void runtime_abort() {
-  et_pal_abort();
+  pal_abort();
 }
 
 } // namespace runtime

runtime/platform/log.cpp

@@ -23,7 +23,7 @@ namespace internal {
  * @retval Monotonically non-decreasing timestamp in system ticks.
  */
 et_timestamp_t get_log_timestamp() {
-  return et_pal_current_ticks();
+  return pal_current_ticks();
 }
 
 // Double-check that the log levels are ordered from lowest to highest severity.
@@ -96,7 +96,7 @@ void vlogf(
       ? kLevelToPal[size_t(level)]
       : et_pal_log_level_t::kUnknown;
 
-  et_pal_emit_log_message(
+  pal_emit_log_message(
       timestamp, pal_level, filename, function, line, buf, len);
 
 #endif // ET_LOG_ENABLED

runtime/platform/platform.cpp

@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ * All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include <executorch/runtime/platform/log.h>
+#include <executorch/runtime/platform/platform.h>
+#include <cstdlib>
+
+namespace executorch {
+namespace runtime {
+
+namespace {
+/**
+ * The singleton instance of the PAL function table.
+ */
+pal_table pal_impl = {
+    et_pal_init,
+    et_pal_abort,
+    et_pal_current_ticks,
+    et_pal_ticks_to_ns_multiplier,
+    et_pal_emit_log_message,
+    et_pal_allocate,
+    et_pal_free,
+    __FILE__};
+
+/**
+ * Tracks whether the PAL has been overridden. This is used to warn when
+ * multiple callers override the PAL.
+ */
+bool is_pal_overridden = false;
+} // namespace
+
+pal_table pal_table::create(
+    et_pal_emit_log_message_t emit_log_message,
+    const char* source_filename) {
+  return pal_table::create(
+      nullptr, // init
+      nullptr, // abort
+      nullptr, // current_ticks
+      nullptr, // ticks_to_ns_multiplier
+      emit_log_message,
+      nullptr, // allocate
+      nullptr, // free
+      source_filename);
+}
+
+pal_table pal_table::create(
+    et_pal_init_t init,
+    et_pal_abort_t abort,
+    et_pal_current_ticks_t current_ticks,
+    et_pal_ticks_to_ns_multiplier_t ticks_to_ns_multiplier,
+    et_pal_emit_log_message_t emit_log_message,
+    et_pal_allocate_t allocate,
+    et_pal_free_t free,
+    const char* source_filename) {
+  return pal_table{
+      init,
+      abort,
+      current_ticks,
+      ticks_to_ns_multiplier,
+      emit_log_message,
+      allocate,
+      free,
+      source_filename};
+}
+
+/**
+ * Override the PAL functions with user implementations. Any null entries in the
+ * table are unchanged and will keep the default implementation.
+ */
+bool register_pal(pal_table impl) {
+  if (is_pal_overridden) {
+    ET_LOG(
+        Error,
+        "register_pal() called multiple times. Subsequent calls will override the previous implementation. Previous implementation was registered from %s.",
+        impl.source_filename != nullptr ? impl.source_filename : "unknown");
+  }
+  is_pal_overridden = true;
+
+  if (impl.abort != nullptr) {
+    pal_impl.abort = impl.abort;
+  }
+
+  if (impl.current_ticks != nullptr) {
+    pal_impl.current_ticks = impl.current_ticks;
+  }
+
+  if (impl.ticks_to_ns_multiplier != nullptr) {
+    pal_impl.ticks_to_ns_multiplier = impl.ticks_to_ns_multiplier;
+  }
+
+  if (impl.emit_log_message != nullptr) {
+    pal_impl.emit_log_message = impl.emit_log_message;
+  }
+
+  if (impl.allocate != nullptr) {
+    pal_impl.allocate = impl.allocate;
+  }
+
+  if (impl.free != nullptr) {
+    pal_impl.free = impl.free;
+  }
+
+  if (impl.init != nullptr) {
+    pal_impl.init = impl.init;
+    if (pal_impl.init != nullptr) {
+      pal_impl.init();
+    }
+  }
+
+  return true;
+}
+
+const pal_table* get_pal_impl() {
+  return &pal_impl;
+}
+
+void pal_init() {
+  pal_impl.init();
+}
+
+ET_NORETURN void pal_abort() {
+  pal_impl.abort();
+  // This should be unreachable, but in case the PAL implementation doesn't
+  // abort, force it here.
+  std::abort();
+}
+
+et_timestamp_t pal_current_ticks() {
+  return pal_impl.current_ticks();
+}
+
+et_tick_ratio_t pal_ticks_to_ns_multiplier() {
+  return pal_impl.ticks_to_ns_multiplier();
+}
+
+void pal_emit_log_message(
+    et_timestamp_t timestamp,
+    et_pal_log_level_t level,
+    const char* filename,
+    const char* function,
+    size_t line,
+    const char* message,
+    size_t length) {
+  pal_impl.emit_log_message(
+      timestamp, level, filename, function, line, message, length);
+}
+
+void* pal_allocate(size_t size) {
+  return pal_impl.allocate(size);
+}
+
+void pal_free(void* ptr) {
+  pal_impl.free(ptr);
+}
+
+} // namespace runtime
+} // namespace executorch