एक्जिक्यूटिव के बीच डेटा स्थानांतरित करना

Question

मेरे पास विंडोज़ पर सी ++ में दो निष्पादन योग्य हैं। मैं एक में कुछ डेटा उत्पन्न करता हूं, और इस डेटा को संसाधित करने के लिए अन्य निष्पादन योग्य को कॉल करना चाहता हूं। मैं डेटा को फ़ाइल में लिख सकता हूं और इसे अन्य निष्पादन योग्य में पढ़ सकता हूं, लेकिन यह डिस्क I/O के संदर्भ में महंगा लगता है। ऐसा करने का एक बेहतर तरीका क्या है? यह एक साधारण पर्याप्त सवाल की तरह लगता है लेकिन गूगल सिर्फ मदद नहीं कर रहा है!

मान लें कि डेटा लगभग 100 एमबी है, और भेजने की आवश्यकता से पहले पूरी तरह से उत्पन्न होता है (यानी कोई स्ट्रीमिंग आवश्यक नहीं है)।

जवाब जो 32 बिट और 64 बिट प्रक्रियाओं को मिलाते समय काम करते हैं, बोनस अंक प्राप्त करते हैं।

Answer 1

यदि आपकी प्रक्रियाएं आसानी से फ़ाइल से लिख और पढ़ी जा सकती हैं, तो बस आगे बढ़ें। CreateFile के साथ फ़ाइल बनाएं और इसे अस्थायी & साझा करने योग्य के रूप में चिह्नित करें। विंडोज भौतिक लिखने में देरी के लिए इस संकेत का उपयोग करता है, लेकिन सभी फाइल अर्थशास्त्र अभी भी पालन किया जाता है। चूंकि आपकी फ़ाइल केवल 100 एमबी है और सक्रिय रूप से उपयोग में है, विंडोज लगभग निश्चित रूप से रैम में अपनी सामग्री को रखने में सक्षम है।

Answer 2

आप Boost.MPI का उपयोग कर सकते हैं। यह बूस्ट, जो उच्च गुणवत्ता मानक है से है, और कोड नमूने बहुत स्पष्ट लगता है:

http://www.boost.org/doc/libs/1_53_0/doc/html/mpi/tutorial.html#mpi.point_to_point

// The following program uses two MPI processes to write "Hello, world!" 
// to the screen (hello_world.cpp): 

int main(int argc, char* argv[]) 
{ 
    mpi::environment env(argc, argv); 
    mpi::communicator world; 

    if (world.rank() == 0) { 
    world.send(1, 0, std::string("Hello")); 
    std::string msg; 
    world.recv(1, 1, msg); 
    std::cout << msg << "!" << std::endl; 
    } else { 
    std::string msg; 
    world.recv(0, 0, msg); 
    std::cout << msg << ", "; 
    std::cout.flush(); 
    world.send(0, 1, std::string("world")); 
    } 
    return 0; 
} 

Answer 3

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

यदि आपको डेटा के द्विपक्षीय प्रवाह की आवश्यकता है, तो आपको दो पाइप, इनपुट के रूप में एक और आउटपुट के रूप में उपयोग करने की आवश्यकता होगी, और आपको एक प्रक्रिया स्थापित करने की आवश्यकता होगी कि बाल प्रक्रिया उन पाइपों से कैसे जुड़ती है [आप कर सकते हैं अभी भी डेटा पथ होने के लिए stdin/stdout सेट अप करें, लेकिन आप नामित पाइप की एक जोड़ी भी उपयोग कर सकते हैं]।

एक तीसरा विकल्प shared memory क्षेत्र है। मैंने विंडोज़ में ऐसा कभी नहीं किया है, लेकिन सिद्धांत जो मैंने लिनक्स में उपयोग किया है [और कई साल पहले ओएस/2 में]: 1. आपके माता-पिता में किसी दिए गए नाम के साथ मेमोरी क्षेत्र बनाएं प्रक्रिया। 2. बाल प्रक्रिया एक ही स्मृति क्षेत्र खोलती है। 3. डेटा मूल प्रक्रिया द्वारा संग्रहीत किया जाता है और बाल प्रक्रिया द्वारा पढ़ा जाता है। 4. यदि आवश्यक हो, तो समापन/परिणाम तैयार/आदि को सिग्नल करने के लिए सेमफोर या इसी तरह का उपयोग किया जा सकता है।