C# - external ASM code breaks when run asynchronously

Question

0.00/5 (No votes)

See more:

Hello, I have an issue with my C# code that calls an external procedure written in x64 ASM.

C#

[DllImport("...", CallingConvention = CallingConvention.StdCall)]
public static extern IntPtr ApplyFilterToImageFragmentAsm(IntPtr bitmapBytes, int bitmapBytesLength, int bitmapWidth, int startIndex, int endIndex, IntPtr filteredFragment);

The project I am working on is a High Pass Image Filter (HP1) that is being put on a 24-bit bitmap image. I have an implementation of that algorithm written in C#, C++ and x64 ASM. The idea of this project is to run these synchronously and asynchronously, and compare the execution times based on the language used and the amount of threads specified.

When I call the C# or C++ methods asynchronously, everything works fine, the returned result is correct, there are no exceptions. The same is true when I call the ASM procedure synchronously - there are no exceptions, ever.

However, I am running into multiple issues when trying to run the procedure asynchronously, using tasks. What I am doing is creating Task objects in a loop, adding them to a list (to keep track of them), then awaiting all of them and synchronizing the results, something like this:

C#

var listOfTasks = new List<Task<IntPtr>>();

// ...

for (int i = 0; i < threadCount; i++)
{
    // ...

    var task = Task.Run(() => ApplyFilterToImageFragmentAsm(bitmapBytesIntPtr, bitmapBytes.Length, bitmapWidth, startIndex, endIndex, filteredFragmentIntPtr));
    listOfTasks.Add(task);
}

// ...

await Task.WhenAll(listOfTasks).ConfigureAwait(false);

When I run this code with threadCount higher than 1, I get the following problems:

1. Sometimes, the program just crashes without an exception.

2. Most of the times, I get an AccessViolationException - sometimes for an address that looks "legitimate" (eg. very close to the address that was passed as parameter), and sometimes for an address that is all zeroes or F's (keep in mind **this never happens when only using a single Task to execute the method**).

3. Some of the times I got an exception of type ExecutionEngineException, which (according to the documentation) is obsolete and not thrown by the runtime anymore, without any additional information.

4. Sometimes, there is no exception, but the returned result is wrong (eg. the image is distorted, the filter is only applied to some parts of it, etc.).

5. And some of the time, the algorithm works fine and returns the correct result, even for a higher number of Tasks like 2, 4 or 8.

I suspect the problem is related to the ASM code itself, in how the registers, stack and variables are shared among the same thread, which makes the code crash the program when multiple procedures are executed on the same thread (instead of separate threads).

My question is - **how can I make the ASM code handle multithreading properly, or how can I ensure the C# code executes different method calls on different threads?**

Important note - when I make the following modification, the code works correctly 100% of the time.

C#

for (int i = 0; i < threadCount; i++)
{
    // ...

    var task = Task.Run(() => ApplyFilterToImageFragmentAsm(bitmapBytesIntPtr, bitmapBytes.Length, bitmapWidth, startIndex, endIndex, filteredFragmentIntPtr));
    listOfTasks.Add(task);

    task.Wait(); //!
}

Therefore, I am almost certain the problem is caused exactly by how multithreading is handled - however, I need the procedure to run in parallel multiple times, so awaiting single calls is not an option for me. Neither is using Task.Delay to delay specific calls, since it would increase the execution time when run with multiple tasks, and that's against the point of this project. (besides, delaying doesn't make the code work 100% of the time anyway)

I can share more information (and the source code itself) if needed. Cheers.

[UPDATE]

Here's the rest of the code that does the Task creation and handling, without the part that synchronizes the results together (because the exception occurs before that part anyway). I added some comments to better explain what is going on:

C#

var listOfTasks = new List<Task<IntPtr>>();

int index = 0;
int bytesPerPart = bitmapBytes.Length / threadCount;	// bitmapBytes is the input array of type byte[] (without bitmap header)
// each value represents one color of one pixel in this order: R, G, B, ...

bytesPerPart -= bytesPerPart % 3;	// Calculating the amount of pixels per function call, and making sure it's divisible by 3

for (int i = 0; i < threadCount; i++)
{
	int startIndex = index;
	int endIndex = startIndex + bytesPerPart - 1;

	if (i == threadCount - 1)
	{
		endIndex = bitmapBytes.Length - 1;
	}

	index = endIndex + 1;

	byte[] bitmapCopy = new byte[bitmapBytes.Length];	// Making a copy of the input array, so that the same memory isn't accessed by multiple threads by the same time

	for (int j = 0; j < bitmapBytes.Length; j++)
	{
		bitmapCopy[j] = bitmapBytes[j];
	}

	byte[] filteredFragment = new byte[endIndex - startIndex + 1];	// Output array, also passed as parameter to the procedure

	for (int x = 0; x < endIndex - startIndex + 1; x++)
	{
		filteredFragment[x] = bitmapBytes[startIndex + x];
	}

	unsafe
	{
		fixed (byte* pointerToByteArray = &(bitmapBytes[0]))		// Pointer to input array
		fixed (byte* pointerToFilteredFragmentArray = &(filteredFragment[0]))	// Pointer to output array
		{
			var bitmapBytesIntPtr = new IntPtr(pointerToByteArray);	// Converting from byte* to IntPtr
			var filteredFragmentIntPtr = new IntPtr(pointerToFilteredFragmentArray);	// Converting from byte* to IntPtr

			var task = Task.Run(() => ApplyFilterToImageFragmentAsm(bitmapBytesIntPtr, bitmapBytes.Length, bitmapWidth, startIndex, endIndex, filteredFragmentIntPtr));

			listOfTasks.Add(task);
		}
	}
}

await Task.WhenAll(listOfTasks).ConfigureAwait(false);
// ...

What I have tried:

1. Awaiting each Task individually - this makes the code work 100% of the time, but goes against the idea of this project.

2. Creating new Threads instead of Tasks - this caused even more issues, I could not get the code to work at all because of constant exceptions or the methods returning zeroes.

3. Using Task.Delay for individual Tasks - this doesn't make the code work, and goes against the idea of this project again.

Posted 10-Dec-21 3:14am

Stukeley

Updated 10-Dec-21 4:15am

v2

Add a Solution

Comments

Richard Deeming 10-Dec-21 9:34am

Almost certainly something to do with the way you're getting the pointer to the bytes - there's a chance the CLR could move the object whilst your task is running in the background, which would make the pointer invalid.

If you update your question to show the missing part of your for loop, it might be more obvious where the problem is.

Stukeley 10-Dec-21 10:02am

Thank you for your answer. I updated my question with the relevant part of my function that creates the task, and the for loop.

Richard Deeming 10-Dec-21 10:04am

That'll do it - the code exits the fixed block before the task has finished, which means your array can be moved around whilst the unmanaged code is trying to access it.

Stukeley 10-Dec-21 10:10am

What would you recommend? How could I keep the pointers fixed for the entire duration of the Task execution?

Richard Deeming 10-Dec-21 10:15am

See solution 1. :)

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Answer 1 · 2021-12-10T04:15:00

As I suspected, the problem is that your unmanaged code is running outside of the fixed blocks, so the CLR is free to move the memory around. The pointer you pass in will be pointing to the wrong thing.

Since you can't await inside a fixed block, you'll need to move those blocks to another method, which will be the target of your Task.Run:

C#

private static void ApplyFilterToImageFragment(byte[] bitmapBytes, int bitmapWidth, int startIndex, int endIndex, byte[] filteredFragment)
{
	unsafe
	{
		fixed (byte* pointerToByteArray = &(bitmapBytes[0]))		// Pointer to input array
		fixed (byte* pointerToFilteredFragmentArray = &(filteredFragment[0]))	// Pointer to output array
		{
			var bitmapBytesIntPtr = new IntPtr(pointerToByteArray);	// Converting from byte* to IntPtr
			var filteredFragmentIntPtr = new IntPtr(pointerToFilteredFragmentArray); // Converting from byte* to IntPtr
            ApplyFilterToImageFragmentAsm(bitmapBytesIntPtr, bitmapBytes.Length, bitmapWidth, startIndex, endIndex, filteredFragmentIntPtr);
		}
	}
}

C#

for (int i = 0; i < threadCount; i++)
{
	int startIndex = index;
	int endIndex = startIndex + bytesPerPart - 1;

	if (i == threadCount - 1)
	{
		endIndex = bitmapBytes.Length - 1;
	}

	index = endIndex + 1;

	byte[] bitmapCopy = new byte[bitmapBytes.Length];
    Array.Copy(bitmapBytes, 0, bitmapCopy, 0, bitmapBytes.Length);

	byte[] filteredFragment = new byte[endIndex - startIndex + 1];
    Array.Copy(bitmapBytes, startIndex, filteredFragment, 0, filteredFragment.Length);
    
    var task = Task.Run(() => ApplyFilterToImageFragment(bitmapCopy, bitmapWidth, startIndex, endIndex, filteredFragment));
    listOfTasks.Add(task);
}

await Task.WhenAll(listOfTasks).ConfigureAwait(false);