C# Unamanged Code Causing Access Violations

[tk121]

Hey all -

I have some unmanaged code that I'm calling into with C# .NET 2.0, and everything works flawlessly in the debugger, but as soon as I run the application as a standalone executable it unexpectedly quits without throwing any exceptions. Even if I start the executable in the debugger it works okay. To see the failure, I need to start the application and then attach the debugger to the process. The function call will work okay twice and the data comes out okay, but on the third call it shuts down without any notice.

When running with Windows Debugging Tools I can see the access violation ("Access violation - code c0000005") and I'm pretty sure it's a NULL pointer exception, but can't figure out why or what to do about it.

I suspect it's because of the garbage collector moving data around, but I thought that the way I had created and passed the pointers in that they would be pinned.

The unmanaged function takes an input of int*, and double*, which it modifies during it's execution.

Here's a short code sample of the calling convention:

[DllImport("MyDll.dll", EntryPoint = "MyFunction", SetLastError = true, CharSet = CharSet.Ansi, ExactSpelling = true, CallingConvention = CallingConvention.Cdecl)]
private unsafe static extern int MyFunction(void* results, void* values);
 
private void CallFunction()
{
    int returnStatus = 0;
    IntPtr resultPtr = IntPtr.Zero;
    IntPtr valPtr = IntPtr.Zero;
    int[] rawResults = new int[RESULT_SIZE];
    double[] rawValues = new double[RESULT_SIZE];
 
    try
    {
        // Allocate memory
        resultPtr = Marshal.AllocHGlobal(RESULT_SIZE * sizeof(int));
        valPtr = Marshal.AllocHGlobal(RESULT_SIZE * sizeof(double));
 
        // Call external function
        unsafe
        {
            returnStatus = MyFunction(resultPtr.ToPointer(), valPtr.ToPointer());
        }
 
        Marshal.Copy((IntPtr)resultPtr, rawResults, 0, RESULT_SIZE);
        Marshal.Copy((IntPtr)valPtr, rawValues, 0, RESULT_SIZE);
    }
    catch (Exception e)
    {
        string errMsg = String.Format("An exception has been caught attempting to call the external function. The following exception was trapped:\n\n{0}", e.Message);
        MessageBox.Show(errMsg, "Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
    finally
    {
        if (resultPtr != IntPtr.Zero)
            Marshal.FreeHGlobal(resultPtr);
        if (valPtr != IntPtr.Zero)
            Marshal.FreeHGlobal(valPtr);
    }
}
 

I've been trying to figure out the best way to go about doing this, and at one time had tried using a structure with fixed variables, but that was also victim to the same problems. I like this approach better and seems more reliable but it's still crashing.

Any help is much appreciated!

Thanks

[tk121]

Well, in case someone stumbles upon something similar in the future, I thought I would post that I found the solution to this problem.

I did some more digging and realized that with data types int, and double supported natively by .NET, there is no need to manually create memory space and marshal the datatypes. Managed arrays passed into the function work just as well. The memory allocation was way overkill.

It doesn't seem as though this is affected by the garbage collector either.

Once I realized that the issue was not related to the .NET code, I began digging for issues with the DLL and the unmanaged code.

Apparently the function in the unmanaged code had too many static initializers that were eating up all the stack space. It would run fine once until the stack space was depleted and after that would throw null pointer references.

So I'm guessing the reason the code worked in the .NET debugger all the time was that the stack space for the DLL was pulled from the heap as opposed to the default for the compiled DLL. As soon as the executable ran on it's own it used the default stack space which was much lower causing the application to crash after a couple runs without throwing an exception. Just a guess, but I'm glad I finally found a solution to this.

If anyone can confirm or deny my suspicions (or provide an explanation), I would like to hear to any other ideas.

Here's a sample of what the new C# source looks like after cleaning it up:

{
    public const int RESULT_SIZE = 10;
 
    [DllImport("MyDll.dll", EntryPoint = "MyFunction", SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
    private static extern int MyFunction(int[] results, double[] values);
 
    public int MyFunctionWrapper
    {
        int returnStatus = 0;
        int[] rawResults = new int[RESULT_SIZE];
        double[] rawValues = new double[RESULT_SIZE];
 
        returnStatus = MyFunction(rawResults, rawValues);
 
        if (returnStatus == 0)
        {
            // Do something with data
            return returnStatus;
        }
        else
        {
            // Throw new exception
            return returnStatus;
        }
    }
}