Remove remainder of support for external startup data (#1758)

* feat: Remove V8 heap snapshot machinery

As per NativeScript/NativeScript#8926, this
isn't supported. "heapSnapshotScript" and "heapSnapshotBlob" keys in
package.json will be ignored, but I believe this isn't a breaking change
because I think they were already nonfunctional.

The V8 library is updated with a build configured with
v8_use_external_startup_data=false, and we can remove the snapshot_blob.h
files because the snapshot data no longer needs to be compiled into the
runtime.

The V8 artifacts were built using NativeScript/v8-buildscripts and GitHub
Actions, with the following provenance:

arm64: commit 0368bca, job https://github.com/NativeScript/v8-buildscripts/actions/runs/4895461273
arm: commit b074e10, job https://github.com/NativeScript/v8-buildscripts/actions/runs/4895462464
x86_64: commit a9bf41b, job https://github.com/NativeScript/v8-buildscripts/actions/runs/4895463287
x86: commit e7aa7ed, job https://github.com/NativeScript/v8-buildscripts/actions/runs/4895464030

* chore: Remove File::Exists()

This was primarily used by the heap snapshot code which is now removed.

It was also used internally in File::ReadBinary(), but that wasn't
necessary, as fopen() also handles the file not existing.

In new code, it's probably a good idea to perform operations without
checking if the file exists first anyway, as otherwise it can lead to race
conditions if the file is deleted.

* chore: Remove MemoryMappedFile

This was only used by the snapshot code, which is now removed.

Author: ptomato

test-app/app/src/main/java/com/tns/RuntimeHelper.java

@@ -112,19 +112,6 @@ public static Runtime initRuntime(Context context) {
                         aE.extractAssets(context, "internal", outputDir, extractPolicy, removePreviouslyInstalledAssets);
                         aE.extractAssets(context, "metadata", outputDir, extractPolicy, false);
 
-                        boolean shouldExtractSnapshots = true;
-
-                        // will extract snapshot of the device appropriate architecture
-                        if (shouldExtractSnapshots) {
-                            if (logger.isEnabled()) {
-                                logger.write("Extracting snapshot blob");
-                            }
-
-                            @SuppressWarnings("deprecation")
-                            String cpu_abi = Build.CPU_ABI;
-                            aE.extractAssets(context, "snapshots/" + cpu_abi, outputDir, extractPolicy, removePreviouslyInstalledAssets);
-                        }
-
                         extractPolicy.setAssetsThumb(context);
                     } finally {
                         extractionFrame.close();

test-app/runtime/CMakeLists.txt

@@ -52,8 +52,6 @@ include_directories(
         src/main/cpp
         src/main/cpp/include
         src/main/cpp/v8_inspector
-        # This folder contains V8's built-in natives and snapshot blobs
-        src/main/libs/${ANDROID_ABI}/include
 )
 
 if (OPTIMIZED_BUILD OR OPTIMIZED_WITH_INSPECTOR_BUILD)

test-app/runtime/src/main/cpp/Constants.cpp

@@ -10,5 +10,3 @@
 std::string Constants::APP_ROOT_FOLDER_PATH = "";
 bool Constants::V8_CACHE_COMPILED_CODE = false;
 std::string Constants::V8_STARTUP_FLAGS = "";
-std::string Constants::V8_HEAP_SNAPSHOT_SCRIPT = "";
-std::string Constants::V8_HEAP_SNAPSHOT_BLOB = "";

test-app/runtime/src/main/cpp/Constants.h

@@ -9,8 +9,6 @@ class Constants {
 
         static std::string APP_ROOT_FOLDER_PATH;
         static std::string V8_STARTUP_FLAGS;
-        static std::string V8_HEAP_SNAPSHOT_SCRIPT;
-        static std::string V8_HEAP_SNAPSHOT_BLOB;
         static bool V8_CACHE_COMPILED_CODE;
 
     private:

test-app/runtime/src/main/cpp/File.cpp

@@ -14,10 +14,7 @@
 using namespace std;
 
 namespace tns {
-bool File::Exists(const string& path) {
-    std::ifstream infile(path.c_str());
-    return infile.good();
-}
+
 string File::ReadText(const string& filePath) {
     int len;
     bool isNew;
@@ -34,9 +31,6 @@ string File::ReadText(const string& filePath) {
 
 void* File::ReadBinary(const string& filePath, int& length) {
     length = 0;
-    if (!File::Exists(filePath)) {
-        return nullptr;
-    }
 
     auto file = fopen(filePath.c_str(), READ_BINARY);
     if (!file) {
@@ -89,34 +83,6 @@ const char* File::ReadText(const string& filePath, int& charLength, bool& isNew)
     return Buffer;
 }
 
-MemoryMappedFile MemoryMappedFile::Open(const char* filePath) {
-    void* memory = nullptr;
-    int length = 0;
-    if (FILE* file = fopen(filePath, "r+")) {
-        if (fseek(file, 0, SEEK_END) == 0) {
-            length = ftell(file);
-            if (length >= 0) {
-                memory = mmap(NULL, length, PROT_READ, MAP_SHARED, fileno(file), 0);
-                if (memory == MAP_FAILED) {
-                    memory = nullptr;
-                }
-            }
-        }
-        fclose(file);
-    }
-    return MemoryMappedFile(memory, length);
-}
-
-MemoryMappedFile::MemoryMappedFile(void* memory, size_t size)
-    :
-    memory(memory), size(size) {
-}
-
-MemoryMappedFile::~MemoryMappedFile() {
-    int result = munmap(this->memory, this->size);
-    assert(result == 0);
-}
-
 char* File::Buffer = new char[BUFFER_SIZE];
 
 const char* File::WRITE_BINARY = "wb";

test-app/runtime/src/main/cpp/File.h

@@ -11,20 +11,10 @@
 #include <string>
 
 namespace tns {
-struct MemoryMappedFile final {
-    static MemoryMappedFile Open(const char* filePath);
-    MemoryMappedFile(void* memory, size_t size);
-    ~MemoryMappedFile();
-
-    void* memory = nullptr;
-    size_t size = 0;
-};
-
 class File {
     public:
         static const char* ReadText(const std::string& filePath, int& length, bool& isNew);
         static std::string ReadText(const std::string& filePath);
-        static bool Exists(const std::string& filePath);
         static bool WriteBinary(const std::string& filePath, const void* inData, int length);
         static void* ReadBinary(const std::string& filePath, int& length);
     private:

test-app/runtime/src/main/cpp/Runtime.cpp

@@ -26,7 +26,6 @@
 #include <console/Console.h>
 #include "sys/system_properties.h"
 #include "ManualInstrumentation.h"
-#include <snapshot_blob.h>
 #include "IsolateDisposer.h"
 #include <unistd.h>
 #include <thread>
@@ -186,15 +185,12 @@ void Runtime::Init(JNIEnv* env, jstring filesPath, jstring nativeLibDir, bool ve
 
     Constants::APP_ROOT_FOLDER_PATH = filesRoot + "/app/";
     // read config options passed from Java
+    // Indices correspond to positions in the com.tns.AppConfig.KnownKeys enum
     JniLocalRef v8Flags(env->GetObjectArrayElement(args, 0));
     Constants::V8_STARTUP_FLAGS = ArgConverter::jstringToString(v8Flags);
     JniLocalRef cacheCode(env->GetObjectArrayElement(args, 1));
     Constants::V8_CACHE_COMPILED_CODE = (bool) cacheCode;
-    JniLocalRef snapshotScript(env->GetObjectArrayElement(args, 2));
-    Constants::V8_HEAP_SNAPSHOT_SCRIPT = ArgConverter::jstringToString(snapshotScript);
-    JniLocalRef snapshotBlob(env->GetObjectArrayElement(args, 3));
-    Constants::V8_HEAP_SNAPSHOT_BLOB = ArgConverter::jstringToString(snapshotBlob);
-    JniLocalRef profilerOutputDir(env->GetObjectArrayElement(args, 4));
+    JniLocalRef profilerOutputDir(env->GetObjectArrayElement(args, 2));
 
     DEBUG_WRITE("Initializing Telerik NativeScript");
 
@@ -207,8 +203,6 @@ void Runtime::Init(JNIEnv* env, jstring filesPath, jstring nativeLibDir, bool ve
 Runtime::~Runtime() {
     delete this->m_objectManager;
     delete this->m_loopTimer;
-    delete this->m_heapSnapshotBlob;
-    delete this->m_startupData;
     CallbackHandlers::RemoveIsolateEntries(m_isolate);
     if (m_isMainThread) {
         if (m_mainLooper_fd[0] != -1) {
@@ -460,11 +454,6 @@ void Runtime::PassUncaughtExceptionFromWorkerToMainHandler(Local<v8::String> mes
     env.CallStaticVoidMethod(runtimeClass, mId, (jstring) jMsgLocal, (jstring) jfileNameLocal, (jstring) stTrace, lineno);
 }
 
-void Runtime::ClearStartupData(JNIEnv* env, jobject obj) {
-    delete m_heapSnapshotBlob;
-    delete m_startupData;
-}
-
 static void InitializeV8() {
     Runtime::platform = v8::platform::NewDefaultPlatform().release();
     V8::InitializePlatform(Runtime::platform);
@@ -475,117 +464,14 @@ Isolate* Runtime::PrepareV8Runtime(const string& filesPath, const string& native
     tns::instrumentation::Frame frame("Runtime.PrepareV8Runtime");
 
     Isolate::CreateParams create_params;
-    bool didInitializeV8 = false;
 
     create_params.array_buffer_allocator = &g_allocator;
 
-    m_startupData = new StartupData();
-
-    void* snapshotPtr = nullptr;
-    string snapshotPath;
-    bool snapshotPathExists = false;
-
-    // If device isn't running on Sdk 17
-    if (m_androidVersion != 17) {
-        snapshotPath = "libsnapshot.so";
-    } else {
-        // If device is running on android Sdk 17
-        // dlopen reads relative path to dynamic libraries or reads from folder different than the nativeLibsDirs on the android device
-        snapshotPath = nativeLibDir + "/libsnapshot.so";
-    }
-
-    snapshotPtr = dlopen(snapshotPath.c_str(), RTLD_LAZY | RTLD_LOCAL);
-    if (snapshotPtr == nullptr) {
-        auto ignoredSearchValue = string("library \"" + snapshotPath + "\" not found");
-        auto currentError = dlerror();
-        std::string stringError(currentError);
-        if (stringError.find(ignoredSearchValue) == std::string::npos) {
-            DEBUG_WRITE_FORCE("Failed to load snapshot: %s", currentError);
-        }
-    }
-
-    bool isCustomSnapshotFound = false;
-    if (snapshotPtr) {
-        m_startupData->data = static_cast<const char*>(dlsym(snapshotPtr, "TNSSnapshot_blob"));
-        m_startupData->raw_size = *static_cast<const unsigned int*>(dlsym(snapshotPtr, "TNSSnapshot_blob_len"));
-        V8::SetSnapshotDataBlob(m_startupData);
-        isCustomSnapshotFound = true;
-        DEBUG_WRITE_FORCE("Snapshot library read %p (%dB).", m_startupData->data, m_startupData->raw_size);
-    } else if (!Constants::V8_HEAP_SNAPSHOT_BLOB.empty() || !Constants::V8_HEAP_SNAPSHOT_SCRIPT.empty()) {
-        DEBUG_WRITE_FORCE("Snapshot enabled.");
-
-        bool saveSnapshot = true;
-        // we have a precompiled snapshot blob provided - try to load it directly
-        if (!Constants::V8_HEAP_SNAPSHOT_BLOB.empty()) {
-            snapshotPath = Constants::V8_HEAP_SNAPSHOT_BLOB;
-            snapshotPathExists = File::Exists(snapshotPath);
-            saveSnapshot = false;
-        } else {
-            std::string oldSnapshotBlobPath = filesPath + "/internal/snapshot.blob";
-            std::string snapshotBlobPath = filesPath + "/internal/TNSSnapshot.blob";
-
-            bool oldSnapshotExists = File::Exists(oldSnapshotBlobPath);
-            bool snapshotExists = File::Exists(snapshotBlobPath);
-
-            snapshotPathExists = oldSnapshotExists || snapshotExists;
-            snapshotPath = oldSnapshotExists ? oldSnapshotBlobPath : snapshotBlobPath;
-        }
-
-        if (snapshotPathExists) {
-            m_heapSnapshotBlob = new MemoryMappedFile(MemoryMappedFile::Open(snapshotPath.c_str()));
-            m_startupData->data = static_cast<const char*>(m_heapSnapshotBlob->memory);
-            m_startupData->raw_size = m_heapSnapshotBlob->size;
-            V8::SetSnapshotDataBlob(m_startupData);
-            isCustomSnapshotFound = true;
-            DEBUG_WRITE_FORCE("Snapshot read %s (%zuB).", snapshotPath.c_str(), m_heapSnapshotBlob->size);
-        } else if (!saveSnapshot) {
-            throw NativeScriptException("No snapshot file found at: " + snapshotPath);
-        } else {
-            InitializeV8();
-            didInitializeV8 = true;
-
-            string customScript;
-
-            // check for custom script to include in the snapshot
-            if (!Constants::V8_HEAP_SNAPSHOT_SCRIPT.empty() && File::Exists(Constants::V8_HEAP_SNAPSHOT_SCRIPT)) {
-                customScript = ReadFileText(Constants::V8_HEAP_SNAPSHOT_SCRIPT);
-            }
-
-            DEBUG_WRITE_FORCE("Creating heap snapshot");
-            *m_startupData = Runtime::CreateSnapshotDataBlob(customScript.c_str());
-
-            if (m_startupData->raw_size == 0) {
-                DEBUG_WRITE_FORCE("Failed to create heap snapshot.");
-            } else {
-                bool writeSuccess = File::WriteBinary(snapshotPath, m_startupData->data, m_startupData->raw_size);
-
-                if (!writeSuccess) {
-                    DEBUG_WRITE_FORCE("Failed to save created snapshot.");
-                } else {
-                    DEBUG_WRITE_FORCE("Saved snapshot of %s (%zuB) in %s (%dB)",
-                                      Constants::V8_HEAP_SNAPSHOT_SCRIPT.c_str(), customScript.size(),
-                                      snapshotPath.c_str(), m_startupData->raw_size);
-                }
-            }
-
-            V8::SetSnapshotDataBlob(m_startupData);
-            isCustomSnapshotFound = true;
-        }
-    }
-
-    if (!isCustomSnapshotFound) {
-        // Load V8's built-in snapshot
-        auto* snapshotBlobStartupData = new StartupData();
-        snapshotBlobStartupData->data = reinterpret_cast<const char*>(&snapshot_blob_bin[0]);
-        snapshotBlobStartupData->raw_size = snapshot_blob_bin_len;
-        V8::SetSnapshotDataBlob(snapshotBlobStartupData);
-    }
-
     /*
      * Setup the V8Platform only once per process - once for the application lifetime
      * Don't execute again if main thread has already been initialized
      */
-    if (!didInitializeV8 && !s_mainThreadInitialized) {
+    if (!s_mainThreadInitialized) {
         InitializeV8();
     }
 
@@ -782,60 +668,6 @@ void Runtime::SetManualInstrumentationMode(jstring mode) {
     }
 }
 
-StartupData Runtime::CreateSnapshotDataBlob(const char* embedded_source) {
-    // Create a new isolate and a new context from scratch, optionally run
-    // a script to embed, and serialize to create a snapshot blob.
-    StartupData result = {nullptr, 0};
-    {
-        SnapshotCreator snapshot_creator;
-        Isolate* isolate = snapshot_creator.GetIsolate();
-        {
-            HandleScope scope(isolate);
-            Local<Context> context = Context::New(isolate);
-            if (embedded_source != nullptr &&
-                    !Runtime::RunExtraCode(isolate, context, embedded_source, "<embedded>")) {
-                return result;
-            }
-            snapshot_creator.SetDefaultContext(context);
-        }
-        result = snapshot_creator.CreateBlob(
-                     SnapshotCreator::FunctionCodeHandling::kClear);
-    }
-
-    return result;
-}
-
-bool Runtime::RunExtraCode(Isolate* isolate, Local<Context> context, const char* utf8_source, const char* name) {
-    Context::Scope context_scope(context);
-    TryCatch try_catch(isolate);
-    Local<v8::String> source_string;
-    if (!v8::String::NewFromUtf8(isolate, utf8_source, NewStringType::kNormal).ToLocal(&source_string)) {
-        return false;
-    }
-    Local<v8::String> resource_name = v8::String::NewFromUtf8(isolate, name, NewStringType::kNormal).ToLocalChecked();
-    ScriptOrigin origin(isolate, resource_name);
-    ScriptCompiler::Source source(source_string, origin);
-    Local<Script> script;
-    if (!ScriptCompiler::Compile(context, &source).ToLocal(&script)) {
-        DEBUG_WRITE_FORCE("# Script compile failed in %s@%d:%d\n%s\n",
-                          *v8::String::Utf8Value(isolate, try_catch.Message()->GetScriptResourceName()),
-                          try_catch.Message()->GetLineNumber(context).FromJust(),
-                          try_catch.Message()->GetStartColumn(context).FromJust(),
-                          *v8::String::Utf8Value(isolate, try_catch.Exception()));
-        return false;
-    }
-    if (script->Run(context).IsEmpty()) {
-        DEBUG_WRITE_FORCE("# Script run failed in %s@%d:%d\n%s\n",
-                          *v8::String::Utf8Value(isolate, try_catch.Message()->GetScriptResourceName()),
-                          try_catch.Message()->GetLineNumber(context).FromJust(),
-                          try_catch.Message()->GetStartColumn(context).FromJust(),
-                          *v8::String::Utf8Value(isolate, try_catch.Exception()));
-        return false;
-    }
-//    CHECK(!try_catch.HasCaught());
-    return true;
-}
-
 void Runtime::DestroyRuntime() {
     s_id2RuntimeCache.erase(m_id);
     s_isolate2RuntimesCache.erase(m_isolate);

test-app/runtime/src/main/cpp/Runtime.h

@@ -60,7 +60,6 @@ class Runtime {
         bool TryCallGC();
         void PassExceptionToJsNative(JNIEnv* env, jobject obj, jthrowable exception, jstring message, jstring fullStackTrace, jstring jsStackTrace, jboolean isDiscarded);
         void PassUncaughtExceptionFromWorkerToMainHandler(v8::Local<v8::String> message, v8::Local<v8::String> stackTrace, v8::Local<v8::String> filename, int lineno);
-        void ClearStartupData(JNIEnv* env, jobject obj);
         void DestroyRuntime();
 
         void Lock();
@@ -101,9 +100,6 @@ class Runtime {
 
         MessageLoopTimer* m_loopTimer;
 
-        v8::StartupData* m_startupData = nullptr;
-        MemoryMappedFile* m_heapSnapshotBlob = nullptr;
-
         int64_t m_lastUsedMemory;
 
         v8::Persistent<v8::Function>* m_gcFunc;
@@ -115,8 +111,6 @@ class Runtime {
 
         v8::Isolate* PrepareV8Runtime(const std::string& filesPath, const std::string& nativeLibsDir, const std::string& packageName, bool isDebuggable, const std::string& callingDir, const std::string& profilerOutputDir, const int maxLogcatObjectSize, const bool forceLog);
         jobject ConvertJsValueToJavaObject(JEnv& env, const v8::Local<v8::Value>& value, int classReturnType);
-        static v8::StartupData CreateSnapshotDataBlob(const char* embedded_source);
-        static bool RunExtraCode(v8::Isolate* isolate, v8::Local<v8::Context> context, const char* utf8_source, const char* name);
         static int GetAndroidVersion();
         static int m_androidVersion;
 

test-app/runtime/src/main/cpp/com_tns_Runtime.cpp

@@ -288,15 +288,6 @@ extern "C" JNIEXPORT void Java_com_tns_Runtime_passExceptionToJsNative(JNIEnv* e
     }
 }
 
-extern "C" JNIEXPORT void Java_com_tns_Runtime_clearStartupData(JNIEnv* env, jobject obj, jint runtimeId) {
-    auto runtime = TryGetRuntime(runtimeId);
-    if (runtime == nullptr) {
-        return;
-    }
-
-    runtime->ClearStartupData(env, obj);
-}
-
 extern "C" JNIEXPORT jint Java_com_tns_Runtime_getPointerSize(JNIEnv* env, jobject obj) {
     return sizeof(void*);
 }