Closure iterators

[blackmius]

still not sure should closure iterator change its api from what it is in nim2.0

first option is to preserve old api, which also makes cps transform easier for calls, but requires lambdalift and cps handle it together and looks it will work slower than in nim 2.0

second option is to transform iterators so they start returning next continutation and result at once via tuple, but it will require to transform each call site and it totaly changes logic of calling x twice and etc

import std/syncio

block:
    proc myiter1(): proc(): int {.closure, passive.} =
        var cont = Continuation()
        var iter_result = 0
        proc body() {.passive, closure.} =
            iter_result = 1
            cont = delay()
            suspend cont.env.caller
            iter_result = 2
            cont = delay()
            suspend cont.env.caller
            iter_result = 3
            cont = Continuation()
        cont = delay body()
        return proc(): int {.closure, passive.} =
            var this = delay()
            cont.env.caller = this
            suspend cont
            return iter_result

    type 
        EnvData = object of RootObj
            cont: Continuation
            iterResult: int64
        Env = object of RootObj
            d: EnvData
        Closure = tuple
            fn: proc ()
            env: ptr Env
        
    var x = myiter1()
    while cast[ptr Closure](x.addr)[].env[].d.cont.fn != nil:
        echo x()

block:
    proc myiter2(): (proc(): (Continuation, int) {.closure, passive.}) =
        var cont = Continuation()
        proc (): (Continuation, int) {.closure, passive.} =
            cont = delay()
            result = (cont, 1)
            suspend()
            cont = delay()
            result = (cont, 2)
            suspend()
            result = (Continuation(), 3)

    var x = myiter2()
    var iter = x()
    while true:
        echo iter[1]
        if iter[0].fn == nil:
            break
        iter[0].complete()

[blackmius]

here I added support for suspend so it can return some continuation back instead of Continuation(nil, nil)
so suspend cont.env.caller here means return cont.env.caller instead of return Continuation(nil, nil)

[blackmius]

some observations on performance

myiter1: 3.0305 ms
myiter2: 0.224667 ms

import std/syncio
import std/monotimes

block:
    proc myiter1(): proc(): int {.closure, passive.} =
        var cont = Continuation()
        var iter_result = 0
        proc body() {.passive, closure.} =
            for i in 0..100:
                iter_result = i
                cont = delay()
                suspend cont.env.caller
            cont = Continuation()
        cont = delay body()
        return proc(): int {.closure, passive.} =
            var this = delay()
            cont.env.caller = this
            suspend cont
            return iter_result

    type 
        EnvData = object of RootObj
            cont: Continuation
            iterResult: int64
        Env = object of RootObj
            d: EnvData
        Closure = tuple
            fn: proc ()
            env: ptr Env
    
    let a = getMonoTime()
    for i in 0..<100:
        var x = myiter1()
        var b = 0
        while cast[ptr Closure](x.addr)[].env[].d.cont.fn != nil:
            b += x()
            # echo x()
    let b = getMonoTime()
    echo (b.ticks - a.ticks).float64 / 1_000_000

block:
    proc myiter2(): (proc(): (Continuation, int) {.closure, passive.}) =
        var cont = Continuation()
        proc (): (Continuation, int) {.closure, passive.} =
            for i in 0..100:
                cont = delay()
                result = (cont, i)
                suspend()
            result = (Continuation(), 0)

    let a = getMonoTime()
    for i in 0..<100:
        var b = 0
        var x = myiter2()
        var iter = x()
        while iter[0].fn != nil:
            b += iter[1]
            iter[0].complete()
    let b = getMonoTime()
    echo (b.ticks - a.ticks).float64 / 1_000_000

[blackmius]

for comparison perfomance of nim 2.0

import std/[monotimes, times]
proc a(): iterator(): int {.closure.}=
    var b = 4
    return iterator(): int {.closure.} =
        for i in 0..100:
            yield i
        return 2

var s = getMonoTime()
for j in 0..100:
    var b = 0
    var x = a()
    for i in x():
        b += i
var e = getMonoTime()
echo (e - s).inNanoseconds / 1_000_000

nim c -r -d:danger test.nim
0.042625

haha, looks this optimised away

[Araq]

You need to compile the Nimony programs with optimization turned on too.

[blackmius]

You need to compile the Nimony programs with optimization turned on too.

there is no way to pass optimisation flag from nimony, I manually pathed final.build.nif file and called nifmake. I added --opt:speed for nifc and -O3 for gcc

[Araq]

There is the args config system so that -O3 can be passed to clang/gcc.