Use std allocator

Author: trueangle

build.gradle.kts

@@ -9,4 +9,12 @@ plugins {
 allprojects {
     group = "io.github.trueangle"
     version = "0.0.2"
-}
+}
+/*
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile> {
+    compilerOptions {
+        freeCompilerArgs.add("-Xallocator=std")
+        freeCompilerArgs.add("-Xruntime-logs=gc=info")
+    }
+}*/

lambda-runtime/build.gradle.kts

@@ -1,4 +1,5 @@
 import dev.mokkery.MockMode
+import org.jetbrains.kotlin.gradle.plugin.mpp.NativeBuildType
 
 plugins {
     alias(libs.plugins.kotlin.multiplatform)
@@ -9,10 +10,23 @@ plugins {
 }
 
 kotlin {
-    macosArm64()
+    macosArm64 {
+        binaries {
+            getTest(NativeBuildType.DEBUG).freeCompilerArgs += listOf("-Xruntime-logs=gc=info", "-Xallocator=std")
+            executable {
+                freeCompilerArgs += listOf("-Xallocator=std")
+            }
+        }
+    }
     macosX64()
     //linuxArm64() // https://youtrack.jetbrains.com/issue/KT-36871/Support-Aarch64-Linux-as-a-host-for-the-Kotlin-Native
-    linuxX64()
+    linuxX64 {
+        binaries {
+            executable {
+                freeCompilerArgs += listOf("-Xruntime-logs=gc=info", "-Xallocator=std")
+            }
+        }
+    }
 
     sourceSets {
         commonMain.dependencies {

lambda-runtime/src/commonMain/kotlin/io/github/trueangle/knative/lambda/runtime/api/LambdaRuntimeClient.kt

@@ -21,6 +21,7 @@ import io.ktor.client.statement.HttpResponse
 import io.ktor.http.HttpStatusCode
 import io.ktor.http.content.OutgoingContent
 import io.ktor.http.contentType
+import io.ktor.http.isSuccess
 import io.ktor.util.reflect.TypeInfo
 import kotlinx.serialization.json.Json
 import kotlin.time.Duration.Companion.minutes
@@ -53,6 +54,11 @@ internal class LambdaClientImpl(private val httpClient: HttpClient): LambdaClien
                 exponentialDelay()
             }
         }
+
+        if(!response.status.isSuccess()) {
+            throw NonRecoverableStateException(message = "Lambda environment is unavailable. Can't retrieve an event. Terminating")
+        }
+
         val context = contextFromResponseHeaders(response)
         val body = try {
             response.body(bodyType) as T

lambda-runtime/src/nativeTest/kotlin/io/github/trueangle/knative/lambda/runtime/LambdaRuntimeTest.kt

@@ -11,7 +11,8 @@ import dev.mokkery.verify.VerifyMode.Companion.exactly
 import dev.mokkery.verify.VerifyMode.Companion.not
 import dev.mokkery.verify.VerifyMode.Companion.order
 import dev.mokkery.verifySuspend
-import io.github.trueangle.knative.lambda.runtime.LambdaEnvironmentException.*
+import io.github.trueangle.knative.lambda.runtime.LambdaEnvironmentException.BadRequestException
+import io.github.trueangle.knative.lambda.runtime.LambdaEnvironmentException.NonRecoverableStateException
 import io.github.trueangle.knative.lambda.runtime.LambdaRuntimeException.Invocation.EventBodyParseException
 import io.github.trueangle.knative.lambda.runtime.LambdaRuntimeException.Invocation.HandlerException
 import io.github.trueangle.knative.lambda.runtime.ReservedRuntimeEnvironmentVariables.AWS_LAMBDA_FUNCTION_NAME
@@ -33,12 +34,8 @@ import io.ktor.client.engine.mock.MockRequestHandleScope
 import io.ktor.client.engine.mock.respond
 import io.ktor.client.engine.mock.respondBadRequest
 import io.ktor.client.engine.mock.respondError
-import io.ktor.client.engine.mock.respondOk
-import io.ktor.client.request.HttpRequestData
 import io.ktor.http.HttpHeaders
 import io.ktor.http.HttpStatusCode
-import io.ktor.http.content.ChannelWriterContent
-import io.ktor.http.content.OutgoingContent
 import io.ktor.http.headers
 import io.ktor.http.headersOf
 import io.ktor.util.reflect.typeInfo
@@ -48,16 +45,15 @@ import io.ktor.utils.io.copyTo
 import kotlinx.cinterop.ExperimentalForeignApi
 import kotlinx.cinterop.toKString
 import kotlinx.coroutines.test.runTest
-import kotlinx.io.Buffer
-import kotlinx.io.RawSource
-import kotlinx.io.Source
 import kotlinx.serialization.json.Json
 import platform.posix.getenv
 import platform.posix.setenv
+import kotlin.experimental.ExperimentalNativeApi
+import kotlin.native.runtime.GC
+import kotlin.native.runtime.NativeRuntimeApi
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertFailsWith
-import kotlin.test.assertTrue
 
 internal const val RESOURCES_PATH = "src/nativeTest/resources"
 
@@ -197,10 +193,7 @@ class LambdaRuntimeTest {
         val lambdaRunner = createRunner(MockEngine { request ->
             val path = request.url.encodedPath
             when {
-                path.contains("/invocation/next") -> {
-                    respondError(HttpStatusCode.InternalServerError)
-                }
-
+                path.contains("/invocation/next") -> respondError(HttpStatusCode.InternalServerError)
                 else -> respondError(HttpStatusCode.Forbidden)
             }
         })
@@ -368,6 +361,68 @@ class LambdaRuntimeTest {
         verify(not) { lambdaRunner.env.terminate() }
     }
 
+    @OptIn(NativeRuntimeApi::class, ExperimentalStdlibApi::class, ExperimentalNativeApi::class)
+    @Test
+    fun `Validate leaks`() = runTest {
+        val invocationCount = 3
+        var invocationIndex = 0
+        val events = buildList(invocationCount) {
+            repeat(invocationCount) { add("Hello world") }
+        }
+
+        val lambdaRunner = createRunner(MockEngine { request ->
+            val path = request.url.encodedPath
+            when {
+                path.contains("invocation/next") -> {
+                    if (invocationIndex >= invocationCount) {
+                        respondError(HttpStatusCode.InternalServerError, headers = headers {
+                            append(HttpHeaders.ContentType, "application/json")
+                            append("Lambda-Runtime-Aws-Request-Id", context.awsRequestId)
+                            append("Lambda-Runtime-Deadline-Ms", context.deadlineTimeInMs.toString())
+                            append("Lambda-Runtime-Invoked-Function-Arn", context.invokedFunctionArn)
+                        })
+                    } else {
+                        respondNextEventSuccess(events[invocationIndex++])
+                    }
+                }
+
+                path.contains("/invocation/${context.awsRequestId}/response") -> respond(
+                    content = ByteReadChannel("Ok"),
+                    status = HttpStatusCode.Accepted,
+                    headers = headersOf(HttpHeaders.ContentType, "application/json")
+                )
+
+                else -> respondBadRequest()
+            }
+        })
+
+        val handler = object : LambdaBufferedHandler<String, String> {
+            override suspend fun handleRequest(input: String, context: Context): String = "Hello"
+        }
+
+        assertFailsWith<TerminateException> {
+            lambdaRunner.run { handler }
+        }
+
+        GC.collect()
+        GC.lastGCInfo?.let {gcInfo->
+            println(
+                "Heap Size Before: ${
+                    gcInfo.memoryUsageBefore.map {
+                        it.key + " - " + it.value.totalObjectsSizeBytes / 1024 / 1024
+                    }
+                }"
+            )
+            println(
+                "Heap Size After: ${
+                    gcInfo.memoryUsageAfter.map {
+                        it.key + " - " + it.value.totalObjectsSizeBytes / 1024 / 1024
+                    }
+                }"
+            )
+        }
+    }
+
     @OptIn(ExperimentalForeignApi::class)
     private fun mockEnvironment() {
         if (getenv(AWS_LAMBDA_FUNCTION_NAME)?.toKString().isNullOrEmpty()) {