स्कैलाज़ 7 zipWithIndex / group enumeratees के साथ मेमोरी लीक से बचना

Question

पृष्ठभूमि

जैसा कि इस प्रश्न में कहा गया है , मैं लगातार ढेर अंतरिक्ष में डेटा की एक बड़ी (यानी, अबाधित) धारा को संसाधित करने के लिए स्केलाज़ 7 पुनरावृत्तियों का उपयोग कर रहा हूं।

मेरा कोड इस तरह दिखता है:

type ErrorOrT[M[+_], A] = EitherT[M, Throwable, A]
type ErrorOr[A] = ErrorOrT[IO, A]

def processChunk(c: Chunk, idx: Long): Result

def process(data: EnumeratorT[Chunk, ErrorOr]): IterateeT[Vector[(Chunk, Long)], ErrorOr, Vector[Result]] =
  Iteratee.fold[Vector[(Chunk, Long)], ErrorOr, Vector[Result]](Nil) { (rs, vs) =>
    rs ++ vs map { 
      case (c, i) => processChunk(c, i) 
    }
  } &= (data.zipWithIndex mapE Iteratee.group(P))

समस्या

मुझे लगता है कि स्मृति रिसाव में चला गया है, लेकिन मैं यह जानने के लिए पर्याप्त नहीं हूं कि स्कैलाज / एफपी से पता चलता है कि बग स्कैलाज में है या मेरे कोड में है। सहज रूप से, मुझे उम्मीद है कि इस कोड को केवल P के Chunk-size स्थान के लिए (के आदेश पर) की आवश्यकता होगी ।

नोट: मुझे एक समान प्रश्न मिला जिसमें एक OutOfMemoryErrorका सामना किया गया था, लेकिन मेरा कोड उपयोग नहीं कर रहा है consume।

परिक्षण

मैंने कोशिश की और समस्या को अलग करने के लिए कुछ परीक्षण चलाए। संक्षेप में, रिसाव केवल जब दोनों उठता प्रतीत होता है zipWithIndexऔर groupकिया जाता है।

// no zipping/grouping
scala> (i1 &= enumArrs(1 << 25, 128)).run.unsafePerformIO
res47: Long = 4294967296

// grouping only
scala> (i2 &= (enumArrs(1 << 25, 128) mapE Iteratee.group(4))).run.unsafePerformIO
res49: Long = 4294967296

// zipping and grouping
scala> (i3 &= (enumArrs(1 << 25, 128).zipWithIndex mapE Iteratee.group(4))).run.unsafePerformIO
java.lang.OutOfMemoryError: Java heap space

// zipping only
scala> (i4 &= (enumArrs(1 << 25, 128).zipWithIndex)).run.unsafePerformIO
res51: Long = 4294967296

// no zipping/grouping, larger arrays
scala> (i1 &= enumArrs(1 << 27, 128)).run.unsafePerformIO
res53: Long = 17179869184

// zipping only, larger arrays
scala> (i4 &= (enumArrs(1 << 27, 128).zipWithIndex)).run.unsafePerformIO
res54: Long = 17179869184

परीक्षणों के लिए कोड:

import scalaz.iteratee._, scalaz.effect.IO, scalaz.std.vector._

// define an enumerator that produces a stream of new, zero-filled arrays
def enumArrs(sz: Int, n: Int) = 
  Iteratee.enumIterator[Array[Int], IO](
    Iterator.continually(Array.fill(sz)(0)).take(n))

// define an iteratee that consumes a stream of arrays 
// and computes its length
val i1 = Iteratee.fold[Array[Int], IO, Long](0) { 
  (c, a) => c + a.length 
}

// define an iteratee that consumes a grouped stream of arrays 
// and computes its length
val i2 = Iteratee.fold[Vector[Array[Int]], IO, Long](0) { 
  (c, as) => c + as.map(_.length).sum 
}

// define an iteratee that consumes a grouped/zipped stream of arrays
// and computes its length
val i3 = Iteratee.fold[Vector[(Array[Int], Long)], IO, Long](0) {
  (c, vs) => c + vs.map(_._1.length).sum
}

// define an iteratee that consumes a zipped stream of arrays
// and computes its length
val i4 = Iteratee.fold[(Array[Int], Long), IO, Long](0) {
  (c, v) => c + v._1.length
}

प्रशन

• क्या मेरे कोड में बग है?
• मैं यह काम कैसे कर सकता हूं?

Comments

मैंने स्कैलाज़ में एक मुद्दे के रूप में इसकी रिपोर्टिंग की ।

— आरोन नोवस्त्रुप

यह कोई मज़ेदार नहीं होगा, लेकिन आप -XX:+HeapDumpOnOutOfMemoryErrorग्रहण MAT Eclipse.org/mat के साथ डंप का विश्लेषण करने की कोशिश कर सकते हैं और यह देख सकते हैं कि सरणियों के लिए कोड की कौन सी रेखा पकड़ रही है।

— हुइन्हज्ल

@huynhjl FWIW, मैंने JProfiler और MAT दोनों के साथ ढेर का विश्लेषण करने की कोशिश की, लेकिन अनाम फ़ंक्शन कक्षाओं के सभी संदर्भों के माध्यम से वेड करने में पूरी तरह से असमर्थ था, आदि Scala को वास्तव में इस तरह की चीज़ों के लिए समर्पित टूल की आवश्यकता है।

— हारून नोवस्त्रुप

क्या होगा अगर कोई रिसाव नहीं है और यह सिर्फ इतना है कि आप जो कर रहे हैं उसके लिए स्मृति की बेतहाशा वृद्धि की आवश्यकता है? आप आसानी से zipWithIndex को उस विशेष FP निर्माण के बिना केवल एक varकाउंटर बनाए रखने के रूप में दोहरा सकते हैं।

— यहेजकेल विक्टर

@EzekielVictor मुझे यकीन नहीं है कि मैं टिप्पणी को समझ सकता हूं। आप सुझाव दे रहे हैं कि Longप्रति एकल इंडेक्स जोड़ने से एल्गोरिथ्म निरंतर से गैर-निरंतर हीप स्थान में बदल जाएगा? नॉन-जिपिंग संस्करण स्पष्ट रूप से निरंतर हीप स्पेस का उपयोग करता है, क्योंकि यह कई प्रक्रिया को "प्रोसेस" कर सकता है क्योंकि आप इंतजार करना चाहते हैं।

— एरोन नोवस्त्रुप

Answer 1

यह किसी के लिए भी कम सांत्वना के रूप में आएगा जो पुराने iterateeएपीआई के साथ फंस गया है, लेकिन मैंने हाल ही में सत्यापित किया है कि स्केलज-स्ट्रीम एपीआई के खिलाफ एक बराबर परीक्षण गुजरता है । यह एक नई स्ट्रीम प्रोसेसिंग एपीआई है जिसे बदलने का इरादा है iteratee।

पूर्णता के लिए, यहाँ परीक्षण कोड है:

// create a stream containing `n` arrays with `sz` Ints in each one
def streamArrs(sz: Int, n: Int): Process[Task, Array[Int]] =
  (Process emit Array.fill(sz)(0)).repeat take n

(streamArrs(1 << 25, 1 << 14).zipWithIndex 
      pipe process1.chunk(4) 
      pipe process1.fold(0L) {
    (c, vs) => c + vs.map(_._1.length.toLong).sum
  }).runLast.run

यह nपैरामीटर के लिए किसी भी मूल्य के साथ काम करना चाहिए (बशर्ते आप लंबे समय तक प्रतीक्षा करने के लिए तैयार हों) - मैंने 2 ^ 14 32MiB सरणियों के साथ परीक्षण किया (यानी, समय के साथ आवंटित स्मृति का कुल आधा टीआईबी)।