System.ExecutionEngineException: Attempting to JIT compile method System.Threading.Interlocked:Exchange

Question

I am aware that the compiler can sometimes omit methods if it thinks nothing uses them and that you can work around this by referencing the method directly in your code to force the compiler to include it. However, in this instance it doesn't seem to work.

Here's the exception and call stack:

System.ExecutionEngineException: Attempting to JIT compile method '(wrapper managed-to-native) System.Threading.Interlocked:Exchange (System.Threading.Tasks.IContinuation&,System.Threading.Tasks.IContinuation)' while running with --aot-only. See http://docs.xamarin.com/ios/about/limitations for more information.

at System.Threading.Tasks.TaskCompletionQueue`1[System.Threading.Tasks.IContinuation].TryGetNextCompletion (IContinuation& continuation) [0x00000] in <filename unknown>:0
at System.Threading.Tasks.Task.ProcessCompleteDelegates () [0x0001b] in /Developer/MonoTouch/Source/mono/mcs/class/corlib/System.Threading.Tasks/Task.cs:521
at System.Threading.Tasks.Task.HandleGenericException (System.AggregateException e) [0x0001a] in /Developer/MonoTouch/Source/mono/mcs/class/corlib/System.Threading.Tasks/Task.cs:563
at System.Threading.Tasks.Task.TrySetException (System.AggregateException aggregate) [0x0003e] in /Developer/MonoTouch/Source/mono/mcs/class/corlib/System.Threading.Tasks/Task.cs:440
at System.Threading.Tasks.TaskCompletionSource`1[System.Net.WebResponse].TrySetException (IEnumerable`1 exceptions) [0x00000] in <filename unknown>:0
at System.Threading.Tasks.TaskCompletionSource`1[System.Net.WebResponse].SetException (IEnumerable`1 exceptions) [0x00000] in <filename unknown>:0
at System.Threading.Tasks.TaskCompletionSource`1[System.Net.WebResponse].SetException (System.Exception exception) [0x00000] in <filename unknown>:0
at System.Threading.Tasks.TaskFactory`1[System.Net.WebResponse].InnerInvoke (System.Threading.Tasks.TaskCompletionSource`1 tcs, System.Func`2 endMethod, IAsyncResult l) [0x00000] in <filename unknown>:0
at System.Threading.Tasks.TaskFactory`1+<FromAsyncBeginEnd>c__AnonStorey21[System.Net.WebResponse].<>m__15 (IAsyncResult l) [0x00000] in <filename unknown>:0
at Vistian.Net.Http.HttpRequestProcessor+<BeginGetResponse>c__AnonStorey3.<>m__5 (IAsyncResult result) [0x00082] in /Users/martinstafford/Projects/Vistian/vistian/common/Vistian.Net/trunk/Vistian.Net.Portable/Http/HttpRequestProcessor.cs:441
at System.Net.WebAsyncResult.CB (System.Object unused) [0x00000] in /Developer/MonoTouch/Source/mono/mcs/class/System/System.Net/WebAsyncResult.cs:148

I've tried including this line in the constructor for the class with the problem in it but the error still occurs:

object dummy = System.Threading.Interlocked.Exchange( ref dummyLock, new object()); 

Here's the code around the error. Sorry there's so much but it gets it in context. The exception is thrown on calling 'callback' - any of them. As you can see I'm trying to implement the Asynchronous Programming Model for a class that encompasses the two async operations of GetRequestStream and GetResponse:

                    public static IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
    {
        var requestProcessor = state as HttpRequestProcessor;

        // create the Uri of the Host and Path in the request
        // and use it to create a HttpWebRequest
        Uri u = new Uri(new Uri(requestProcessor.Request.Host), requestProcessor.Request.Path);
        requestProcessor.HttpWebRequest = WebRequest.Create(u) as HttpWebRequest;

        // set up the header of the HttpWebRequest
        requestProcessor.SetupHeader(requestProcessor.HttpWebRequest, requestProcessor.Request);

        requestProcessor.WebResponse = null;
        requestProcessor.RaisedException = null;

        // set up an event to be used to 'timeout' the forthcoming async process
        var syncRef = new System.Threading.AutoResetEvent(false);

        System.Diagnostics.Debug.WriteLine(string.Format("HttpRequestProcessor.BeginGetResponse: started method={0}", requestProcessor.Request.Method));

        // perform the request using the Async method
        // GET and POST requests are processed differently
        if (requestProcessor.Request.Method == HttpMethod.POST)
        {
            // create the request content using the serialiser
            var bytes = requestProcessor.Encoder.Encode(requestProcessor.Request.Data, requestProcessor.Request.ContentType);

            System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: BeginGetRequestStream started");

            // start the async process by adding the content to the request
            requestProcessor.HttpWebRequest.BeginGetRequestStream((IAsyncResult result) =>
            {
                // the asyncronous Get RequestStream has finished in some way
                // complete the Get RequestStream process by calling EndGetRequestStream

                // get the HttpWebRequest provided in the 'state' parameter and
                // use it to call EndGetRequestStream
                var request = result.AsyncState as HttpWebRequest;
                try
                {
                    // fill the request stream with the content
                    using (Stream requestStream = request.EndGetRequestStream(result))
                    {
                        requestStream.Write(bytes, 0, bytes.Length);
                    }

                    System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: EndGetRequestStream");
                }
                catch (Exception e)
                {
                    // if the filling of the request stream fails, finish the Async process here
                    System.Diagnostics.Debug.WriteLine(string.Format("HttpRequestProcessor.BeginGetResponse: EndGetRequestSteam failed. Uri={0}", request.RequestUri));

                    // remember the exception, to be picked up by the subsequent call in to EndGetResponse
                    requestProcessor.RaisedException = e;

                    // clear the timeout event to indicate the async process has finished
                    syncRef.Set();

                    // call the callback as the async process is finished
                    callback(new AsyncResult(requestProcessor, true));

                    return;
                }

                System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: BeginGetResponse started");

                // the HttpWebRequest has the request content in it
                // send the request and get the response
                request.BeginGetResponse((IAsyncResult responseResult) =>
                {
                    // the Async process GetResponse has finished in some way
                    // get the HttpWebRequest provided as a parameter and use it
                    // to complete the GetRespone process

                    HttpWebRequest req = responseResult.AsyncState as HttpWebRequest;
                    try
                    {
                        requestProcessor.WebResponse = req.EndGetResponse(responseResult);
                        System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: EndGetResponse");
                    }
                    catch (Exception e)
                    {
                        // if getting the response fails, catch and remember the exception
                        // for the subsequent call in to EndGetResponse
                        System.Diagnostics.Debug.WriteLine(string.Format("HttpRequestProcessor.BeginGetResponse: EndGetResponse failed. Uri={0}", req.RequestUri));
                        requestProcessor.RaisedException = e;
                    }

                    // clear the timeout timer event
                    syncRef.Set();

                    // call the async callback 
                    callback(new AsyncResult(requestProcessor, true));

                    System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: POST callback complete");

                }, request);

            }, requestProcessor.HttpWebRequest);
        }
        else
        {
            requestProcessor.HttpWebRequest.BeginGetResponse((IAsyncResult responseResult) =>
            {
                HttpWebRequest req = responseResult.AsyncState as HttpWebRequest;

                try
                {
                    requestProcessor.WebResponse = req.EndGetResponse(responseResult);
                    System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: EndGetResponse");
                }
                catch (Exception e)
                {
                    System.Diagnostics.Debug.WriteLine(string.Format("HttpRequestProcessor.BeginGetResponse: EndGetResponse failed. Uri={0}", req.RequestUri));
                    requestProcessor.RaisedException = e;
                }

                syncRef.Set();

                callback(new AsyncResult(requestProcessor, true));

                System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: GET callback complete");

            }, requestProcessor.HttpWebRequest);
        }

        // wait for the async process to finish or timeout
        if (!syncRef.WaitOne(requestProcessor.Request.Timeout))
        {
            // async process has time out
            System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.BeginGetResponse: BeginGetStreamRequest timed out");

            // abort the async process and create and remember an exception
            // to be picked up by the call in the EndGetResponse
            requestProcessor.HttpWebRequest.Abort();
            requestProcessor.RaisedException = new TimeoutException("loading request stream timed out");
        }

        return new AsyncResult(requestProcessor, false);
    }

    public static WebResponse EndGetResponse(IAsyncResult result)
    {
        System.Diagnostics.Debug.WriteLine("HttpRequestProcessor.EndGetResponse:");

        var requestProcessor = result.AsyncState as HttpRequestProcessor;

        if (requestProcessor.RaisedException != null)
        {
            throw requestProcessor.RaisedException;
        }
        return requestProcessor.WebResponse;
    }

Answer 1

adding this to the constructor did it:

var dummy = System.Threading.Interlocked.Exchange( ref dummyTask, System.Threading.Tasks.Task.Factory.StartNew (() =>{}));