Native Polling System

build.sbt

@@ -772,6 +772,14 @@ lazy val core = crossProject(JSPlatform, JVMPlatform, NativePlatform)
       } else Seq()
     }
   )
+  .nativeSettings(
+    mimaBinaryIssueFilters ++= Seq(
+      ProblemFilters.exclude[MissingClassProblem](
+        "cats.effect.unsafe.PollingExecutorScheduler$SleepTask"),
+      ProblemFilters.exclude[MissingClassProblem]("cats.effect.unsafe.QueueExecutorScheduler"),
+      ProblemFilters.exclude[MissingClassProblem]("cats.effect.unsafe.QueueExecutorScheduler$")
+    )
+  )
 
 /**
  * Test support for the core project, providing various helpful instances like ScalaCheck

core/native/src/main/scala/cats/effect/FileDescriptorPoller.scala

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-2022 Typelevel
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package cats.effect
+
+trait FileDescriptorPoller {
+
+  /**
+   * Registers a file descriptor with the poller and monitors read- and/or write-ready events.
+   */
+  def registerFileDescriptor(
+      fileDescriptor: Int,
+      monitorReadReady: Boolean,
+      monitorWriteReady: Boolean
+  ): Resource[IO, FileDescriptorPollHandle]
+
+}
+
+trait FileDescriptorPollHandle {
+
+  /**
+   * Recursively invokes `f` until it is no longer blocked. Typically `f` will call `read` or
+   * `recv` on the file descriptor.
+   *   - If `f` fails because the file descriptor is blocked, then it should return `Left[A]`.
+   *     Then `f` will be invoked again with `A` at a later point, when the file handle is ready
+   *     for reading.
+   *   - If `f` is successful, then it should return a `Right[B]`. The `IO` returned from this
+   *     method will complete with `B`.
+   */
+  def pollReadRec[A, B](a: A)(f: A => IO[Either[A, B]]): IO[B]
+
+  /**
+   * Recursively invokes `f` until it is no longer blocked. Typically `f` will call `write` or
+   * `send` on the file descriptor.
+   *   - If `f` fails because the file descriptor is blocked, then it should return `Left[A]`.
+   *     Then `f` will be invoked again with `A` at a later point, when the file handle is ready
+   *     for writing.
+   *   - If `f` is successful, then it should return a `Right[B]`. The `IO` returned from this
+   *     method will complete with `B`.
+   */
+  def pollWriteRec[A, B](a: A)(f: A => IO[Either[A, B]]): IO[B]
+
+}

core/native/src/main/scala/cats/effect/IOApp.scala

@@ -20,6 +20,7 @@ import cats.effect.metrics.NativeCpuStarvationMetrics
 
 import scala.concurrent.CancellationException
 import scala.concurrent.duration._
+import scala.scalanative.meta.LinktimeInfo
 
 /**
  * The primary entry point to a Cats Effect application. Extend this trait rather than defining
@@ -165,6 +166,21 @@ trait IOApp {
    */
   protected def runtimeConfig: unsafe.IORuntimeConfig = unsafe.IORuntimeConfig()
 
+  /**
+   * The [[unsafe.PollingSystem]] used by the [[runtime]] which will evaluate the [[IO]]
+   * produced by `run`. It is very unlikely that users will need to override this method.
+   *
+   * [[unsafe.PollingSystem]] implementors may provide their own flavors of [[IOApp]] that
+   * override this method.
+   */
+  protected def pollingSystem: unsafe.PollingSystem =
+    if (LinktimeInfo.isLinux)
+      unsafe.EpollSystem
+    else if (LinktimeInfo.isMac)
+      unsafe.KqueueSystem
+    else
+      unsafe.SleepSystem
+
   /**
    * The entry point for your application. Will be called by the runtime when the process is
    * started. If the underlying runtime supports it, any arguments passed to the process will be
@@ -186,12 +202,8 @@ trait IOApp {
       import unsafe.IORuntime
 
       val installed = IORuntime installGlobal {
-        IORuntime(
-          IORuntime.defaultComputeExecutionContext,
-          IORuntime.defaultComputeExecutionContext,
-          IORuntime.defaultScheduler,
-          () => (),
-          runtimeConfig)
+        val loop = IORuntime.createEventLoop(pollingSystem)
+        IORuntime(loop, loop, loop, () => (), runtimeConfig)
       }
 
       _runtime = IORuntime.global

core/native/src/main/scala/cats/effect/IOCompanionPlatform.scala

@@ -17,6 +17,9 @@
 package cats.effect
 
 import cats.effect.std.Console
+import cats.effect.unsafe.EventLoopExecutorScheduler
+
+import scala.reflect.ClassTag
 
 import java.time.Instant
 
@@ -62,4 +65,11 @@ private[effect] abstract class IOCompanionPlatform { this: IO.type =>
    */
   def readLine: IO[String] =
     Console[IO].readLine
+
+  def poller[Poller](implicit ct: ClassTag[Poller]): IO[Option[Poller]] =
+    IO.executionContext.map {
+      case loop: EventLoopExecutorScheduler if ct.runtimeClass.isInstance(loop.poller) =>
+        Some(loop.poller.asInstanceOf[Poller])
+      case _ => None
+    }
 }