Mirror of forum.nim-lang.org

4722 :: Lock code block without explicit lock variable ?

• jackhftang (orginal) [2019-03-17T08:16:09+01:00] view original

  I saw an example in vlang, which use a special keyword lock to lock a block of code. And I want to implement it (let's call it lockBlock) in nim. Ideally, it should be something like

  
  var val = 0
  proc run() =
    lockBlock:
      var n = val
      for i in ..10000:
        n += 1 - 2*(i mod 2) # what is doing here does not mater
      val = n
  
  for i in 1..8: spawn run()
  sync()
  
  echo val  # correct output should be 8
  Run

  I tried the following implementation of lockBlock, but it didn't work

  
  import locks, threadpool
  
  template lockBlock(code: untyped): untyped =
    var lock {.global.} : Lock  # declare to globals
    
    # template local variable for one time initialization
    var uninitialized = true
    if uninitialized:
      uninitialized = false
      initLock(lock)
    
    # copy withLock implementation
    block:
      acquire(lock)
      defer:
        release(lock)
      {.locks: [lock].}:
        code
  Run

  How can I make the above code work ??

  FYI, a program that have the same effect with explicit declaration of a lock

  
  import locks, threadpool
  
  var valLock : Lock
  initLock(valLock)
  
  var val = 0
  proc run() =
    withLock valLock:
      var n = val
      for i in ..10000:
        n += 1 - 2*(i mod 2)
      val = n
  
  for i in 1..8: spawn run()
  sync()
  
  echo val  # output 8
  Run

---

• Araq (orginal) [2019-03-17T09:01:11+01:00] view original

  This works, check your basic program logic, it's wrong.

  import locks, threadpool
  
  var lock: Lock  # declare to globals
  initLock(lock)
  
  template lockBlock(code: untyped): untyped =
    # copy withLock implementation
    acquire(lock)
    try:
      {.locks: [lock].}:
        code
    finally:
      release(lock)
  
  var val = 0
  proc run() =
    lockBlock:
      var n = val
      for i in ..10000:
        n += 1 - 2*(i mod 2) # what is doing here does not mater
      val = n
  
  for i in 1..8: spawn run()
  sync()
  
  echo val  # correct output should be 8
  Run

---

• jackhftang (orginal) [2019-03-17T10:29:09+01:00] view original

  The point is that I don't want to explicitly declare a lock variable in globals.

  I want write something that whenever I use lockBlock, it implicitly create a lock variable and automatically acquire lock and release lock.

---

• jackhftang (orginal) [2019-03-17T10:31:59+01:00] view original

  The effect is like this example written in vlang, which has a lock section to prevent race on cursor

  
  const STORIES_URL = 'https://hacker-news.firebaseio.com/v0/topstories.json'
  const ITEM_URL_BASE = 'https://hacker-news.firebaseio.com/v0/item'
  
  struct Story {
      title string
  }
  
  fn main() {
      resp := http.get(STORIES_URL)?
      ids := json.decode([]int, resp.body)?
      mut cursor := 0
      for _ in 0..8 {
          go fn() {
              for {
                  lock {
                      if cursor >= ids.len {
                          break
                      }
                      id := ids[cursor]
                      cursor++
                  }
                  resp := http.get('$ITEM_URL_BASE/$id.json')?
                  story := json.decode(Story, resp.body)?
                  println(story.title)
              }
          }()
      }
      runtime.wait()
  }
  Run

---

• Araq (orginal) [2019-03-17T15:42:29+01:00] view original

  You can easily declare the Lock variable once in your module, don't export it and assume it's not the utter disaster for performance that it is in reality.

---

• jyapayne (orginal) [2019-03-18T18:42:20+01:00] view original

  Your original example works if you also make uninitialized global because if you don't, it will create a new var for every call to lockBlock. For example:

  # ty.nim
  import locks
  
  template lockBlock*(code: untyped): untyped =
    var lock {.global.}: Lock  # declare to globals
    var uninitialized {.global.} = true
    
    # template local variable for one time initialization
    if uninitialized:
      uninitialized = false
      initLock(lock)
    
    # copy withLock implementation
    block:
      acquire(lock)
      defer:
        release(lock)
      {.locks: [lock].}:
        code
  Run

  # tx.nim
  import ty, threadpool
  
  var val = 0
  proc run() =
    lockBlock:
      var n = val
      for i in ..10000:
        n += 1 - 2*(i mod 2) # what is doing here does not mater
      val = n
  
  for i in 1..8: spawn run()
  sync()
  
  echo val  # correct output should be 8
  Run

---