मैंने विकिपीडिया लेख के आधार पर एक टोपोलॉजिकल प्रकार को लागू किया है जो मैं निर्भरता समाधान के लिए उपयोग कर रहा हूं, लेकिन यह एक रैखिक सूची देता है। स्वतंत्र पथों को खोजने के लिए मैं किस प्रकार के एल्गोरिथ्म का उपयोग कर सकता हूं?
मैंने विकिपीडिया लेख के आधार पर एक टोपोलॉजिकल प्रकार को लागू किया है जो मैं निर्भरता समाधान के लिए उपयोग कर रहा हूं, लेकिन यह एक रैखिक सूची देता है। स्वतंत्र पथों को खोजने के लिए मैं किस प्रकार के एल्गोरिथ्म का उपयोग कर सकता हूं?
जवाबों:
मेरा मानना है कि एक बढ़त मतलब है कि को से पहले निष्पादित किया जाना है । यदि यह मामला नहीं है, तो सभी किनारों को घुमाएं। मैं आगे यह मानता हूं कि आप पथों में कम दिलचस्पी लेते हैं (जो पहले से ही डीएजी द्वारा दिए गए हैं) निर्भरता को देखते हुए एक अच्छी निष्पादन रणनीति की तुलना में।
आप आसानी से टोपोलॉजिकल सॉर्ट प्रक्रिया को अनुकूलित कर सकते हैं: अपील करने के बजाय, एक ही "गहराई" की सभी वस्तुओं को एक सेट में मर्ज करें। आपको सेट की एक सूची मिलती है, जिनमें से प्रत्येक में वे आइटम होते हैं जिन्हें आप समानांतर में निष्पादित / स्थापित कर सकते हैं। औपचारिक रूप से, सेट को ग्राफ लिए इस प्रकार परिभाषित किया गया है :
फिर आप इस तरह से अपने कार्यों को अंजाम दे सकते हैं (मान लें कि सेट हैं):
for i=0 to k
parallel foreach T in S_k
execute T
बेशक, यह अधिकतम थ्रूपुट का उत्पादन नहीं करता है यदि कार्य अलग-अलग समय लेते हैं: प्रत्येक तत्व के बाद दो समानांतर, स्वतंत्र रैखिक श्रृंखलाएं सिंक। इसे दरकिनार करने के लिए, मेरा सुझाव है कि आप स्रोत नोड्स में शुरू होने वाले समानांतर ट्रैवर्सल के साथ डीएजी पर सीधे काम करें - जो - और कई आवक / आउटगोइंग किनारों के साथ नोड्स में सिंकिंग / :
parallel foreach T in S_0
recursive_execute T
कहाँ पे
recursive_execute T {
atomic { if T.count++ < T.indeg then return }
execute T
parallel foreach T' in T.succ
recursive_execute T'
}
और T.count
पूर्ववर्ती की संख्या को धारण करने वाला एक सरल काउंटर T
है, जिसे पहले से ही निष्पादित किया गया है , पूर्ववर्ती की T.indeg
संख्या और T.succ
उत्तराधिकारियों का सेट।