skinny delegates

[Jonathan Marler]

On Thursday, 2 August 2018 at 16:21:58 UTC, Jonathan Marler wrote:
> On Monday, 30 July 2018 at 21:02:56 UTC, Steven Schveighoffer 
> wrote:
>> Would it be a valid optimization to have D remove the 
>> requirement for allocation when it can determine that the 
>> entire data structure of the item in question is an rvalue, 
>> and would fit into the data pointer part of the delegate?
>>
>> Here's what I'm looking at:
>>
>> auto foo(int x)
>> {
>>    return { return x + 10; };
>> }
>>
>> In this case, D allocates a pointer on the heap to hold "x", 
>> and then return a delegate which uses the pointer to read x, 
>> and then return that plus 10.
>>
>> However, we could store x itself in the storage of the pointer 
>> of the delegate. This removes an indirection, and also saves 
>> the heap allocation.
>>
>> Think of it like "automatic functors".
>>
>> Does it make sense? Would it be feasible for the language to 
>> do this? The type system already casts the delegate pointer to 
>> a void *, so it can't make any assumptions, but this is a 
>> slight break of the type system.
>>
>> The two requirements I can think of are:
>> 1. The data in question must fit into a word
>> 2. It must be guaranteed that the data is not going to be 
>> mutated (either via the function or any other function). Maybe 
>> it's best to require the state to be const/immutable.
>>
>> I've had several cases where I was tempted to not use 
>> delegates because of the allocation cost, and simply return a 
>> specialized struct, but it's so annoying to do this compared 
>> to making a delegate. Plus something like this would be 
>> seamless with normal delegates as well (in case you do need a 
>> real delegate).
>>
>> -Steve
>
> I think the number of cases where you could optimize this is 
> very small.  And the complexity of getting the compiler to 
> analyze cases to determine when this is possible would be very 
> large.
>
> In addition, a developer can already do this explicitly if they 
> want, i.e.
>
> auto foo(int x)
> {
>     static struct DummyStructToMakeFunctionWithDelegateAbi
>     {
>         int passthru() const { return cast(int)&this; }
>     }
>     DummyStructToMakeFunctionWithDelegateAbi dummyStruct;
>     auto dg = &dummyStruct.passthru;
>     dg.ptr = cast(void*)(x + 10); // treat the void* pointer as 
> an int value
>     return dg;
> }
>
> void main(string[] args)
> {
>     auto dg = foo(32);
>     import std.stdio;
>     writefln("dg() = %s", dg());
> }
>
> It's definitely ugly but it works.  This will print the number 
> "42" as expected.
>
> This would be a case where DIP1011 extern(delegate) would come 
> in handy :) i.e.
>
> extern(delegate) int passthru(void* ptr) { return cast(int)ptr; 
> }
> int delegate() foo2(int x)
> {
>     return &(cast(void*)(x + 10)).passthru;
> }

Actually, I'll do you one better.  Here's a potential library 
function for it.  I'm calling these types of delegates "value 
pointer delegates".

// Assume this is in a library somewhere
auto makeValuePtrDelegate(string valueName, string funcBody, T)(T 
value)
{
     static struct DummyStruct
     {
         auto method() const
         {
             mixin("auto " ~ valueName ~ " = cast(T)&this;");
             mixin (funcBody);
         }
     }
     DummyStruct dummy;
     auto dg = &dummy.method;
     dg.ptr = cast(void*)value;
     return dg;
}

auto foo(int x)
{
     return makeValuePtrDelegate!("val", q{ return val + 10; })(x);
}

void main(string[] args)
{
     auto dg = foo(32);
     import std.stdio;
     writefln("dg() = %s", dg());
}