JS memory management. (#181)

.github/workflows/blank.yml

@@ -18,7 +18,6 @@ jobs:
    macos:
     # The type of runner that the job will run on
     runs-on: macos-10.15
-
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
@@ -35,7 +34,6 @@ jobs:
           ./gradlew -Pskiko.native.enabled=true publishToMavenLocal
    linux:
     runs-on: ubuntu-16.04
-    
     # Steps represent a sequence of tasks that will be executed as part of the job
     steps:
       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
@@ -61,6 +59,36 @@ jobs:
           sudo apt-get install ninja-build fontconfig libfontconfig1-dev libglu1-mesa-dev libxrandr-dev zip -y
           ./gradlew jvmTest
           ./gradlew publishToMavenLocal
+   js:
+     runs-on: ubuntu-20.04
+     # Steps represent a sequence of tasks that will be executed as part of the job
+     steps:
+       # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+       - uses: actions/checkout@v2
+       - uses: actions/setup-java@v2
+         with:
+           distribution: 'adopt'
+           java-version: '11'
+       # Runs a set of commands using the runners shell
+       - shell: bash
+         run: |
+           cd ./skiko
+           sudo apt-get update -y
+           sudo apt-get install binutils build-essential -y
+           sudo apt-get install software-properties-common -y
+           sudo apt-get install python git curl wget -y
+           if [ -d ./emsdk ]; then
+             cd ./emsdk
+             git pull
+           else
+             git clone https://github.com/emscripten-core/emsdk.git
+             cd ./emsdk
+           fi
+           ./emsdk install 2.0.29
+           ./emsdk activate 2.0.29
+           source ./emsdk_env.sh
+           cd ..
+           ./gradlew skikoJsJar
    windows:
     runs-on: windows-2019
     steps:

skiko/build.gradle.kts

@@ -117,7 +117,7 @@ kotlin {
             testTask {
                 testLogging.showStandardStreams = true
                 dependsOn(project.tasks.named("wasmCompile"))
-                useKarma() {
+                useKarma {
                     useChromeHeadless()
                 }
             }
@@ -338,15 +338,14 @@ project.tasks.register<Exec>("objcCompile") {
 
 project.tasks.register<Exec>("wasmCompile") {
     dependsOn(skiaWasmDir)
+    val skiaDir = skiaWasmDir.get().absolutePath
     val inputDir = "$projectDir/src/jsMain/cpp"
     val outDir = "$buildDir/wasm"
     val names = File(inputDir).listFiles()!!.filter { it.name.endsWith(".cc") }.map { it.name.removeSuffix(".cc") }
     val srcs = names.map { "$inputDir/$it.cc" }.toTypedArray()
     val outJs = "$outDir/skiko.js"
     val outWasm = "$outDir/skiko.wasm"
-    val skiaDir = skiaWasmDir.get().absolutePath
     workingDir = File(outDir)
-    val libs = fileTree("$skiaDir/out/Release-wasm-wasm").filter { it.name.endsWith(".a") }
     commandLine = listOf(
         "emcc",
         *Arch.Wasm.clangFlags,
@@ -355,12 +354,14 @@ project.tasks.register<Exec>("wasmCompile") {
         "-I$skiaDir/include/core",
         "-I$skiaDir/include/effects",
         "-I$skiaDir/include/gpu",
-        "-std=c++17",
-        "--bind",
         "-o", outJs,
-        *libs.files.map { it.absolutePath }.toTypedArray(),
         *srcs
     )
+    argumentProviders.add(CommandLineArgumentProvider {
+        val skiaBinDir = "$skiaDir/out/${buildType.id}-wasm-wasm"
+        // We must compute this list after Skia unpacking task has finished.
+        listOf(skiaBinDir).findAllFiles(".a")
+    })
     file(outDir).mkdirs()
     inputs.files(srcs)
     outputs.files(outJs, outWasm)
@@ -662,11 +663,6 @@ project.tasks.register<Jar>("skikoJsJar") {
     }
 }
 
-project.tasks.register<JavaExec>("run") {
-    main = "org.jetbrains.skiko.MainKt"
-    classpath = files(skikoJvmRuntimeJar.map { it.archiveFile })
-}
-
 // disable unexpected native publications (default C++ publications are failing)
 tasks.withType<AbstractPublishToMaven>().configureEach {
     doFirst {
@@ -808,8 +804,7 @@ publishing {
                     afterEvaluate {
                         artifact(project.tasks.withType(KotlinNativeCompile::class.java)
                                 .single { it.name.startsWith("compileKotlin") } // Exclude compileTestKotlin.
-                                .outputs.getFiles().single { it.name.endsWith(".klib") }
-                                )
+                                .outputs.files.single { it.name.endsWith(".klib") })
                     }
             }
         }

skiko/buildSrc/src/main/kotlin/properties.kt

@@ -15,7 +15,7 @@ enum class OS(val id: String, val clangFlags: Array<String>) {
 enum class Arch(val id: String, val clangFlags: Array<String>) {
     X64("x64", arrayOf("-arch", "x86_64")),
     Arm64("arm64", arrayOf("-arch", "arm64")),
-    Wasm("wasm", emptyArray())
+    Wasm("wasm", arrayOf("-std=c++17", "--bind"))
 }
 
 enum class SkiaBuildType(

skiko/src/jsMain/cpp/BackendRenderTarget.cc

@@ -9,7 +9,7 @@ static void deleteBackendRenderTarget(GrBackendRenderTarget* rt) {
 
 EMSCRIPTEN_KEEPALIVE
 extern "C" KPointer BackendRenderTarget_nGetFinalizer() {
-    return static_cast<KPointer>(reinterpret_cast<uintptr_t>(&deleteBackendRenderTarget));
+    return reinterpret_cast<KPointer>(reinterpret_cast<uintptr_t>(&deleteBackendRenderTarget));
 }
 
 EMSCRIPTEN_KEEPALIVE

skiko/src/jsMain/cpp/ColorFilter.cc

@@ -4,6 +4,7 @@
 #include "SkLumaColorFilter.h"
 #include "SkOverdrawColorFilter.h"
 #include "SkTableColorFilter.h"
+
 #include "common.h"
 
 #include <emscripten.h>

skiko/src/jsMain/cpp/ColorSpace.cc

@@ -3,6 +3,7 @@
 #include "common.h"
 #include <emscripten.h>
 
+EMSCRIPTEN_KEEPALIVE
 extern "C" void org_jetbrains_skia_ColorSpace__nConvert(
         KPointer fromPtr, KPointer toPtr, float r, float g, float b, float a, float* result) {
     SkColorSpace* from = reinterpret_cast<SkColorSpace*>(fromPtr);

skiko/src/jsMain/cpp/Managed.cc

+#include "common.h"
+#include <emscripten.h>
+
+typedef void (*finalizer_t)(void*);
+
+EMSCRIPTEN_KEEPALIVE
+extern "C" void org_jetbrains_skia_ColorSpace__nInvokeFinalizer(KPointer finalizer, KPointer obj) {
+    finalizer_t finalizer_f = reinterpret_cast<finalizer_t>(finalizer);
+    finalizer_f(obj);
+}
\ No newline at end of file

skiko/src/jsMain/cpp/RefCnt.cc

+#include <emscripten.h>
+
+#include "common.h"
+
+#include "SkRefCnt.h"
+
+class SkRefCntHack {
+public:
+    void* x;
+    mutable std::atomic<int32_t> fRefCnt;
+};
+
+void unrefSkRefCnt(SkRefCnt* p) {
+    p->unref();
+}
+
+EMSCRIPTEN_KEEPALIVE
+extern "C" KPointer org_jetbrains_skia_impl_RefCnt__1nGetFinalizer() {
+    return reinterpret_cast<KPointer>(&unrefSkRefCnt);
+}
+
+EMSCRIPTEN_KEEPALIVE
+extern "C" KInt org_jetbrains_skia_impl_RefCnt__1nGetRefCount(KPointer ptr) {
+    SkRefCnt* instance = reinterpret_cast<SkRefCnt*>(ptr);
+    return reinterpret_cast<SkRefCntHack*>(instance)->fRefCnt.load(std::memory_order_relaxed);
+}

skiko/src/jsMain/cpp/common.h

 #pragma once
 
+#include <stdint.h>
+
 typedef int32_t KInt;
 typedef int64_t KLong;
-typedef int32_t KPointer;
+typedef void* KPointer;
 
 typedef uint8_t* KByteArray;

skiko/src/jsMain/kotlin/org/jetbrains/skia/impl/Library.js.kt

@@ -3,6 +3,7 @@ package org.jetbrains.skia.impl
 actual class Library {
     actual companion object {
         actual fun staticLoad() {
+            // TODO: load wasm and js modules, maybe just js, as it will load Wasm.
             TODO()
         }
     }

skiko/src/jsMain/kotlin/org/jetbrains/skia/impl/Managed.js.kt

 package org.jetbrains.skia.impl
 
+private class FinalizationThunk(private val finalizer: NativePointer, private var obj: NativePointer) {
+    fun clean() {
+        if (obj != 0)
+            _nInvokeFinalizer(finalizer, obj)
+        obj = 0
+    }
+}
+
+external class FinalizationRegistry(cleanup: (dynamic) -> Unit) {
+    fun register(obj: dynamic, handle: dynamic)
+    fun unregister(obj: dynamic)
+}
+
+private val registry = FinalizationRegistry {
+    val thunk = it as FinalizationThunk
+    thunk.clean()
+}
+
+private fun register(managed: Managed, thunk: FinalizationThunk) {
+    registry.register(managed, thunk)
+}
+
+private fun unregister(managed: Managed) {
+    registry.unregister(managed)
+}
+
 actual abstract class Managed actual constructor(ptr: NativePointer, finalizer: NativePointer, managed: Boolean) : Native(ptr) {
-    actual open fun close(): Unit = TODO()
+    private var cleaner: FinalizationThunk? = null
+
+    actual open fun close() {
+        if (NullPointer == _ptr)
+            throw RuntimeException("Object already closed: ${this::class.simpleName}, _ptr=$_ptr")
+        else if (null == cleaner)
+            throw RuntimeException("Object is not managed, can't close(): ${this::class.simpleName}, _ptr=$_ptr")
+        else {
+            unregister(this)
+            cleaner!!.clean()
+            cleaner = null
+            _ptr = 0
+        }
+    }
 
     actual open val isClosed: Boolean
         get() = _ptr == NullPointer
-}
+
\ No newline at end of file
+    init {
+        if (managed) {
+            require(ptr != 0) { "Managed ptr is 0" }
+            require(finalizer != 0) { "Managed finalizer is 0" }
+            val thunk = FinalizationThunk(ptr, finalizer)
+            register(this, thunk)
+            cleaner = thunk
+        }
+    }
+}
+
+@JsName("org_jetbrains_skia_Managed__invokeFinalizer")
+private external fun _nInvokeFinalizer(finalizer: NativePointer, obj: NativePointer)
\ No newline at end of file

skiko/src/jsMain/kotlin/org/jetbrains/skia/impl/RefCnt.js.kt

 package org.jetbrains.skia.impl
 
 actual abstract class RefCnt : Managed {
-    actual protected constructor(ptr: NativePointer): super(ptr, NullPointer, false) { TODO() }
-    actual protected constructor(ptr: NativePointer, allowClose: Boolean): super(ptr, 0, allowClose) { TODO() }
-}
+    actual protected constructor(ptr: NativePointer): super(ptr, _FinalizerHolder.PTR, false)
+    actual protected constructor(ptr: NativePointer, allowClose: Boolean): super(ptr, _FinalizerHolder.PTR, allowClose)
+
\ No newline at end of file
+    val refCount: Int
+        get() {
+            Stats.onNativeCall()
+            return _nGetRefCount(_ptr)
+        }
+
+    override fun toString(): String {
+        val s = super.toString()
+        return s.substring(0, s.length - 1) + ", refCount=" + refCount + ")"
+    }
+}
+
+private object _FinalizerHolder {
+    val PTR = _nGetFinalizer()
+}
+
+@JsName("org_jetbrains_skia_RefCnt__nGetFinalizer")
+private external fun _nGetFinalizer(): NativePointer
+@JsName("org_jetbrains_skia_RefCnt__nGetCount")
+private external fun _nGetRefCount(ptr: NativePointer): Int

skiko/src/jsMain/kotlin/org/jetbrains/skia/impl/Stats.js.kt

 package org.jetbrains.skia.impl
 
 actual object Stats {
-    actual fun onNativeCall() {
-        TODO()
-    }
+    actual fun onNativeCall() {}
 
-    actual fun onAllocated(className: String) {
-        TODO()
-    }
+    actual fun onAllocated(className: String) {}
 
-    actual fun onDeallocated(className: String) {
-        TODO()
-    }
+    actual fun onDeallocated(className: String) {}
 }
\ No newline at end of file

skiko/src/jvmMain/kotlin/org/jetbrains/skia/impl/Managed.jvm.kt

@@ -6,9 +6,11 @@ actual abstract class Managed actual constructor(ptr: Long, finalizer: Long, man
     AutoCloseable {
     private var _cleanable: Cleaner.Cleanable? = null
     actual override fun close() {
-        if (0L == _ptr) throw RuntimeException("Object already closed: $javaClass, _ptr=$_ptr") else if (null == _cleanable) throw RuntimeException(
-            "Object is not managed in JVM, can't close(): $javaClass, _ptr=$_ptr"
-        ) else {
+        if (0L == _ptr)
+            throw RuntimeException("Object already closed: $javaClass, _ptr=$_ptr")
+        else if (null == _cleanable)
+            throw RuntimeException("Object is not managed in JVM, can't close(): $javaClass, _ptr=$_ptr")
+        else {
             _cleanable!!.clean()
             _cleanable = null
             _ptr = 0

skiko/src/jvmMain/kotlin/org/jetbrains/skia/impl/RefCnt.jvm.kt

@@ -3,7 +3,7 @@ package org.jetbrains.skia.impl
 import java.lang.ref.Reference
 
 actual abstract class RefCnt : Managed {
-    protected actual constructor(ptr: NativePointer) : super(ptr, _FinalizerHolder.PTR) {}
+    protected actual constructor(ptr: NativePointer) : super(ptr, _FinalizerHolder.PTR)
     protected actual constructor(ptr: NativePointer, allowClose: Boolean) : super(ptr, _FinalizerHolder.PTR, allowClose)
 
     val refCount: Int