netasm Wiki & Documentation Rss Feed

Updated Wiki: Home

alexandre_mutel — Tue, 13 Oct 2009 08:44:44 GMT

_
The last update of the 3.5 SP1 seems to have broken NetAsm. There is no way to correct this (NetAsm is based on old SSCLI 2.0 source code project released in 2006).

NetAsm project is probably dead!

Just hope that Microsoft will improve their JIT using SIMD as it has been done for the Mono project (See Mono's SIMD Support).
_

Project Description

NetAsm provides a hook to the .NET JIT compiler and enables to inject your own native code in replacement of the default CLR JIT compilation. With this library, it is possible, at runtime, to inject x86 assembler code in CLR methods with the speed of a pure CLR method call and without the cost of Interop/PInvoke calls.

NetAsm can be used to integrate optimized native code using CPU extended instructions (SSE,MMX) into your managed code. The NetAsmDemo sample provides two benchmarks that unveil the power of using native code injection with NetAsm.
For more information about NetAsm, code injection techniques and recommendations, please consult the NetAsm-UserGuide.

NetAsm wouldn't have been possible without the brilliant article “.NET Internals and Native Compiling” from Daniel Pistelli.

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.
- Static code injection: The native code is stored in an attribute of the method.
- Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
- Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.
Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

This sample is available in NetAsmDemo and is fully documented in the the NetAsm User guide.

Using native code injection with NetAsm is a very simple task that can be achieved in two steps:
1) Specify the native code injection in a class
2) Install the hook in the main program of your application

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;

namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

The steps to allow and use code injection on a method in a class are:

1. Set AllowCodeInjection attribute on the class you want to do code injection.
2. Set CodeInjection attribute on the method that will be injected with native code
3. For void NetAsmReturn() method in TestHelloWorld, the native code used is : new byte[] { 0xC3 }. In x86 assembler, it’s the “RET” (return) command. This method does nothing more than immediately returning after a call.
4. In our example, we have set the attribute MethodImpl(MethodImplOptions.NoInlining) : This attribute force the JIT to not inline the IL code inside the method. This is for the purpose of the demonstration but should be used with caution (see usage recommendation chapter).

That’s all to use code injection!
In NetAsm, this kind of native code injection is called static native code injection. TestHelloWorld only use static code injection at the method level. We will see later that NetAsm provides other code injection techniques.
Now, to run this code injection test, we need to install NetAsm JITHook.Install().

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;

namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook
            JITHook.Install();
            // Run TestHelloWorld Method
            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook
            JITHook.Remove();
        }
    }
}

If you run this program, it will return without any exception. While executing this code, the CLR Virtual Machine use our native code “RET” command instead of the IL code inside the method. It means that the original IL code is not compiled by the default JIT compiler.

Additionnal information and other code injection techniques are available in the NetAsm User Guide.

Blog : Code4k

Updated Wiki: Home

alexandre_mutel — Mon, 09 Feb 2009 21:17:29 GMT

___________________________________________________________________________________________________________________________
The last update of the 3.5 SP1 seems to have broken NetAsm. There is no way to correct this (NetAsm is based on old SSCLI 2.0 source code project released in 2006).

NetAsm project is probably dead!

Just hope that Microsoft will improve their JIT using SIMD as it has been done for the Mono project (See Mono's SIMD Support).
___________________________________________________________________________________________________________________________

Project Description

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.

Static code injection: The native code is stored in an attribute of the method.
Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.

Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual __asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;
namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;
namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook

            JITHook.Install();
            // Run TestHelloWorld Method

            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook

            JITHook.Remove();
        }
    }
}

Updated Wiki: Home

alexandre_mutel — Fri, 16 Jan 2009 17:10:45 GMT

Project Description

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.

Static code injection: The native code is stored in an attribute of the method.
Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.

Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual __asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;
namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;
namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook

            JITHook.Install();
            // Run TestHelloWorld Method

            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook

            JITHook.Remove();
        }
    }
}

Updated Wiki: Home

alexandre_mutel — Thu, 07 Aug 2008 08:54:35 GMT

In order to support x64, i need to buy a windows vista 64 licence. You can help me and make a donation for NetAsm!

Project Description

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.

Static code injection: The native code is stored in an attribute of the method.
Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.

Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual __asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;
namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;
namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook

            JITHook.Install();
            // Run TestHelloWorld Method

            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook

            JITHook.Remove();
        }
    }
}

Updated Wiki: Home

alexandre_mutel — Thu, 07 Aug 2008 08:53:29 GMT

Project Description

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.

Static code injection: The native code is stored in an attribute of the method.
Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.

Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual __asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;
namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;
namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook

            JITHook.Install();
            // Run TestHelloWorld Method

            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook

            JITHook.Remove();
        }
    }
}

Updated Wiki: Home

alexandre_mutel — Thu, 07 Aug 2008 08:52:27 GMT

Project Description

News

25 july 2008, NetAsm 1.0 is released.

Features

Runs on x86 32bit Microsoft .NET platform with 2.0+ CLR runtime (x64 may be supported in the future).
Provides three different native code injection techniques: Static, DLL, and Dynamic.

Static code injection: The native code is stored in an attribute of the method.
Dll code injection : this method is similar to the DllImport mechanism but CLR methods are directly bind to the DLL function, without going through the interop layers.
Dynamic code injection: you can generate native code dynamically with a callback interface that is called by the JIT when compilation of a method is occurring. It means that you can compile a method “on the fly”. You have also access to the IL code of the method being compiled.

Supports for debugging static and dynamic code injection.
Supports for different calling conventions: StdCall, FastCall, ThisCall, Cdecl. Default calling convention is CLRCall.
NetAsm can be used inside any .NET language.
Very small library <100Ko.

Future plans

You are welcome to vote for the following features (or any new features) or even contribute to one of them if you have a good experience in such domain:

Add a simplified assembler to code inject textual __asm instructions from CodeInjection attribute?
Add support for 64bit platform?
Add support for Mono platform?

HelloWorld example

Setup native code injection in a class

using System;
using System.Runtime.CompilerServices;
using NetAsm;
namespace NetAsmDemo
{
    [AllowCodeInjection]
    class TestHelloWorld
    {
        [CodeInjection(new byte[] { 0xC3 }), MethodImpl(MethodImplOptions.NoInlining)]
        static public void NetAsmReturn()
        {
            throw new Exception("With NetAsm, You should not have an exception!");
        }
    }
}

Install the hook and run the code injection

To call the TestHelloWorld method, the main program has to initialize NetAsm:

using System;
using NetAsm;
namespace NetAsmDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // Install the JIT Hook

            JITHook.Install();
            // Run TestHelloWorld Method

            TestHelloWorld.NetAsmReturn();
            // Remove the JIT Hook

            JITHook.Remove();
        }
    }
}

Updated Wiki: benchmarks

alexandre_mutel — Fri, 25 Jul 2008 22:02:39 GMT

Benchmarks

NetAsmDemo provides two micro-benchmarks to explicit performance gains using NetAsm:

Simple Add Benchmark is a benchmark that demonstrates the overhead of calling methods using different managed, interop techniques against NetAsm.
Matrix Multiplication Benchmark SSE2 is a benchmark that demonstrates the use of SSE2 for optimized methods and compare different calling techniques (interop, mixed, managed and NetAsm).

The main results are:

For calling overhead, NetAsm can perform as fast as pure managed calls and is two times faster than fast interop (no security checks).
In the case of using optimized instructions not available in .NET (like SSE2 in the matrix benchmark), NetAsm was able to be 50-60% faster than managed code.

Although, be aware that micro-benchmarks are always subject to issues and should not be considered as a proof for any other benchmarks. All the benchmarks here use a warm-up loop to avoid the cost of any compilation effects at startup and run the test several times.

Simple Add benchmark

This benchmark consists in measuring the processing time for adding 2 integers. This benchmark measure the performance between several implementations:
• Managed and Managed Inline : we test both managed with NoInline (with the attribute MethodImpl(MethodImplOptions.NoInlining)) and the default managed code inline.
• Interop and Interop NoSecurity : we test default Interop technique and Interop with no security attribute flag (SuppressUnmanagedCodeSecurity)
• Mixed Cpp/CLI : we test the use of an external Mixed Cpp/CLI using native code.
• NetAsm : we use NetAsm with a static native code injection.

For example, the implementation of the Managed Inline is like:

        public int ManagedAddInlined(int x, int y)
        {
            return x + y;
        }

The NetAsm code of the Add method is:

[CodeInjection(new byte[] { 0x8b, 0x44, 0x24, 0x04, 0x03, 0xc2, 0xc2, 0x04, 0x00 }), MethodImpl(MethodImplOptions.NoInlining)]
public int NetAsmAdd(int x, int y)
{
    // This method is compiled using the native code from the CodeInjection Attribute

    // The IL code of this method is never compiled by the JIT 

    // ADD +1 to check that this method is not used.

    return x + y + 1;
}

It was generated from the C method and the assembler code was copied from the *.cod output assembler listing files generated by Microsoft visual C++ :

extern "C" int __fastcall NetAsmAddInC(void* pThis, int x, int y) {
	return x + y;
}
// The generated native code of this method is :

  00000	8b 44 24 04	 mov	 eax, DWORD PTR _y$[esp-4]
  00004	03 c2		 add	 eax, edx
  00006	c2 04 00	 ret	 4

Results are indexed on a 100 time based. The default base is managed inline. Lower is better.

As we can see, NetAsm performs almost as fast as Managed Inline and is twice faster than the Interop (with no security checks).
This result was expected, as NetAsm native code is considered by the CLR VM as pure managed code compiled by the JIT. Therefore, the performance should be the same than managed code.

See TestSimpleAddBenchmark.cs in NetAsmDemo for the code of this benchmark.

Matrix Multiplication benchmark using SSE2

This benchmark is based on the work of scapecode in the article "Playing with the .NET JIT Part3" : it measures the performance between different matrix multiplications implementations using standard CLR, standard C and SSE2 instructions.
As for SimpleAddBenchmark, this benchmark compares different implementations:

Managed Std and Managed Unsafe: we test both standard managed code and unsafe managed code (using pointers on matrix array instead of CLR arrays).
Interop Std and Interop SSE2, and Interop SSE2 NoSecurity : we test default Interop technique with a C implementation (without using any SSE2 instructions), and two interop using SSE2 (with one using the no security attribute flag SuppressUnmanagedCodeSecurity )
Mixed SSE2 Cpp/CLI : we test the use of an external Mixed Cpp/CLI using native code.
NetAsm Std and NetAsm SSE2: we use NetAsm with a standard C matrix multiplication and a SSE2 implementations.

Results are indexed on a 100 time based. The default base is managed inline. Lower is better.

There are several remarks concerning the results:

First, NetAsm SSE2 outperforms any other implementations, ranging from 10% to 300% in speed gain (70% faster than the default managed code).
Managed Unsafe and NetAsm unsafe are often equivalent: it means that the default JIT compiler is performing very well in optimizing the C# code (as fast as C code). Consequently, you should always test if it is relevant to replace managed code with c code, as the JIT compiler can generate a fast native code.
NetAsm SSE2 is only 10% faster than Interop SSE2: this result is different from SimpleAddBenchmark. The reason is the cost of calling the interop code is negligible compare to the time used for computing the result.

See TestMatrixMulBenchmark.cs, NetAsmDemoCLib.dll and NetAsmDemoMixedLib.dll in NetAsmDemo for the code of this benchmark.