support SoA indirections when GC is off

Author: vidsinghal

gibbon-compiler/examples/soa_examples/packedList.hs

@@ -40,10 +40,14 @@ sumList lst = case lst of
                                        sumRst = sumList rst
                                      in j + i' + sumRst
 
+id :: List -> List
+id lst = lst
+
+
 gibbon_main = let 
                 pi = mkPackedInt 10
                 lst = mkList 100
-                lst' = add1 lst
+                lst' = id (add1 lst)
                in (sumList lst')
 
 

gibbon-compiler/examples/soa_examples/tree.hs

@@ -28,14 +28,17 @@ sumTree tr =
     Leaf n m   -> n
     Node i j k _ l r ll rr -> i + j + k + (sumTree l) + (sumTree r) + (sumTree ll) + (sumTree rr)
 
+id :: Tree -> Tree 
+id tree = tree
+
 gibbon_main = 
-   let tree = mkTree 7
-       tree' = add1Tree tree
+   let tree = id (mkTree 7)
+       tree' = id (add1Tree tree)
        val = sumTree tree'
        _ = printsym (quote "(sum: ")
        _ = printint val 
        _ = printsym (quote ", rightmost: ")
        rmost = rightmost tree'
        _ = printint rmost
        _ = printsym (quote ")\n\n")
-     in ()
+     in val

gibbon-compiler/src/Gibbon/Passes/AddCastInstructions.hs

@@ -456,6 +456,7 @@ addCastsExp fundef cenv env ex =
     Ext (Assert e) -> do
       e' <- go e
       pure $ Ext $ Assert e'
+    Ext (CastPtr v ty) -> pure ex
     Ext {} -> error $ "addCastsExp : Unexpected instruction " ++ show ex
     MapE {} -> error "addCastsExp: MapE TODO"
     FoldE {} -> error "addCastsExp: FoldE TODO"

gibbon-compiler/src/Gibbon/Passes/Cursorize.hs

@@ -1362,7 +1362,12 @@ cursorizePackedExp freeVarToVarEnv lenv ddfs fundefs denv tenv senv ex =
                 CursorTy -> do
                    rnd' <- cursorizeExp freeVarToVarEnv lenv ddfs fundefs denv tenv senv rnd
                    after_indirection <- gensym "aft_indirection"
-                   LetE (d',[], CursorTy, Ext $ WriteTaggedCursor aft_dloc rnd') <$>
+                   casted_var <- gensym "cast"
+                   let rnd_var = case rnd' of 
+                                VarE v -> v
+                                _ -> error "Did not expected variable!"
+                   LetE (casted_var, [], CursorTy, Ext $ CastPtr rnd_var CursorTy) <$>
+                    LetE (d',[], CursorTy, Ext $ WriteTaggedCursor aft_dloc (VarE casted_var)) <$>
                     LetE (after_indirection,[], CursorTy, VarE d') <$> --Ext $ AddCursor aft_dloc (L3.LitE 8)
                     go2 marker_added freeVarToVarEnv after_indirection from_rec_end aft_flocs rst
 
@@ -1587,13 +1592,34 @@ cursorizePackedExp freeVarToVarEnv lenv ddfs fundefs denv tenv senv ex =
                                         Just var -> var 
             go freeVarToVarEnv tenv senv (DataConE from dcon [VarE locs_var])
           else do
-            start <- gensym "start"
-            end <- gensym "end"
-            return $ Di $
-              (mkLets [("_",[],ProdTy [],Ext (IndirectionBarrier tycon (((unwrapLocVar . toLocVar) from),((unwrapLocVar . toLocVar) from_reg),((unwrapLocVar . toLocVar) to),((unwrapLocVar . toLocVar) to_reg)))),
-                       (start, [], CursorTy, VarE ((unwrapLocVar . toLocVar) from)),
-                       (end, [], CursorTy, Ext $ AddCursor ((unwrapLocVar . toLocVar) from) (L3.LitE 9))]
-                 (MkProdE [VarE start, VarE end]))
+            case (toLocVar from) of 
+              Single{} -> do
+                start <- gensym "start"
+                end <- gensym "end"
+                let from_var = case M.lookup (fromLocArgToFreeVarsTy from) freeVarToVarEnv of 
+                                               Nothing -> error "Did not find variable for location!"
+                                               Just var -> var
+                let to_var = case M.lookup (fromLocArgToFreeVarsTy to) freeVarToVarEnv of 
+                                              Nothing -> error "Did not find variable for location!"
+                                              Just var -> var
+                let reg_from_reg = fromLocVarToRegVar (toLocVar from_reg)
+                let reg_to_reg = fromLocVarToRegVar (toLocVar to_reg)
+                let from_reg_var = case M.lookup (fromRegVarToFreeVarsTy reg_from_reg) freeVarToVarEnv of 
+                                            Nothing -> error "Did not find variable for location!"
+                                            Just var -> var
+                let to_reg_var = case M.lookup (fromRegVarToFreeVarsTy reg_to_reg) freeVarToVarEnv of 
+                                            Nothing -> error "Did not find variable for location!"
+                                            Just var -> var
+                -- VS : [09/20/2025 -- For SoA case, indirection with gc need a bit more thinking]
+                -- One way could be to call indirection barrier seperately on every buffer/region 
+                -- Then follow them seperately for every region in the case.
+                -- For now i'm erroring out but this needs more thought.
+                return $ Di $
+                    (mkLets [("_",[],ProdTy [],Ext (IndirectionBarrier tycon ((from_var),(from_reg_var),(to_var),(to_reg_var)))),
+                             (start, [], CursorTy, VarE (from_var)),
+                             (end, [], CursorTy, Ext $ AddCursor (from_var) (L3.LitE 9))]
+                             (MkProdE [VarE start, VarE end]))
+              SoA _ flds -> error "Indirection when GC is enabled is not implemented for SoA! Please turn off the GC!"
 
         AddFixed{} -> error "cursorizePackedExp: AddFixed not handled."
 

gibbon-compiler/src/Gibbon/Passes/ThreadRegions2.hs

@@ -687,13 +687,17 @@ threadRegionsExp ddefs fundefs fnLocArgs renv env2 lfenv rlocs_env wlocs_env pkd
           rlocs_env' = updRLocsEnv (unTy2 ty) rlocs_env
           wlocs_env' = foldr (\loc2 acc -> M.delete loc2 acc) wlocs_env (NewL2.locsInTy ty)
       bod' <- threadRegionsExp ddefs fundefs fnLocArgs renv env2' lfenv rlocs_env' wlocs_env' pkd_env' region_locs ran_env indirs redirs bod
-      let boundscheck =
-            let locarg = a'
-                regarg = b'
-                -- bc = boundsCheck ddefs tcon
-                bc = 18
-             in LetE ("_", [], MkTy2 IntTy, Ext $ BoundsCheck bc regarg locarg)
-      pure $ boundscheck $ LetE (v, locs, ty, (Ext (IndirectionE tcon dcon (a', b') (c', d') cpy))) bod'
+      -- VS: 09/20/2025
+      -- Removing bounds check for now since assuming that the function should do this and may not need this. 
+      -- TODO: this might not be true though
+      --let boundscheck =
+      --      let locarg = a'
+      --          regarg = b'
+      --          -- bc = boundsCheck ddefs tcon
+      --          bc = 18
+      --       in LetE ("_", [], MkTy2 IntTy, Ext $ BoundsCheck bc regarg locarg)
+      --pure $ boundscheck $ LetE (v, locs, ty, (Ext (IndirectionE tcon dcon (a', b') (c', d') cpy))) bod'
+      pure $ LetE (v, locs, ty, (Ext (IndirectionE tcon dcon (a', b') (c', d') cpy))) bod'
     Ext (StartOfPkdCursor cur) -> do
       let (PackedTy _ loc) = unTy2 (lookupVEnvLocVar (fromVarToFreeVarsTy cur) env2)
       case M.lookup loc pkd_env of