Multicore async, works

#Problem: Works ONLY if --boundChecks:on
#Problem is on windows(haven't tested on others) that
#Nim version 0.11.2: compiled --d:release --threads:on --boundChecks:on

import asyncdispatch
import rawsockets
import threadpool
import net
import selectors

const content = "Hello!"
const response = "HTTP/1.1 200 OK\r\LContent-Length: " & $content.len & "\r\L\r\L" & content

type
    ChannelServerWorker = ref object
        SockChan: TChannel[TAsyncFD]
        S: Server

    Server = ref object
        Workers: seq[ChannelServerWorker]
        Sockets: seq[TAsyncFD]
        Listener: Socket


proc HandleSock(sock: TAsyncFD)=
    let futureRead = sock.recv(1023)
    futureRead.callback = proc() =
        discard sock.send(response)
        closeSocket(sock)
    #echo("sock closed!")

proc Idle() =
    #idle so the poll wont complain that nothing is registered!
    var sleepF = sleepAsync(100)
    sleepF.callback = proc() =
     Idle()

proc Run(csw: ChannelServerWorker) {.thread.} =
    Idle()
    while true:
        let sockTuple = csw.SockChan.tryRecv()
        if sockTuple.dataAvailable:
            let sock = sockTuple.msg
            register(sock)
            sock.HandleSock()
        poll(1)

proc NewServer():Server =
    var server = Server()
    server.Workers = @[]
    server.Sockets = @[]
    server.Listener = newSocket()
    return server

proc Run(server: Server, numCores:int=4) =
    var threads = newSeq[TThread[ChannelServerWorker]](numCores)
    #Start the threads:
    for t in threads.mitems:
        var csw = ChannelServerWorker()
        csw.S = server
        csw.SockChan.open()
        server.Workers.add(csw)
        t.createThread Run, csw

    server.Listener.bindAddr(Port(80), "127.0.0.1")
    server.Listener.listen()

    #Loop forever, accept new sock for every worker
    var selector = newSelector()

    discard selector.register(server.Listener.getFD(), {EvRead}, nil)

    while true:
        for worker in server.Workers:
          if selector.select(1000).len > 0:
              var client: Socket = newSocket()
              accept(server.Listener, client)
              client.getFd().setBlocking(false)
              worker.SockChan.send(client.getFd().TAsyncFD)


var server = NewServer()
server.Run(4)