[vm] Cleanup experimental createUriForKernelBlob API

This API was added in https://dart-review.googlesource.com/c/sdk/+/232682
in order to support one of the strategies for running macros,
but it is no longer needed.

TEST=ci

Change-Id: I8da233932351f27fd5dfd01b66f481195d7ca0e1
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/407540
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: alexmarkov

pkg/frontend_server/test/frontend_server_test.dart

@@ -1773,11 +1773,6 @@ extension type Foo(int value) {
         }
       }
 
-      Uri registerKernelBlob(Uint8List bytes) {
-        bytes = new Uint8List.fromList(bytes);
-        return (Isolate.current as dynamic).createUriForKernelBlob(bytes);
-      }
-
       Future<void> runWithServer(
         Future<void> Function(RequestChannel) f,
       ) async {
@@ -1941,11 +1936,6 @@ void main(List<String> arguments, SendPort sendPort) {
             );
 
             expect(kernelBytes, hasLength(greaterThan(200)));
-            final Uri kernelUri = registerKernelBlob(kernelBytes);
-
-            final ReceivePort receivePort = new ReceivePort();
-            await Isolate.spawnUri(kernelUri, [], receivePort.sendPort);
-            expect(await receivePort.first, 42);
           });
         });
       });

runtime/bin/dfe.cc

@@ -9,7 +9,6 @@
 #include "bin/error_exit.h"
 #include "bin/exe_utils.h"
 #include "bin/file.h"
-#include "bin/lockers.h"
 #include "bin/platform.h"
 #include "bin/snapshot_utils.h"
 #include "bin/utils.h"
@@ -67,9 +66,7 @@ DFE::DFE()
       use_incremental_compiler_(false),
       frontend_filename_(nullptr),
       application_kernel_buffer_(nullptr),
-      application_kernel_buffer_size_(0),
-      kernel_blobs_(&SimpleHashMap::SameStringValue, 4),
-      kernel_blobs_lock_() {}
+      application_kernel_buffer_size_(0) {}
 
 DFE::~DFE() {
   if (frontend_filename_ != nullptr) {
@@ -80,9 +77,6 @@ DFE::~DFE() {
   free(application_kernel_buffer_);
   application_kernel_buffer_ = nullptr;
   application_kernel_buffer_size_ = 0;
-
-  kernel_blobs_.Clear(
-      [](void* value) { delete reinterpret_cast<KernelBlob*>(value); });
 }
 
 void DFE::Init() {
@@ -242,19 +236,14 @@ void DFE::ReadScript(const char* script_uri,
                      const AppSnapshot* app_snapshot,
                      uint8_t** kernel_buffer,
                      intptr_t* kernel_buffer_size,
-                     bool decode_uri,
-                     std::shared_ptr<uint8_t>* kernel_blob_ptr) {
+                     bool decode_uri) const {
   int64_t start = Dart_TimelineGetMicros();
   if (!TryReadKernelFile(script_uri, app_snapshot, kernel_buffer,
-                         kernel_buffer_size, decode_uri, kernel_blob_ptr)) {
+                         kernel_buffer_size, decode_uri)) {
     return;
   }
   if (!Dart_IsKernel(*kernel_buffer, *kernel_buffer_size)) {
-    if (kernel_blob_ptr != nullptr && *kernel_blob_ptr) {
-      *kernel_blob_ptr = nullptr;
-    } else {
-      free(*kernel_buffer);
-    }
+    free(*kernel_buffer);
     *kernel_buffer = nullptr;
     *kernel_buffer_size = -1;
   }
@@ -438,20 +427,10 @@ bool DFE::TryReadKernelFile(const char* script_uri,
                             const AppSnapshot* app_snapshot,
                             uint8_t** kernel_ir,
                             intptr_t* kernel_ir_size,
-                            bool decode_uri,
-                            std::shared_ptr<uint8_t>* kernel_blob_ptr) {
+                            bool decode_uri) const {
   *kernel_ir = nullptr;
   *kernel_ir_size = -1;
 
-  if (decode_uri && kernel_blob_ptr != nullptr) {
-    *kernel_blob_ptr = TryFindKernelBlob(script_uri, kernel_ir_size);
-    if (*kernel_blob_ptr) {
-      *kernel_ir = kernel_blob_ptr->get();
-      ASSERT(DartUtils::SniffForMagicNumber(*kernel_ir, *kernel_ir_size) ==
-             DartUtils::kKernelMagicNumber);
-      return true;
-    }
-  }
   if (app_snapshot == nullptr || app_snapshot->IsKernel() ||
       app_snapshot->IsKernelList()) {
     uint8_t* buffer;
@@ -479,72 +458,5 @@ bool DFE::TryReadKernelFile(const char* script_uri,
   return false;
 }
 
-const char* DFE::RegisterKernelBlob(const uint8_t* kernel_buffer,
-                                    intptr_t kernel_buffer_size) {
-  ASSERT(DartUtils::SniffForMagicNumber(kernel_buffer, kernel_buffer_size) ==
-         DartUtils::kKernelMagicNumber);
-  uint8_t* buffer_copy = reinterpret_cast<uint8_t*>(malloc(kernel_buffer_size));
-  if (buffer_copy == nullptr) {
-    return nullptr;
-  }
-  memmove(buffer_copy, kernel_buffer, kernel_buffer_size);
-
-  MutexLocker ml(&kernel_blobs_lock_);
-  ++kernel_blob_counter_;
-  char* uri =
-      Utils::SCreate("dart-kernel-blob://blob%" Pd, kernel_blob_counter_);
-  KernelBlob* blob = new KernelBlob(uri, buffer_copy, kernel_buffer_size);
-
-  const uint32_t hash = SimpleHashMap::StringHash(uri);
-  SimpleHashMap::Entry* entry =
-      kernel_blobs_.Lookup(uri, hash, /*insert=*/true);
-  ASSERT(entry != nullptr);
-  ASSERT(entry->value == nullptr);
-  entry->value = blob;
-
-  return uri;
-}
-
-std::shared_ptr<uint8_t> DFE::TryFindKernelBlob(const char* uri,
-                                                intptr_t* kernel_length) {
-  *kernel_length = -1;
-
-  MutexLocker ml(&kernel_blobs_lock_);
-  if (kernel_blob_counter_ == 0) {
-    return nullptr;
-  }
-
-  // This const_cast is safe as this 'key' is only used to find entry, not add.
-  void* key = const_cast<char*>(uri);
-  const uint32_t hash = SimpleHashMap::StringHash(uri);
-  SimpleHashMap::Entry* entry =
-      kernel_blobs_.Lookup(key, hash, /*insert=*/false);
-  if (entry == nullptr) {
-    return nullptr;
-  }
-
-  KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value);
-  *kernel_length = blob->size();
-  return blob->buffer();
-}
-
-void DFE::UnregisterKernelBlob(const char* uri) {
-  MutexLocker ml(&kernel_blobs_lock_);
-
-  // This const_cast is safe as this 'key' is only used to find entry, not add.
-  void* key = const_cast<char*>(uri);
-  const uint32_t hash = SimpleHashMap::StringHash(uri);
-  SimpleHashMap::Entry* entry =
-      kernel_blobs_.Lookup(key, hash, /*insert=*/false);
-  if (entry == nullptr) {
-    return;
-  }
-
-  KernelBlob* blob = reinterpret_cast<KernelBlob*>(entry->value);
-  entry->value = nullptr;
-  kernel_blobs_.Remove(key, hash);
-  delete blob;
-}
-
 }  // namespace bin
 }  // namespace dart

runtime/bin/dfe.h

@@ -7,12 +7,10 @@
 
 #include <memory>
 
-#include "bin/thread.h"
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/globals.h"
-#include "platform/hashmap.h"
 #include "platform/utils.h"
 
 namespace dart {
@@ -97,34 +95,26 @@ class DFE {
   // Returns an in memory kernel representation of the specified script is a
   // valid kernel file, sets 'kernel_buffer' to nullptr otherwise.
   //
-  // If 'kernel_blob_ptr' is not nullptr, then this function can also
-  // read kernel blobs. In such case it sets 'kernel_blob_ptr'
-  // to a shared pointer which owns the kernel buffer.
-  // Otherwise, the caller is responsible for free()ing 'kernel_buffer'.
+  // The caller is responsible for free()ing 'kernel_buffer'.
   void ReadScript(const char* script_uri,
                   const AppSnapshot* app_snapshot,
                   uint8_t** kernel_buffer,
                   intptr_t* kernel_buffer_size,
-                  bool decode_uri = true,
-                  std::shared_ptr<uint8_t>* kernel_blob_ptr = nullptr);
+                  bool decode_uri = true) const;
 
   bool KernelServiceDillAvailable() const;
 
   // Tries to read 'script_uri' as a Kernel IR file.
   // Returns `true` if successful and sets 'kernel_buffer' and 'kernel_length'
   // to be the kernel IR contents.
   //
-  // If 'kernel_blob_ptr' is not nullptr, then this function can also
-  // read kernel blobs. In such case it sets 'kernel_blob_ptr'
-  // to a shared pointer which owns the kernel buffer.
-  // Otherwise, the caller is responsible for free()ing 'kernel_buffer'
+  // The caller is responsible for free()ing 'kernel_buffer'
   // if `true` was returned.
   bool TryReadKernelFile(const char* script_uri,
                          const AppSnapshot* app_snapshot,
                          uint8_t** kernel_buffer,
                          intptr_t* kernel_buffer_size,
-                         bool decode_uri = true,
-                         std::shared_ptr<uint8_t>* kernel_blob_ptr = nullptr);
+                         bool decode_uri = true) const;
 
   // We distinguish between "intent to use Dart frontend" vs "can actually
   // use Dart frontend". The method UseDartFrontend tells us about the
@@ -137,22 +127,6 @@ class DFE {
   void LoadKernelService(const uint8_t** kernel_service_buffer,
                          intptr_t* kernel_service_buffer_size);
 
-  // Registers given kernel blob and returns blob URI which
-  // can be used in TryReadKernelFile later to load the given kernel.
-  // Data from [kernel_buffer] is copied, it doesn't need to stay alive.
-  // Returns nullptr if failed to allocate memory.
-  const char* RegisterKernelBlob(const uint8_t* kernel_buffer,
-                                 intptr_t kernel_buffer_size);
-
-  // Looks for kernel blob using the given [uri].
-  // Returns non-null pointer to the kernel blob if successful and
-  // sets [kernel_length].
-  std::shared_ptr<uint8_t> TryFindKernelBlob(const char* uri,
-                                             intptr_t* kernel_length);
-
-  // Unregisters kernel blob with given URI.
-  void UnregisterKernelBlob(const char* uri);
-
  private:
   bool use_dfe_;
   bool use_incremental_compiler_;
@@ -164,33 +138,11 @@ class DFE {
   uint8_t* application_kernel_buffer_;
   intptr_t application_kernel_buffer_size_;
 
-  // Registry of kernel blobs. Maps URI (char *) to KernelBlob.
-  SimpleHashMap kernel_blobs_;
-  intptr_t kernel_blob_counter_ = 0;
-  Mutex kernel_blobs_lock_;
-
   void InitKernelServiceAndPlatformDills();
 
   DISALLOW_COPY_AND_ASSIGN(DFE);
 };
 
-class KernelBlob {
- public:
-  // Takes ownership over [uri] and [buffer].
-  KernelBlob(char* uri, uint8_t* buffer, intptr_t size)
-      : uri_(uri), buffer_(buffer, std::free), size_(size) {}
-
-  std::shared_ptr<uint8_t> buffer() { return buffer_; }
-  intptr_t size() const { return size_; }
-
- private:
-  CStringUniquePtr uri_;
-  std::shared_ptr<uint8_t> buffer_;
-  const intptr_t size_;
-
-  DISALLOW_COPY_AND_ASSIGN(KernelBlob);
-};
-
 class PathSanitizer {
  public:
   explicit PathSanitizer(const char* path);

runtime/bin/isolate_data.h

@@ -66,16 +66,6 @@ class IsolateGroupData {
     kernel_buffer_size_ = size;
   }
 
-  // Associate the given kernel buffer with this IsolateGroupData and give it
-  // ownership of the buffer. The buffer is already owned by another
-  // IsolateGroupData.
-  void SetKernelBufferAlreadyOwned(std::shared_ptr<uint8_t> buffer,
-                                   intptr_t size) {
-    ASSERT(kernel_buffer_.get() == nullptr);
-    kernel_buffer_ = std::move(buffer);
-    kernel_buffer_size_ = size;
-  }
-
   const char* resolved_packages_config() const {
     return resolved_packages_config_;
   }

runtime/bin/main_impl.cc

@@ -696,7 +696,6 @@ static Dart_Isolate CreateIsolateGroupAndSetupHelper(
   int64_t start = Dart_TimelineGetMicros();
   ASSERT(script_uri != nullptr);
   uint8_t* kernel_buffer = nullptr;
-  std::shared_ptr<uint8_t> kernel_buffer_ptr;
   intptr_t kernel_buffer_size = 0;
   AppSnapshot* app_snapshot = nullptr;
 
@@ -762,8 +761,7 @@ static Dart_Isolate CreateIsolateGroupAndSetupHelper(
 
   if (kernel_buffer == nullptr && !isolate_run_app_snapshot) {
     dfe.ReadScript(script_uri, app_snapshot, &kernel_buffer,
-                   &kernel_buffer_size, /*decode_uri=*/true,
-                   &kernel_buffer_ptr);
+                   &kernel_buffer_size, /*decode_uri=*/true);
   }
   PathSanitizer script_uri_sanitizer(script_uri);
   PathSanitizer packages_config_sanitizer(packages_config);
@@ -772,13 +770,8 @@ static Dart_Isolate CreateIsolateGroupAndSetupHelper(
   auto isolate_group_data = new IsolateGroupData(
       script_uri, packages_config, app_snapshot, isolate_run_app_snapshot);
   if (kernel_buffer != nullptr) {
-    if (kernel_buffer_ptr) {
-      isolate_group_data->SetKernelBufferAlreadyOwned(
-          std::move(kernel_buffer_ptr), kernel_buffer_size);
-    } else {
-      isolate_group_data->SetKernelBufferNewlyOwned(kernel_buffer,
-                                                    kernel_buffer_size);
-    }
+    isolate_group_data->SetKernelBufferNewlyOwned(kernel_buffer,
+                                                  kernel_buffer_size);
   }
 
   Dart_Isolate isolate = nullptr;
@@ -896,16 +889,6 @@ static Dart_Isolate CreateIsolateGroupAndSetup(const char* script_uri,
                                           error, &exit_code);
 }
 
-#if !defined(DART_PRECOMPILED_RUNTIME)
-static const char* RegisterKernelBlob(const uint8_t* kernel_buffer,
-                                      intptr_t kernel_buffer_size) {
-  return dfe.RegisterKernelBlob(kernel_buffer, kernel_buffer_size);
-}
-static void UnregisterKernelBlob(const char* kernel_blob_uri) {
-  dfe.UnregisterKernelBlob(kernel_blob_uri);
-}
-#endif  // !defined(DART_PRECOMPILED_RUNTIME)
-
 static void OnIsolateShutdown(void* isolate_group_data, void* isolate_data) {
   Dart_EnterScope();
   Dart_Handle sticky_error = Dart_GetStickyError();
@@ -1399,10 +1382,6 @@ void main(int argc, char** argv) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   init_params.start_kernel_isolate =
       dfe.UseDartFrontend() && dfe.CanUseDartFrontend();
-  if (init_params.start_kernel_isolate) {
-    init_params.register_kernel_blob = RegisterKernelBlob;
-    init_params.unregister_kernel_blob = UnregisterKernelBlob;
-  }
 #else
   init_params.start_kernel_isolate = false;
 #endif