initial implementation

Author: MasonProtter

.github/workflow/CI.yml

@@ -0,0 +1,42 @@
+name: CI
+on:
+  - push
+  - pull_request
+jobs:
+  test:
+    name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        version:
+          - '1.6'
+          - '1.9'
+          - '1.10.0'
+          - 'nightly'
+        os:
+          - ubuntu-latest
+        arch:
+          - x64
+    steps:
+      - uses: actions/checkout@v2
+      - uses: julia-actions/setup-julia@v1
+        with:
+          version: ${{ matrix.version }}
+          arch: ${{ matrix.arch }}
+      - uses: actions/cache@v1
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+      - uses: julia-actions/julia-buildpkg@v1
+      - uses: julia-actions/julia-runtest@v1
+      - uses: julia-actions/julia-processcoverage@v1
+      - uses: codecov/codecov-action@v1
+        with:
+          file: lcov.info

.github/workflow/TagBot.yml

@@ -0,0 +1,33 @@
+name: TagBot
+on:
+  issue_comment:
+    types:
+      - created
+  workflow_dispatch:
+    inputs:
+      lookback:
+        default: 3
+permissions:
+  actions: read
+  checks: read
+  contents: write
+  deployments: read
+  issues: read
+  discussions: read
+  packages: read
+  pages: read
+  pull-requests: read
+  repository-projects: read
+  security-events: read
+  statuses: read
+jobs:
+  TagBot:
+    if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          # Edit the following line to reflect the actual name of the GitHub Secret containing your private key
+          ssh: ${{ secrets.DOCUMENTER_KEY }}
+          # ssh: ${{ secrets.NAME_OF_MY_SSH_PRIVATE_KEY_SECRET }}

Project.toml

@@ -0,0 +1,13 @@
+name = "StableTasks"
+uuid = "91464d47-22a1-43fe-8b7f-2d57ee82463f"
+authors = ["Mason Protter <[email protected]>"]
+version = "0.1.0"
+
+[compat]
+julia = "1.6"
+
+[extras]
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["Test"]

README.md

@@ -0,0 +1,17 @@
+# StableTasks.jl
+
+StableTasks is a simple package with one main API `SimpleTasks.@spawn` (not exported by default). 
+
+It works like `Threads.@spawn`, except it is *type stable* to `fetch` from (and it does not yet support threadpools
+other than the default threadpool).
+
+``` julia
+julia> Core.Compiler.return_type(() -> fetch(StableTasks.@spawn 1 + 1), Tuple{})
+Int64
+```
+versus
+
+``` julia
+julia> Core.Compiler.return_type(() -> fetch(Threads.@spawn 1 + 1), Tuple{})
+Any
+```

src/StableTasks.jl

@@ -0,0 +1,13 @@
+module StableTasks
+
+macro spawn end
+
+using Base: RefValue
+struct StableTask{T}
+    t::Task
+    ret::RefValue{T}
+end
+
+include("internals.jl")
+
+end # module StableTasks

src/internals.jl

@@ -0,0 +1,83 @@
+module Internals 
+
+import StableTasks: @spawn, StableTask
+
+function Base.fetch(t::StableTask{T}) where {T}
+    fetch(t.t)
+    t.ret[]
+end
+
+for func ∈ [:wait, :istaskdone, :istaskfailed, :istaskstarted, :yield, :yieldto]
+    if isdefined(Base, func)
+        @eval Base.$func(t::StableTask) = $func(t.t)
+    end
+end
+
+Base.yield(t::StableTask, x) = yield(t.t, x)
+Base.yieldto(t::StableTask, x) = yieldto(t.t, x)
+if isdefined(Base, :current_exceptions)
+    Base.current_exceptions(t::StableTask; backtrace::Bool=true) = current_exceptions(t.t; backtrace)
+end
+if isdefined(Base, :errormonitor)
+    Base.errormonitor(t::StableTask) = errormonitor(t.t)
+end
+Base.schedule(t::StableTask) = (schedule(t.t); t)
+Base.schedule(t, val; error=false) = (schedule(t.t, val; error); t)
+
+
+macro spawn(ex)
+    tp = QuoteNode(:default)
+
+    letargs = Base._lift_one_interp!(ex)
+
+    thunk = Base.replace_linenums!(:(()->($(esc(ex)))), __source__)
+    var = esc(Base.sync_varname) # This is for the @sync macro which sets a local variable whose name is
+                                 # the symbol bound to Base.sync_varname
+                                 # I asked on slack and this is apparently safe to consider a public API
+    quote
+        let $(letargs...)
+            f = $thunk
+            T = Core.Compiler.return_type(f, Tuple{})
+            ref = Ref{T}()
+            f_wrap = () -> (ref[] = f(); nothing)
+            task = Task(f_wrap)
+            task.sticky = false
+            if $(Expr(:islocal, var))
+                put!($var, task) # Sync will set up a Channel, and we want our task to be in there.
+            end
+            schedule(task)
+            StableTask(task, ref)
+        end
+    end
+end
+
+
+# Copied from base rather than calling it directly because who knows if it'll change in the future
+function _lift_one_interp!(e)
+    letargs = Any[]  # store the new gensymed arguments
+    _lift_one_interp_helper(e, false, letargs) # Start out _not_ in a quote context (false)
+    letargs
+end
+_lift_one_interp_helper(v, _, _) = v
+function _lift_one_interp_helper(expr::Expr, in_quote_context, letargs)
+    if expr.head === :$
+        if in_quote_context  # This $ is simply interpolating out of the quote
+            # Now, we're out of the quote, so any _further_ $ is ours.
+            in_quote_context = false
+        else
+            newarg = gensym()
+            push!(letargs, :($(esc(newarg)) = $(esc(expr.args[1]))))
+            return newarg  # Don't recurse into the lifted $() exprs
+        end
+    elseif expr.head === :quote
+        in_quote_context = true   # Don't try to lift $ directly out of quotes
+    elseif expr.head === :macrocall
+        return expr  # Don't recur into macro calls, since some other macros use $
+    end
+    for (i,e) in enumerate(expr.args)
+        expr.args[i] = _lift_one_interp_helper(e, in_quote_context, letargs)
+    end
+    expr
+end
+
+end # module Internals

test/runtests.jl

@@ -0,0 +1,25 @@
+using Test, StableTasks
+using StableTasks: @spawn
+
+@testset "Type stability" begin
+    @test 2 ==@inferred fetch(@spawn 1 + 1)
+    t = @eval @spawn inv([1 2 ; 3 4])
+    @test inv([1 2 ; 3 4]) == @inferred fetch(t)
+end
+
+@testset "API funcs" begin
+    T = @spawn rand(Bool)
+    @test isnothing(wait(T))
+    @test istaskdone(T)
+    @test istaskfailed(T) == false
+    @test istaskstarted(T)
+    r = Ref(0)
+    @sync begin
+        @spawn begin
+            sleep(5)
+            r[] = 1
+        end
+        @test r[] == 0
+    end
+    @test r[] == 1
+end