Deadlock in a multithreaded C# code which uses EmguCV

I had nothing to do so I wrote a quick example to help you utilize the AsyncResult pattern as well as locking.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Collections;

namespace CodeProjectHelpProject
{
    //An example program
    class Program
    {
        /// <summary>
        /// A small class to derive from exception to ensure filtering is managable.
        /// </summary>
        class OperatingException : Exception
        {
            public OperatingException(string ex) : base(ex) { }
            public OperatingException(string ex, Exception innerEx) : base(ex, innerEx) { }
        }

        /// <summary>
        /// A small class to utilize during a program which will assist in multi threading
        /// </summary>
        class OperationManager
        {
            /// <summary>
            /// The history of operation results sorted by date and time
            /// </summary>
            public readonly SortedDictionary<datetime,> ResultHistory = new SortedDictionary<datetime,>();

            /// <summary>
            /// The currently executing operation
            /// </summary>
            public OperationResult CurrentOperation { get; private set; }

            /// <summary>
            /// Begins the process of executing a new operation on this instance of the OperationManager
            /// </summary>
            /// <param name="newOperation">The class which is passes for state observation and added to the ResultHistory upon any action</param>
            /// <param name="cancelExisting">A signal which indicates if there is a operation already executing to cancel the operation</param>
            /// <param name="resumePoint">A WaitCallback which may be used to give signal to external code</param>
            public void Begin(OperationResult newOperation, bool cancelExisting = false, WaitCallback resumePoint = null)
            {
                //If there is a CurrentOperation and there is no operation which is expected to be canceled indicate so by throwing an OperatingException.
                if (CurrentOperation != null && !cancelExisting) throw new OperatingException("The Operation Manager does not support multiple operations and there is currently an operation pending");
                else
                {
                    //Obtain a lock around this OperationManager
                    lock (this)
                    {
                        //Lock the CurrentOperation
                        lock (CurrentOperation)
                        {
                            //If there is a value assigned to the CurrentOperation and it is not completed
                            if (CurrentOperation != null && !CurrentOperation.Signal)
                            {
                                //Cancel the CurrentOperation
                                CurrentOperation.Cancel();                                
                            }
                        }

                        //Add the result to history
                        AddHistoryResult(CurrentOperation);

                        //Assign the newOperation to the CurrentOperation
                        CurrentOperation = newOperation;

                        //Create a scope to enclose the exposed logic
                        try
                        {
                            //Begin the CurrentOperation
                            CurrentOperation.Begin();
                        }
                        catch
                        {
                            //On exception of the resumePoint is not null
                            if (resumePoint != null)
                            {
                                //Add the history result
                                AddHistoryResult(newOperation);

                                //Invoke it passing the CurrentOperation
                                resumePoint.Invoke(CurrentOperation);

                                //Set the CurrentOperation to nil.
                                CurrentOperation = null;
                            }
                        }
                    }
                }
            }

            private void AddHistoryResult(OperationResult what, DateTime? when = null)
            {
                //If there is no what to add return
                if (what == null) return;
                try
                {
                    //Guard when to it's value or DateTime.UtcNow
                    when = when ?? DateTime.UtcNow;
                    //Add the result to the history statefully
                    IDictionary securePointer = ResultHistory;
                    lock (securePointer.SyncRoot)
                    {
                        //Attempt to add what at when
                        ResultHistory.Add(when.Value, what);
                    }
                    //Remove the reference
                    securePointer = null;
                }
                catch
                {
                    //Catch and propagate the exception
                    throw;
                }
            }

        }

        /// <summary>
        /// A small class which is useful for storing operating results on.
        /// Currently it only contains the Signal Member which is used in this example to display completeness of the operation in question.
        /// </summary>
        sealed class OperationResult : IAsyncResult
        {
            /// <summary>
            /// The manager in which this result was created for
            /// </summary>
            private OperationManager manager;

            public OperationResult(OperationManager manager)
            {
                // TODO: Complete member initialization
                this.manager = manager;
            }
            public bool Signal { get; set; }

            /// <summary>
            /// Do something here if desired
            /// </summary>
            internal void Cancel()
            {
                lock (this)
                {
                    this.Signal = true;
                }
            }

            /// <summary>
            /// Called when the Operation Begins
            /// </summary>
            internal void Begin()
            {
                lock (this)
                {
                    if (this.Signal) return;
                    else
                    {
                        try
                        {
                            //Call another method or override in a derived class etc.
                            new Thread(() =>
                            {
                                //Do work in here and add to this object statefully
                                this.Signal = true;
                                return;
                            }).Start();
                        }
                        catch(Exception ex)
                        {
                            //Pass to the propagation mechanism
                            PropagateException(ex);
                        }
                    }
                }
            }

            /// <summary>
            /// Does the needful thing
            /// </summary>
            /// <param name="ex">The exception</param>
            private void PropagateException(Exception ex)
            {
                throw new OperatingException("An exception occured", ex);
            }

            public object AsyncState
            {
                get { throw new NotImplementedException(); }
            }

            public WaitHandle AsyncWaitHandle
            {
                get { throw new NotImplementedException(); }
            }

            public bool CompletedSynchronously
            {
                get { throw new NotImplementedException(); }
            }

            public bool IsCompleted
            {
                get { return !Signal; }
            }
        }

        /// <summary>
        /// Logic for cancelation will occur in this function.
        /// This function may be called from inside any function and the invocation of this function should indicate the current action is being canceled.
        /// </summary>
        /// <param name="parameter"></param>
        static void OnCancel(object parameter)
        {
            //Whatever you need
        }

        static void AfterProcessing(IAsyncResult result)
        {
            //Checks and sh*t
        }

        static void Main(string[] args)
        {
            //Create an OperationManager for this static execution
            OperationManager manager = new OperationManager();

            //We create a callback which can be invoked from inside the logic, the logic points to the OnCancel Method.
            WaitCallback resumePoint = new WaitCallback(OnCancel);
            
            //We create a result to indicate when the operation has completed
            var result = new OperationResult(manager);

            //Begin the operation
            manager.Begin(result, false, resumePoint);

            //Save the old thread priority
            ThreadPriority oldPriority = Thread.CurrentThread.Priority; 

            //While there is no signal
            while (result.Signal)
            {
                //Reduce priority
                Thread.CurrentThread.Priority = ThreadPriority.Lowest;
                //Do a big wait which is different depending on the year
                Thread.SpinWait((int)DateTime.Now.Ticks / DateTime.UtcNow.Year);
            }

            //Set the oldPriority to the currentThread
            Thread.CurrentThread.Priority = oldPriority;

            //Do work after processing
            AfterProcessing(result);

            //An example of this could work without the OperationManager
            //resumePoint.BeginInvoke(resumePoint, new AsyncCallback(AfterProcessing), result);

            //It would utilize the ThreadPool
            //ThreadPool.QueueUserWorkItem(resumePoint);

        }
    }
}

Let me know how you like it!

It is not 100% complete but it should provide you a suitable base to construct a properly synchronized design pattern.

For instance one thing I would do is utilize the ThreadPool rather than Threads due to the intrinsic memory overhead of creating threads however your external code may require thread local storage and I can see how this may be beneficial due to how old code using fast calls are executed.

Another would be to move the resumePoint to the OperationResult and then invocate it from the Begin or any other Method when required. Right now there is separation which I have purposefully done because I want you to learn a thing or two as you work with the code.

There is a lot being shown in the example and if you have further questions you know exactly where to ask them!

Sincerely,
V//

The problem I can immediately see is that you are allowing multiple threads to invoke the same library. While I am not familiar with the library in question I would say that when you release the semaphore the unman-aged code is still executing in other threads. If the library is utilizing shared local memory then this is possibly what is causing you problems.

Another thing I see is that when the semaphore is released as previously stated there other threads are still executing withing their scope (managed and unmangaged performing cleanup), this causes memory leaks if not watched carefully and on top of that causes the runtime to mangle objects which are being marshaled across application boundaries due to destructor invocation.

I would utilize a class and pass the class by reference "ref" this will ensure that the local legacy code can make changes to the object just like it would in native execution.

I would implement IDisposable and I would utilize IAsyncResult as given in the example.

Without you giving us more information relevant to the errors you are receiving and possibly giving us more code to run and see the results all I can do at this time is vaguely speculate.

One immediate solution I can pose which would definitely help you is to break the file down into several more manageable chunks.

Use a thread per chunk and interleave the extra data per chunk to a new chunk which can be run before post processing.

E.g.

Create Byte[] From File.

Split Byte[] into chunks.

Let Remainder = new List<byte[]>();

Setup storage(e.g. Dictionary or List)

Invoke library.

Check Remainder slots for extra Byte[] data left over from each fragment, sort and run process again.

Finally check storage for results.

Users can then actually peek into storage during operation and not interfere with the search operation.

v//