Mirror of forum.nim-lang.org

5300 :: Using `{.gcsafe.}` on a global string

• sschwarzer (orginal) [2019-10-07T19:30:44+02:00] view original

  I have the following program:

  import os
  import posix_utils
  import strformat
  import threadpool
  
  
  let tempRootPath = mkdtemp("vppdiff")
  
  proc xmiFilePath(fileNumber: int, cleaned: bool): string =
    let cleanedSuffix = "_cleaned"
    return tempRootPath / fmt"xmi{fileNumber}{cleanedSuffix}.xmi"
  
  var fv = spawn xmiFilePath(1, false)
  
  echo ^fv
  Run

  When I try to compile it with Nim 1.0.0, I get

  
  $ nim c --threads:on -r src/gcsafe_example.nim
  ...
  gcsafe_example.nim(13, 27) Error: 'spawn' takes a GC safe call expression
  Run

  Looking at https://nim-lang.org/docs/manual.html#threads-gc-safety , this is reasonable. Actually with a {.gcsafe.} block, as in

  import os
  import posix_utils
  import strformat
  import threadpool
  
  
  let tempRootPath = mkdtemp("vppdiff")
  
  proc xmiFilePath(fileNumber: int, cleaned: bool): string =
    let cleanedSuffix = "_cleaned"
    {.gcsafe.}:
      return tempRootPath / fmt"xmi{fileNumber}{cleanedSuffix}.xmi"
  
  var fv = spawn xmiFilePath(1, false)
  
  echo ^fv
  Run

  the program is compiled and seems to work.

  Questions:

  • Have a understood the GC safety concept correctly in that this should actually be safe? My reasoning is that tempRootPath is set once before xmiFilePath is called, so there shouldn't be any race condition or tempRootPath going away while xmiFilePath runs. Is this correct?
  • Would I get an error or at least a warning if using a {.gcsafe.} block actually wouldn't be safe?
  • If the answer to my first question is "yes", could Nim, maybe in a future version, recognize by itself that this usage is safe and accept the code without the {.gcsafe.} usage? Should the compiler do this?
  • Is there more documentation on GC safety, for example an article, that would answer at least the first question? :-)

---

• Araq (orginal) [2019-10-08T07:34:37+02:00] view original

  1. This is currently safe code. I wouldn't use it.
  2. No, you are on your own.
  3. In the future strings and seqs should use a shared heap and be gcsafe out of the box.
  4. I'm not aware of any such article, but here is a hint, I would code it as:

  import os
  import posix_utils
  import strformat
  import threadpool
  
  
  var tempRootPath {.threadvar.}: string
  
  proc xmiFilePath(fileNumber: int, cleaned: bool): string =
    let cleanedSuffix = "_cleaned"
    if tempRootPath.len == 0:
      # I'm assuming here that ``mkdtemp`` uses a lock...
      tempRootPath = mkdtemp("vppdiff")
    return tempRootPath / fmt"xmi{fileNumber}{cleanedSuffix}.xmi"
  
  var fv = spawn xmiFilePath(1, false)
  
  echo ^fv
  Run

---

• sschwarzer (orginal) [2019-10-08T11:48:35+02:00] view original

  Thanks for your answers and the code suggestion. I see what you're doing here, but I need the same temporary directory for all threads. :-)

  Would the approach with deepcopy as in the manual be safe?

  import os
  import posix_utils
  import strformat
  import threadpool
  
  
  let tempRootPath = mkdtemp("vppdiff")
  var tempRootPathPerThread {.threadvar.}: string
  
  proc xmiFilePath(fileNumber: int, cleaned: bool): string =
    let cleanedSuffix = "_cleaned"
    {.gcsafe.}:
      deepcopy(tempRootPathPerThread, tempRootPath)
    return tempRootPathPerThread / fmt"xmi{fileNumber}{cleanedSuffix}.xmi"
  
  var fv = spawn xmiFilePath(1, false)
  
  echo ^fv
  Run

  I'm looking forward to the new GC. :-)

---

• sschwarzer (orginal) [2019-10-08T12:07:50+02:00] view original

  Re 1.: How would I be able to tell whether the code is safe in the future? Will there be a new definition of "GC-safe" at some point or was my understanding of GC safety wrong to begin with?

---

• sschwarzer (orginal) [2019-10-08T22:32:37+02:00] view original

  I suppose the reason why I might want to override the compiler's analysis would probably not be that I want to "risk it" despite GC-unsafe code. I'd use the pragma because there are - hopefully - clear rules what is GC-safe and what isn't and I'd want to override the compiler in case the code is GC-safe although the compiler assumes the code is GC-unsafe. At least that's how I assume the pragma is intended to be used. :-) In other words: When is it actually GC-safe to override the compiler analysis?

---