Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] View of /branches/vis15/src/compiler/high-to-mid/clean-index.sml
ViewVC logotype

View of /branches/vis15/src/compiler/high-to-mid/clean-index.sml

Parent Directory Parent Directory | Revision Log Revision Log

Revision 3565 - (download) (annotate)
Sun Jan 10 17:29:35 2016 UTC (4 years, 10 months ago) by jhr
File size: 3679 byte(s)
working on merge
(* clean-index.sml
 * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
 * COPYRIGHT (c) 2016 The University of Chicago
 * All rights reserved.

cleanIndex.sml cleans the indices in the EIN expression. This process is a bit more complicated because the vast number of possibilities. We need to both know all indices used in the subexpression in order to create a mapp, and the shape of the subexpression. 

For each subexpression we look for the\\
ashape(mu list): all the indices mentioned in body
tshape(mu list):shape of tensor replacement
size(int list): TensorType of tensor replacement\\
structure CleanIndex : sig

    val clean : ? -> ?

  end = struct

    structure E = Ein
    structure S = GetShape
    structure R = RewriteIndices
    structure IMap = IntRedBlackMap

    fun getShapes e = S.getShapes e
    fun rewriteIx e = R.rewrite e
    fun err str=raise Fail str

    (*dictionary to lookup mapp*)
    fun lookupIx (e1, mapp, str) = (case IMap.find(mapp, e1)
           of SOME l => l
            | _ => raise Fail(str^ Integer.toString e1)
          (* endcase *))

    * create sizeMapp for bound on mu
    fun mkSizeMapp (index, sx) = let
	  fun m ([], mapp) = mapp
	    | m ((E.V v, _, ub)::es, mapp) = m (es, IMap.insert(mapp, v, ub+1))
	    | m ( _, _) = err "Non-V-index in sx"
	  fun f (_, [], mapp) = mapp
	    | f (counter, ix::es, mapp) = f (counter+1, es, IMap.insert(mapp, counter, ix))
	  val mapp = f(0, index, IMap.empty)
            m (sx, mapp)

     (* mkIndexMapp:int list, sum_id list*mu list*mu list=>dict*int list *mu list
     * A map is created to match index-ids in e1 to their new ids.
     * First we iterate over indices in $tshape\beta$ and set a counter to 0.
     * i.e. [$\beta_0 \longrightarrow 0,\beta_1 \longrightarrow 1,..,\beta_n \longrightarrow n $]$\in $indexMapp
     Then from i=0 to i=maxium possible index-id.
     if (i $\not \in $indexMapp and i $\in \gamma$) then $i \longrightarrow counter \in indexMapp$
    fun mkIndexMapp (index, sx, ashape, tshape) = let
	  fun f (mapp, [],tocounter) = (mapp, tocounter)
	    | f (mapp, (E.V e1)::es, tocounter) = let
		val dict = IMap.insert(mapp, e1, tocounter)
	  fun m (mapp, [], tocounter) = mapp
	    | m (mapp, e1::es, tocounter) = (case IMap.lookup(mapp, e1)
		    of SOME _=> m (mapp, es, tocounter)
		     | _ => (case (List.find (fn x => x = E.V e1) ashape)
			   of NONE => m (mapp, es, tocounter)
			    | SOME _ => let
				val dict = IMap.insert (mapp, e1, tocounter)
			  (* end case *))
		  (* end case *))
	  val (mapp, tocounter) = f (IMap.empty, tshape, 0)
	  val pp = List.map (fn E.V v => v | _ => 0) ashape
	  val max = List.foldl (fn (a, b) => Int.max(a, b)) (length index-1) pp
	  (*finds max element in ashape and creates [0,1,2,....,max]*)
	  val maxmu = List.tabulate (max+1, fn e => e)
	  val indexMapp = m (mapp, maxmu, tocounter)

    (* cleanIndex:ein_exp*int list *sum_id ->mu list *int list*ein_exp
    * cleans index in body
    * returns shape of replacement in index variable list, size, and rewritten body
    fun clean (e, index, sx) = let
	  val (ashape, tshape) = getShapes(e, index, sx)
	  val sizeMapp = mkSizeMapp(index, sx)
	  val sizes = List.map (fn E.V e1 => lookupIx(e1, sizeMapp, "Could not find Size of")) tshape
	  val indexMapp = mkIndexMapp (index, sx, ashape, tshape)
	  val body = rewriteIx (indexMapp, e)

  end (* CleanIndex *)

ViewVC Help
Powered by ViewVC 1.0.0