Mirror of forum.nim-lang.org

5590 :: "out of memory" when creating new Thread inside sharedTable lock

• c0ntribut0r (orginal) [2019-11-25T16:34:04+01:00] view original

  Hello guys! I need your help, cannot figure out wtf is going on here.

  I made a minimal example which produces an "out of memory" error. The idea is simple: create a "spawn" proc which

  1. accepts a name (just a string)
  2. runs some dumb thread
  3. adds mapping to shared table: name -> thread

  Since I use shared table, each thread can (safely, due to lock) access other thread information using thread's name.

  Here is the code:

  import sharedtables
  import strformat
  import os
  import typetraits
  
  
  type
    ThreadName = string
    ThreadInfo = object
      thread: Thread[ThreadName]
      # ... and some other info (channel etc)
  
  
  var threads: SharedTable[ThreadName, ThreadInfo]
  threads.init()
  
  
  proc threadEntrypoint(name: ThreadName) {.thread.} =
    echo &"Inside thread: name={name}"
  
  
  proc spawn(name: ThreadName) =
    echo &"Spawning: name={name}"
    
    threads.withKey(name) do (key: ThreadName, value: var ThreadInfo, pairExists: var bool):
      if pairExists:
        raise newException(ValueError, "Thread with this name was already registered")
      
      echo &"withKey: name={key}"
      
      value = ThreadInfo()
      echo &"Creating thread: name={key}"
      value.thread.createThread(param=key, tp=threadEntrypoint)
      echo &"Created thread: name={key}"
      
      pairExists = true
  
  
  when isMainModule:
    spawn(name="a")
    
    sleep(1000)
  
  Run

  The output is really surprising, I cant google something similar and it's even not an exception:

  
  Spawning: name=a
  withKey: name=a
  Creating thread: name=a
  Created thread: name=a
  out of memory
  Run

  It's probably something related to shared table lock and spawning a thread during this lock (but im not sure). I tried different ways to fill that shared table with spawned threads but didn't succeed.

---

• enthus1ast (orginal) [2019-11-25T17:04:32+01:00] view original

  your example works for me (on win10, Nim Compiler Version 1.1.0 [Windows: amd64])

---

• c0ntribut0r (orginal) [2019-11-25T22:45:03+01:00] view original

  Thanks for testing it!

  I tried different combinations for writing thread instance to sharedTable. Seems that creating temporary variable may help, but other cases simply don't work:

  import sharedtables
  import strformat
  import os
  import typetraits
  
  
  type ThreadInfo = object
    thread: Thread[void]
  
  
  var threads: SharedTable[string, ThreadInfo]
  threads.init()
  
  
  proc threadEntrypoint() {.thread.} =
    while true:
      echo "OK"
  
  
  when isMainModule:
    let key = "key"
    
    # 1) works (well, if it didn't work nim would worth nothing)
    
    var value = ThreadInfo()
    value.thread.createThread(tp=threadEntrypoint)
    
    
    
    # 2) illegal storage access
    
    threads.withKey(key) do (key: string, value: var ThreadInfo, pairExists: var bool):
      if pairExists:
        raise newException(ValueError, "Thread with this name was already registered")
      
      value = ThreadInfo()
      value.thread.createThread(tp=threadEntrypoint)
      
      pairExists = true
    
    
    
    # 3) works
    
    threads.withValue(key, value) do:
      echo "Value already exists"
    do:
      var info = ThreadInfo()
      info.thread.createThread(tp=threadEntrypoint)
      threads[key] = info
    
    
    
    # 4) hangs forever
    
    threads.withValue(key, _) do:
      echo "Value already exists"
    do:
      threads[key] = ThreadInfo()
      threads.mget(key).thread.createThread(tp=threadEntrypoint)
    
    
    
    sleep(1000)
  Run

---

• c0ntribut0r (orginal) [2019-11-26T17:23:30+01:00] view original

  Workaround with pointer to table and custom lock ¯_(ツ)_/¯

  import tables
  import strformat
  import os
  import typetraits
  import locks
  
  
  type
    ThreadName = string
    ThreadInfo = object
      thread: Thread[ThreadName]
  
  
  var threads = initTable[ThreadName, ThreadInfo]()
  let threadsPtr = threads.addr
  var threadsLock: Lock
  threadsLock.initLock()
  
  
  proc threadEntrypoint(name: ThreadName) {.thread.} =
    while true:
      echo &"Inside thread: name={name}"
  
  
  proc spawn(name: ThreadName) =
    echo &"Spawning: name={name}"
    
    withLock threadsLock:
      if name in threadsPtr[]:
        raise newException(ValueError, "Thread with this name was already registered")
      
      threadsPtr[][name] = ThreadInfo()
      threadsPtr[][name].thread.createThread(param=name, tp=threadEntrypoint)
      echo &"Created thread: name={name}"
  
  
  when isMainModule:
    spawn(name="a")
    spawn(name="b")
    
    sleep(1000)
  Run

---