शेयरिंग डेटा स्थानीय रूप से (सॉकेट के साथ की तरह)

Question

मेरा लक्ष्य भेजने/शेयर डेटाके बीच कई कार्यक्रमों है। ये विकल्प मैं के बारे में सोचा हैं:

• मैं एक फ़ाइल इस्तेमाल कर सकते हैं, लेकिन क्योंकि यह आम तौर पर तेजी मेरे राम उपयोग करने के लिए पसंद करते हैं।
• मैं सॉकेट का उपयोग कर सकता हूं, लेकिन उसमें बहुत सारी पता जानकारी की आवश्यकता होगी जो स्थानीय सामान के लिए अनावश्यक है। और बंदरगाह भी।
• मैं अन्य से ऐसा करने के लिए एक कुशल तरीके से पूछ सकता हूं।

मैंने आखिरी बार चुना।

तो, एक प्रोग्राम से दूसरे प्रोग्राम में डेटा भेजने का एक प्रभावी तरीका क्या होगा? यह एक बफर उपयोग कर सकते हैं, उदाहरण के लिए, और यह करने के लिए बाइट लिखने और रिसीवर के लिए प्रतीक्षा पहली बाइट चिह्नित करने के लिए 'के रूप में पढ़ा' (मूल रूप से बाइट लिखा से कुछ और), तो फिर से लिखना है, लेकिन जहां क्या मैं बफर डालूंगा और मैं इसे दोनों प्रोग्रामों के लिए सुलभ कैसे बनाऊंगा? या शायद कुछ और भी काम कर सकता है?

मैं लिनक्स का उपयोग करता हूं।

Answer 1

fifos और पाइप के बारे में क्या? यदि आप लिनक्स पर्यावरण पर हैं, तो यह तरीका है कि 2 प्रोग्राम डेटा साझा करने की अनुमति दें।

Answer 2

उसी होस्ट पर चल रही प्रक्रियाओं के लिए सबसे तेज़ आईपीसी एक साझा स्मृति है।

संक्षेप में, कई प्रक्रियाएं समान मेमोरी सेगमेंट तक पहुंच सकती हैं।

यह tutorial देखें।

Answer 3

आपको कम से Boost.Interprocess

Boost.Interprocess एक बार देख ले सकते हैं आम interprocess संचार और तुल्यकालन तंत्र के उपयोग को सरल और उनमें से एक विस्तृत श्रृंखला प्रदान करता है:

• साझा स्मृति।

• मेमोरी-मैप की गई फ़ाइलें।

• सेमफोर, म्यूटेक्स, हालत चर और अपग्रेड करने योग्य म्यूटेक्स प्रकार उन्हें साझा मेमोरी और मेमोरी मैप की गई फ़ाइलों में रखने के लिए।

• उन सिंक्रनाइज़ेशन ऑब्जेक्ट्स के नामित संस्करण, यूनिक्स/विंडोज sem_open/CreateSemaphore API के समान।

• फ़ाइल लॉकिंग।

• सापेक्ष पॉइंटर्स।

• संदेश कतार।

Answer 4

लिनक्स पर, जब फ़ाइलों का उपयोग कर, वे बहुत बार कैश में कर रहे हैं, ताकि आप डिस्क है कि अक्सर नहीं पढ़ा होगा, और आप की तरह tmpfs (वास्तव में tmpfs उपयोग आभासी एक "रैम" फाइल सिस्टम इस्तेमाल कर सकते हैं स्मृति, तो रैम + स्वैप, और व्यावहारिक रूप से फ़ाइलों को ज्यादातर समय रैम में रखा जाता है)।

मुख्य मुद्दा सिंक्रनाइज़ेशन रहता है।

सॉकेट का उपयोग करना (जो हो सकता है, यदि सभी प्रक्रियाएं एक ही मशीन पर हैं, AF_UNIX सॉकेट जो टीसीपी/आईपी वाले से तेज़ हैं) हमारे कोड को ऐसे वातावरण में आसानी से पोर्टेबल बनाने का लाभ है जहां आप कई प्रक्रियाओं को चलाने के लिए पसंद करते हैं कई मशीनें

और आप समांतर निष्पादन के लिए मौजूदा ढांचे का भी उपयोग कर सकते हैं, जैसे उदा। MPI, Corba, आदि इत्यादि

आपको बैंडविड्थ और आपके आवेदन से मिलने वाली विलंबता का एक संपूर्ण विचार होना चाहिए। (यह वही नहीं है यदि आपको हर मिलीसेकंड के दर्जन मेगाबाइट्स या सेकेंड के दसवें किलोबाइट्स साझा करने की आवश्यकता है)।

मैं करूंगा अधिक serialization के बारे में तकनीक, स्वरूपों और XDR, ASN1, JSON, YAML, s11n, jsoncpp आदि

और भेजने या डेटा को साझा करने के समान नहीं है की तरह पुस्तकालयों सीखने सुझाव देते हैं। जब आप डेटा भेजते हैं (और प्राप्त करते हैं), तो आप संदेश भेजने के मामले में सोचते हैं। जब आप डेटा साझा करते हैं तो आप साझा स्मृति के संदर्भ में सोचते हैं। प्रोग्रामिंग शैली बहुत अलग है।

Answer 5

साझा स्मृति प्रक्रियाओं के बीच डेटा साझा करने के लिए सबसे अच्छी है। लेकिन इसे बहुत सारे सिंक्रनाइज़ेशन की आवश्यकता है और यदि 2 से अधिक प्रक्रियाएं डेटा साझा कर रही हैं तो सिंक्रनाइज़ेशन साइक्लोप्स की तरह है। (एकल आंख - एकल साझा स्मृति)।

लेकिन यदि आप सॉकेट (मल्टीकास्ट सॉकेट) का उपयोग करते हैं, तो कार्यान्वयन थोड़ा मुश्किल होगा, लेकिन मापनीयता और रखरखाव बहुत आसान है। आपको परेशान करने की आवश्यकता नहीं है कि डेटा के लिए कितने ऐप्स इंतजार करेंगे, आप बस मल्टीकास्ट कर सकते हैं और वे डेटा और प्रक्रिया को सुनेंगे। डेटा को पढ़ने के लिए सेमफोर (साझा स्मृति सिंक्रनाइज़ेशन तकनीक) के लिए प्रतीक्षा करने की आवश्यकता नहीं है।

तो डेटा समय पढ़ने को कम किया जा सकता है।
साझा स्मृति - सेमफोर के लिए प्रतीक्षा करें, डेटा पढ़ें और डेटा को संसाधित करें।
सॉकेट - डेटा प्राप्त करें, डेटा को संसाधित करें।

प्रदर्शन, मापनीयता और रखरखाव सॉकेट के साथ लाभ जोड़ा जाएगा।

सादर,
SSuman185

Answer 6

आपके सवालों के जवाब के लिए:

एक फ़ाइल का उपयोग करना शायद सबसे अच्छा तरीका नहीं है, और फ़ाइलें आमतौर पर भीतरी प्रक्रिया जानकारी पारित करने के लिए उपयोग नहीं किया जाता। याद रखें कि ओएस को खोलना, पढ़ना, लिखना, बंद करना है। हालांकि वे लॉकिंग के लिए उपयोग किए जाते हैं (http://en.wikipedia.org/wiki/File_locking)।

पाइपस्ट्रीम (http://linux.die.net/man/3/popen) का उपयोग करके आप उच्चतम प्रदर्शन प्राप्त करते हैं, लेकिन लिनक्स में इसे सही करना मुश्किल है। आपको stdin, stdout, और stderr को पुनर्निर्देशित करना होगा। यह प्रत्येक आंतरिक प्रक्रिया के लिए किया जाना है। तो यह दो अनुप्रयोगों के लिए अच्छी तरह से काम करेगा लेकिन इससे आगे बढ़ जाएगा और यह बहुत बालों वाली हो जाता है।

मेरा पसंदीदा समाधान, सॉकेटपेयर का उपयोग करें (http://pubs.opengroup.org/onlinepubs/009604499/functions/socketpair.html)। ये बहुत मजबूत और सेटअप करने में आसान हैं। लेकिन यदि आप एकाधिक अनुप्रयोगों का उपयोग करते हैं तो आपको एप्लिकेशन का उपयोग करने के लिए कुछ प्रकार के पूल तैयार करना होगा।