क्या LINQ के withDegreeOfParallelism पर स्कैला समांतर संग्रहों में कोई समतुल्य है जो क्वेरी चलाने वाले धागे की संख्या निर्धारित करता है? मैं समानांतर में एक ऑपरेशन चलाने के लिए चाहता हूं जिसके लिए सेट की संख्या निर्धारित होनी चाहिए।समानांतरता की स्केल समांतर संग्रह की डिग्री
, JVM 1.6 या नए का उपयोग कर, का उपयोग करें:
collection.parallel.ForkJoinTasks.defaultForkJoinPool.setParallelism(parlevel: Int)
यह भविष्य में बदलाव के लिए एक विषय है, हालांकि हो सकता है। सभी स्काला कार्य समांतर एपीआई को कॉन्फ़िगर करने के लिए एक और एकीकृत दृष्टिकोण अगले रिलीज के लिए योजनाबद्ध है।
नोट, हालांकि, यह निर्धारित करेगा कि यह पूछताछ प्रोसेसर की संख्या निर्धारित करेगा, यह क्वेरी चलाने में शामिल थ्रेड की वास्तविक संख्या नहीं हो सकती है। चूंकि समांतर संग्रह नेस्टेड समांतरता का समर्थन करते हैं, इसलिए वास्तविक थ्रेड पूल कार्यान्वयन क्वेरी को चलाने के लिए अधिक थ्रेड आवंटित कर सकता है यदि यह पता चलता है कि यह आवश्यक है।
संपादित करें:
स्काला 2.10 से शुरू, समानांतरवाद स्तर सेट करने के लिए पसंदीदा तरीका निम्न उदाहरण में, एक नया TaskSupport वस्तु को tasksupport क्षेत्र की स्थापना के माध्यम से है:
scala> import scala.collection.parallel._
import scala.collection.parallel._
scala> val pc = mutable.ParArray(1, 2, 3)
pc: scala.collection.parallel.mutable.ParArray[Int] = ParArray(1, 2, 3)
scala> pc.tasksupport = new ForkJoinTaskSupport(new scala.concurrent.forkjoin.ForkJoinPool(2))
pc.tasksupport: scala.collection.parallel.TaskSupport = [email protected]
scala> pc map { _ + 1 }
res0: scala.collection.parallel.mutable.ParArray[Int] = ParArray(2, 3, 4)
instantiating जबकि एक फोर्क जॉइन पूल के साथ ForkJoinTaskSupport ऑब्जेक्ट, फोर्क में शामिल पूल के समांतरता स्तर को वांछित मान (2 उदाहरण में) पर सेट किया जाना चाहिए।
स्काला 2.9+ (शुरू की समानांतर संग्रह) के साथ JVM संस्करण, की स्वतंत्र रूप से, आप भी grouped(Int) और par कार्यों का एक संयोजन इस तरह, छोटे-छोटे टुकड़ों पर समानांतर नौकरियों निष्पादित करने के लिए उपयोग कर सकते हैं:
scala> val c = 1 to 5
c: scala.collection.immutable.Range.Inclusive = Range(1, 2, 3, 4, 5)
scala> c.grouped(2).seq.flatMap(_.par.map(_ * 2)).toList
res11: List[Int] = List(2, 4, 6, 8, 10)
grouped(2) लंबाई 2 या उससे कम के टुकड़े बनाता है, seq यह सुनिश्चित करता है कि भाग का संग्रह समानांतर नहीं है (इस उदाहरण में बेकार), तो _ * 2 फ़ंक्शन को छोटे समांतर हिस्सों (par के साथ बनाया गया) पर निष्पादित किया जाता है, इस प्रकार यह सुनिश्चित करता है कि अधिकतम 2 धागे समानांतर में निष्पादित किया जाता है।
हालांकि यह कार्यकर्ता पूल पैरामीटर सेट करने से थोड़ा कम कुशल हो सकता है, मुझे इसके बारे में निश्चित नहीं है।
मुझे संदेह है कि यह वास्तव में आपको कुछ भी प्राप्त करेगा। मुझे इसे साबित करने वाले बेंचमार्क नंबरों को देखना होगा। –