X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=cfcea389bba715344bcbeecdf886ba632981e292;hp=6e10deec45fb3479b5638f92fa4c4a06b45a1c74;hb=30c122df62ec75f9ed7f392f24c2925675bf1d06;hpb=17bf0a5763b2a94ee88f8bebfe61c84f20cc9d05 diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index 6e10dee..cfcea38 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -1,5 +1,14 @@ +{-# OPTIONS -w #-} +-- The above warning supression flag is a temporary kludge. +-- While working on this module you are encouraged to remove it and fix +-- any warnings in the module. See +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings +-- for details + module VectType ( vectTyCon, vectType, vectTypeEnv, - PAInstance, buildPADict ) + mkRepr, arrShapeTys, arrShapeVars, arrSelector, + PAInstance, buildPADict, + fromVect ) where #include "HsVersions.h" @@ -26,15 +35,17 @@ import Var ( Var ) import Id ( mkWildId ) import Name ( Name, getOccName ) import NameEnv -import TysWiredIn ( unitTy, unitTyCon, intTy, intDataCon, unitDataConId ) +import TysWiredIn import TysPrim ( intPrimTy ) import Unique import UniqFM import UniqSet +import Util ( singleton ) import Digraph ( SCC(..), stronglyConnComp ) import Outputable +import FastString import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_, mapAndUnzipM ) import Data.List ( inits, tails, zipWith4, zipWith5 ) @@ -61,7 +72,7 @@ vectType (TyVarTy tv) = return $ TyVarTy tv vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2) vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys) vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon) - (mapM vectType [ty1,ty2]) + (mapM vectAndBoxType [ty1,ty2]) vectType ty@(ForAllTy _ _) = do mdicts <- mapM paDictArgType tyvars @@ -72,6 +83,23 @@ vectType ty@(ForAllTy _ _) vectType ty = pprPanic "vectType:" (ppr ty) +vectAndBoxType :: Type -> VM Type +vectAndBoxType ty = vectType ty >>= boxType + +-- ---------------------------------------------------------------------------- +-- Boxing + +boxType :: Type -> VM Type +boxType ty + | Just (tycon, []) <- splitTyConApp_maybe ty + , isUnLiftedTyCon tycon + = do + r <- lookupBoxedTyCon tycon + case r of + Just tycon' -> return $ mkTyConApp tycon' [] + Nothing -> return ty +boxType ty = return ty + -- ---------------------------------------------------------------------------- -- Type definitions @@ -231,6 +259,13 @@ data Repr = ProdRepr { , void_bottom :: CoreExpr } + | EnumRepr { + enum_tycon :: TyCon + , enum_data_con :: DataCon + , enum_arr_tycon :: TyCon + , enum_arr_data_con :: DataCon + } + voidRepr :: VM Repr voidRepr = do @@ -241,6 +276,21 @@ voidRepr , void_bottom = Var var } +enumRepr :: VM Repr +enumRepr + = do + tycon <- builtin enumerationTyCon + let [data_con] = tyConDataCons tycon + (arr_tycon, _) <- parrayReprTyCon (mkTyConApp tycon []) + let [arr_data_con] = tyConDataCons arr_tycon + + return $ EnumRepr { + enum_tycon = tycon + , enum_data_con = data_con + , enum_arr_tycon = arr_tycon + , enum_arr_data_con = arr_data_con + } + unboxedProductRepr :: [Type] -> VM Repr unboxedProductRepr [] = voidRepr unboxedProductRepr [ty] = return $ IdRepr ty @@ -252,7 +302,8 @@ boxedProductRepr tys tycon <- builtin (prodTyCon arity) let [data_con] = tyConDataCons tycon - (arr_tycon, _) <- parrayReprTyCon $ mkTyConApp tycon tys + tys' <- mapM boxType tys + (arr_tycon, _) <- parrayReprTyCon $ mkTyConApp tycon tys' let [arr_data_con] = tyConDataCons arr_tycon return $ ProdRepr { @@ -286,6 +337,10 @@ sumRepr reprs where arity = length reprs +splitSumRepr :: Repr -> [Repr] +splitSumRepr (SumRepr { sum_components = reprs }) = reprs +splitSumRepr repr = [repr] + boxRepr :: Repr -> VM Repr boxRepr (VoidRepr {}) = boxedProductRepr [] boxRepr (IdRepr ty) = boxedProductRepr [ty] @@ -298,63 +353,87 @@ reprType (SumRepr { sum_tycon = tycon, sum_components = reprs }) = mkTyConApp tycon (map reprType reprs) reprType (IdRepr ty) = ty reprType (VoidRepr { void_tycon = tycon }) = mkTyConApp tycon [] +reprType (EnumRepr { enum_tycon = tycon }) = mkTyConApp tycon [] arrReprType :: Repr -> VM Type arrReprType = mkPArrayType . reprType arrShapeTys :: Repr -> VM [Type] -arrShapeTys (SumRepr {}) - = do - int_arr <- builtin parrayIntPrimTyCon - return [intPrimTy, mkTyConApp int_arr [], mkTyConApp int_arr []] +arrShapeTys (SumRepr {}) = sumShapeTys arrShapeTys (ProdRepr {}) = return [intPrimTy] arrShapeTys (IdRepr _) = return [] arrShapeTys (VoidRepr {}) = return [intPrimTy] +arrShapeTys (EnumRepr {}) = sumShapeTys + +sumShapeTys :: VM [Type] +sumShapeTys = do + int_arr <- builtin intPrimArrayTy + return [intPrimTy, int_arr, int_arr] + arrShapeVars :: Repr -> VM [Var] arrShapeVars repr = mapM (newLocalVar FSLIT("sh")) =<< arrShapeTys repr replicateShape :: Repr -> CoreExpr -> CoreExpr -> VM [CoreExpr] -replicateShape (ProdRepr {}) len _ = return [len] -replicateShape (SumRepr {}) len tag +replicateShape (ProdRepr {}) len _ = return [len] +replicateShape (SumRepr {}) len tag = replicateSumShape len tag +replicateShape (IdRepr _) _ _ = return [] +replicateShape (VoidRepr {}) len _ = return [len] +replicateShape (EnumRepr {}) len tag = replicateSumShape len tag + +replicateSumShape :: CoreExpr -> CoreExpr -> VM [CoreExpr] +replicateSumShape len tag = do rep <- builtin replicatePAIntPrimVar up <- builtin upToPAIntPrimVar return [len, Var rep `mkApps` [len, tag], Var up `App` len] -replicateShape (IdRepr _) _ _ = return [] -replicateShape (VoidRepr {}) len _ = return [len] -arrReprElemTys :: Repr -> VM [[Type]] -arrReprElemTys (SumRepr { sum_components = prods }) - = mapM arrProdElemTys prods -arrReprElemTys prod@(ProdRepr {}) - = do - tys <- arrProdElemTys prod - return [tys] -arrReprElemTys (IdRepr ty) = return [[ty]] -arrReprElemTys (VoidRepr { void_tycon = tycon }) - = return [[mkTyConApp tycon []]] - -arrProdElemTys (ProdRepr { prod_components = [] }) - = do - void <- builtin voidTyCon - return [mkTyConApp void []] -arrProdElemTys (ProdRepr { prod_components = tys }) - = return tys -arrProdElemTys (IdRepr ty) = return [ty] -arrProdElemTys (VoidRepr { void_tycon = tycon }) - = return [mkTyConApp tycon []] - -arrReprTys :: Repr -> VM [[Type]] -arrReprTys repr = mapM (mapM mkPArrayType) =<< arrReprElemTys repr +arrSelector :: Repr -> [CoreExpr] -> VM (CoreExpr, CoreExpr, CoreExpr) +arrSelector (SumRepr {}) [len, sel, is] = return (len, sel, is) +arrSelector (EnumRepr {}) [len, sel, is] = return (len, sel, is) + +emptyArrRepr :: Repr -> VM [CoreExpr] +emptyArrRepr (SumRepr { sum_components = prods }) + = liftM concat $ mapM emptyArrRepr prods +emptyArrRepr (ProdRepr { prod_components = [] }) + = return [Var unitDataConId] +emptyArrRepr (ProdRepr { prod_components = tys }) + = mapM emptyPA tys +emptyArrRepr (IdRepr ty) + = liftM singleton $ emptyPA ty +emptyArrRepr (VoidRepr { void_tycon = tycon }) + = liftM singleton $ emptyPA (mkTyConApp tycon []) +emptyArrRepr (EnumRepr { enum_tycon = tycon }) + = return [] + +arrReprTys :: Repr -> VM [Type] +arrReprTys (SumRepr { sum_components = reprs }) + = liftM concat $ mapM arrReprTys reprs +arrReprTys (ProdRepr { prod_components = [] }) + = return [unitTy] +arrReprTys (ProdRepr { prod_components = tys }) + = mapM mkPArrayType tys +arrReprTys (IdRepr ty) + = liftM singleton $ mkPArrayType ty +arrReprTys (VoidRepr { void_tycon = tycon }) + = liftM singleton $ mkPArrayType (mkTyConApp tycon []) +arrReprTys (EnumRepr {}) + = return [] + +arrReprTys' :: Repr -> VM [[Type]] +arrReprTys' (SumRepr { sum_components = reprs }) + = mapM arrReprTys reprs +arrReprTys' repr = liftM singleton $ arrReprTys repr arrReprVars :: Repr -> VM [[Var]] arrReprVars repr - = mapM (mapM (newLocalVar FSLIT("rs"))) =<< arrReprTys repr + = mapM (mapM (newLocalVar FSLIT("rs"))) =<< arrReprTys' repr mkRepr :: TyCon -> VM Repr mkRepr vect_tc - = sumRepr =<< mapM unboxedProductRepr rep_tys + | [tys] <- rep_tys = boxedProductRepr tys + -- | all null rep_tys = enumRepr + | otherwise = sumRepr =<< mapM unboxedProductRepr rep_tys where rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc @@ -382,7 +461,7 @@ buildToPRepr repr vect_tc prepr_tc _ , sum_tycon = tycon }) expr = do - (vars, bodies) <- mapAndUnzipM prod_alt prods + (vars, bodies) <- mapAndUnzipM to_unboxed prods return . Case expr (mkWildId (exprType expr)) res_ty $ zipWith4 mk_alt cons vars (tyConDataCons tycon) bodies where @@ -391,24 +470,30 @@ buildToPRepr repr vect_tc prepr_tc _ ty_args = map (Type . reprType) prods + to_repr (EnumRepr { enum_data_con = data_con }) expr + = return . Case expr (mkWildId (exprType expr)) res_ty + $ map mk_alt cons + where + mk_alt con = (DataAlt con, [], mkConApp data_con [mkDataConTag con]) + to_repr prod expr = do - (vars, body) <- prod_alt prod + (vars, body) <- to_unboxed prod return $ Case expr (mkWildId (exprType expr)) res_ty [(DataAlt con, vars, body)] - prod_alt (ProdRepr { prod_components = tys - , prod_data_con = data_con }) + to_unboxed (ProdRepr { prod_components = tys + , prod_data_con = data_con }) = do vars <- mapM (newLocalVar FSLIT("r")) tys return (vars, mkConApp data_con (map Type tys ++ map Var vars)) - prod_alt (IdRepr ty) + to_unboxed (IdRepr ty) = do var <- newLocalVar FSLIT("y") ty return ([var], Var var) - prod_alt (VoidRepr { void_bottom = bottom }) + to_unboxed (VoidRepr { void_bottom = bottom }) = return ([], bottom) @@ -433,17 +518,34 @@ buildFromPRepr repr vect_tc prepr_tc _ expr = do vars <- mapM (newLocalVar FSLIT("x")) (map reprType prods) - bodies <- sequence . zipWith3 from_prod prods cons + bodies <- sequence . zipWith3 from_unboxed prods cons $ map Var vars return . Case expr (mkWildId (reprType repr)) res_ty $ zipWith3 sum_alt (tyConDataCons tycon) vars bodies where sum_alt data_con var body = (DataAlt data_con, [var], body) - from_repr repr expr = from_prod repr con expr + from_repr repr@(EnumRepr { enum_data_con = data_con }) expr + = do + var <- newLocalVar FSLIT("n") intPrimTy - from_prod prod@(ProdRepr { prod_components = tys - , prod_data_con = data_con }) + let res = Case (Var var) (mkWildId intPrimTy) res_ty + $ (DEFAULT, [], error_expr) + : zipWith mk_alt (tyConDataCons vect_tc) cons + + return $ Case expr (mkWildId (reprType repr)) res_ty + [(DataAlt data_con, [var], res)] + where + mk_alt data_con con = (LitAlt (mkDataConTagLit data_con), [], con) + + error_expr = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty + . showSDoc + $ sep [text "Invalid NDP representation of", ppr vect_tc] + + from_repr repr expr = from_unboxed repr con expr + + from_unboxed prod@(ProdRepr { prod_components = tys + , prod_data_con = data_con }) con expr = do @@ -451,10 +553,10 @@ buildFromPRepr repr vect_tc prepr_tc _ return $ Case expr (mkWildId (reprType prod)) res_ty [(DataAlt data_con, vars, con `mkVarApps` vars)] - from_prod (IdRepr _) con expr + from_unboxed (IdRepr _) con expr = return $ con `App` expr - from_prod (VoidRepr {}) con expr + from_unboxed (VoidRepr {}) con expr = return con buildToArrPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr @@ -512,12 +614,20 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc . mkConApp data_con $ map Type tys ++ map Var (len_var : repr_vars) + to_repr shape_vars + _ + (EnumRepr { enum_arr_tycon = tycon + , enum_arr_data_con = data_con }) + = return . wrapFamInstBody tycon [] + . mkConApp data_con + $ map Var shape_vars + to_prod repr_vars@(r : _) - (ProdRepr { prod_components = tys + (ProdRepr { prod_components = tys@(ty : _) , prod_arr_tycon = tycon , prod_arr_data_con = data_con }) = do - len <- lengthPA (Var r) + len <- lengthPA ty (Var r) return . wrapFamInstBody tycon tys . mkConApp data_con $ map Type tys ++ len : map Var repr_vars @@ -603,6 +713,19 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc return $ Case scrut (mkWildId scrut_ty) res_ty [(DataAlt data_con, shape_vars ++ repr_vars, body)] + from_prod (EnumRepr { enum_arr_tycon = tycon + , enum_arr_data_con = data_con }) + expr + shape_vars + _ + res_ty + body + = let scrut = unwrapFamInstScrut tycon [] expr + scrut_ty = mkTyConApp tycon [] + in + return $ Case scrut (mkWildId scrut_ty) res_ty + [(DataAlt data_con, shape_vars, body)] + from_prod (IdRepr ty) expr shape_vars @@ -640,6 +763,9 @@ buildPRDictRepr (SumRepr { dfun <- prDFunOfTyCon tycon return $ dfun `mkTyApps` map reprType prods `mkApps` prs +buildPRDictRepr (EnumRepr { enum_tycon = tycon }) + = prDFunOfTyCon tycon + buildPRDict :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildPRDict repr vect_tc prepr_tc _ = do @@ -692,7 +818,7 @@ buildPArrayDataCon orig_name vect_tc repr_tc shape_tys <- arrShapeTys repr repr_tys <- arrReprTys repr - let tys = shape_tys ++ concat repr_tys + let tys = shape_tys ++ repr_tys liftDs $ buildDataCon dc_name False -- not infix @@ -729,13 +855,12 @@ vectDataConWorkers :: Repr -> TyCon -> TyCon -> TyCon -> VM () vectDataConWorkers repr orig_tc vect_tc arr_tc = do - arr_tys <- arrReprElemTys repr bs <- sequence . zipWith3 def_worker (tyConDataCons orig_tc) rep_tys $ zipWith4 mk_data_con (tyConDataCons vect_tc) rep_tys - (inits arr_tys) - (tail $ tails arr_tys) + (inits reprs) + (tail $ tails reprs) mapM_ (uncurry hoistBinding) bs where tyvars = tyConTyVars vect_tc @@ -745,17 +870,16 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc res_ty = mkTyConApp vect_tc var_tys rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc + reprs = splitSumRepr repr [arr_dc] = tyConDataCons arr_tc mk_data_con con tys pre post = liftM2 (,) (vect_data_con con) - (lift_data_con tys (concat pre) - (concat post) - (mkDataConTag con)) + (lift_data_con tys pre post (mkDataConTag con)) vect_data_con con = return $ mkConApp con ty_args - lift_data_con tys pre_tys post_tys tag + lift_data_con tys pre_reprs post_reprs tag = do len <- builtin liftingContext args <- mapM (newLocalVar FSLIT("xs")) @@ -764,8 +888,8 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc shape <- replicateShape repr (Var len) tag repr <- mk_arr_repr (Var len) (map Var args) - pre <- mapM emptyPA pre_tys - post <- mapM emptyPA post_tys + pre <- liftM concat $ mapM emptyArrRepr pre_reprs + post <- liftM concat $ mapM emptyArrRepr post_reprs return . mkLams (len : args) . wrapFamInstBody arr_tc var_tys @@ -885,3 +1009,41 @@ tyConsOfType other = pprPanic "ClosureConv.tyConsOfType" $ ppr other tyConsOfTypes :: [Type] -> UniqSet TyCon tyConsOfTypes = unionManyUniqSets . map tyConsOfType + +-- ---------------------------------------------------------------------------- +-- Conversions + +fromVect :: Type -> CoreExpr -> VM CoreExpr +fromVect ty expr | Just ty' <- coreView ty = fromVect ty' expr +fromVect (FunTy arg_ty res_ty) expr + = do + arg <- newLocalVar FSLIT("x") arg_ty + varg <- toVect arg_ty (Var arg) + varg_ty <- vectType arg_ty + vres_ty <- vectType res_ty + apply <- builtin applyClosureVar + body <- fromVect res_ty + $ Var apply `mkTyApps` [varg_ty, vres_ty] `mkApps` [expr, varg] + return $ Lam arg body +fromVect ty expr + = identityConv ty >> return expr + +toVect :: Type -> CoreExpr -> VM CoreExpr +toVect ty expr = identityConv ty >> return expr + +identityConv :: Type -> VM () +identityConv ty | Just ty' <- coreView ty = identityConv ty' +identityConv (TyConApp tycon tys) + = do + mapM_ identityConv tys + identityConvTyCon tycon +identityConv ty = noV + +identityConvTyCon :: TyCon -> VM () +identityConvTyCon tc + | isBoxedTupleTyCon tc = return () + | isUnLiftedTyCon tc = return () + | otherwise = do + tc' <- maybeV (lookupTyCon tc) + if tc == tc' then return () else noV +