Proposal: C# AMP and restrict keyword

[fo40225]

Idea from C++ AMP.

Until now, use C# to calculate on GPGPU still not easy

(DirectCompute, OpenGL, OpenCL, CUDA, Vulkan ... etc).

Although .NET have the Parallel class can do parallel for easily like OpenMP, C# lack more simple syntax to do a massive parallel compute like OpenACC, C++ AMP or OpenMP 4.0.

So we need something like this:

int[] aCS = { 1, 2, 3, 4, 5 };
int[] bCS = { 6, 7, 8, 9, 10 };
int[] sumCS = new int[5];

var a = new ArrayView(aCS);
var b = new ArrayView(bCS);
var sum = new ArrayView(sumCS);

GPUParallel.ForEach(
    sum.extent,
    restrict(amp) idx =>
    {
        sum[idx] = a[idx] + b[idx];
    });

But let Roslyn to emit GPU code is too over, the only thing Roslyn should do is to limit expressions in lambda and give generate expressions to GPU provider.

restrict(amp) hint to do limitation.

Actually do this:

AMPExpression<Action<Index>> foo = restrict(amp) idx => { sum[idx] = a[idx] + b[idx]; };

AGPUParallelProvider.ForEach(sum.extent, foo);

Allow more complex "restrict(amp) method"

restrict(amp) void Foo()
{
    // something amazing
}

Even crazy, we can make a LINQ to GPU, just like Entity Framework.

var db = new AdventureWorksEntities();
var query = db
    .Where(bar)
    .Select(foobar)
    .Average(baz); // Run on Database

var source = AGPUParallelProvider.CreateContext(...);
var query = source
    .Where(bar)
    .Select(foobar)
    .Aggregate(baz); // Run on GPU!

By the way, there is a lot of expression trees in .NET and those should be refactoring.

Expressions -- abstract expression trees
               IQueryable should take this?

    IL Expressions -- can generate IL code
                      cast from delegate (Action, Func) or all?
                      LINQ to Object should actually take this? (even do optimize in LINQ to Object)
                      enhance System.Reflection.Emit (easy to modify)

    System.CodeDom.Expressions
    Roslyn Syntax Tree
    System.Linq.Expressions
        can generate IL Expressions?

    AMP expression -- generate code SIMD, hlsl, opencl, cuda etc.
                      restrict(amp)
                      restrict(cuda)
                      ...

    query expression -- perhaps used by EF to generate sql?
                        restrict(ansisql)
                        restrict(mssql)
                        ...
    Microsoft.EntityFrameworkCore.Query.Expressions

Maybe with restrict(mssql) EntityFramework can do more thing?

    restrict(mssql) void ComplexSQLQuery()
    {
        // something crazying query logic can translate from C# to SQL
    }

[svick]

What would restrict(amp) give you that a combination of extending expression trees to statement lambdas (https://github.com/dotnet/roslyn/issues/2060) and an analyzer to catch invalid code couldn't?

[iam3yal]

This is better left for the framework level and not the language, much like they did with SIMD where they introduced a new type called Vector that is an abstraction over it.

I hope they will expand the CLR to support more hardware features through abstractions without going through interops and stuff.

[fo40225]

@svick , [restrict(amp)] will be a better design?

@eyalsk, Of course GPU support should be implemented on the framework level, but an expression tree subset (profile) will help provider developer and programmer.

This is exist feature:

Func<bool> dele1 = () => true;
Expression<Func<bool>> exp1 = () => true;

/* modify exp1 to build dynamic LINQ query */

Func<bool> mod1 = exp1.Compile();

we can enhance it, give a restrict keyword to hint roslyn to leave the expression tree.

Func<bool> dele1 = () => true;
ILExpression<Func<bool>> exp1 = restrict(clr) () => true;
/* modify exp1 to build dynamic method */

exp1 = dele1.GetMethodBodyTree();
/* easily to modify exist method */

Func<bool> mod1 = exp1.Compile();
/* just like System.Reflection.Emit do */

(#2060) 's problem, it can use restrict(csharp)

var dataSource = new[] { 1, 2, 3, 4, 5 }.AsQueryable();

CSharpExpression<Func<int, int>> exp1 = restrict(csharp) i => i + 1;
/* modify exp1 to build dynamic LINQ query */

var query = dataSource.Select(exp1).Select(exp1).Select(exp1);
/* query.Expression can be optimized by QueryableProvider */

Func<int, int> mod1 = exp1.Compile();
/* roslyn already done this */

ILExpression<Func<bool>> exp2 = exp1.ConvertToIL();
/*Is the logic of roslyn's backend? */

exp1 = mod1.Decompile();
/* decompiler actually do this */

if allow restrict keyword not only on a method, perhaps make metaprogramming on C# more easily.

CSharpExpression<Type> myClass = restrict(csharp) class
{

}

/* modify myClass*/

var newTypeExpression = /* make a new CSharpExpression<Type> from magically modified myClass */

Type t = newTypeExpression.Compile();

/* do something on newType */

restrict(amp) will limit full C# expression to a subset (GPU profile)

var GPUContext = new[] { 1, 2, 3, 4, 5 }.AsAcceleratable();
AMPExpression<Func<int, int>> exp1 =
    restrict(amp) i =>
    {
        // allow GPU operation only.
        return i + 1;
    };
/* modify exp1 to build dynamic GPU query */

var query = GPUContext.Select(exp1).Select(exp1).Select(exp1);
/* query.Expression can be optimized by QueryableProvider */

Func<int, int> mod1 = query.Compile();
/* emit GPU code (hlsl, OpenCL, CUDA etc.) by provider */

another idea is restrict(sql), it is also a subset.

var db = new NorthwindEntities();
SQLExpression<Func<int, Order>> exp1 =
    restrict(sql) o =>
    {
        // only SQL can do
        // foreach => CURSOR
        // while => WHILE
        // switch => CASE WHEN THEN ELSE
        // etc.
        return o.OrderID;
    };
/* modify exp1 to build dynamic SQL query */

var query = db.Select(exp1);
/* query.Expression can be optimized by EF */

var SQLtext = query.Expression.ToString();
/* get the SQL query */

[AdamSpeight2008]

Doesn't Mono already have something along this line.