Introducing Speculation

@Asger: You could likely exploit the speculation primitive if you supply your own equality check that checked fitness instead of value and used it to wrap the continuation, but I’ll admit I haven’t thought it through in depth.

@Pepe: There are a couple of things happening here.

You definitely shouldn’t be getting segfaults on the unboxed version. If so, then I have faulty reasoning and will need to revert to the boxed version.

With regards to the boxed version still showing unevaluated-ness, what you’re experiencing is that the ‘i’ value at that point still points to the indirection because a garbage collection hasn’t happened yet to propagate the tag bits. I’d hazard that if you inserted a call to performGc in the middle there that you’d start seeing the tags.

Ed,

thanks for the tips. I tried inserting a call to performGC in the example, but it didn’t help the boxed version.

main = do
  let i = trace "–> evaluated" ()
  putStrLn $ "tagbits: " ++ show (unsafeGetTagBits i)
  print i
  performGC >> putStrLn "–> GC performed"
  putStrLn $ "tagbits: " ++ show (unsafeGetTagBits i)

pepe:~/Dropbox/code/snippets$ ghc –make TagBits&& ./TagBits
Linking TagBits …
tagbits: 0
–> evaluated
()
–> GC performed
tagbits: 0

Nevertheless, I have gone back to my actual use case (pruning the non-evaluated branches of an incomplete infinite proof tree, for display purposes), and found I was traversing the tree bottom-up, with a non strict fold. In a bottom-up traversal, the boxed version was *correctly* returning False for subtrees (since the fold is lazy), whereas the unboxed version was actually seq’ing subtrees and returning True, which in the particular example at hand was what I expected. Hence the unboxed version was hiding an actual mistake in my reasoning. Now the boxed version works as expected with a top-down traversal.

To see why the unboxed version forces evaluation of the argument, let’s look at the core generated by ghc:

Data.TagBits.unsafeGetTagBits =
\ (@ a_aqz) (a_syV :: a_aqz) ->
case a_syV
`cast` (CoUnsafe a_aqz GHC.Prim.Word# :: a_aqz ~ GHC.Prim.Word#)
of wild_syX { __DEFAULT ->
case GHC.Prim.and# wild_syX __word 3 of sat_sz3 { __DEFAULT ->
GHC.Word.W# sat_sz3
}
}

There is a case expression where the scrutinee is the argument. Unless I am wrong, this case expression forces the evaluation of the argument.

If you are curious I also cooked a version of unsafeIsEvaluated which avoids the tricky pointer tagging business and looks directly at the info table: http://gist.github.com/504764

I was deliberately avoiding reading the info table to avoid dealing with variations in ghc compilation options changing the layout.

I’ll revert to the boxed version for now I guess and then see if I can get a better way to do the unsafeCoerce# without forcing.

That said, it might be worthwhile to add that as a second check, assuming we can get something like the unboxed version to work in the first place.

That way it could check the tag bits, and if zero, before giving up it could double check the info table, that way we avoid having to actually use the target object in case where the tag bits having been propagated, which potentially avoids paging it in.

FYI, I did wind up adding that info table check to the tag-bits library, although I do so only after checking the tag bits themselves as a fallback.

It works well, and lets the library be useful even from ghci.

Thanks!

Apparently, undefined will sometimes claim to be evaluated. Now I need to chase bottoms too!