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 3562 - (download) (annotate)
Sun Jan 10 16:56:09 2016 UTC (4 years, 1 month ago) by jhr
File size: 3732 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

    fun getShapes e= S.getShapes e
    fun rewriteIx e= R.rewrite e
    fun iTos i =Int.toString i
(* FIXME *)
    fun insert (key, value) d =(fn s =>
        if s = key then SOME value
        else d s)
    fun lookup k d = d k
    val empty =fn key =>NONE

    fun err str=raise Fail str
    (*dictionary to lookup mapp*)
    fun lkupIX(e1,mapp,str)=(case (lookup e1 mapp)
        of SOME l=>l
        | _=> raise Fail(str^iTos(e1))

    * create sizeMapp for bound on mu
    fun mkSizeMapp (index, sx) = let
	  fun m ([],mapp) = mapp
	    | m ((E.V v, _,ub)::es,mapp)= m(es,insert(v,ub+1) mapp)
	    | m ( _,_)=err"Non-V-index in sx"
	  fun f (_,[],mapp)= mapp
	    | f (counter,ix::es,mapp) = f(counter+1, es, insert(counter, ix) mapp)
	  val mapp = f(0, index, 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=insert(e1, tocounter) mapp
	  fun m (mapp, [], tocounter) = mapp
	    | m (mapp, e1::es, tocounter) = (case (lookup e1 mapp)
		    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 = insert (e1, tocounter) mapp
			  (* end case *))
		  (* end case *))
	  val (mapp, tocounter) =f (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 => lkupIX(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