[k2] add new confdata implementation

CMakeLists.txt

@@ -83,7 +83,7 @@ endif()
 add_custom_target(kphp ALL DEPENDS ${OBJS_DIR}/php_lib_version.sha256)
 
 if (COMPILE_RUNTIME_LIGHT)
-    add_dependencies(kphp kphp2cpp kphp-light-runtime-pic)
+    add_dependencies(kphp kphp2cpp kphp-light-runtime-pic kphp-confdata-pic)
 else ()
     add_dependencies(kphp kphp2cpp kphp-full-runtime-no-pic kphp-full-runtime-pic)
 endif ()
@@ -95,6 +95,10 @@ install_symlink(${VK_INSTALL_DIR}/bin/kphp2cpp ${CMAKE_INSTALL_PREFIX}/bin/kphp
 
 # k2 specific
 if(COMPILE_RUNTIME_LIGHT)
+    install(TARGETS kphp-confdata-pic
+            LIBRARY DESTINATION ${INSTALL_KPHP_SOURCE}/objs
+            COMPONENT KPHP)
+
     install(FILES ${OBJS_DIR}/libk2kphp-rt.a
             COMPONENT KPHP
             DESTINATION ${INSTALL_KPHP_SOURCE}/objs)

builtin-functions/kphp-light/stdlib/confdata-functions.txt

@@ -2,11 +2,8 @@
 
 function is_confdata_loaded(): bool;
 
-/** @kphp-extern-func-info interruptible */
 function confdata_get_value($key ::: string): mixed;
 
-/** @kphp-extern-func-info interruptible */
 function confdata_get_values_by_any_wildcard($wildcard ::: string): mixed[];
 
-/** @kphp-extern-func-info interruptible */
 function confdata_get_values_by_predefined_wildcard($wildcard ::: string): mixed[];

compiler/compiler-settings.cpp

@@ -340,6 +340,8 @@ void CompilerSettings::init() {
 
   ss << " -I" << kphp_src_path.get() + "objs/include ";
   if (is_k2_mode) {
+    // Generated code and its precompiled header must use the light runtime declarations.
+    ss << " -DRUNTIME_LIGHT";
     // for now k2-component must be compiled with clang and statically linked libc++
     ss << " -stdlib=libc++";
     if (!dynamic_incremental_linkage.get()) {

runtime-common/core/allocator/pool-allocator.h

@@ -12,17 +12,25 @@
 namespace kphp::memory {
 
 struct pool_allocator : private vk::not_copyable {
+  struct external_memory {};
+
 private:
+  enum class memory_mode {
+    owned_growable,
+    external_fixed, // Never grows or releases the externally owned backing buffer.
+  };
+
   memory_resource::unsynchronized_pool_resource memory_resource;
+  memory_mode m_memory_mode{memory_mode::owned_growable};
   size_t m_min_extra_mem_size{0};
 
   auto request_extra_memory(size_t requested_size) noexcept -> void;
 
 public:
-  pool_allocator() = default;
   pool_allocator(size_t script_mem_size, size_t min_extra_mem_size, size_t oom_handling_mem_size) noexcept;
+  // Borrows the buffer without growing it or releasing it in free().
+  pool_allocator(external_memory, void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept;
 
-  auto init(void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept -> void;
   auto free() noexcept -> void;
 
   auto alloc_script_memory(size_t size) noexcept -> void*;

runtime-common/core/allocator/runtime-allocator.h

@@ -1,32 +1,58 @@
-//  Compiler for PHP (aka KPHP)
-//  Copyright (c) 2024 LLC «V Kontakte»
-//  Distributed under the GPL v3 License, see LICENSE.notice.txt
+// Compiler for PHP (aka KPHP)
+// Copyright (c) 2024 LLC «V Kontakte»
+// Distributed under the GPL v3 License, see LICENSE.notice.txt
 
 #pragma once
 
 #include <cstddef>
+#ifdef RUNTIME_LIGHT
+#include <cstdint>
+#include <functional>
+#include <type_traits>
+#include <utility>
 
+#include "common/containers/final_action.h"
 #include "runtime-common/core/allocator/pool-allocator.h"
+#endif
 
 struct RuntimeAllocator final {
+#ifdef RUNTIME_LIGHT
 private:
   kphp::memory::pool_allocator m_allocator;
+  std::reference_wrapper<kphp::memory::pool_allocator> m_allocator_ref{m_allocator};
+#endif
 
 public:
   static auto get() noexcept -> RuntimeAllocator&;
 
-  RuntimeAllocator() = default;
+#ifdef RUNTIME_LIGHT
   RuntimeAllocator(size_t script_mem_size, size_t min_extra_mem_size, size_t oom_handling_mem_size) noexcept;
-
+#else
+  RuntimeAllocator() = default;
   auto init(void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept -> void;
+#endif
+
   auto free() noexcept -> void;
 
   auto alloc_script_memory(size_t size) noexcept -> void*;
   auto calloc_script_memory(size_t size) noexcept -> void*;
   auto realloc_script_memory(void* mem, size_t new_size, size_t old_size) noexcept -> void*;
   auto free_script_memory(void* mem, size_t size) noexcept -> void;
 
+#ifdef RUNTIME_LIGHT
   auto get_memory_resource() noexcept -> memory_resource::unsynchronized_pool_resource& {
-    return m_allocator.get_memory_resource();
+    return m_allocator_ref.get().get_memory_resource();
+  }
+
+  // The callback must run synchronously without yielding. Objects allocated by it
+  // may outlive the scope, but later operations that allocate or deallocate their
+  // memory must install the same allocator. The replacement must outlive the callback.
+  template<typename callback_type,
+           std::enable_if_t<std::is_nothrow_invocable_v<callback_type> && std::is_same_v<std::invoke_result_t<callback_type>, void>, int32_t> = 0>
+  auto with_allocator(kphp::memory::pool_allocator& replacement, callback_type&& callback) noexcept -> void {
+    const auto previous_allocator{std::exchange(m_allocator_ref, std::ref(replacement))};
+    const auto restore_allocator{vk::finally([this, previous_allocator]() noexcept { m_allocator_ref = previous_allocator; })};
+    std::invoke(std::forward<callback_type>(callback));
   }
+#endif
 };

runtime-common/core/memory-resource/resource_allocator.h

@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include <forward_list>
 #include <functional>
 #include <list>
 #include <map>
@@ -88,6 +89,9 @@ using vector = std::vector<T, resource_allocator<T, Resource>>;
 template<class T, class Resource>
 using list = std::list<T, resource_allocator<T, Resource>>;
 
+template<class T, class Resource>
+using forward_list = std::forward_list<T, resource_allocator<T, Resource>>;
+
 template<class Resource>
 using string = std::basic_string<char, std::char_traits<char>, resource_allocator<char, Resource>>;
 } // namespace stl

runtime-common/core/std/containers.h

@@ -5,6 +5,7 @@
 #pragma once
 
 #include <deque>
+#include <forward_list>
 #include <functional>
 #include <list>
 #include <map>
@@ -41,6 +42,9 @@ using queue = std::queue<T, std::deque<T, Allocator<T>>>;
 template<class T, template<class> class Allocator>
 using list = std::list<T, Allocator<T>>;
 
+template<class T, template<class> class Allocator>
+using forward_list = std::forward_list<T, Allocator<T>>;
+
 template<class T, template<class> class Allocator>
 using vector = std::vector<T, Allocator<T>>;
 

runtime-light/allocator/allocator.h

@@ -5,7 +5,8 @@
 #pragma once
 
 #include <concepts>
-#include <cstddef>
+#include <memory>
+#include <utility>
 
 #include "runtime-common/core/allocator/script-allocator-managed.h"
 #include "runtime-light/allocator/allocator-state.h"
@@ -17,6 +18,7 @@ auto make_unique_on_script_memory(Args&&... args) noexcept {
 }
 
 namespace kphp::memory {
+
 struct libc_alloc_guard final {
   libc_alloc_guard() noexcept {
     AllocatorState::get_mutable().enable_libc_alloc();

runtime-light/allocator/pool-allocator.cpp

@@ -16,25 +16,22 @@ namespace kphp::memory {
 
 pool_allocator::pool_allocator(size_t script_mem_size, size_t min_extra_mem_size, size_t oom_handling_mem_size) noexcept
     : m_min_extra_mem_size(min_extra_mem_size) {
-  // kphp::log::debug("create pool allocator -> {:p}: script memory -> {}, oom handling size -> {}", reinterpret_cast<void*>(this), script_mem_size,
-  //                 oom_handling_mem_size);
   void* buffer{kphp::memory::platform::alloc(script_mem_size)};
-
   kphp::log::assertion(buffer != nullptr);
-
   memory_resource.init(buffer, script_mem_size, oom_handling_mem_size);
 }
 
-auto pool_allocator::init(void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept -> void {
+pool_allocator::pool_allocator(external_memory /*unused*/, void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept
+    : m_memory_mode{memory_mode::external_fixed} {
   kphp::log::assertion(buffer != nullptr);
-
-  // kphp::log::debug("init pool allocator -> {:p}: buffer -> {:p}, script memory -> {}, oom handling size -> {}", reinterpret_cast<void*>(this), buffer,
-  //                  script_mem_size, oom_handling_mem_size);
   memory_resource.init(buffer, script_mem_size, oom_handling_mem_size);
 }
 
 auto pool_allocator::free() noexcept -> void {
-  // kphp::log::debug("free pool allocator -> {:p}", reinterpret_cast<void*>(this));
+  if (m_memory_mode == memory_mode::external_fixed) {
+    return;
+  }
+
   auto* extra_memory{memory_resource.get_extra_memory_head()};
   while (extra_memory->get_pool_payload_size() != 0) {
     auto* extra_memory_to_release{extra_memory};
@@ -94,6 +91,9 @@ auto pool_allocator::free_script_memory(void* mem, size_t size) noexcept -> void
 }
 
 auto pool_allocator::request_extra_memory(size_t requested_size) noexcept -> void {
+  // Fixed pools must fail on exhaustion instead of allocating outside their buffer.
+  kphp::log::assertion(m_memory_mode == memory_mode::owned_growable);
+
   // Extra mem size have to be greater than max chunk block
   const auto min_size{std::max(m_min_extra_mem_size, memory_resource::unsynchronized_pool_resource::MAX_CHUNK_BLOCK_SIZE)};
 
@@ -103,12 +103,8 @@ auto pool_allocator::request_extra_memory(size_t requested_size) noexcept -> voi
   // The smallest power of two that is not smaller than `extra_mem_size`
   extra_mem_size = std::bit_ceil(extra_mem_size);
 
-  // kphp::log::debug("requested extra memory pool with size {} bytes, will be allocated {} bytes", requested_size, extra_mem_size);
-
   auto* extra_mem{kphp::memory::platform::alloc(extra_mem_size)};
-
   kphp::log::assertion(extra_mem != nullptr);
-
   memory_resource.add_extra_memory(new (extra_mem) memory_resource::extra_memory_pool{extra_mem_size});
 }
 

runtime-light/allocator/runtime-light-allocator.cpp

@@ -3,7 +3,6 @@
 // Distributed under the GPL v3 License, see LICENSE.notice.txt
 
 #include "runtime-common/core/allocator/runtime-allocator.h"
-
 #include "runtime-light/allocator/allocator-state.h"
 
 auto RuntimeAllocator::get() noexcept -> RuntimeAllocator& {
@@ -13,26 +12,22 @@ auto RuntimeAllocator::get() noexcept -> RuntimeAllocator& {
 RuntimeAllocator::RuntimeAllocator(size_t script_mem_size, size_t min_extra_mem_size, size_t oom_handling_mem_size) noexcept
     : m_allocator{script_mem_size, min_extra_mem_size, oom_handling_mem_size} {}
 
-auto RuntimeAllocator::init(void* buffer, size_t script_mem_size, size_t oom_handling_mem_size) noexcept -> void {
-  m_allocator.init(buffer, script_mem_size, oom_handling_mem_size);
-}
-
 auto RuntimeAllocator::free() noexcept -> void {
   m_allocator.free();
 }
 
 auto RuntimeAllocator::alloc_script_memory(size_t size) noexcept -> void* {
-  return m_allocator.alloc_script_memory(size);
+  return m_allocator_ref.get().alloc_script_memory(size);
 }
 
 auto RuntimeAllocator::calloc_script_memory(size_t size) noexcept -> void* {
-  return m_allocator.calloc_script_memory(size);
+  return m_allocator_ref.get().calloc_script_memory(size);
 }
 
 auto RuntimeAllocator::realloc_script_memory(void* mem, size_t new_size, size_t old_size) noexcept -> void* {
-  return m_allocator.realloc_script_memory(mem, new_size, old_size);
+  return m_allocator_ref.get().realloc_script_memory(mem, new_size, old_size);
 }
 
 auto RuntimeAllocator::free_script_memory(void* mem, size_t size) noexcept -> void {
-  m_allocator.free_script_memory(mem, size);
+  m_allocator_ref.get().free_script_memory(mem, size);
 }

runtime-light/components/confdata/confdata-component.cpp

@@ -85,12 +85,12 @@ VISIBILITY_DEFAULT k2::PollStatus k2_poll() {
 }
 
 VISIBILITY_DEFAULT const ImageInfo* k2_describe() {
-  static constexpr std::array extra_info{ImageInfo::KeyValuePair{.key = "compiler_version", .value = K2_CONFDATA_COMPILER_VERSION}};
-  static constexpr ImageInfo image_info{.image_name = kphp::confdata::COMPONENT_NAME.data(),
+  static constexpr std::array extra_info{ImageInfo::KeyValuePair{.key = "compiler_version", .value = KPHP_CONFDATA_COMPILER_VERSION}};
+  static constexpr ImageInfo image_info{.image_name = kphp::confdata::IMAGE_NAME.data(),
                                         .is_oneshot = 0,
-                                        .build_timestamp = K2_CONFDATA_BUILD_TIMESTAMP,
+                                        .build_timestamp = KPHP_CONFDATA_BUILD_TIMESTAMP,
                                         .header_h_version = K2_PLATFORM_HEADER_H_VERSION,
-                                        .version = "0.0.1",
+                                        .version = "1.0.0",
                                         .extra_info_size = extra_info.size(),
                                         .extra_info = extra_info.data()};
   return std::addressof(image_info);