Atomic values support. (#1695)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/descriptors/DescriptorUtils.kt

@@ -83,17 +83,17 @@ internal fun IrSimpleFunction.resolveFakeOverride(): IrSimpleFunction {
 }
 
 private val intrinsicAnnotation = FqName("konan.internal.Intrinsic")
-private val immutableAnnotation = FqName("konan.internal.Immutable")
+private val frozenAnnotation = FqName("konan.internal.Frozen")
 
 // TODO: don't forget to remove descriptor access here.
 internal val FunctionDescriptor.isIntrinsic: Boolean
     get() = this.descriptor.annotations.hasAnnotation(intrinsicAnnotation)
 
-internal val org.jetbrains.kotlin.descriptors.DeclarationDescriptor.isImmutable: Boolean
-    get() = this.annotations.hasAnnotation(immutableAnnotation)
+internal val org.jetbrains.kotlin.descriptors.DeclarationDescriptor.isFrozen: Boolean
+    get() = this.annotations.hasAnnotation(frozenAnnotation)
 
-internal val DeclarationDescriptor.isImmutable: Boolean
-    get() = this.descriptor.isImmutable
+internal val DeclarationDescriptor.isFrozen: Boolean
+    get() = this.descriptor.isFrozen
 
 private val intrinsicTypes = setOf(
         "kotlin.Boolean", "kotlin.Char",

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/IrToBitcode.kt

@@ -42,7 +42,6 @@ import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid
 import org.jetbrains.kotlin.ir.visitors.acceptVoid
 import org.jetbrains.kotlin.konan.target.CompilerOutputKind
 import org.jetbrains.kotlin.konan.target.KonanTarget
-import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
@@ -1413,7 +1412,7 @@ internal class CodeGeneratorVisitor(val context: Context, val lifetimes: Map<IrE
     private fun needMutationCheck(descriptor: org.jetbrains.kotlin.descriptors.DeclarationDescriptor): Boolean {
         // For now we omit mutation checks on immutable types, as this allows initialization in constructor
         // and it is assumed that API doesn't allow to change them.
-        return !descriptor.isImmutable
+        return !descriptor.isFrozen
     }
 
     private fun evaluateSetField(value: IrSetField): LLVMValueRef {

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/llvm/RTTIGenerator.kt

@@ -20,7 +20,6 @@ import llvm.*
 import org.jetbrains.kotlin.backend.konan.Context
 import org.jetbrains.kotlin.backend.konan.descriptors.*
 import org.jetbrains.kotlin.backend.konan.irasdescriptors.*
-import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.declarations.IrProperty
 import org.jetbrains.kotlin.name.FqName
@@ -31,7 +30,7 @@ internal class RTTIGenerator(override val context: Context) : ContextUtils {
 
     private fun flagsFromClass(classDescriptor: ClassDescriptor): Int {
         var result = 0
-        if (classDescriptor.isImmutable)
+        if (classDescriptor.isFrozen)
            result = result or 1 /* TF_IMMUTABLE */
         return result
     }

backend.native/tests/build.gradle

@@ -671,6 +671,12 @@ task freeze2(type: RunKonanTest) {
     source = "runtime/workers/freeze2.kt"
 }
 
+task atomic0(type: RunKonanTest) {
+    disabled = (project.testTarget == 'wasm32') // Workers need pthreads.
+    goldValue = "35\n" + "20\n"
+    source = "runtime/workers/atomic0.kt"
+}
+
 task enumIdentity(type: RunKonanTest) {
     disabled = (project.testTarget == 'wasm32') // Workers need pthreads.
     goldValue = "true\n"

backend.native/tests/runtime/workers/atomic0.kt

@@ -0,0 +1,83 @@
+package runtime.workers.atomic0
+
+import kotlin.test.*
+
+import konan.worker.*
+
+fun test1(workers: Array<Worker>) {
+    val atomic = AtomicInt(15)
+    val futures = Array(workers.size, { workerIndex ->
+        workers[workerIndex].schedule(TransferMode.CHECKED, { atomic }) {
+            input -> input.increment()
+        }
+    })
+    futures.forEach {
+        it.result()
+    }
+    println(atomic.get())
+}
+
+fun test2(workers: Array<Worker>) {
+    val atomic = AtomicInt(0)
+    val counter = AtomicInt(0)
+    val futures = Array(workers.size, { workerIndex ->
+        workers[workerIndex].schedule(TransferMode.CHECKED, { Triple(atomic, workerIndex, counter) }) {
+            (place, index, result) ->
+            while (place.compareAndSwap(index, index + 1) != index) {}
+            result.increment() == index + 1
+        }
+    })
+    futures.forEach {
+        assertEquals(it.result(), true)
+    }
+    println(counter.get())
+}
+
+data class Data(val value: Int)
+
+fun test3(workers: Array<Worker>) {
+    val common = AtomicReference<Data>()
+    val futures = Array(workers.size, { workerIndex ->
+        workers[workerIndex].schedule(TransferMode.CHECKED, { Pair(common, workerIndex) }) {
+            (place, index) ->
+            val mine = Data(index).freeze()
+            // Try to publish our own data, until successful, in a tight loop.
+            while (place.compareAndSwap(null, mine) != null) {}
+        }
+    })
+    val seen = mutableSetOf<Data>()
+    for (i in 0 until workers.size) {
+        do {
+            val current = common.get()
+            if (current != null && !seen.contains(current)) {
+                seen += current
+                // Let others publish.
+                assertEquals(common.compareAndSwap(current, null), current)
+                break
+            }
+        } while (true)
+    }
+    futures.forEach {
+        it.result()
+    }
+    assertEquals(seen.size, workers.size)
+}
+
+fun test4() {
+    assertFailsWith<InvalidMutabilityException> {
+        AtomicReference(Data(1))
+    }
+    assertFailsWith<InvalidMutabilityException> {
+        AtomicReference<Data>().compareAndSwap(null, Data(2))
+    }
+}
+
+@Test fun runTest() {
+    val COUNT = 20
+    val workers = Array(COUNT, { _ -> startWorker()})
+
+    test1(workers)
+    test2(workers)
+    test3(workers)
+    test4()
+}