Variable compartida entre procesos Ruby

process shared-objects

Question

Tengo un programa de Ruby que carga dos archivos yaml muy grandes, por lo que puedo acelerar un poco aprovechando los múltiples núcleos mediante el bloqueo de algunos procesos. Intenté buscar, pero tengo problemas para calcular cómo, o incluso si puedo compartir variables en diferentes procesos.

El siguiente código es el que tengo actualmente:

@proteins = ""
@decoyProteins = "" 

fork do
  @proteins = YAML.load_file(database)
  exit
end

fork do
  @decoyProteins = YAML.load_file(database)
  exit
end

p @proteins["LVDK"]

P muestra nil debido a la horquilla.

Entonces, ¿es posible que los procesos bifurcados compartan las variables? Y si es así, ¿cómo?

Answer 1

Es posible compartir variables entre procesos; DRuby es probablemente la forma más sencilla de barrera a la entrada para hacerlo.

Answer 2

Es probable que desee utilizar un hilo en lugar de un tenedor si desea compartir datos.

http://ruby-doc.org/docs/ProgrammingRuby/html/tut_threads.html

Ah, y si realmente quieres aprovechar los hilos, querrás usar JRuby. En [c] Ruby 1.9, es posible que siempre quiera echar un vistazo a las fibras. Aunque no los he visto, no sé si es una solución para ti.

Answer 3

Un problema es que necesita utilizar Process.wait para esperar a que se completen sus procesos bifurcados. La otra es que no se puede hacer comunicación entre procesos a través de variables. Para ver esto:

@one = nil
@two = nil
@hash = {}
pidA = fork do
    sleep 1
    @one = 1
    @hash[:one] = 1
    p [:one, @one, :hash, @hash] #=> [ :one, 1, :hash, { :one => 1 } ]
end
pidB = fork do
    sleep 2
    @two = 2
    @hash[:two] = 2
    p [:two, @two, :hash, @hash] #=> [ :two, 2, :hash, { :two => 2 } ]
end
Process.wait(pidB)
Process.wait(pidA)
p [:one, @one, :two, @two, :hash, @hash] #=> [ :one, nil, :two, nil, :hash, {} ]

Una forma de hacer comunicación entre procesos es usar una tubería ( IO::pipe ). Ábrelo antes de hornear, luego haz que cada lado del tenedor cierre un extremo de la tubería.

De ri IO::pipe :

    rd, wr = IO.pipe

    if fork
      wr.close
      puts "Parent got: <#{rd.read}>"
      rd.close
      Process.wait
    else
      rd.close
      puts "Sending message to parent"
      wr.write "Hi Dad"
      wr.close
    end

 _produces:_

    Sending message to parent
    Parent got: <Hi Dad>

Si quiere compartir variables, use hilos:

@one = nil
@two = nil
@hash = {}
threadA = Thread.fork do
    sleep 1
    @one = 1
    @hash[:one] = 1
    p [:one, @one, :hash, @hash] #=> [ :one, 1, :hash, { :one => 1 } ] # (usually)
end
threadB = Thread.fork do
    sleep 2
    @two = 2
    @hash[:two] = 2
    p [:two, @two, :hash, @hash] #=> [ :two, 2, :hash, { :one => 1, :two => 2 } ] # (usually)
end
threadA.join
threadB.join
p [:one, @one, :two, @two, :hash, @hash] #=> [ :one, 1, :two, 2, :hash, { :one => 1, :two => 2 } ]

Sin embargo, no estoy seguro de si enhebrar obtendrá alguna ganancia cuando esté vinculado a IO.

Answer 4

Cod está diseñado para la comunicación entre procesos y le permitirá enviar datos fácilmente entre procesos bifurcados.