org/objectweb/proactive/mpi/MPISpmdProxy.java

/* 
 * ################################################################
 * 
 * ProActive: The Java(TM) library for Parallel, Distributed, 
 *            Concurrent computing with Security and Mobility
 * 
 * Copyright (C) 1997-2007 INRIA/University of Nice-Sophia Antipolis
 * Contact: proactive@objectweb.org
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *  
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *  
 *  Initial developer(s):               The ProActive Team
 *                        http://www.inria.fr/oasis/ProActive/contacts.html
 *  Contributor(s): 
 * 
 * ################################################################
 */ 
package org.objectweb.proactive.mpi;

import org.apache.log4j.Logger;

import org.objectweb.proactive.ActiveObjectCreationException;
import org.objectweb.proactive.ProActive;
import org.objectweb.proactive.core.descriptor.data.VirtualNode;
import org.objectweb.proactive.core.node.NodeException;
import org.objectweb.proactive.core.util.log.Loggers;
import org.objectweb.proactive.core.util.log.ProActiveLogger;

import java.io.IOException;

import java.util.ArrayList;
import java.util.Hashtable;


public class MPISpmdProxy implements MPISpmd, java.io.Serializable {
    protected final static Logger MPI_PROXY_LOGGER = ProActiveLogger.getLogger(Loggers.MPI);

    private String status = MPIConstants.MPI_DEFAULT_STATUS;

    private String name;

    private MPISpmdImpl target;

    public MPISpmdProxy(VirtualNode vn) throws RuntimeException {
        try {
            target = (MPISpmdImpl) ProActive.newActive(MPISpmdImpl.class.getName(),
                    new Object[] { vn });
        } catch (ActiveObjectCreationException e) {
            e.printStackTrace();
        } catch (NodeException e) {
            e.printStackTrace();
        }
        name = target.getName();
        MPI_PROXY_LOGGER.debug("[MPI Proxy] creating MPI SPMD active object: " +
            name);
        MPI_PROXY_LOGGER.debug("[MPI Proxy] status : " + status);

        try {
            ProActive.setImmediateService(target, "killMPI");
            ProActive.setImmediateService(target, "getStatus");
            ProActive.setImmediateService(target, "isFinished");
            ProActive.setImmediateService(target, "getSpmdClassesParams");
            ProActive.setImmediateService(target, "getSpmdClasses");
            ProActive.setImmediateService(target, "getClassesParams");
            ProActive.setImmediateService(target, "getClasses");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public MPIResult startMPI() throws IllegalMPIStateException {
        MPI_PROXY_LOGGER.debug(
            "[MPI Proxy] call start method on active object ");
        MPI_PROXY_LOGGER.debug("[MPI Proxy] status : " + status);
        // UNSTARTED/DEFAULT status
        if (status.equals(MPIConstants.MPI_UNSTARTED)) {
            setStatus(MPIConstants.MPI_RUNNING);
            return target.startMPI();
        } else {
            ProActive.terminateActiveObject(target, true);
            throw new IllegalMPIStateException(
                "!!! ERROR: cannot start MPI process " + this.name +
                " Caused by: MPI process has already been started once ");
        }
    }

    public MPIResult reStartMPI() throws IllegalMPIStateException {
        MPI_PROXY_LOGGER.debug(
            "[MPI Proxy] call reStart method on active object ");
        MPI_PROXY_LOGGER.debug("[MPI Proxy] status : " + status);
        // check if program is already finished and change status if yes
        checkTerminationStatus();
        // UNSTARTED
        if (!status.equals(MPIConstants.MPI_UNSTARTED)) {
            setStatus(MPIConstants.MPI_RUNNING);
            target.reinitProcess();
            return target.startMPI();
        } else {
            ProActive.terminateActiveObject(target, true);
            throw new IllegalMPIStateException(
                "!!! ERROR: cannot restart MPI process " + this.name +
                " Caused by: no mpi process has been started once before");
        }
    }

    public boolean killMPI() {
        MPI_PROXY_LOGGER.debug("[MPI Proxy] Kill MPI Process ");
        checkTerminationStatus();
        // RUNNING status
        if (status.equals(MPIConstants.MPI_RUNNING)) {
            setStatus(MPIConstants.MPI_KILLED);
            return target.killMPI();
        } // FINISHED/KILLED status
        else if (status.equals(MPIConstants.MPI_FINISHED) ||
                status.equals(MPIConstants.MPI_KILLED)) {
            return false;
        }
        // UNSTARTED status
        else {
            ProActive.terminateActiveObject(target, true);
            throw new IllegalMPIStateException(
                "!!! ERROR: cannot kill MPI process " + this.name +
                " Caused by: no mpi process has been started once before!");
        }
    }

    public String getStatus() {
        checkTerminationStatus();
        return status;
    }

    public void setMPICommandArguments(String arguments) {
        target.setMPICommandArguments(arguments);
    }

    public String getName() {
        return this.name;
    }

    public String toString() {
        StringBuilder sb = new StringBuilder(target.toString());
        sb.append("\n Status: ");
        sb.append(getStatus());
        return sb.toString();
    }

    //
    // -- PRIVATE METHODS FOR SERIALIZATION -------------------------------------------------
    //
    //    private void writeObject(java.io.ObjectOutputStream out)
    //        throws IllegalMPIStateException {
    //        target.killMPI();
    //        ProActive.terminateActiveObject(target, true);
    //        throw new IllegalMPIStateException(
    //            "Copy's not allowed for MPI proxy object");
    //    }
    private void setStatus(String status) {
        this.status = status;
    }

    private void checkTerminationStatus() {
        if (target.isFinished() && (!status.equals(MPIConstants.MPI_FINISHED)) &&
                (!status.equals(MPIConstants.MPI_KILLED))) {
            status = MPIConstants.MPI_FINISHED;
        }
    }

    public VirtualNode getVn() {
        return this.target.getVn();
    }

    //  ----+----+----+----+----+----+----+----+----+----+----+-------+----+----
    //  --+----+---- methods for the future wrapping with control ----+----+----
    //  ----+----+----+----+----+----+----+----+----+----+----+-------+----+----
    public void newActiveSpmd(String cl) {
        this.target.newActiveSpmd(cl);
    }

    public void newActiveSpmd(String cl, Object[] params) {
        this.target.newActiveSpmd(cl, params);
    }

    public void newActiveSpmd(String cl, Object[][] params) {
        this.target.newActiveSpmd(cl, params);
    }

    public void newActive(String cl, Object[] params, int rank) {
        this.target.newActive(cl, params, rank);
    }

    public ArrayList getClasses() {
        return this.target.getClasses();
    }

    public ArrayList getSpmdClasses() {
        return this.target.getSpmdClasses();
    }

    public Hashtable getClassesParams() {
        return this.target.getClassesParams();
    }

    public Hashtable getSpmdClassesParams() {
        return this.target.getSpmdClassesParams();
    }

    public String getRemoteLibraryPath() {
        return this.target.getRemoteLibraryPath();
    }
}

---