Hidlibrary: ReadReport () मेमोरी लीक

कज़ार्ट,

दुर्भाग्य से वह कोड बहुत पुराना है और मेरे पास इसे देने का समय नहीं है
कोई टीएलसी। इस बिंदु पर मेरे पास इसे एक संदर्भ के रूप में है। तुम्हारा सर्वोत्तम
शर्त कांटा/सुधार करना है।

एम

सूर्य पर, अगस्त १४, २०११ पूर्वाह्न १०:३७, कज़ार्ट <
उत्तर@reply.github.com>लिखा:

महान पुस्तकालय माइक, इस विशाल कार्य के लिए बहुत-बहुत धन्यवाद।

समस्या तब होती है जब मैं डेटा के साथ इनपुट रिपोर्ट भरना चाहता हूं:

इनपुट रिपोर्ट = डिवाइस। रीड रिपोर्ट ();

जहां इनपुट रिपोर्ट है:

HidLibrary.HidReport InputReport = new
HidLibrary.HidReport(ukp.Capabilities.InputReportByteLength);

यह रिसाव स्मृति का एक बहुत बड़ा है, खासकर जब मैं async में रिपोर्ट पढ़ता हूं
डिवाइस से मोड (उदाहरण के लिए, एक सेकंड के लिए 100 बार)। कुछ ही मिनटों में यह कर सकते हैं
सैकड़ों मेगाबाइट लेता है।

मैं सी # प्रोग्रामिंग में शुरुआत कर रहा हूं और समस्या का समाधान नहीं मिला
ऊपर वर्णित ;(

अभिवादन!

इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें:
https://github.com/mikeobrien/HidLibrary/issues/11

कज़ार्ट,

क्या आपको एक समाधान मिला? मैंने अभी वही बात नोटिस की है।
महान पुस्तकालय माइक, बहुत बहुत धन्यवाद! मैं एंडिसिया यूएसबी स्केल के साथ काम कर रहा हूं और यह बहुत मजेदार है।

जॉरॉकफ्ल,

दुर्भाग्य से मेरे पास इस मुद्दे को ठीक करने के लिए पर्याप्त समय और कोई कौशल नहीं था :(

अभिवादन

समस्या यह है कि HidReport और Devicedata को मुक्त नहीं किया गया है, इसलिए यह कचरा संग्रहण की प्रतीक्षा करता है।
इसे संसाधित करने के बाद इसे रिलीज़ करना एक आसान समाधान है ...

अंत में मुझे इस मुद्दे को ठीक करना पड़ा और मैंने जो पाया वह साझा करता हूं

1) सबसे पहले, पुस्तकालय में प्रत्येक एक पढ़ने/लिखने के तरीकों की जांच करें कि क्या डिवाइस कनेक्ट है, जिसके लिए बहुत अधिक प्रदर्शन खर्च होता है क्योंकि IsConnected विधि हर बार EnumerateHidDevices() को कॉल करती है। व्यवहार में, जब मैं डिवाइस से डेटा का बड़ा पैकेज भेजता हूं, तो पीसी होस्ट एचआईडी डिवाइस की तुलना में धीमा होता है और सीमित रिंग बफर के कारण कुछ पैकेट खो जाते हैं (डिफ़ॉल्ट रूप से 32 रिपोर्ट, 512 तक बढ़ाया जा सकता है लेकिन यह अंतिम समाधान नहीं है)।
पुनश्च आप अपने रिंग बफर को 32 से बढ़ाकर अधिकतम 512 रिपोर्ट कॉल कर सकते हैं:
NativeMethods।HidD_SetNumInputBuffers((int)device.ReadHandle, 512); // यह XP और बाद में काम करेगा।
2) दूसरे, EnumerateHidDevices() में "यील्ड रिटर्न डिवाइसपाथ" के कारण बड़ी मेमोरी लीक है; लाइन ६९ में और NativeMethods.SetupDiDestroyDeviceInfoList(deviceInfoSet); कभी नहीं बुलाया जाएगा।

मेरा समाधान:
1) हर पढ़ने/लिखने के लिए IsConnected को कॉल न करें। HidDevice में अतिरिक्त isConnected वैरिएबल बनाएं:
सार्वजनिक बूल जुड़ा हुआ है;
सफल कनेक्ट के बाद वैरिएबल को सही पर सेट करें (उदाहरण के लिए आपके कनेक्ट() फ़ंक्शन में):
device.isConnected = सच;
इसे प्रत्येक DeviceEventMonitorInserted() और DeviceEventMonitorRemoved() ईवेंट में अपडेट करें, जैसे:
अगर (सम्मिलित! = शून्य) सम्मिलित ();
के साथ बदलें:
अगर (सम्मिलित != शून्य )
{
जुड़ा हुआ = सच;
डाला ();
}
तथा:
अगर (हटाया गया! = शून्य) हटाया गया ();
के साथ बदलें:
अगर (हटाया गया! = शून्य)
{
जुड़ा हुआ = झूठा;
निकाला गया();
}
इस चर को प्रत्येक रीड/राइट कॉल फ़ंक्शन की जांच करें:
अगर (कनेक्टेड है) के बजाय अगर (कनेक्टेड)
हर बार आपको यह जांचने की आवश्यकता होती है कि क्या डिवाइस कनेक्ट है, सार्वजनिक चर की स्थिति जांचें कनेक्ट है। यह मेरे लिए काम करता है - रीड थ्रेड के लिए 10-20% के बजाय 0-1% प्रोसेसर का उपयोग।

2) HidDevice.cs लाइन #69 में हटाएं:
// यील्ड रिटर्न डिवाइसपाथ;
यह NativeMethods को अनुमति देगा। SetupDiDestroyDeviceInfoList(deviceInfoSet); शीघ्र बुलाया जा सकता है।
इसके बाद, NativeMethods .SetupDiDestroyDeviceInfoList(deviceInfoSet) के बाद जोड़ें:
foreach (उपकरणों में स्ट्रिंग डिवाइसपाथ)
उपज वापसी डिवाइसपाथ;
यह बड़ी मेमोरी लीक को ठीक करेगा (मेरे मामले में प्रत्येक 1 एमबी प्राप्त डेटा के लिए लगभग 256 एमबी)

आशा है कि हेप्स।

बढ़िया, आपके संकेत के लिए धन्यवाद, kaczart !!!

यहाँ प्रदर्शन समस्या के लिए मेरा सुझाव दिया गया है कि kaczart (और I) ने देखा:
https://github.com/macaba/HidLibrary/commit/8f1864e1351ccca4772d5bbc18a0f94d7ba07fe7

उपयोग की तर्ज पर है:

device.ConnectionCheckOverride = device.IsConnected;
methodRequiringFasterUSBReadWrite();
device.ConnectionCheckOverride = false;

इसने मेरे बल्क USB ट्रांसफर टेस्ट केस निष्पादन समय को 159 सेकंड से घटाकर 47 सेकंड कर दिया।

मैं kaczart के समाधान के लिए उत्सुक नहीं था क्योंकि IsConnected संपत्ति का उपयोग HidDeviceEventMonitor में किया जाता है, इसलिए वर्तमान में कनेक्टेड USB उपकरणों की गणना की मूल कार्यक्षमता को बनाए रखने की आवश्यकता है। सीधे शब्दों में कहें; मुझे नहीं लगता कि सम्मिलित और हटाई गई घटनाओं को कभी भी kaczart के कोड में बुलाया जाएगा (इसके माध्यम से एक संक्षिप्त रूप से)।

प्रत्येक पढ़ने और लिखने पर डिवाइस कनेक्शन की जांच करना उच्च आवृत्ति अनुप्रयोगों में एक प्रमुख प्रदर्शन बाधा है। मेरे विशेष मामले में यह मान लेना ३० गुना तेज था कि डिवाइस कनेक्शन के लिए फिर से जांच करने के बजाय डिवाइस जुड़ा हुआ था; राउंड ट्रिप लगभग 70ms से घटकर 2ms हो गया।

इसलिए मैंने तेजी से पूलिंग उपयोग के लिए अपने स्वयं के आईओ को संभालने के लिए कुछ विस्तार विधियों को लिखा है:

        [DllImport("hid.dll", SetLastError = true)]
        static internal extern bool HidD_SetOutputReport(IntPtr hidDeviceObject, byte[] lpReportBuffer, int reportBufferLength);

        [DllImport("kernel32.dll", SetLastError = true)]
        static internal extern bool ReadFile(IntPtr hFile, [Out] byte[] lpBuffer, uint nNumberOfBytesToRead, out uint lpNumberOfBytesRead, IntPtr lpOverlapped);
        public static bool FastWrite(this HidLibrary.HidDevice device, byte[] outputBuffer)
        {
            try
            {
                if (NativeMethods.HidD_SetOutputReport(device.Handle, outputBuffer, outputBuffer.Length))
                    return true;
                else
                    return false;
            }
            catch
            {
                return false;
            }
        }
        public static ReadStatus FastRead(this HidLibrary.HidDevice device, byte[] inputBuffer)
        {
            try
            {
                uint bytesRead;
                if (NativeMethods.ReadFile(device.Handle, inputBuffer, (uint)inputBuffer.Length, out bytesRead, IntPtr.Zero))
                {
                    return ReadStatus.Success;
                }
                else
                {
                    return ReadStatus.NoDataRead;
                }
            }
            catch (Exception)
            {
                return ReadStatus.ReadError;
            }
        }