Chciałbym móc podłączyć mojego Maca do moich instancji EC2, aby przeprowadzić równoległe przetwarzanie w AWS przezparallel pakiet za pomocąmakePSOCKcluster lubmakeSOCKCluster.

W tej chwili moja próba pozostawia R 'wiszące', więc dostosowałemmakePSOCKcluster, a niektóre z jego podprogramów tak, że niektóre z jego wyników można zobaczyć, dodając-v opcja do ssh. Myślę, że udało mi się poradzić sobie z hasłem bez logowania ssh, ale utknąłem na tymsocketConnection część, która moim zdaniem powoduje problemy.

Próbowałem powiązać elastyczne adresy IP i używać ich jako adresów IP bezskutecznie, próbowałem również dostosować grupy zabezpieczeń, tak aby zawierały domyślny port, który makePSOCKcluster nie działa na nic ... W tym drugim przypadku nie użyłem argument port i użył domyślnej opcji portu 10187, do której mówi:

Error in socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  : 
  cannot open the connection
In addition: Warning message:
In socketConnection("localhost", port = port, server = TRUE, blocking = TRUE,  :
  port 10187 cannot be opened

Patrząc na kilka pytań z listy mailingowej hpc, wydawało się, że jest to problem związany z byciem Windows ... ale biorąc pod uwagę, że łączę się z komputerem Mac, nie sądzę, żebym zaliczał się do tej kategorii.

Thehosts Obiekt jest po prostu publicznym DNS, który jest dostarczany po uruchomieniu instancji EC2.

Poniżej przedstawiam moją obecną próbę adaptacji niektórychmakePSOCKcluster funkcja domakePSOCKcluster1 powinny być mniej więcej takie same.

Podałemrscript parametr pasujący do tego, którego można by oczekiwać na instancji ubuntu, i określiłemubuntu jako nazwa użytkownika do logowania jako na instancji ubuntu EC2.

makePSOCKcluster1 <- function (names, ...) {
    if (is.numeric(names)) 
        names <- rep("localhost", names[1])
    options <- parallel:::addClusterOptions(parallel:::defaultClusterOptions, list(...))
    cl <- vector("list", length(names))
    for (i in seq_along(cl)) cl[[i]] <- newPSOCKnode1(names[[i]], 
        options = options, rank = i)
    class(cl) <- c("SOCKcluster", "cluster")
    cl
}



newPSOCKnode1 <- function (machine = "localhost", ..., options = parallel:::defaultClusterOptions, 
                           rank) 
{
    options <- options
    if (is.list(machine)) {
        options <- options
        machine <- machine$host
    }
    outfile <- parallel:::getClusterOption("outfile", options)
    master <- if (machine == "localhost") 
        "localhost"
    else parallel:::getClusterOption("master", options)
    port <- parallel:::getClusterOption("port", options)
    manual <- parallel:::getClusterOption("manual", options)
    timeout <- parallel:::getClusterOption("timeout", options)
    methods <- parallel:::getClusterOption("methods", options)
    useXDR <- parallel:::getClusterOption("useXDR", options)
    env <- paste("MASTER=", master, " PORT=", port, " OUT=", 
                 outfile, " TIMEOUT=", timeout, " METHODS=", methods, 
                 " XDR=", useXDR, sep = "")
    arg <- "parallel:::.slaveRSOCK()"
    rscript <- if (parallel:::getClusterOption("homogeneous", options)) {
        shQuote(parallel:::getClusterOption("rscript", options))
    }
    else "Rscript"
    cmd <- paste(rscript, "-e", shQuote(arg), env)
    renice <- parallel:::getClusterOption("renice", options)
    if (!is.na(renice) && renice) 
        cmd <- sprintf("nice +%d %s", as.integer(renice), cmd)
    if (manual) {
        cat("Manually start worker on", machine, "with\n    ", 
            cmd, "\n")
        flush.console()
    }
    else {
        if (machine != "localhost") {
            rshcmd <- parallel:::getClusterOption("rshcmd", options)
            user <- parallel:::getClusterOption("user", options)
            cmd <- shQuote(cmd)
            cmd <- paste(rshcmd, "-v -l", user, machine, cmd)
            print(cmd)
        }
        if (.Platform$OS.type == "windows") {
            system(cmd, wait = FALSE, input = "")
        }
        else system(cmd, wait = FALSE)
    }
    print("ssh done!!! about to start socketConnection....")
    con <- socketConnection("localhost", port = port, server = TRUE, 
                            blocking = TRUE, open = "a+b", timeout = timeout)
    print("socketConnection complete!!!")
    structure(list(con = con, host = machine, rank = rank), class = if (useXDR) 
        "SOCKnode"
              else "SOCK0node")
}



 hosts <- c("ec2-xxx-xx-xxx-xxxx.zone.compute.amazonaws.com","ec2-xx-xxx-xxx-xxx.zone.compute.amazonaws.com")
 # the code to try and connect to the actual EC2 instance...
 cl1 <- makePSOCKcluster1(hosts, user="ubuntu", rscript="/usr/lib/R/bin/Rscript", port=8787)



[1] "ssh -v -l ubuntu ec2-xxxxxxxxxxx.zone.compute.amazonaws.com \"'/usr/lib/R/bin/Rscript' -e 'parallel:::.slaveRSOCK()' MASTER=local.machine.name PORT=8787 OUT=/dev/null TIMEOUT=2592000 METHODS=TRUE XDR=TRUE\""
[1] "ssh done!!! about to start socketConnection...."
OpenSSH_5.2p1, OpenSSL 0.9.8r 8 Feb 2011
debug1: Reading configuration data /etc/ssh_config
debug1: Connecting to ec2-xxxxxxxxxxx.zone.compute.amazonaws.com [xx.xxx.xx.x.x] port 22.
debug1: Connection established.
debug1: identity file /Users/username/.ssh/identity type -1
debug1: identity file /Users/username/.ssh/id_rsa type 1
debug1: identity file /Users/username/.ssh/id_dsa type 2
debug1: Remote protocol version 2.0, remote software version OpenSSH_5.9p1 Debian-5ubuntu1
debug1: match: OpenSSH_5.9p1 Debian-5ubuntu1 pat OpenSSH*
debug1: Enabling compatibility mode for protocol 2.0
debug1: Local version string SSH-2.0-OpenSSH_5.2
debug1: SSH2_MSG_KEXINIT sent
debug1: SSH2_MSG_KEXINIT received
debug1: kex: server->client aes128-ctr hmac-md5 none
debug1: kex: client->server aes128-ctr hmac-md5 none
debug1: SSH2_MSG_KEX_DH_GEX_REQUEST(1024<1024<8192) sent
debug1: expecting SSH2_MSG_KEX_DH_GEX_GROUP
debug1: SSH2_MSG_KEX_DH_GEX_INIT sent
debug1: expecting SSH2_MSG_KEX_DH_GEX_REPLY
Warning: Permanently added 'ec2-xx-xx-xxx-xxx-xx.ap-southeast-1.compute.amazonaws.com,xx.xxx.xxx.xx.x' (RSA) to the list of known hosts.
debug1: ssh_rsa_verify: signature correct
debug1: SSH2_MSG_NEWKEYS sent
debug1: expecting SSH2_MSG_NEWKEYS
debug1: SSH2_MSG_NEWKEYS received
debug1: SSH2_MSG_SERVICE_REQUEST sent
debug1: SSH2_MSG_SERVICE_ACCEPT received
debug1: Authentications that can continue: publickey
debug1: Next authentication method: publickey
debug1: Offering public key: /Users/username/.ssh/id_rsa
debug1: Server accepts key: pkalg ssh-rsa blen 277
debug1: Authentication succeeded (publickey).
debug1: channel 0: new [client-session]
debug1: Requesting [email protected]
debug1: Entering interactive session.
debug1: Sending command: '/usr/lib/R/bin/Rscript' -e 'parallel:::.slaveRSOCK()' MASTER=local.machine.name PORT=8787 OUT=/dev/null TIMEOUT=2592000 METHODS=TRUE XDR=TRUE
debug1: client_input_channel_req: channel 0 rtype exit-status reply 0
debug1: channel 0: free: client-session, nchannels 1
debug1: fd 0 clearing O_NONBLOCK
debug1: fd 1 clearing O_NONBLOCK
debug1: fd 2 clearing O_NONBLOCK
Transferred: sent 2352, received 2400 bytes, in 20.0 seconds
Bytes per second: sent 117.5, received 119.9
debug1: Exit status 1

Korzystam z komputera Mac w systemie OS X 10.6.8, aby połączyć się z instancją Debian Ubunutu. Jeśli istnieją lepsze sposoby łączenia się z instancjami EC2 w celu przeprowadzenia przetwarzania równoległego, o którym wiedzą ludzie, byłoby to niezwykle przydatne.

Celem końcowym jest użycieforeach do przeprowadzenia tego przetwarzania po zarejestrowaniu klastra.

Również jako pytanie dodatkowe zastanawiałem się, jakie są plusy i minusy szybkości / przetwarzania związane z przeprowadzaniem procesu równolegle z użyciem MPI? lub jakąś inną metodę?

Z góry dziękuję!

EDYTOWAĆ Udało mi się zdobyćmakePSOCKcluster do pracy, jeśli zaczniesz od osobnej instancji EC2, aparLapply funkcja działa, a nawet mogę się zarejestrować za pomocąregisterDoParallel(cl1) gdziecl1 jest obiektem klastra, ale z jakiegoś powoduforeach...%dopar% nie działa ... dając błąd:

Error in serialize(data, node$con) : error writing to connection

lub

Error in unserialize(node$con) : error reading from connection

połączenia wyglądają dobrze, gdy się patrzyshowConnections() z tym jako następujące wyjście:

> showConnections()
  description                                                 class      mode  text     isopen   can read can write
3 "<-ip-xx-xxxx-x-xxx.zone.compute.internal:10187"   "sockconn" "a+b" "binary" "opened" "yes"    "yes"    
4 "<-ip-yy-yyyy-y-yyyy.zone.compute.internal:10187" "sockconn" "a+b" "binary" "opened" "yes"    "yes"    
5 "<-ip-zz-zzzz-z-zzzz.zone.compute.internal:10187"  "sockconn" "a+b" "binary" "opened" "yes"    "yes"    
> 

gdziex,y & z reprezentują różne adresy IP ....foreach przykłady pochodzą bezpośrednio z przykładów podanych w plikach pomocyforeach a ponadto niektóre z nichclusterCall/clusterExport/clusterEvalQ funkcje zparallel pakiet też nie działa ... dając podobny komunikat o błędzie jak wcześniej ....

Nadal chciałbym móc połączyć się z komputera Mac ... ale nadal chciałbym móc używać foreach do przetwarzania równoległego ... mam nadzieję, że dodatkowe informacje pomogą