Multithreading/develop

.github/workflows/run-tests-linux-multiarch.yml

@@ -83,19 +83,21 @@ jobs:
         build-mode: [debug, release-fast]
         lto: [none, thin]
         gc: [boehm, immix, commix]
+        multithreading: [true, false]
         exclude:
-          # Immix does not suppoort Immix/Commix GCs
-          - gc: immix
-            arch: linux-x86
-          - gc: commix
-            arch: linux-x86
+          # LTO is broken on linux-x86/llvm-10
+          - arch: linux-x86
+            lto: thin
           # Release without LTO produces 1 big file taking long to compile, especially when emulated
           - build-mode: release-fast
             lto: none
           - build-mode: release-size
             lto: none
           - build-mode: debug
             lto: thin
+          # Commix does not support multithreading
+          - gc: commix
+            multithreading: true
           # Reduce ammount of builds combinations
           - gc: immix
             lto: none
@@ -123,7 +125,7 @@ jobs:
         with:
           path: /tmp/docker-registry
           key: docker-registry-${{ hashFiles('ci-docker/Dockerfile') }}-${{matrix.arch}}
-     
+
       - name: Prepare native config
         shell: bash
         # Following envs CROSS_ are always present in docker container
@@ -137,20 +139,18 @@ jobs:
 
           SetConfigTemplate=$(cat << EOM
             nativeConfig ~= { prev =>
-              val sysRoot: List[String] = Option{
-                sys.process.stringSeqToProcess(
-                  Seq(
+              val sysRoot: List[String] =
+                if(Seq("linux-x86").contains("${{ matrix.arch }}")) Nil
+                else Option {
+                  sys.process.stringSeqToProcess(Seq(
                     s"\${sys.env("CROSS_ROOT")}/bin/\${sys.env("CROSS_TRIPLE")}-gcc",
                     "-print-sysroot"
-                  )
-                ).!!.trim
-              }.filter(_.nonEmpty)
-                .fold(List.empty[String]){ root =>
-                  List(
+                  )).!!.trim
+                  }.filter(_.nonEmpty)
+                  .fold(List.empty[String]){ root => List(
                     s"--sysroot=\${root}",
                     s"--gcc-toolchain=\${sys.env("CROSS_ROOT")}"
-                  )
-                };
+                  )};
 
               prev
                 .withMode(scalanative.build.Mode.${buildMode})
@@ -160,22 +160,19 @@ jobs:
                 .withOptimize(true)
                 .withCheck(true)
                 .withCheckFatalWarnings(true)
-                .withTargetTriple(sys.env("CROSS_TRIPLE"))
+                .withTargetTriple(sys.env.get("CROSS_TRIPLE"))
+                .withMultithreadingSupport(${{matrix.multithreading}})
                 .withCompileOptions(
                   prev.compileOptions ++ sysRoot ++ List("-fuse-ld=lld")
                 )
                 .withLinkingOptions(
-                  prev.linkingOptions ++ sysRoot ++ List("-fuse-ld=lld")
+                  prev.linkingOptions ++ sysRoot ++ List("-fuse-ld=lld", "-latomic")
                 )
             }
           EOM
           )
 
-          if [[ "${{matrix.arch}}" == "linux-x86" ]]; then
-            echo set-native-config=nativeConfig ~= identity >> $GITHUB_ENV
-          else
-            echo set-native-config=${SetConfigTemplate} >> $GITHUB_ENV
-          fi
+          echo set-native-config=${SetConfigTemplate} >> $GITHUB_ENV
 
       # Conditionally disable some of the tests (Scala 2 only)
       - name: Set filters for partests

.github/workflows/run-tests-linux.yml

@@ -26,6 +26,7 @@ jobs:
       - uses: ./.github/actions/linux-setup-env
         with:
           scala-version: ${{matrix.scala}}
+          java-version: 8
 
       - name: Test tools
         run: sbt "++ ${{ matrix.scala }} -v" "-no-colors" "-J-Xmx3G" "test-tools ${{ matrix.scala }}"
@@ -43,6 +44,12 @@ jobs:
           "scalaPartest${{env.project-version}}/fetchScalaSource"
           scala-cli scripts/partest-check-files.scala -- ${{ matrix.scala }}
 
+        # scala-cli-setup can override default java version
+      - uses: ./.github/actions/linux-setup-env
+        with:
+          scala-version: ${{matrix.scala}}
+          java-version: 8
+
         # Running all partests would take ~2h for each Scala version, run only single test of each kind
         # to make sure that infrastructure works correctly.
       - name: Run subset of partest tests
@@ -187,3 +194,66 @@ jobs:
         run: |
           export LLVM_BIN=$(dirname $(readlink -f /usr/bin/clang))
           sbt "test-scripted ${{matrix.scala}}"
+
+  test-multihreading:
+    name: Test experimental multithreading support
+    runs-on: ubuntu-20.04
+    needs: tests-tools
+    strategy:
+      fail-fast: false
+      matrix:
+        scala: [3.2.1, 2.13.10]
+        build-mode: [debug, release-fast]
+        gc: [boehm, immix]
+        lto: [thin]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/linux-setup-env
+        with:
+          scala-version: ${{matrix.scala}}
+
+      - name: Prepare native config command
+        shell: bash
+        # Following envs CROSS_ are always present in docker container
+        run: |
+          buildMode=${{matrix.build-mode}}
+          if [[ "$buildMode" == "release-fast" ]]; then 
+            buildMode=releaseFast
+          fi
+
+          SetConfigTemplate=$(cat << EOM
+            nativeConfig ~= { prev =>
+              prev
+                .withMode(scalanative.build.Mode.${buildMode})
+                .withGC(scalanative.build.GC.${{matrix.gc}})
+                .withLTO(scalanative.build.LTO.${{matrix.lto}})
+                .withEmbedResources(true)
+                .withCheck(true)
+                .withCheckFatalWarnings(true)
+                .withMultithreadingSupport(true)
+            }
+          EOM
+          )
+
+          echo set-native-config=${SetConfigTemplate} >> $GITHUB_ENV
+
+      - name: Run tests
+        # 2x more then it should take to build and run tests
+        timeout-minutes: 60
+        env: 
+          TEST_COMMAND: >
+            ++${{matrix.scala}} -v;
+            set sandbox.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set tests.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set junitTestOutputsNative.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set scalaPartestJunitTests.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+
+            show sandbox${{env.project-version}}/nativeConfig;
+
+            sandbox${{env.project-version}}/run;
+            testsJVM${{env.project-version}}/test;
+            tests${{env.project-version}}/test;
+            junitTestOutputsJVM${{env.project-version}}/test;
+            junitTestOutputsNative${{env.project-version}}/test;
+            scalaPartestJunitTests${{env.project-version}}/test
+        run: sbt -J-Xmx5G "${TEST_COMMAND}"

.github/workflows/run-tests-macos.yml

@@ -66,3 +66,73 @@ jobs:
         run: |
           export LLVM_BIN=$(brew --prefix llvm@15)/bin
           sbt "test-scripted ${{matrix.scala}}"
+
+  test-multihreading:
+    name: Test experimental multithreading support
+    runs-on: macos-11
+    strategy:
+      fail-fast: false
+      matrix:
+        scala: [3.2.1, 2.13.10]
+        build-mode: [debug, release-fast]
+        gc: [boehm, immix]
+        lto: [thin]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/macos-setup-env
+        with:
+          scala-version: ${{matrix.scala}}
+
+      - name: Prepare native config command
+        shell: bash
+        # Linking on MacOS in GithubActions fails when using default linker (ld), use lld instead
+        run: |
+          buildMode=${{matrix.build-mode}}
+          if [[ "$buildMode" == "release-fast" ]]; then 
+            buildMode=releaseFast
+          fi
+
+          SetConfigTemplate=$(cat << EOM
+            nativeConfig ~= { prev =>
+              prev
+                .withMode(scalanative.build.Mode.${buildMode})
+                .withGC(scalanative.build.GC.${{matrix.gc}})
+                .withLTO(scalanative.build.LTO.${{matrix.lto}})
+                .withEmbedResources(true)
+                .withCheck(true)
+                .withCheckFatalWarnings(true)
+                .withMultithreadingSupport(true)
+                .withLinkingOptions(prev.linkingOptions ++ Seq("-fuse-ld=lld") )
+            }
+          EOM
+          )
+
+          echo set-native-config=${SetConfigTemplate} >> $GITHUB_ENV
+
+      - name: Run tests
+        # 2x more then it should take to build and run tests
+        timeout-minutes: 60
+        env:
+          TEST_COMMAND: >
+            ++${{matrix.scala}} -v;
+            set sandbox.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set tests.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set junitTestOutputsNative.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+            set scalaPartestJunitTests.forBinaryVersion("${{env.binary-version}}")/${{env.set-native-config}};
+
+            show tests${{env.project-version}}/nativeConfig;
+
+            sandbox${{env.project-version}}/run;
+            testsJVM${{env.project-version}}/test;
+            tests${{env.project-version}}/test;
+            junitTestOutputsJVM${{env.project-version}}/test;
+            junitTestOutputsNative${{env.project-version}}/test;
+            scalaPartestJunitTests${{env.project-version}}/test
+        run: |
+          # lld fails to link with BoehmGC when using shared library, force linking using static library
+          if [[ "${{matrix.gc}}" == "boehm" ]]; then 
+            unlink /usr/local/lib/libgc.dylib
+          fi
+          export LLVM_BIN="$(brew --prefix llvm@15)/bin"
+          $LLVM_BIN/clang --version
+          sbt -J-Xmx5G "${TEST_COMMAND}"

.github/workflows/run-tests-windows.yml

@@ -134,3 +134,35 @@ jobs:
           tests${{env.project-version}}/test
           testsExt${{env.project-version}}/test
         shell: cmd
+
+  test-multihreading:
+    name: Test experimental multithreading support
+    runs-on: windows-2019
+    strategy:
+      fail-fast: false
+      matrix:
+        scala: [3.2.1, 2.13.10]
+        build-mode: [debug, release-fast]
+        gc: [boehm, immix]
+        lto: [thin]
+    steps:
+      - name: Setup git config
+        run: git config --global core.autocrlf false
+      - uses: actions/checkout@v3
+      - uses: ./.github/actions/windows-setup-env
+        id: setup
+        with:
+          scala-version: ${{matrix.scala}}
+
+      - name: Run tests
+        # 2x more then it should take to build and run tests
+        timeout-minutes: 60
+        run: >
+          set SCALANATIVE_GC=${{matrix.gc}}&
+          set SCALANATIVE_INCLUDE_DIRS=${{steps.setup.outputs.vcpkg-dir}}\include&
+          set SCALANATIVE_LIB_DIRS=${{steps.setup.outputs.vcpkg-dir}}\lib&
+          set SCALANATIVE &
+          sbt -Dscala.scalanative.multithreading.enable=true
+          "++${{matrix.scala}} -v"
+          "test-runtime ${{matrix.scala}}"
+        shell: cmd

auxlib/src/main/scala/scala/runtime/BoxesRunTime.scala

@@ -2,6 +2,7 @@ package scala.runtime
 
 import scala.math.ScalaNumber
 import scala.scalanative.unsafe._
+import scala.annotation.switch
 
 class BoxesRunTime
 
@@ -46,4 +47,97 @@ object BoxesRunTime {
   def hashFromFloat(o: java.lang.Float): Int = ???
   def hashFromDouble(o: java.lang.Double): Int = ???
   def hashFromLong(o: java.lang.Long): Int = ???
+
+  def equals(x: Any, y: Any): Boolean = {
+    (x, y) match {
+      case (x: AnyRef, y: AnyRef) => x eq y
+      case _                      => equals2(x, y)
+    }
+  }
+
+  /** Since all applicable logic has to be present in the equals method of a
+   *  ScalaNumber in any case, we dispatch to it as soon as we spot one on
+   *  either side.
+   */
+  def equals2(x: Any, y: Any): Boolean = {
+    x match {
+      case number: Number  => equalsNumObject(number, y)
+      case char: Character => equalsCharObject(char, y)
+      case _ =>
+        if (x == null) y == null
+        else x == y
+    }
+  }
+
+  def equalsNumObject(xn: Number, y: Any): Boolean = {
+    y match {
+      case number: Number       => equalsNumNum(xn, number)
+      case character: Character => equalsNumChar(xn, character)
+      case _ =>
+        if (xn == null) y == null
+        else xn == y
+    }
+  }
+
+  private final val CHAR = 0
+  /* BYTE = 1, SHORT = 2, */
+  private final val INT = 3
+  private final val LONG = 4
+  private final val FLOAT = 5
+  private final val DOUBLE = 6
+  private final val OTHER = 7
+
+  /** We don't need to return BYTE and SHORT, as everything which might care
+   *  widens to INT.
+   */
+  private def typeCode(a: Any): Int = {
+    a match {
+      case _: Integer         => INT
+      case _: Double          => DOUBLE
+      case _: Long            => LONG
+      case _: Character       => CHAR
+      case _: Float           => FLOAT
+      case _: Byte | _: Short => INT
+      case _                  => OTHER
+    }
+  }
+
+  def equalsNumNum(xn: Number, yn: Number): Boolean = {
+    val xcode = typeCode(xn)
+    val ycode = typeCode(yn)
+    val toMatch = if (ycode > xcode) ycode else xcode
+    (toMatch: @switch) match {
+      case INT    => xn.intValue == yn.intValue
+      case LONG   => xn.longValue == yn.longValue
+      case FLOAT  => xn.floatValue == yn.floatValue
+      case DOUBLE => xn.doubleValue == yn.doubleValue
+      case _ =>
+        if (yn.isInstanceOf[ScalaNumber] && !xn.isInstanceOf[ScalaNumber])
+          yn == xn
+        else if (xn == null) yn == null
+        else xn == yn
+    }
+  }
+
+  def equalsCharObject(xc: Character, y: Any): Boolean = {
+    y match {
+      case character: Character => return xc.charValue == character.charValue
+      case number: Number       => equalsNumChar(number, xc)
+      case _ =>
+        if (xc == null) y == null
+        else xc == y
+    }
+  }
+
+  def equalsNumChar(xn: Number, yc: Character): Boolean = {
+    if (yc == null) return xn == null
+    val ch = yc.charValue
+    (typeCode(xn): @switch) match {
+      case INT    => xn.intValue == ch
+      case LONG   => xn.longValue == ch
+      case FLOAT  => xn.floatValue == ch
+      case DOUBLE => xn.doubleValue == ch
+      case _      => xn == ch.toInt
+    }
+  }
 }