Changes between Version 3 and Version 4 of BlockObjects/FakingIt

Timestamp:

08/25/11 23:47:32 (21 months ago)

Author:

chak

Comment:

--

BlockObjects/FakingIt

@@ -9 +9 @@
 === Block literals ===
 
-Blocks are by default allocated on the stack in C and only promoted to the heap using an explicity `Block_copy()` function.  In Haskell, we always allocate them on the heap, which is indicated by the pointer being placed in a block literals `isa` field:
+Blocks are by default allocated on the stack in C and only promoted to the heap using an explicity `Block_copy()` function.  In Haskell, we always allocate them on the heap, which is indicated by the pointer constant that we place in every block literal's `isa` field:
 {{{
 foreign import ccall "& _NSConcreteGlobalBlock" nsConcreteGlobalBlock :: Ptr ()
@@ -40 +40 @@
 newtype Block a = Block (Ptr (Block a))
 }}}
-
 
 When turning a Haskell function into a C function pointer to be included in a block literal as the `invoke` function, we need to take care to add a pointer to the block literal itself as a new first argument:
@@ -80 +79 @@
 }}}
 
+=== Turning a comparison function into a block literal ===
+
+The comparison function passed to `qsort_b`, gets pointers to the array elements it is to compare.  As these array elements are marshalled Haskell thunks, they are themselves '''stable''' pointers to the actual values that ought to be compared.
+{{{
+type CmpFun a = Ptr (StablePtr a) -> Ptr (StablePtr a) -> IO Int
+}}}
+We use a foreign import wrapper to perform the actual marshalling of the Haskell function
+{{{
+foreign import ccall "wrapper" mkCmpWrapper 
+  :: (Block (CmpFun a) -> CmpFun a) -> IO (FunPtr (Block (CmpFun a) -> CmpFun a))
+}}}
+and pass that wrapper to the `mkBlock` function when creating a block:
+{{{
+mkCmpBlock :: CmpFun a -> IO (Block (CmpFun a))
+mkCmpBlock = mkBlock mkCmpWrapper
+}}}
+
+=== Calling quicksort ===
+
+With these auxiliary definitions, the actual invocation of `qsort_b` is straight forward.  We import `qsort_b` with an explicit block argument for the comparison function:
+{{{
+foreign import ccall "stdlib.h" qsort_b 
+  :: Ptr (StablePtr a) -> CSize -> CSize -> Block (CmpFun a) -> IO ()
+}}}
+Then, we use `mkCmpBlock` to turn the Haskell comparison into a block literal that we pass as the last argument to `qsort_b`:
+{{{
+do {   -- convert a list of strings into a C array of stable pointers to those strings in the
+       -- Haskell heap
+   ; ptrs <- mapM newStablePtr myCharacters
+   ; sortedPtrs <- withArray ptrs $ \myCharactersArray -> do
+       {
+           -- get the size in bytes of a stable pointer to a Haskell string
+       ; let elemSize = fromIntegral $ sizeOf (undefined :: StablePtr String)
+
+           -- invoke C land 'qsort_b' with a Haskell comparison function passed as a block
+           -- object; mutates 'myCharactersArray'
+       ; cmpBlock <- mkCmpBlock $ \lPtr rPtr -> do 
+           { l <- deRefStablePtr =<< peek lPtr
+           ; r <- deRefStablePtr =<< peek rPtr
+           ; return $ fromOrdering (l `compare` r)
+           }
+       ; qsort_b myCharactersArray (genericLength myCharacters) elemSize cmpBlock
+
+       ; peekArray (length ptrs) myCharactersArray
+       }
+
+      -- turn the array of Haskell strings back into a list of strings
+   ; mySortedCharacters <- mapM deRefStablePtr sortedPtrs
+   }
+}}}
+The complete code is in the attachment `QSortB_wrapper.hs`.
 
 '''TODO:'''