Quantcast

saxon9he .net memory leak with IKVM.Internal.BootstrapClassLoader

classic Classic list List threaded Threaded
1 message Options
Reply | Threaded
Open this post in threaded view
|  
Report Content as Inappropriate

saxon9he .net memory leak with IKVM.Internal.BootstrapClassLoader

dmrgrg
This post was updated on .
Hallo

i use my custom wrapper class XQueryProcessor for processing xml objects with saxon9he-api (9.6.0.8) in .net 4.6 console application. I have memory leak problem after heavy concurrents operations (async and parallel) with this component IKVM.Internal.BootstrapClassLoader [Static variable IKVM.Internal.ClassLoaderWrapper.bootstrapClassLoader]. Diagnostic tool of visual studio show me
15.651 occurrence of Dictionary<Int32, List<Int32>> related to bootstrapClassLoader that not are disposed.

there seems to be a connection with this saxon event sender
net.sf.saxon.event.Sender+__<CallerID> [Static variable net.sf.saxon.event.Sender.__<callerID>] 1

memory leak global view

memory leak detail

i use my XQueryProcessor class in this way:

using (var xQueryProcessor = new XQueryProcessor())
            {
                try
                {
                    commandResponse = new GenericKeyedCollection<Guid, IOperation>(operation => operation.Id);
 
                    //Parallel.ForEach(command.AnalysisOperations, async (operation) =>
                    foreach (var operation in command.AnalysisOperations)
                    {
                        var cisElement = operation.OperationCis.XmlCis?.Element("CIS");

                        if (cisElement == null)
                        {
                            //throw exception
                            _logger.Warn("cisElement is null");
                            continue;
                        }

                        var analysisCdaList =await _operationEntity.GetLocalCdaMasterData();

                        try
                        {
   
                            foreach (var cda in analysisCdaList?.Where(cda => !string.IsNullOrWhiteSpace(cda.Query.WhereClause)))
                            {
                                xQueryProcessor.Load(cda.Query.WhereClause);

                                var resultQuery = xQueryProcessor?.RunIntQuery(cisElement.ToXmlNode());

                                var cdaId = cda.GetId();
                                operation.AnalysisResults?.TryAdd(cdaId, new OperationAnalysisResult
                                {
                                    IdCda = cdaId,
                                    Value = resultQuery.Value,
                                    Time = DateTime.UtcNow
                                });
                            }
                        }
                        catch (Exception ex)
                        {
                            _logger.Error(ex);
                            if (operation.ErrorLog == null)
                            {
                                operation.ErrorLog = new XDocument();
                            }
                            operation.ErrorLog.Add(new XElement("Error", new XAttribute("Type", "Exception"),
                                new XAttribute("Operation", "query analysis"),
                                new XAttribute("Description", ex.Message)));
                        }
                        finally
                        {
                            var finishTime = DateTime.UtcNow;
                            operation.CompletitionTime = finishTime;
                            operation.LastStatusChangedTime = finishTime;
                            commandResponse.Add(operation);            
                        }
                    }
                }
                catch (Exception ex)
                {
                    commandResponse = null;
                    _logger.Error(ex);
                }
                finally
                {
                    localCdaMasterData = null;
                }
            }

--- THIS IS MY CLASS----
namespace Service.Common.Processors
{
    public interface IXQueryProcessor : IDisposable
    {
        void Load(string query);
        void LoadFromFile(string fileName);
        XmlNode RunQuery(XmlNode xmlNode);
        void RunQuery(XmlNode xmlNode, XmlWriter output);
        bool RunBooleanQuery(XmlNode xmlNode);
        int RunIntQuery(XmlNode xmlNode);
    }

    public class XQueryProcessor : IXQueryProcessor
    {
        private bool _disposed;
        private Processor _processor;
        private XQueryCompiler _compiler;
        private XQueryEvaluator _xqueryEvaluator;

        public XQueryProcessor()
        {
            _processor = new Processor();
            _compiler = _processor.NewXQueryCompiler();
        }

        public void Load(string query)
        {
            _xqueryEvaluator = _compiler.Compile(query).Load();
        }

        public void LoadFromFile(string fileName)
        {
            using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                _xqueryEvaluator = _compiler.Compile(fs).Load();
            }
        }

        public XmlNode RunQuery(XmlNode xmlNode)
        {
            using (var xmlNodeReader = new XmlNodeReader(xmlNode))
            {
                XdmNode indoc = _processor.NewDocumentBuilder().Build(xmlNodeReader);
                DomDestination dest = new DomDestination();
                _xqueryEvaluator.ContextItem = indoc;
                _xqueryEvaluator.Run(dest);
                return dest.XmlDocument;
            }
        }

        public bool RunBooleanQuery(XmlNode xmlNode)
        {
            using (var xmlNodeReader = new XmlNodeReader(xmlNode))
            {
                DocumentBuilder documentBuilder = _processor.NewDocumentBuilder();
                XdmNode indoc = documentBuilder.Build(xmlNodeReader);
                _xqueryEvaluator.ContextItem = indoc;
                XdmAtomicValue result = (XdmAtomicValue) _xqueryEvaluator.EvaluateSingle();
                return int.Parse(result.Value.ToString()) == 1;
            }
        }

        public int RunIntQuery(XmlNode xmlNode)
        {
            using (var xmlNodeReader = new XmlNodeReader(xmlNode))
            {
                DocumentBuilder documentBuilder = _processor.NewDocumentBuilder();
                XdmNode indoc = documentBuilder.Build(xmlNodeReader);
                _xqueryEvaluator.ContextItem = indoc;
                XdmAtomicValue result = (XdmAtomicValue)_xqueryEvaluator.EvaluateSingle();
                return int.Parse(result.Value.ToString());
            }
        }

        public void RunQuery(XmlNode xmlNode, XmlWriter output)
        {
            using (var xmlNodeReader = new XmlNodeReader(xmlNode))
            {
                XdmNode indoc = _processor.NewDocumentBuilder().Build(xmlNodeReader);
                TextWriterDestination twd = new TextWriterDestination(output);
                _xqueryEvaluator.ContextItem = indoc;
                _xqueryEvaluator.Run(twd);
                twd.Close();
            }
        }

        public static XmlNode RunQuery(XmlNode xmlNode, string xQuery)
        {
            using (var saxonXQuery = new XQueryProcessor())
            {
                saxonXQuery.Load(xQuery);
                return saxonXQuery.RunQuery(xmlNode);
            }
        }

        public static void RunQuery(XmlNode inputNode, string xQuery, XmlWriter outputWriter)
        {
            using (var saxonXQuery = new XQueryProcessor())
            {
                saxonXQuery.Load(xQuery);
                saxonXQuery.RunQuery(inputNode, outputWriter);
            }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~XQueryProcessor()
        {
            Dispose(false);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (_disposed)
                return;

            if (disposing)
            {
                // free other managed objects that implement
                // IDisposable only
            }

            // release any unmanaged objects set the object references to null
            _processor = null;
            _compiler = null;
            _xqueryEvaluator = null;

            _disposed = true;
        }
    }
}
Loading...