Calling SSE code in managed code (alignment)

Question

Here's my problem: We have a math library written in C++ that is heavily using SSE. We need to use that same math library in our the managed layer of our tools (which are written in C#).

The problem is, that the math library classes must be 16-byte aligned (for SSE to work). However when compiling the managed code, I get lots of errors, because the "__declspec (align(X))" is not supported.

Any ideas whether this is possible somehow? I wasn't able to find any useful information.

Some additional information:

The math library, written in C++, uses SSE for maximum performance. However our tool does not require maximum performance, we can even take a performance hit compared to general C# code. It is more about being able to actually execute all our code (it is a huge code base), without having people to convert back and forth between data types.

So this is really only about usability, not about performance.

I tried this: I put all our math functions into a cpp, instead of having them as inline functions. Now they are exported from their own DLL. However the vector-class of course still has a __m128 private member for its data.

As soon as I just put such a variable in managed code, the compiler tells me that my managed code is now native code.

Does that mean I must not have such a type in my class definition and hide it completely behind a DLL interface? Thanks.

To whoever downvoted this, please provide an explanation. I don't see a problem with the question. — Polynomial, Nov 14 '11 at 16:19
Why not force native compilation on those parts? (I thought that would be the case anyways for performance) — leppie, Nov 14 '11 at 16:31
@Jan - can you clarify whether your original math C++ DLL is in native or managed (C++/CLI) code? Thanks. — Steve Townsend, Nov 15 '11 at 12:27
The math code is in a native C++ DLL. I try to access it from managed C++ (which wraps the native code, so that it can then be called by C# code). The problem is that the C++ class has a private member "__m128" which is of course visible to the managed code compiler, and it doesn't like it. It seems I must hide all SSE code inside the functions, which makes a math library not very useful. — Jan, Nov 15 '11 at 17:30

Steve Townsend · Answer 1 · 2011-11-14T16:27:37.450

5

Sounds like you are trying to compile your math library to managed code? Instead, you should leave it in native code and call it direct from managed code using P/Invoke.

Marshalling of the required structs from C# into native code with correct alignment will still be complex, but should be doable.

The work shown here could be useful to you in understanding the issues.

I'm embarking on the adventurous course of trying to accelerate a simulation application written entirely in C#.NET using SSE2. So far I've spent a few days looking at the feasibility of using SSE2 in a .NET application.

edited Nov 14 '11 at 16:27

answered Nov 14 '11 at 16:20

Steve Townsend

53,498
9
91
140

He's using C++/CLI, no pinvoke required. – Hans Passant Nov 15 '11 at 10:54
@Hans - how do you know this? – Steve Townsend Nov 15 '11 at 11:54
`the compiler tells me that my managed code is now native code.` – Hans Passant Nov 15 '11 at 12:01
As I read it that refers to the exported data from the DLL. Talk of C++ DLLs does not typically imply C++/CLI - if he said an assembly contained the C++ SSE math code then I would agree with you. This is unclear and I will ask OP to clarify. – Steve Townsend Nov 15 '11 at 12:26

score 2 · Answer 2 · answered Nov 14 '11 at 16:18

2

Can struct packing help you at all?

http://www.developerfusion.com/article/84519/mastering-structs-in-c/

You can use it to align fields to specific areas in memory.

answered Nov 14 '11 at 16:18

Bryan Boettcher

4,412
1
28
49

Hm, I'll have to investigate those options. Thanks for the info guys. – Jan Nov 14 '11 at 17:50

score 1 · Answer 3 · edited Nov 19 '11 at 00:09

Well, just to wrap things up:

We decided that it is way too complicated to get our code working directly with the SSE math library. So we will have two math libraries. One that uses SSE for high performance code, which will be used deep inside our C++ code. And another one that is implemented without SSE, which will be used in all the interfaces and the not so much performance critical code.

This way we can compile and link everything with managed code, but can still boost our performance by using the SSE code where it really matters.

However getting anything to compile with managed code, if the compiler can "see" the SSE stuff (e.g. you simply have a __m128 member in a class), is a nightmare. You have to put lots of wrappers around everything.

I guess that's simply a use-case that C# and managed code were never really meant to be compatible with.

Anyway, thanks for all your suggestions, it helped me get a clearer picture of the problem.

Avoid signing your posts, your profile is linked to everything you post already. — Bert, Nov 18 '11 at 23:56

score 0 · Answer 4 · answered Nov 19 '11 at 00:18

0

BTW, fftw wrapper I use calls fftw methods for memory allocation, then the data is filled in managed code, then again fftw is called for processing. Can you use similar paradigm?

answered Nov 19 '11 at 00:18

Daniel Mošmondor

19,718
12
58
99

Calling SSE code in managed code (alignment)

4 Answers4