more logs for failures at load (#17986)

Summary: Just more logs for when failures happen at load

Differential Revision: D95627087

Author: JacobSzwejbka

runtime/executor/method.cpp

@@ -410,13 +410,15 @@ Error Method::parse_values(const NamedDataMap* external_data_map) {
   const size_t n_value = flatbuffer_values->size();
   values_ = memory_manager_->method_allocator()->allocateList<EValue>(n_value);
   if (values_ == nullptr) {
+    ET_LOG(Error, "Failed to allocate values array of size %zu", n_value);
     return Error::MemoryAllocationFailed;
   }
   const size_t n_input = inputs_size();
   if (n_input > 0) {
     input_set_ =
         memory_manager_->method_allocator()->allocateList<bool>(n_input);
     if (input_set_ == nullptr) {
+      ET_LOG(Error, "Failed to allocate input_set array of size %zu", n_input);
       return Error::MemoryAllocationFailed;
     }
     for (size_t i = 0; i < n_input; ++i) {
@@ -440,6 +442,10 @@ Error Method::parse_values(const NamedDataMap* external_data_map) {
         memory_manager_->method_allocator()->allocateList<NamedData>(
             max_external_constants.get());
     if (external_constants_ == nullptr) {
+      ET_LOG(
+          Error,
+          "Failed to allocate external_constants array of size %zu",
+          max_external_constants.get());
       return Error::MemoryAllocationFailed;
     }
     Error err = parse_external_constants(external_data_map);
@@ -814,6 +820,7 @@ Result<Method> Method::load(
         memory_manager->method_allocator()
             ->allocateInstance<PlatformMemoryAllocator>();
     if (platform_allocator == nullptr) {
+      ET_LOG(Error, "Failed to allocate PlatformMemoryAllocator");
       return Error::MemoryAllocationFailed;
     }
     new (platform_allocator) PlatformMemoryAllocator();
@@ -863,6 +870,8 @@ Error Method::init(
     size_t n_delegate = delegates->size();
     delegates_ = method_allocator->allocateList<BackendDelegate>(n_delegate);
     if (delegates_ == nullptr) {
+      ET_LOG(
+          Error, "Failed to allocate delegates array of size %zu", n_delegate);
       return Error::MemoryAllocationFailed;
     }
 
@@ -886,6 +895,7 @@ Error Method::init(
       merged_data_map_ =
           method_allocator->allocateInstance<internal::MergedDataMap>();
       if (merged_data_map_ == nullptr) {
+        ET_LOG(Error, "Failed to allocate MergedDataMap");
         return Error::MemoryAllocationFailed;
       }
       new (merged_data_map_) internal::MergedDataMap(std::move(merged.get()));
@@ -938,6 +948,7 @@ Error Method::init(
     n_chains_ = chains->size();
     chains_ = method_allocator->allocateList<Chain>(n_chains_);
     if (chains_ == nullptr) {
+      ET_LOG(Error, "Failed to allocate chains array of size %zu", n_chains_);
       return Error::MemoryAllocationFailed;
     }
 
@@ -957,11 +968,15 @@ Error Method::init(
       auto chain_instruction_kernels =
           method_allocator->allocateList<OpFunction>(num_instructions);
       if (chain_instruction_kernels == nullptr) {
+        ET_LOG(
+            Error, "Failed to allocate instruction kernels for chain %zu", i);
         return Error::MemoryAllocationFailed;
       }
       auto chain_instruction_arg_lists =
           method_allocator->allocateList<InstructionArgs>(num_instructions);
       if (chain_instruction_arg_lists == nullptr) {
+        ET_LOG(
+            Error, "Failed to allocate instruction arg lists for chain %zu", i);
         return Error::MemoryAllocationFailed;
       }
 

runtime/executor/program.cpp

@@ -291,13 +291,19 @@ size_t Program::num_methods() const {
 
 Result<const char*> Program::get_method_name(size_t plan_index) const {
   if (plan_index >= this->num_methods()) {
+    ET_LOG(
+        Error,
+        "Plan index %zu >= num methods %zu",
+        plan_index,
+        this->num_methods());
     return Error::InvalidArgument;
   }
   auto internal_program =
       static_cast<const executorch_flatbuffer::Program*>(internal_program_);
   // We know that the execution plan exists because num_methods() returned > 0.
   auto name = internal_program->execution_plan()->Get(plan_index)->name();
   if (name == nullptr) {
+    ET_LOG(Error, "Execution plan %zu has null name", plan_index);
     return Error::InvalidProgram;
   }
   return name->c_str();

runtime/executor/program_validation.cpp

@@ -22,11 +22,13 @@ namespace runtime {
 ET_NODISCARD Error
 validate_tensor(const executorch_flatbuffer::Tensor* tensor) {
   if (tensor == nullptr) {
+    ET_LOG(Error, "Tensor is null");
     return Error::InvalidProgram;
   }
 
   const auto* sizes = tensor->sizes();
   if (sizes == nullptr) {
+    ET_LOG(Error, "Tensor has null sizes");
     return Error::InvalidProgram;
   }
 
@@ -82,6 +84,7 @@ validate_tensor(const executorch_flatbuffer::Tensor* tensor) {
 ET_NODISCARD Error
 validate_program(const executorch_flatbuffer::Program* program) {
   if (program == nullptr) {
+    ET_LOG(Error, "Program is null");
     return Error::InvalidProgram;
   }
 

schema/extended_header.cpp

@@ -70,6 +70,11 @@ uint64_t GetUInt64LE(const uint8_t* data) {
     const void* data,
     size_t size) {
   if (size < ExtendedHeader::kNumHeadBytes) {
+    ET_LOG(
+        Error,
+        "Extended header data size %zu < minimum %zu",
+        size,
+        ExtendedHeader::kNumHeadBytes);
     return Error::InvalidArgument;
   }
   const uint8_t* header =