DEV Community: Volatile Delegate

Interface Proxy

Volatile Delegate — Wed, 11 Oct 2023 21:25:41 +0000

Terminology

NET: net core 6.0+
NETFRAMEWORK: classic or legacy .NetFramework

History 📚

A technology called Remoting was once in fashion. This technology was built as an alternative to DCOM.

It was available for NETFRAMEWORK.

It provided classes and interfaces that allowed developers to create and configure distributed applications.

These classes and interfaces lived in the namespace System.Runtime.Remoting

The developer requested an instance of a remote service and the remoting infrastructure returned a proxy (a Transparent Proxy).

Depending on the activation mode, each call to this proxy service was handled in the server by a new instance or by the same instance. This was also related to the life cycle of the instances on the remoting server.

This can be seen summarized in the WellKnownObjectMode enumeration.

public enum WellKnownObjectMode
{
    //Every call is serviced by the same instance
    Singleton = 1,
    //Every call is serviced by a new instance.
    SingleCall
}

Problems 😰

With the arrival of NET, Microsoft abandoned this technology.

How could we migrate this technology to NET in a Windows Forms Application with a SingleCall Remoting implementation?

Microsoft offered several alternatives, for example streamjsonrpc

microsoft / vs-streamjsonrpc

The StreamJsonRpc library offers JSON-RPC 2.0 over any .NET Stream, WebSocket, or Pipe. With bonus support for request cancellation, client proxy generation, and more.

vs-StreamJsonRpc

StreamJsonRpc

StreamJsonRpc is a cross-platform, .NET portable library that implements the JSON-RPC wire protocol.

It works over Stream, WebSocket, or System.IO.Pipelines pipes, independent of the underlying transport.

Bonus features beyond the JSON-RPC spec include:

Request cancellation
.NET Events as notifications
Dynamic client proxy generation
Support for compact binary serialization via MessagePack
Pluggable architecture for custom message handling and formatting.

Learn about the use cases for JSON-RPC and how to use this library from our documentation.

View on GitHub

Or gRpc

grpc / grpc-dotnet

gRPC for .NET

gRPC is a modern, open source, high-performance remote procedure call (RPC) framework that can run anywhere. gRPC enables client and server applications to communicate transparently, and simplifies the building of connected systems.

gRPC functionality for .NET Core 3.0 or later includes:

Grpc.AspNetCore – An ASP.NET Core framework for hosting gRPC services. gRPC on ASP.NET Core integrates with standard ASP.NET Core features like logging, dependency injection (DI), authentication and authorization.
Grpc.Net.Client – A gRPC client for .NET Core that builds upon the familiar HttpClient. The client uses new HTTP/2 functionality in .NET Core.
Grpc.Net.ClientFactory – gRPC client integration with HttpClientFactory. The client factory allows gRPC clients to be centrally configured and injected into your app with DI.

For more information, see An introduction to gRPC on .NET.

gRPC for .NET is now the recommended implementation!

Starting from May 2021, gRPC for .NET is the recommended…

View on GitHub

Alternate Solution 🎃

Personally I find it easier to forward http calls to a REST API if you had a stateless server.

You have more control and i think it is more standard.

Now imagine that you have 1000+ interfaces with their respective methods.

How can you redirect those calls to our new REST server?

Let's take an example to better understand the problem. Below we can see a payment service with a method:

public interface IPayment
{
    Task<Payment> Checkout(Basket basket);
}

One assumption here (and most of the methods) is that Basket and Payment classes inherits from System.Data.Dataset 😨

One possibility is to use the Service Locator pattern and Inversion of Control.

Since we have these interfaces, we can decorate them with some attribute that indicates that they participate in IOC.

Then we can call an instance calling something like:

IPayment payment = ServiceLocator.Current.GetInstance<IPayment>();
payment.Checkout(...)

But what happens if you are not allowed to use an IOC? (insert multiple and diverse causes here) 😭

Not everything is lost.

We can create a class that is a RealProxy that makes the appropriate calls to the remote server and returns a TransparentProxy, which as if it were a black box allows us to invoke the methods of our interface and our new server will respond.

Suppose that in our legacy application we have a static class called RemotingServiceFactory that returns instances of IPayment and other services.

One example of use would be as follows:

// This is a Transparent Proxy returned by 
// the RemotingServiceFactory class
IPayment proxy = RemotingServiceFactory.GetService<IPayment>();

Basket basket = new ();
basket.AddProduct(new Product { Name = "Bananas", Quantity = 10 });

// This is the actual call to remote service
Payment response = await proxy.Checkout(basket);

We can modify RemotingServiceFactory.GetService to forward
calls from some services to our new server and be able to incrementally migrate our services.

We store the types of those services that we have migrated in a dictionary called _httpServices so that if when requesting a service, its type is among them, we return our new TransparentProxy.

public static T GetService<T>() where T : class
{
    if (_httpServices.TryGetValue(typeof(T), out IInterceptor? interceptor))
    {
        // New
        return GetHttpService<T>(interceptor);
    }
    else
    {
        // Legacy
        return GetRemotingService<T>();
    }
}

Wait a minute, what is that interface called IInterceptor?

It's a class that intercepts the calls to our IPayment and other services and make the real call without the need to implement that interface 😎

public class SingleDataSetInterceptor : IInterceptor
{
    ...
    ...

    // This method is called every time we call a method in our interface
    public void Intercept(IInvocation invocation)
    {
        invocation.ReturnValue = InvokeHttpPostAsync(invocation.Method.DeclaringType?.FullName, invocation.Method.Name
            , (DataSet)invocation.GetArgumentValue(0), invocation.Method.ReturnType);
    }

    private async Task<DataSet> InvokeHttpPostAsync(string? classPath, string methodName, DataSet? parameter, Type returnType)
    {
        ArgumentNullException.ThrowIfNull(classPath);
        ArgumentNullException.ThrowIfNull(methodName);
        ArgumentNullException.ThrowIfNull(parameter);

        using HttpResponseMessage response = await _httpClient.PostAsync($"/{classPath}/{methodName}"
            , new ObjectContent(parameter.GetType(), parameter, _httpSendFormatter));
        response.EnsureSuccessStatusCode();

        return (DataSet)await response.Content.ReadAsAsync(returnType, _httpReceiveFormatters);
    }
}

Now, we need some magic to glue all the parts, and that glue is the fantastic library Castle.Core

Castle.Core includes a lightweight runtime proxy generator that we can use to create TransparentProxies of our interfaces without being implemented.

castleproject / Core

Castle Core, including Castle DynamicProxy, Logging Services and DictionaryAdapter

Castle Core

Castle Core provides common Castle Project abstractions including logging services. It also features Castle DynamicProxy a lightweight runtime proxy generator, and Castle DictionaryAdapter.

See the documentation.

Releases

See the Releases.

Debugging symbols are available in symbol packages in the AppVeyor build artifacts since version 4.1.0. For example, here are the artifacts for 4.1.0.

License

Contributing

Browse the contributing section of our Home repository to get involved.

Building

Platforms	NuGet Feed
Windows & Linux	Preview Feed

On Windows

build.cmd

Compilation requires a C# 9 compiler, an up-to-date .NET Core SDK, and MSBuild 15+ (which should be included in the former).

Running the unit tests additionally requires the .NET Framework 4.6.2+ as well as the .NET Core 2.1, 3.1 and 6.0 runtimes to…

View on GitHub

ProxyGenerator generator = new ProxyGenerator();
var interceptor = new SingleDataSetInterceptor(...);
// This is magic !!
IPayment proxy = generator.CreateInterfaceProxyWithoutTarget<IPayment>(interceptor);

Payment response = await proxy.Checkout(...);

If we include this in the private method GetHttpService of the static class RemotingServiceFactory then we have completed our journey:

    //_generator is a ProxyGenerator
    private static T GetHttpService<T>(IInterceptor interceptor) where T :  class
    {
        return _generator.CreateInterfaceProxyWithoutTarget<T>(interceptor);
    }

As allways all the code is hosted in Github.

Be kind and love your family 💖

NetDefender / InterfaceProxy

InterfaceProxy

Create lightweight dynamic proxies of Interfaces without Classes through Castle.Core

See RemotingServiceFactory.GetService and SingleDataSetInterceptor

See post in https://dev.to/netdefender/interface-proxy-5djm

View on GitHub

SIMD aggregate performance

Volatile Delegate — Fri, 22 Sep 2023 22:24:59 +0000

Foreword 🍓

Dotnet provides several classes, some under the System.Runtime.Intrinsics namespace that allow hardware to execute instructions in parallel.

using System.Runtime.Intrinsics;

Vector512 v512;
Vector256 v256;
Vector128 v128;

The number suffix (512, 256, 128) indicates the size in bits of the vector that the hardware can process in parallel.

This has positive impact in operations that performs aggregates, specially in a loop with large arrays.

To know if the hardware allows this type of registers we can consult the static read-only property IsHardwareAccelerated

if (Vector256.IsHardwareAccelerated)
{
    _is256 = true;
    ...
}

The above code will test if our hardware supports 256 bit vector operations through JIT intrinsics.

Exploring 🧠

Suppose we want to simultaneously calculate the maximum and minimum of a sequence of integers using Vector256.

The process will consist of creating a loop in which we will move forward taking 256-bit chunks and updating the maximum and minimum

(T Min, T Max) MinMax256<T>(ReadOnlySpan<T> source) 
    where T : struct, INumber<T>
{

}

First we initialize some variables to hold the current element, the last element, and the last size wise element (the to variable)

ref T current = ref MemoryMarshal.GetReference(source);
ref T last = ref Unsafe.Add(ref current, source.Length);
ref T to = ref Unsafe.Add(ref last, -Vector256<T>.Count);

Vector256<T> minElement = Vector256.LoadUnsafe(ref current);
Vector256<T> maxElement = minElement;

Then we start the loop. Inside, we load data in 256 bit chunks calling Vector256.LoadUsafe

 while (Unsafe.IsAddressLessThan(ref current, ref to))
 {
     Vector256<T> tempElement = Vector256.LoadUnsafe(ref current);
     minElement = Vector256.Min(minElement, tempElement);
     maxElement = Vector256.Max(maxElement, tempElement);
     current = ref Unsafe.Add(ref current, Vector256<T>.Count);
 }

We use the static Min and Max methods of Vector256and store the value in minElement and maxElement.

Finally, we increment the position counter (current) by adding 256 bits to the pointer.

Once we have exceeded the established size, we have to calculate the maximum and minimum individually

T min = minElement[0];
T max = maxElement[0];

for (int i = 1; i < Vector256<T>.Count; i++)
{
    T tempMin = minElement[i];
    if (tempMin < min)
    {
        min = tempMin;
    }
    T tempMax = maxElement[i];
    if (tempMax > max)
    {
        max = tempMax;
    }
}

After that we calculate the remaining elements if any:

while (Unsafe.IsAddressLessThan(ref current, ref last))
{
    if (current < min)
    {
        min = current;
    }
    if (current > max)
    {
        max = current;
    }
    current = ref Unsafe.Add(ref current, 1);
}

And that's all, we return the results:

return (min, max);

Benchmark 🔥

A quick test with BenchmarkDotnet calculating the maximum and minimum of an array of 10_000 integers reveals a performance improvement of x146 with Vector256 support.

💡 Ryzen 7 1700, 1 CPU
.NET SDK=8.0.100-rc.1.23455.8

Method	Mean (ns)
🐢 MinMaxLinq .NET Framework 4.8	118,675.226
⚡ MinMaxSimd .NET 8.0	808.150

Farewell

All the code with a more elavorated example is hosted in github. Be happy and love your family 💖

NetDefender / SimdIteration

SIMD tests

Simd Iteration

Test SIMD 512, 256, 128 registers for fast aggregate calculations.

Unfortunately my hardware doesn't support Vector512.

Anyway, the performance improvement is mindblowing.

Important

net8 is x146 times faster than net48 for calculate the Min and Max at the same time !!

Results

BenchmarkDotNet=v0.13.5, OS=Windows 10 (10.0.19044.3086/21H2/November2021Update)
AMD Ryzen 7 1700, 1 CPU, 16 logical and 8 physical cores
.NET SDK=8.0.100-rc.1.23455.8
[Host] : .NET 8.0.0 (8.0.23.41904), X64 RyuJIT AVX2
.NET 7.0 : .NET 7.0.11 (7.0.1123.42427), X64 RyuJIT AVX2
.NET 8.0 : .NET 8.0.0 (8.0.23.41904), X64 RyuJIT AVX2
.NET Framework 4.8 : .NET Framework 4.8 (4.8.4644.0), X64 RyuJIT VectorSize=256

Method	Runtime	Size	Mean	Allocated
MinMaxLinq	.NET Framework 4.8	10000	118,675.226 ns	65 B
MinMaxLinq	.NET 7.0	10000	2,350.046 ns	-
MinMaxLinq	.NET 8.0	10000	1,228.518 ns	-
MinMaxSimd	.NET 7.0	10000	834.291 ns	-
MinMaxSimd	.NET 8.0	10000	808.150 ns	-

View on GitHub

References

System.Runtime.Intrinsics Espacio de nombres | Microsoft Learn

Contiene tipos que se usan para crear y transmitir estados de registro de distintos tamaños y formatos para su uso con las extensiones del conjunto de instrucciones. Para obtener instrucciones sobre cómo manipular estos registros, vea System.Runtime.Intrinsics.X86 y System.Runtime.Intrinsics.Arm.

learn.microsoft.com

System.Runtime.Intrinsics work planned for .NET 8 #79005

dakersnar posted on Nov 29, 2022

This is a work in progress as we develop our .NET 8 plans. This list is expected to change throughout the release cycle according to ongoing planning and discussions, with possible additions and subtractions to the scope.

Summary

During .NET 8, we will be focusing on AVX-512, an effort that includes the addition of a new intrinsic type Vector512 as well as Vector<T> improvements. Beyond that major theme, we will invest in quality, enhancements and new APIs. This is an ambitious set of work, so it's likely that several of the items below will be pushed out beyond .NET 8. It is also likely additional items will be added throughout the year.

DEV Community: Volatile Delegate

Interface Proxy

Terminology

History 📚

Problems 😰

microsoft / vs-streamjsonrpc

The StreamJsonRpc library offers JSON-RPC 2.0 over any .NET Stream, WebSocket, or Pipe. With bonus support for request cancellation, client proxy generation, and more.

vs-StreamJsonRpc

StreamJsonRpc

grpc / grpc-dotnet

gRPC for .NET

gRPC for .NET

gRPC for .NET is now the recommended implementation!

Alternate Solution 🎃

castleproject / Core

Castle Core, including Castle DynamicProxy, Logging Services and DictionaryAdapter

Castle Core

Releases

License

Contributing

Building

On Windows

NetDefender / InterfaceProxy

InterfaceProxy

SIMD aggregate performance

Foreword 🍓

Exploring 🧠

Benchmark 🔥

Farewell

NetDefender / SimdIteration

SIMD tests

Simd Iteration

Results

References

System.Runtime.Intrinsics Espacio de nombres | Microsoft Learn

System.Runtime.Intrinsics work planned for .NET 8 #79005

Summary

Planned for .NET 8

AVX-512

Quality

Enhancements / New APIs

Hardware Intrinsics in .NET Core - .NET Blog