Histogram na dwóch wątkach pytanie

1

Witam mam problem z wrzuceniem histogramu na dwa wątki

/////////////////////////
#Thread:0x00000001d4d2e8
2 wątek
#Thread:0x00000001d4d090
///////////////////////////

a = [0,1,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,5,5,6,6,6,7,7,7,7,7,8,9,9,10]
a.count
half = (a.count/2)-1
half+1
b=a[0…half]
c=a[half+1…20]
tab1 = Hash[*b.group_by{ |v| v }.flat_map{ |k, v| [k, v.size] }]
c=a[half+1…20]
tab2 = Hash[*c.group_by{ |v| v }.flat_map{ |k, v| [k, v.size] }]
puts t1=Thread.new{tab1}
puts “2 theard”
puts t2=Thread.new{tab2}
t1.join
t2.join

2

Zacząłbym jednak od nauki umiejętnego przedstawiania problemów i zadawania pytań. To Ci się w przyszłości przyda.

3

Kolejny raz polecę przeczytanie: http://stackoverflow.com/help/how-to-ask

4

Jest tu kilka problemow:

  • half + 1 nie robi nic - a jesli chodzilo Ci o half = half + 1 to raczej tez nie jest potrzebne
  • 2ga polowka powinna byc ‘do konca’ a nie do 20go elementu (w tablicy poczatkowej jest ich wiecej). Jesli chcesz adresowac koniec tablicy, bezpieczniej uzywac indeksu -1
  • w Twojej wersji tab1 oraz tab2 wykonaja sie od razu, wiec do watku przekazujesz wynik obliczenia, zamiast algorytm - powinienes przekazac block lub funkcje
  • musisz jakos odczytac wynik obliczen (z watkow) - albo sprawic, by watek sam zapisal wynik w miejsce, do ktorego mozesz sie z zewnatrz odwolac. Przy czym wtedy musisz uwazac na to, by nie dzielic jednej zmiennej miedzy watkami - jesli np. watek #1 zapisalby wynik do 1go elementu ‘globalnej’ tablicy, zas watek #2 do 2go elementu tej samej tablicy, to musialbys synchronizowac dostep do tej tablicy. Latwiej uzyc osobnych zmiennych (w tym konkretnym przypadku)

Zakladam, że chodzilo Ci o cos takiego?

a = [0,1,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,5,5,6,6,6,7,7,7,7,7,8,9,9,10]               
middle_idx = (a.size / 2) - 1                                                      
                                                                                
half1 = a[0 .. middle_idx]                                                           
half2 = a[middle_idx + 1 .. -1]                                                    
                                                                                   
group1 = {}                                                                        
group2 = {}                                                                        
                                                                                   
calculate = lambda { |arr| Hash[*arr.group_by{ |v| v }.flat_map{ |k, v| [k, v.size] }] }
                                                                                   
t1 = Thread.new { group1 = calculate.call(half1) }                                 
t2 = Thread.new { group2 = calculate.call(half2) }                                 
                                                                                   
t1.join                                                                            
t2.join                                                                            
                                                                                   
puts group1.inspect                                                                
puts group2.inspect
5

A to przykladowa wersja dla N watkow.

a = [0,1,2,2,2,2,2,3,3,3,3,3,3,4,4,4,4,5,5,6,6,6,7,7,7,7,7,8,9,9,10]               
                                                                                   
threads_count = 3                                                                  
                                                                                   
chunks = (0 ... threads_count).map do |n|                                          
  chunks_count = threads_count - n                                                 
  chunk_size = a.size / chunks_count                                               
  a.shift(chunk_size)                                                              
end                                                                                
                                                                                   
puts "Chunks:"                                                                     
puts chunks.inspect                                                                
puts "Chunk sizes:"                                                                
puts chunks.map(&:size).inspect                                                    
                                                                                   
calculate = lambda { |arr| Hash[*arr.group_by{ |v| v }.flat_map{ |k, v| [k, v.size] }] }
                                                                                   
threads = chunks.map do |slice|                                                    
  Thread.new { puts calculate.call(slice) }                                        
end                                                                                
                                                                                   
threads.each &:join