Memoria compartida vs. comunicación de canal Go

ipc shared-memory

Question

Uno de los eslóganes de Go es No comunicarse compartiendo memoria; en su lugar, compartir la memoria mediante la comunicación .

Me pregunto si Go permite que dos binarios compilados de Go diferentes que se ejecuten en la misma máquina se comuniquen entre sí (es decir, cliente-servidor), y qué tan rápido sería en comparación con boost :: interprocess en C ++. Todos los ejemplos que he visto hasta ahora solo ilustran la comunicación entre las rutinas del mismo programa.

¡Un ejemplo simple de Go (con cliente y código separado) sería muy apreciado!

Answer 1

He observado hacer algo similar para envolver la biblioteca MPI. Mi pensamiento actual es usar algo como

func SendHandler(comm Comm){
    // Look for sends to a process
    for {
        i := <-comm.To;
        comm.Send(i,dest);  
    }
}
func ReceiveHandler(comm Comm){
    // Look for recieves from a process
    // Ping the handler to read out
    for {
        _ = <-comm.From;
        i := comm.Recv(source);
        comm.From <- i;
     }
}

donde comm.Send y comm.Recv envuelven ac biblioteca de comunicaciones. Sin embargo, no estoy seguro de cómo haces la configuración de un canal para dos programas diferentes, no tengo experiencia en ese tipo de cosas.

Answer 2

Rob ha dicho que están pensando mucho en cómo hacer que los canales funcionen como un RPC transparente (en red), esto no funciona en este momento, pero obviamente esto es algo que quieren tomar el tiempo para hacerlo bien .

Mientras tanto, puede usar el paquete Gob que, aunque no es una solución perfecta y perfecta, ya funciona bastante bien.

Answer 3

Una de las primeras cosas en las que pensé cuando leí esto fue Stackless Python. Los canales en Go me recuerdan un montón de Python sin pila, pero eso es probable porque (a) lo he usado y (b) el lenguaje / pensamientos de los que realmente provienen, nunca los he tocado.

Nunca he intentado usar los canales como IPC, pero probablemente sea porque la alternativa es mucho más segura. Aquí hay algunos psuedocode:

programa1

chan = channel()
ipc = IPCManager(chan, None)
send_to_other_app(ipc.underlying_method)

chan.send("Ahoy!")

programa2

chan = channel()
recv_from_other_app(underlying_method)
ipc = IPCManager(chan, underlying_method)

ahoy = chan.recv()

Si utiliza un método tradicional de IPC, puede tener canales en cada lado que envuelvan su comunicación por encima de él. Esto lleva a algunos problemas en la implementación, que ni siquiera puedo pensar en cómo abordarlos, y probablemente en algunas condiciones inesperadas de la carrera.

Sin embargo, estoy de acuerdo; la capacidad de comunicarse a través de procesos utilizando la misma flexibilidad de los canales de Go sería fenomenal (pero me temo inestable).

Sin embargo, envolver un simple zócalo con canales en cada lado le brinda casi todos los beneficios.