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

SCM Repository

[diderot] View of /branches/vis15/src/compiler/gen/ir/mid-ir.spec
ViewVC logotype

View of /branches/vis15/src/compiler/gen/ir/mid-ir.spec

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4043 - (download) (annotate)
Sun Jun 26 14:00:38 2016 UTC (3 years, 2 months ago) by jhr
File size: 5874 byte(s)
  Working on merge: changed the way that we handle kernels in the AST and SimpleAST IRs (treat
  them like literals, instead of like variables).  Added code to rewrite Inside tests in Simple
  IR to use the image instead of the field, which fixes a problem with trying to do inside tests
  on Ein fields.  Added code to promote locals to globals as part of the simplify-vars phase.
# specification of operators for MidIR version of the IR.  Each line (other than comments)
# specifies an operator using five fields, which are separated by ":".  The fields are
#       name
#       argument type           (optional)
#       result arity
#       arity
#       comment                 (optional)
#
# Operations with effects are denoted by a "!" as the first character of the line.
#
# integer operations
IAdd : : 1 : 2 : integer addition
ISub : : 1 : 2 : integer subtraction
IMul : : 1 : 2 : integer multiplication
IDiv : : 1 : 2 : integer division
IMod : : 1 : 2 : integer modulo
INeg : : 1 : 1 : integer negation
#
# comparisons (integer and scalar)
LT : ty : 1 : 2 :
LTE : ty : 1 : 2 :
EQ : ty : 1 : 2 :
NEQ : ty : 1 : 2 :
GT : ty : 1 : 2 :
GTE : ty : 1 : 2 :
Not : : 1 : 1 : boolean negation
Abs : ty : 1 : 1 :
Max : ty : 1 : 2 :
Min : ty : 1 : 2 :
# Clamp<ty>(lo, hi, x) -- clamps x to the range lo..hi, where lo and hi are scalars and x
# has type ty
Clamp : ty : 1 : 3 : clamp argument to range
# MapClamp<ty>(lo, hi, x) -- clamps x[alpha] to the range lo[alpha]..hi[alpha], where
# x, lo, and hi all have type ty (which is a non-scalar tensor type).
MapClamp : ty : 1 : 3 : clamp argument to range
# Lerp<ty>(a, b, t) -- computes a + t*(b-a), where a and b have type ty and t has type real
Lerp : ty : 1 : 3 : linear interpolation between 0 and 1
#
### tensor operations
#
# TensorIndex<ty,idxs>(T) returns the scalar T[idxs], where T has type ty
TensorIndex : ty * shape : 1 : 1 :
#
### matrix operations
#
EigenVecs2x2 : : 1 : 1 : Eigen vectors and values for 2x2 matrix
EigenVecs3x3 : : 1 : 1 : Eigen vectors and values for 3x3 matrix
EigenVals2x2 : : 1 : 1 : Eigen values for 2x2 matrix
EigenVals3x3 : : 1 : 1 : Eigen values for 3x3 matrix
# Zero<ty>() -- zero tensor
Zero : ty : 1 : 0 : all zeros tensor
#
### tuple operations
#
# Select<ty,i>(u)  -- select ith element of tuple; ty is tuple type
Select : ty * int : 1 : 1 :
#
### operations on sequences
#
# Subscript<ty>(u,i) -- select ith element of sequence; ty is type of sequence
Subscript : ty : 1 : 2 :
# MkDynamic<ty,n> -- make a sequence with type ty[n] into a dynamic sequence
!MkDynamic : ty * int : 1 : 1 : make a fixed-length sequence dynamic
!Append : ty : 1 : 2 : append an element onto a dynamic sequence
!Prepend : ty : 1 : 2 : prepend an element onto a dynamic sequence
!Concat : ty : 1 : 2 : concatenate two dynamic sequences
# Range(lo,hi) -- create a sequence with values [lo, lo+1, ..., hi]
Range : : 1 : 2 : create a range sequence
# Length<ty> -- return the length of a sequence with type ty[]
Length : ty : 1 : 1 : return the length of a dynamic sequence
#
# SphereQuery<posType,seqTy>(??)
SphereQuery : ty * ty : 1 : 2 : find strands within a sphere
#
# compute integral parts of reals
Ceiling : int : 1 : 1 : compute real ceiling of a vector
Floor : int : 1 : 1 : compute real floor of a vector
Round : int : 1 : 1 : compute real rounding to nearest integral real of a vector
Trunc : int : 1 : 1 : compute real truncation to integral real of a vector
#
### conversions; the real to int forms are vector ops
IntToReal : : 1 : 1 :
RealToInt : int : 1 : 1 : cast reals to ints and vectors to int sequences
#
# reduction operations
R_All      : ty : 1 : 3 :
R_Exists   : ty : 1 : 3 :
R_Max      : ty : 1 : 3 :
R_Min      : ty : 1 : 3 :
R_Sum      : ty : 1 : 3 :
R_Product  : ty : 1 : 3 :
R_Mean     : ty : 1 : 3 :
R_Variance : ty : 1 : 4 :
#
### image/kernel operations
#
# BuildPos<s>(x) -- builds a vector of 2s kernel arguments at positions [x-s, .., x+(s-1)]
BuildPos : int : 1 : 1 : compute vector of kernel arguments
#
# EvalKernel<d,h,k>(u) -- computes h^(k)(u_i) for 1<i<d, where d is the size of vector u.
EvalKernel : int * Kernel.t * int : 1 : 1 : evaluate a kernel function application
#
# Kernel<h,k>() -- represents the k'th derivative of the kernel h.
Kernel    : Kernel.t * int  : 1 : 0 :
#
Transform  : ImageInfo.info : 1 : 1 : Pulls transformation matrix from image.
Translate  : ImageInfo.info : 1 : 1 : Pulls translation vector from image.
#
# LoadVoxels<I,s>(V,n) -- loads a tensor of voxels from the image V, where I is the
# image info for V, s is size of the sample (i.e., twice the kernel support), and
# n is a sequence of integer indices that specifies the corner of the loaded tensor.
# If V has the type "image(d)[shp]", then n has type "int[n]" and the resulting tensor
# has the type "tensor[shp,s^d]".
LoadVoxels : ImageInfo.info * int : 1 : 2 : load a cube of voxels
#
# LoadVoxelsWithCtl<I,s,ctl>(V,n) -- like LoadVoxels, but it also uses the specified
# index control to deal with out-of-bounds indices.
LoadVoxelsWithCtl : ImageInfo.info * int * idxctl : 1 : 2 : load a cube of voxels
#
# Inside<I,s>(n,V) -- tests to see if the index sequence n is inside the domain of V.
# I is the image info for V, s is the size of the sample to be loaded (see LoadVoxels)
Inside : ImageInfo.info * int : 1 : 2 :
#
# ImageDim<I,i>(V) -- returns the i'th dimension of the image
ImageDim : ImageInfo.info * int : 1 : 1 :
#
# BorderCtlDefault<I>(V,t) -- wrap the image V with the border control that returns a default value t
BorderCtlDefault : ImageInfo.info : 1 : 2 :
# BorderCtlClamp<I>(V) -- wrap the image V with the border control that clamps the index
BorderCtlClamp : ImageInfo.info : 1 : 1 :
# BorderCtlMirror<I>(V) -- wrap the image V with the border control that mirrors the index
BorderCtlMirror : ImageInfo.info : 1 : 1 :
# BorderCtlWrap<I>(V) -- wrap the image V with the border control that wraps the index
BorderCtlWrap : ImageInfo.info : 1 : 1 :
#
# nrrd file loading
LoadSeq   : ty * string : 1 : 0 : load sequence from nrrd file
LoadImage : ty * string : 1 : 0 : load image from nrrd file
#
# printing support for debugging
!Print : tys : 0 : * : print strings
#
# unlifted math functions
MathFn : MathFns.t : 1 : * : math function

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0