internal static Attribute[] GetAttribs(LambdaExpression func, Type attribType)
{
Attribute[] attribs1 = AttributeSystem.Get(func, attribType);
Attribute[] attribs2 = null;
if (func.Body is MethodCallExpression)
{
MethodCallExpression expr = (MethodCallExpression)func.Body;
attribs2 = Attribute.GetCustomAttributes(expr.Method, attribType);
}
else if (func.Body is NewExpression && ((NewExpression)func.Body).Constructor != null)
{
NewExpression expr = (NewExpression)func.Body;
attribs2 = Attribute.GetCustomAttributes(expr.Constructor, attribType);
}
else if (func.Body is BinaryExpression)
{
BinaryExpression expr = (BinaryExpression)func.Body;
if (expr.Method != null)
{
attribs2 = Attribute.GetCustomAttributes(expr.Method, attribType);
}
}
else if (func.Body is InvocationExpression)
{
InvocationExpression expr = (InvocationExpression)func.Body;
if (expr.Expression is LambdaExpression)
{
attribs2 = GetAttribs((LambdaExpression)expr.Expression, attribType);
}
}
if (attribs1 == null)
{
return(attribs2);
}
if (attribs2 == null)
{
return(attribs1);
}
ArrayList alist = new ArrayList();
foreach (var x in attribs1)
{
alist.Add(x);
}
foreach (var x in attribs2)
{
alist.Add(x);
}
Attribute[] attribs = (Attribute[])alist.ToArray(attribType);
return(attribs);
}
internal override Expression VisitMethodCall(MethodCallExpression mcExpr)
{
Attribute resourceAttrib = AttributeSystem.GetAttrib(mcExpr, typeof(ResourceAttribute));
if (resourceAttrib == null)
{
this.m_isExpensive = true;
}
else
{
this.m_isExpensive = this.m_isExpensive || ((ResourceAttribute)resourceAttrib).IsExpensive;
}
return(mcExpr);
}
internal override Expression VisitBinary(BinaryExpression b)
{
if (b.Method == null)
{
return(base.VisitBinary(b));
}
else
{
Attribute resourceAttrib = AttributeSystem.GetAttrib(b, typeof(ResourceAttribute));
if (resourceAttrib == null)
{
this.m_isExpensive = true;
}
else
{
this.m_isExpensive = this.m_isExpensive || ((ResourceAttribute)resourceAttrib).IsExpensive;
}
return(b);
}
}
internal override Expression VisitUnary(UnaryExpression u)
{
if (u.Method == null)
{
return(base.VisitUnary(u));
}
else
{
Attribute resourceAttrib = AttributeSystem.GetAttrib(u, typeof(ResourceAttribute));
if (resourceAttrib == null)
{
this.m_isExpensive = true;
this.m_isStateful = true;
}
else
{
this.m_isExpensive = this.m_isExpensive || ((ResourceAttribute)resourceAttrib).IsExpensive;
this.m_isStateful = this.m_isStateful || ((ResourceAttribute)resourceAttrib).IsStateful;
}
return(u);
}
}
private static DecompositionInfo GetDecompositionInfo(ParameterExpression groupParam,
MethodCallExpression mcExpr,
HpcLinqCodeGen codeGen)
{
if (mcExpr.Arguments.Count == 0 || mcExpr.Arguments[0] != groupParam)
{
return(null);
}
for (int i = 1; i < mcExpr.Arguments.Count; i++)
{
if (HpcLinqExpression.Contains(groupParam, mcExpr.Arguments[i]))
{
return(null);
}
}
ExpressionSimplifier <object> evaluator = new ExpressionSimplifier <object>();
Type[] paramTypeArgs = groupParam.Type.GetGenericArguments();
Type sourceElemType = paramTypeArgs[paramTypeArgs.Length - 1];
Type resultType = mcExpr.Type;
Type decomposerType = null;
DecomposableAttribute decomposableAttrib = AttributeSystem.GetDecomposableAttrib(mcExpr);
if (decomposableAttrib != null)
{
decomposerType = decomposableAttrib.DecompositionType;
}
else
{
MethodInfo mInfo = mcExpr.Method;
if (mInfo.DeclaringType == typeof(System.Linq.Enumerable) ||
mInfo.DeclaringType == typeof(System.Linq.Queryable))
{
// For built-in decomposable operators.
switch (mInfo.Name)
{
case "Count":
case "LongCount":
{
Type outputType;
Expression body;
if (mInfo.Name == "Count")
{
outputType = typeof(Int32);
body = Expression.Constant(1, outputType);
}
else
{
outputType = typeof(Int64);
body = Expression.Constant((long)1, outputType);
}
ParameterExpression param1 = Expression.Parameter(outputType, "a");
ParameterExpression param2 = Expression.Parameter(sourceElemType, "e");
LambdaExpression seedExpr = Expression.Lambda(body, param2);
body = Expression.AddChecked(param1, body);
LambdaExpression accumulateExpr = Expression.Lambda(body, param1, param2);
param2 = Expression.Parameter(outputType, "b");
body = Expression.AddChecked(param1, param2);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(body, param1, param2);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "Any":
{
ParameterExpression param1 = Expression.Parameter(typeof(bool), "a");
ParameterExpression param2;
Expression body;
if (mcExpr.Arguments.Count == 1)
{
param2 = Expression.Parameter(sourceElemType, "e");
body = Expression.Constant(true, typeof(bool));
}
else
{
LambdaExpression predExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
param2 = predExpr.Parameters[0];
body = predExpr.Body;
}
LambdaExpression seedExpr = Expression.Lambda(body, param2);
LambdaExpression accumulateExpr = Expression.Lambda(Expression.Or(param1, body), param1, param2);
param2 = Expression.Parameter(typeof(bool), "b");
body = Expression.Or(param1, param2);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(body, param1, param2);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "All":
{
ParameterExpression param1 = Expression.Parameter(typeof(bool), "a");
LambdaExpression predExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
ParameterExpression param2 = predExpr.Parameters[0];
Expression body = predExpr.Body;
LambdaExpression seedExpr = Expression.Lambda(body, param2);
LambdaExpression accumulateExpr = Expression.Lambda(Expression.And(param1, body), param1, param2);
param2 = Expression.Parameter(typeof(bool), "b");
body = Expression.And(param1, param2);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(body, param1, param2);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "First":
{
ParameterExpression param1 = Expression.Parameter(sourceElemType, "a");
ParameterExpression param2 = Expression.Parameter(sourceElemType, "e");
LambdaExpression seedExpr = Expression.Lambda(param2, param2);
LambdaExpression accumulateExpr = Expression.Lambda(param1, param1, param2);
LambdaExpression recursiveAccumulateExpr = accumulateExpr;
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "Last":
{
ParameterExpression param1 = Expression.Parameter(sourceElemType, "a");
ParameterExpression param2 = Expression.Parameter(sourceElemType, "e");
LambdaExpression seedExpr = Expression.Lambda(param2, param2);
LambdaExpression accumulateExpr = Expression.Lambda(param2, param1, param2);
LambdaExpression recursiveAccumulateExpr = accumulateExpr;
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "Sum":
{
ParameterExpression param1;
ParameterExpression param2;
Expression arg2;
if (mInfo.GetParameters().Length == 1)
{
param2 = Expression.Parameter(sourceElemType, "e");
arg2 = param2;
}
else
{
LambdaExpression selectExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
param2 = selectExpr.Parameters[0];
arg2 = selectExpr.Body;
}
Expression abody, sbody;
if (arg2.Type.IsGenericType)
{
param1 = Expression.Parameter(arg2.Type.GetGenericArguments()[0], "a");
MethodInfo accumulateInfo = typeof(HpcLinqVertex).GetMethod(
"SumAccumulate",
new Type[] { param1.Type, arg2.Type });
sbody = Expression.Constant(0, param1.Type);
sbody = Expression.Call(accumulateInfo, sbody, arg2);
abody = Expression.Call(accumulateInfo, param1, arg2);
}
else
{
param1 = Expression.Parameter(arg2.Type, "a");
sbody = arg2;
abody = Expression.AddChecked(param1, arg2);
}
LambdaExpression seedExpr = Expression.Lambda(sbody, param2);
LambdaExpression accumulateExpr = Expression.Lambda(abody, param1, param2);
param2 = Expression.Parameter(param1.Type, "b");
Expression rbody = Expression.AddChecked(param1, param2);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(rbody, param1, param2);
Expression fbody = Expression.Convert(param1, arg2.Type);
LambdaExpression finalReduceExpr = Expression.Lambda(fbody, param1);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr,
recursiveAccumulateExpr, finalReduceExpr));
}
case "Max":
case "Min":
{
ParameterExpression param2;
Expression abody;
if (mInfo.GetParameters().Length == 1)
{
param2 = Expression.Parameter(sourceElemType, "e");
abody = param2;
}
else
{
LambdaExpression selectExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
param2 = selectExpr.Parameters[0];
abody = selectExpr.Body;
}
ParameterExpression param1 = Expression.Parameter(abody.Type, "a");
Expression sbody = abody;
MethodInfo accumulateInfo;
string methodName = (mInfo.Name == "Max") ? "MaxAccumulate" : "MinAccumulate";
if (mInfo.IsGenericMethod && (mInfo.GetParameters().Length == 1))
{
accumulateInfo = typeof(HpcLinqVertex).GetMethod(methodName + "Generic");
accumulateInfo = accumulateInfo.MakeGenericMethod(sourceElemType);
}
else
{
accumulateInfo = typeof(HpcLinqVertex).GetMethod(
methodName,
new Type[] { param1.Type, abody.Type });
}
abody = Expression.Call(accumulateInfo, param1, abody);
LambdaExpression seedExpr = Expression.Lambda(sbody, param2);
LambdaExpression accumulateExpr = Expression.Lambda(abody, param1, param2);
param2 = Expression.Parameter(param1.Type, "b");
Expression rbody = Expression.Call(accumulateInfo, param1, param2);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(rbody, param1, param2);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "Aggregate":
{
ParameterExpression elemParam = Expression.Parameter(sourceElemType, "e");
LambdaExpression accumulateExpr;
LambdaExpression seedExpr;
if (mcExpr.Arguments.Count == 2)
{
accumulateExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
seedExpr = Expression.Lambda(elemParam, elemParam);
}
else
{
accumulateExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[2]);
object seedVal = evaluator.Eval(mcExpr.Arguments[1]);
Expression body = Expression.Constant(seedVal, seedVal.GetType());
ParameterSubst subst = new ParameterSubst(accumulateExpr.Parameters[0], body);
body = subst.Visit(accumulateExpr.Body);
seedExpr = Expression.Lambda(body, accumulateExpr.Parameters[1]);
}
if (!HpcLinqExpression.IsAssociative(accumulateExpr))
{
return(null);
}
LambdaExpression recursiveAccumulateExpr = HpcLinqExpression.GetAssociativeCombiner(accumulateExpr);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, null));
}
case "Average":
{
ParameterExpression param2;
Expression abody;
if (mInfo.GetParameters().Length == 1)
{
param2 = Expression.Parameter(sourceElemType, "e");
abody = param2;
}
else
{
LambdaExpression selectExpr = HpcLinqExpression.GetLambda(mcExpr.Arguments[1]);
param2 = selectExpr.Parameters[0];
abody = selectExpr.Body;
}
Type aggValueType = abody.Type;
if (aggValueType == typeof(int) ||
aggValueType == typeof(int?))
{
aggValueType = typeof(long);
}
else if (aggValueType == typeof(long?))
{
aggValueType = typeof(long);
}
else if (aggValueType == typeof(float) ||
aggValueType == typeof(float?))
{
aggValueType = typeof(double);
}
else if (aggValueType == typeof(double?))
{
aggValueType = typeof(double);
}
else if (aggValueType == typeof(decimal?))
{
aggValueType = typeof(decimal);
}
Type sumAndCountType = typeof(AggregateValue <>).MakeGenericType(aggValueType);
ParameterExpression param1 = Expression.Parameter(sumAndCountType, "a");
MethodInfo accumulateInfo = typeof(HpcLinqVertex).GetMethod(
"AverageAccumulate",
new Type[] { sumAndCountType, abody.Type });
// Seed:
Expression sbody = Expression.New(sumAndCountType);
sbody = Expression.Call(accumulateInfo, sbody, abody);
LambdaExpression seedExpr = Expression.Lambda(sbody, param2);
// Accumulate:
abody = Expression.Call(accumulateInfo, param1, abody);
LambdaExpression accumulateExpr = Expression.Lambda(abody, param1, param2);
// RecursiveAccumulate:
param2 = Expression.Parameter(param1.Type, "b");
PropertyInfo valueInfo = sumAndCountType.GetProperty("Value");
PropertyInfo countInfo = sumAndCountType.GetProperty("Count");
Expression sumExpr1 = Expression.Property(param1, valueInfo);
Expression countExpr1 = Expression.Property(param1, countInfo);
Expression sumExpr2 = Expression.Property(param2, valueInfo);
Expression countExpr2 = Expression.Property(param2, countInfo);
Expression sumExpr = Expression.AddChecked(sumExpr1, sumExpr2);
Expression countExpr = Expression.AddChecked(countExpr1, countExpr2);
ConstructorInfo cinfo = sumAndCountType.GetConstructor(new Type[] { sumExpr.Type, countExpr.Type });
Expression rbody = Expression.New(cinfo, sumExpr, countExpr);
LambdaExpression recursiveAccumulateExpr = Expression.Lambda(rbody, param1, param2);
// FinalReduce:
if (sumExpr1.Type == typeof(long))
{
sumExpr1 = Expression.Convert(sumExpr1, typeof(double));
}
Expression fbody = Expression.Divide(sumExpr1, countExpr1);
fbody = Expression.Convert(fbody, resultType);
if (resultType.IsGenericType)
{
Expression zeroExpr = Expression.Constant(0, typeof(long));
Expression condExpr = Expression.GreaterThan(countExpr1, zeroExpr);
Expression nullExpr = Expression.Constant(null, resultType);
fbody = Expression.Condition(condExpr, fbody, nullExpr);
}
LambdaExpression finalReduceExpr = Expression.Lambda(fbody, param1);
return(new DecompositionInfo(mcExpr, seedExpr, accumulateExpr, recursiveAccumulateExpr, finalReduceExpr));
}
case "Contains":
{
decomposerType = typeof(ContainsDecomposition <>).MakeGenericType(sourceElemType);
break;
}
case "Distinct":
{
decomposerType = typeof(DistinctDecomposition <>).MakeGenericType(sourceElemType);
break;
}
default:
{
return(null);
}
}
}
}
if (decomposerType == null)
{
return(null);
}
Type implementedInterface = null;
Type[] interfaces = decomposerType.GetInterfaces();
foreach (Type intf in interfaces)
{
if (intf.GetGenericTypeDefinition() == typeof(IDecomposable <, ,>))
{
if (implementedInterface != null)
{
throw new DryadLinqException("Decomposition class can implement only one decomposable interface.");
}
implementedInterface = intf;
}
}
if (implementedInterface == null ||
implementedInterface.GetGenericArguments().Length != 3)
{
throw new DryadLinqException("Decomposition class " + decomposerType.FullName +
"must implement IDecomposable<,,>");
}
// The second type of the implemented interface definition is the accumulatorType.
Type accumulatorType = implementedInterface.GetGenericArguments()[1];
// Now check that all the types match up.
Type decomposerInterface = typeof(IDecomposable <, ,>).MakeGenericType(
sourceElemType, accumulatorType, resultType);
if (!decomposerInterface.IsAssignableFrom(decomposerType))
{
throw new DryadLinqException("Decomposition class must match the function that it decorates.");
}
if (decomposerType.ContainsGenericParameters)
{
if (decomposerType.GetGenericArguments().Length != 1 ||
!decomposerType.GetGenericArguments()[0].IsGenericParameter)
{
throw new DryadLinqException(decomposerType.Name + " must match the function it annotates.");
}
decomposerType = decomposerType.MakeGenericType(sourceElemType);
}
if (decomposerType.GetConstructor(Type.EmptyTypes) == null)
{
throw new DryadLinqException("Decomposition class must have a default constructor.");
}
// Add to the codegen a call of the static Initializer of decomposerType
Expression[] args = new Expression[mcExpr.Arguments.Count - 1];
for (int i = 0; i < args.Length; i++)
{
args[i] = Expression.Convert(mcExpr.Arguments[i + 1], typeof(object));
}
Expression stateExpr = Expression.NewArrayInit(typeof(object), args);
string decomposerName = codeGen.AddDecompositionInitializer(decomposerType, stateExpr);
ParameterExpression decomposer = Expression.Parameter(decomposerType, decomposerName);
// Seed: TSource => TAccumulate
MethodInfo seedInfo1 = decomposerType.GetMethod("Seed");
ParameterExpression p2 = Expression.Parameter(sourceElemType, "e");
Expression sbody1 = Expression.Call(decomposer, seedInfo1, p2);
LambdaExpression seedExpr1 = Expression.Lambda(sbody1, p2);
// Accumulate: (TAccumulate, TSource) => TAccumulate
MethodInfo accumulateInfo1 = decomposerType.GetMethod("Accumulate");
ParameterExpression p1 = Expression.Parameter(accumulatorType, "a");
Expression abody1 = Expression.Call(decomposer, accumulateInfo1, p1, p2);
LambdaExpression accumulateExpr1 = Expression.Lambda(abody1, p1, p2);
// RecursiveAccumulate: (TAccumulate, TAccumulate) => TAccumulate
MethodInfo recursiveAccumulateInfo1 = decomposerType.GetMethod("RecursiveAccumulate");
p2 = Expression.Parameter(accumulatorType, "e");
Expression rbody1 = Expression.Call(decomposer, recursiveAccumulateInfo1, p1, p2);
LambdaExpression recursiveAccumulateExpr1 = Expression.Lambda(rbody1, p1, p2);
// FinalReduce: TAccumulate => TResult
MethodInfo finalReduceInfo1 = decomposerType.GetMethod("FinalReduce");
Expression fbody1 = Expression.Call(decomposer, finalReduceInfo1, p1);
LambdaExpression finalReduceExpr1 = Expression.Lambda(fbody1, p1);
return(new DecompositionInfo(mcExpr, seedExpr1, accumulateExpr1, recursiveAccumulateExpr1, finalReduceExpr1));
}