Ruby multiple threads and processes get stuck - ruby

Question

I want to compare multiple threads and processes. I have to send the data which bubble-sorted in different child processes back to parent process then merge data. When data size is <= 10000, it succeeds, but when I input larger data ( 50000, 100000, 500000, max to 1000000):
Data example: 4 152 15 9523 526 1514 2623 ....
（Fisrt number is 4 for now.The others are just random numbers between 0～10000）
Case 3 will get stuck at the line like this:wt1.write... when size is over 50000. If size of data is 500000, even case 1 will be stuck.
Can anybody tell my what's problem in my code ?
This is my code :
def bubble_sort(list)
return list if list.size <= 1
swapped = true
while swapped do
swapped = false
0.upto(list.size-2) do |i|
if list[i] > list[i+1]
list[i], list[i+1] = list[i+1], list[i] # swap the values
swapped = true
end
end
end
return list
end
def mergesort(list)
return list if list.size <= 1
mid = list.size / 2
left = list[0, mid]
right = list[mid, list.size-mid]
merge(mergesort(left), mergesort(right))
end
def merge(left, right)
sorted = []
until left.empty? or right.empty?
if left.first <= right.first
sorted << left.shift # take out left first and push back to sorted
else
sorted << right.shift
end
end
return sorted.concat(left).concat(right)
end
#------------------------------------------------------------------method
#------------------------------------------------------------------main
#print "Input File Name: "
print "Filename is : "
fName = STDIN.gets.chomp() # file name
until File.exist?(fName)
print "Wrong file name! Type again :"
fName = STDIN.gets.chomp()
end
list = File.read(fName).split(' ').map{ |n| n.to_i} # File.read() will return string then split by space.
fName.insert(-5,"_output")
k = list[0].to_i # K is 4 for now
list.delete_at(0) # delete the K
SizeofInput = list.length # get the size of input
copylist = list.clone # copy from list
p = (SizeofInput / k ).to_i # every part size of input
print "Function Number is (1~4, 0 to exit ): "
fNum = STDIN.gets.chomp().to_i
outFile = File.open(fName,'a+') # new an output file n
until fNum === 0
copylist = list.clone
case fNum
when 1 # Case 1-----------------------------------------
puts "#{Time.now}"
start1 = Time.now
bubble_sort(copylist)
stop1 = Time.now
outFile.write(copylist)
outFile.write("\nFunc 1 spend time: #{stop1-start1} seconds Size of input : #{SizeofInput} " + "\n" *5)
puts "Original Time : #{stop1-start1} seconds. Size of input : #{SizeofInput} "
when 2 # Case 2------------------------------------------
sList = Array.new(k) { Array.new()} # sorted list
puts "#{Time.now}"
start2 = Time.now
threads = (0..k-1).map do |i|
if i == k-1
numbers = copylist[i*p..SizeofInput-1].clone# copy the origin array by converting into byte stream
else
numbers = copylist[i*p,p].clone# copy the origin array
end
Thread.new(i) do |i|
bubble_sort(numbers)
sList[i] = numbers.clone
end
end
threads.each{|t| t.join} # => This line will spend lot of time?!
# => main thread waits for child threads
mList = Array.new(k/2) {Array.new()}
thr = (0...k/2).map do |i|
Thread.new(i) do |j|
mList[j] = merge(sList[j*2],sList[(j*2 )+ 1]).clone
end
end
thr.each{|t| t.join}
copylist = merge(mList[0],mList[1]).clone
stop2 = Time.now
outFile.write(copylist)
outFile.write("\nFunc 2 spend time: #{stop2-start2} seconds Size of input : #{SizeofInput} " + "\n" *5)
puts "Spent time: #{stop2 - start2 } seconds. Size of Input : #{copylist.length}"
when 3 # Case 3-------------------------------------------
sList = Array.new(k) { Array.new()}
rd1,wt1 = IO.pipe # reader & writer
rd2,wt2 = IO.pipe
rd3,wt3 = IO.pipe
rd4,wt4 = IO.pipe
rd5,wt5 = IO.pipe
rd6,wt6 = IO.pipe
rd7,wt7 = IO.pipe
puts "#{Time.now}"
start2 = Time.now
pid1 = fork {
puts "1 starts"
rd1.close
numbers = copylist[0,p].clone
bubble_sort(numbers)
sList[0] = numbers.clone
wt1.write sList[0] #Marshal.dump(sList[0])
puts "1 is ok"
Process.exit!(true)
}
pid2 = fork {
puts "2 starts"
rd2.close
numbers = copylist[p,p].clone
bubble_sort(numbers)
sList[1] = numbers.clone
wt2.write sList[1] #Marshal.dump(sList[1])
puts "2 is ok"
Process.exit!(true)
exit
}
pid3 = fork {
puts "3 starts"
rd3.close
numbers = copylist[2*p,p].clone
bubble_sort(numbers)
sList[2] = numbers.clone
wt3.write sList[2] #Marshal.dump(sList[2])
puts "3 is ok"
Process.exit!(true)
}
pid4 = fork {
puts "4 starts"
rd4.close
numbers = copylist[3*p..SizeofInput-1].clone
bubble_sort(numbers)
sList[3] = numbers.clone
wt4.write sList[3] #Marshal.dump(sList[3])
puts "4 is ok"
Process.exit!(true)
}
mList = Array.new(k/2) {Array.new()}
Process.waitpid(pid1)
Process.waitpid(pid2)
wt1.close
wt2.close
puts "Finish Pid1 & 2"
pid5 = fork {
rd5.close
a = ( rd1.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} # Marshal.load(rd1.read)
b = ( rd2.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} # Marshal.load(rd2.read)
mList[0] = merge(a,b).clone
wt5.write mList[0] #Marshal.dump(mList[0])
Process.exit!(true)
}
Process.waitpid(pid3)
Process.waitpid(pid4)
wt3.close
wt4.close
puts "Finish Pid3 & 4"
pid6 = fork {
rd6.close
a = (rd3.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} #Marshal.load(rd3.read)
b = (rd4.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} #Marshal.load(rd4.read)
mList[1] = merge(a,b).clone
wt6.write mList[1] #Marshal.dump(mList[1])
Process.exit!(true)
}
Process.waitpid(pid5)
Process.waitpid(pid6)
wt5.close
wt6.close
puts "Finish Pid5 & 6"
pid7 = fork {
rd7.close
a = (rd5.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} #Marshal.load(rd5.read)
b = (rd6.read.delete '[]').split(%r{,\s*}).map{ |n| n.to_i} #Marshal.load(rd6.read)
copylist = merge(a,b)
puts "7 is ok"
wt7.write copylist #Marshal.dump(copylist)
Process.exit!(true)
}
Process.waitpid(pid7)
puts "Finish Pid7"
wt7.close
stop2 = Time.now
outFile.write(rd7.read) #Marshal.load(rd7.read))
outFile.write("\nFunc 3 spend time: #{stop2-start2} seconds Size of input : #{SizeofInput} " + "\n" *5)
puts "Spent time: #{stop2 - start2 } seconds. Size of Input : #{copylist.length}"
when 4 # Case 4-------------------------------------------
sList = Array.new(4) { Array.new() } # sort list
start3 = Time.now
(0..3).map do |i|
if i === 3
numbers = copylist[i*p..SizeofInput-1].clone # copy the origin array
else
numbers = copylist[i*p,p].clone
end
sList[i] = bubble_sort(numbers)
end
mList = Array.new(2) { Array.new() } # merge lsit
(0..1).map do |t|
mList[t] = merge(sList[t*2],sList[t*2+1]).clone
end
copylist = merge(mList[0],mList[1]).clone
stop3 = Time.now
outFile.write(copylist)
outFile.write("\nFunc 4 spend time: #{stop3-start3} seconds Size of input : #{SizeofInput} " + "\n" *5)
puts "Spent time: #{stop3 - start3 } seconds. Size of Input : #{copylist.length}"
else puts "Wrong Number!! Try Again!"
end
print "Function Number is (1~4, 0 to exit ): "
fNum = STDIN.gets.chomp().to_i
end # end of until loop
outFile.close()
puts "See you again~"