parallel/server/XuluServer.java

package appl.parallel.server;

import java.awt.Rectangle;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.MulticastSocket;
import java.net.URL;
import java.net.UnknownHostException;
import java.rmi.MarshalledObject;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RMISecurityManager;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.activation.Activatable;
import java.rmi.activation.ActivationID;
import java.rmi.server.ServerNotActiveException;
import java.rmi.server.UnicastRemoteObject;
import java.util.HashMap;
import java.util.Vector;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

import net.jini.loader.pref.PreferredClassLoader;

import org.apache.log4j.BasicConfigurator;
import org.apache.log4j.Level;
import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.net.SocketAppender;

import appl.ext.XuluConfig;
import appl.parallel.ComputingResourceProperties;
import appl.parallel.client.DataServer;
import appl.parallel.client.ClientDataServer;
import appl.parallel.event.CommEventSink;
import appl.parallel.event.TimeEvent;
import appl.parallel.event.CommEvent.CommType;
import appl.parallel.services.RemoteEventProxy;
import appl.parallel.spmd.AdvancedSPMDServerController;
import appl.parallel.spmd.AdvancedSPMDServerInterface;
import appl.parallel.spmd.SPMDServerController;
import appl.parallel.spmd.SPMDServerInterface;
import appl.parallel.spmd.SPMDTask;
import appl.parallel.spmd.split.SinglePartitionInfo;
import appl.parallel.spmd.split.SplitMap;
import appl.parallel.spmd.split.SplitMap1DVertical;
import appl.parallel.spmd.split.AbstractSplitMap.NeighborhoodBoxingMode;
import appl.parallel.thread.OneMethodThread;
import appl.parallel.util.Helper;
import appl.util.benchmark.Benchmark;

/**
 * The Server manages the remote execution of program code. It may be started
 * using the {@link #main(String[])} method.<br>
 * The Server reads the following properties from {@link XuluConfig} - the
 * values given should be the defaults.<br>
 * <table border="1">
 * <tr>
 * <th>Property</th>
 * <th>Default</th>
 * <th>Desc</th>
 * </tr>
 * <tr>
 * <td>XuluServer.useCodeDownloading</td>
 * <td>false</td>
 * <td>if true, the server tries to download task class files from a
 * HTTP-server at the client-url</td>
 * </tr>
 * <tr>
 * <td>XuluServer.registryPort</td>
 * <td>1099</td>
 * <td>The port at which a new registry is created, if no running registry was
 * found</td>
 * </tr>
 * <tr>
 * <td>XuluServer.multicastgroup</td>
 * <td>239.1.1.1</td>
 * <td>The default multicast group</td>
 * </tr>
 * <tr>
 * <td> XuluServer.multicastport</td>
 * <td>10000</td>
 * <td>The default multicast port</td>
 * </tr>
 * <tr>
 * <td>XuluServer.eventDelay</td>
 * <td>50</td>
 * <td>Events generated on server side may be delayed to collect multiple
 * Events and send them at once (this saves communication time).Time is given in
 * milliseconds</td>
 * </tr>
 * <tr>
 * <td>XuluServer.log4j.logLevel</td>
 * <td>info</td>
 * <td>the level can be '<i>debug</i>','<i>info</i>','<i>warn</i>','<i>error</i>'
 * or '<i>fatal</i>' and can be overridden by commandline - Parameters<br>
 * <br>
 * </td>
 * </tr>
 * <td>XuluServer.log4j.mode</td>
 * <td>console</td>
 * <td>the mode can be '<i>file</i>','<i>chainsaw</i>' or '<i>console</i>'.
 * File means that the configurationfile xuluserverlog4j.cfg is read. <br>
 * <i>'chainsaw'</i> means that the server tries to configure the logger each
 * time a new client for a chainsaw instance running at the client ip
 * (standardports) <br>
 * </td>
 * </tr>
 * <td>XuluServer.benchmarkclass</td>
 * <td>appl.util.benchmark.SimpleBenchmark</td>
 * <td>The Benchmark to get a rating for this machine. Notice that you can
 * override the rating with the -rating parameter</td>
 * </tr>
 * <tr>
 * <td>XuluServer.useThreads</td>
 * <td>max</td>
 * <td>The number of threads to be used by the server for tasks that support
 * multi-threading. Per default one thread is created for every available
 * Processors (value='max'). More threads than processors may be useful for
 * testing tasks which support multihreading or for processors which support
 * hyperthreading.</td>
 * </tr>
 * <tr>
 * <td>XuluServer.runbench</td>
 * <td>true</td>
 * <td>the benchmark is run automatically</td>
 * </tr>
 * </table> <br>
 * <b>Multicasting:</b> <br>
 * If multicasting does not work, try to disable your firewall or configure it
 * to allow multicast UDP packages. Notice also, that multicasting may not work
 * in virtual machines like VMWare or MS Virtual PC 2004/7. <br>
 * <br>
 * <b>Assumptions</b> 
 * Only one client is connected to the server (and can run Tasks) <br>
  *<br>
  * See {@link #main(String[])} for details about command line parameters
 * @see ServerMulticastReceiver
 * @author Dominik Appl
 */
public class XuluServer extends UnicastRemoteObject implements SPMDResource {

        /**
         * This Thread is used when multiple threads should be executed simultaneous during multithreading
         *
         * @author Dominik Appl
         */
        class SimpleCallThread implements Callable {

                private final SPMDTask task;

                private final Object[] parameters;

                /**
                 * @param task the task to be executed
                 * @param parameters the parameters for the run method of the task
                 */
                public SimpleCallThread(SPMDTask task, Object... parameters) {
                        this.task = task;
                        this.parameters = parameters;
                }

                /*
                 * (non-Javadoc)
                 *
                 * @see java.util.concurrent.Callable#call()
                 */
                public Object call() throws Exception {
                        return task.run(parameters);
                }
        }

        private static final Logger LOG = LogManager
                        .getLogger("appl.parallel.server.XuluServer");

        private static String bindingName = "XuluServer";

        private static final String helloFromServerMessage = "Hello Xulu from XuluServer";

        private static String log4jfilename = "xuluserverlog4j.cfg";

        private static boolean chainsaw = false;

        private static SocketAppender chainsawAppender;

        /**
         * @param mode the mode of the execution
         */
        private static void log4jConfig(String mode) {
                if (mode.equals("chainsaw")) {
                        BasicConfigurator.resetConfiguration();
                        chainsawAppender = new SocketAppender();
                        BasicConfigurator.configure(chainsawAppender);
                        System.out.println("Server configured for chainsaw.");
                        chainsaw = true;
                } else if (mode.equals("file")) {
                        BasicConfigurator.resetConfiguration();
                        PropertyConfigurator.configure(log4jfilename);
                } else if (mode.equals("console")) {
                        BasicConfigurator.resetConfiguration();
                        BasicConfigurator.configure();
                } else {
                        System.err.println("Invalid log4j-Config parameter found: " + mode);
                        printInfoMessage();
                        System.exit(0);
                }
        }

        /**
         * configures the log4j level
         *
         * @see #main(String[])
         */
        private static void log4jLevel(String level) {
                if (level.equals("info")) {
                        LOG.setLevel(Level.INFO);
                } else if (level.equals("debug")) {
                        LOG.setLevel(Level.DEBUG);
                } else if (level.equals("error")) {
                        LOG.setLevel(Level.ERROR);
                } else if (level.equals("fatal")) {
                        LOG.setLevel(Level.FATAL);
                } else if (level.equals("warn")) {
                        LOG.setLevel(Level.WARN);
                } else if (level.equals("off")) {
                        LOG.setLevel(Level.OFF);
                } else {
                        System.err.println("Invalid log4j-Level found: " + level);
                        printInfoMessage();
                        System.exit(0);
                }
                System.out.println("Setting logLevel to " + level);
        }

        /**
         * Starts the server.
         *
         * @param args
         * The following parameters are valid: <br>
         * <br>
         * -loglevel:<code>LEVEL</code> - where <code>LEVEL</code> is '<i>debug</i>','<i>info</i>'
         * (DEFAULT),'<i>warn</i>','<i>error</i>' or '<i>fatal</i>' <br>
         * <br>
         * -logconfig:<code>CONFIG</code> - where <code>CONFIG</code> is '<i>file</i>','<i>chainsaw</i>' or '<i>console</i>'
         * <li>'chainsaw' means that the server tries to configure the logger each time a
         * new client for a chainsaw instance running at the client ip
         * (standardports) </li><br>
         * <li>'<i>file</i>' means that the file '<i>xuluserverlog4j.cfg</i>'
         * in the home-directory is used for configuration <br> </li>
         * <li>'<i>console</i>'
         * means of course, that the console is used for output <br> </li>
         * <br>
         * -port:PORTNUMBER - binds the server to the specified port (default 1099)
         *

         */
        public static void main(String[] args) {
                // parse arguments
                int serverPort = 0;
                for (String arg : args) {
                        if (arg.toLowerCase().startsWith("-loglevel:"))
                                log4jLevel(arg.substring(10).toLowerCase());
                        else if (arg.toLowerCase().startsWith("-logconfig:"))
                                log4jConfig(arg.substring(11).toLowerCase());
                        else if (arg.toLowerCase().startsWith("-port:"))
                                serverPort = Integer.valueOf(arg.substring(6));
                        else {
                                System.err.println("Invalid Argument found: " + arg);
                                printInfoMessage();
                                System.exit(0);
                        }
                }

                if (System.getSecurityManager() == null) {
                        System.setSecurityManager(new RMISecurityManager());
                }
                Remote server;
                try {
                        server = new XuluServer(serverPort);
                        System.out.println("Xulu Server is up and running!");
                } catch (RemoteException e) {
                        System.err.println("Xulu Server could not start!");
                        e.printStackTrace();
                }
        }

        private static void printInfoMessage() {
                System.out
                                .println("The following arguments are valid: \n"
                                                + "-loglevel:<LEVEL> \n"
                                                + "   where <LEVEL> is 'off','debug','info' (DEFAULT),'warn','error' or 'fatal'\n\n"
                                                + "-logconfig:<CONFIG> \n"
                                                + "   where <CONFIG> is 'file','chainsaw' or 'console'(DEFAULT) \n"
                                                + "   'chainsaw' means that the server tries to configure the logger each\n"
                                                + "   time a new client for a chainsaw instance running at the client ip\n"
                                                + "   (standardports) \n"
                                                + "   'file' means that the file 'xuluserverlog4j.cfg' in the home-directory "
                                                + "         is used for configuration \n"
                                                + "   'console' means of course, that the console is used for output"
                                                + "-port:<portnumber> \n"
                                                + "   The Server is bound to the specified port");
        }

        private static void unbind() {
                Helper.unbind(bindingName);
        }

        /**
         * The {@link Class} objects of the currently active connection. Every time
         * {@link #runSPMDModelTask(String, int, Object[])} is called the
         * newest class is loaded from the client. For performance reasons this will
         * happen only one time per connection. In this map the current active
         * classes are stored.
         */
        private HashMap<String, SPMDTask[]> spmdTaskInstances;

        /* standard is should be 1099 */
        private int registryPort = 1099;

        private int multicastPort;

        private String multiCastIP;

        ServerMulticastReceiver multicastThread;

        InetAddress multiCastGroup;

        // says whether a client is connected
        private boolean connected = false;

        private long starttime = System.currentTimeMillis();

        private String connectedClient;

        private PartitionDataManager dataManager;

        private RemoteEventProxy remoteEventReceiver;

        // User specified name of the Server or hostname
        private String serverName;

        private int machineRating = 0;

        private final boolean loggingEnabled;

        private int taskPriority = Thread.NORM_PRIORITY;

        private int availableProcessors = 1;

        private int toUseThreads = 1;

        private final boolean isInternalServer;

        private ClientDataServer localSPMDClient;

        private boolean useCodeDownloading;

        private ExecutorService executor;

        // used for execution results
        private Future[] resultCalls;

        /**
         * Creates a new instance at the standard port
         *
         * @throws RemoteException
         */
        public XuluServer() throws RemoteException {
                this(true, false, 0);
        }

        /**
         * @param configLogging
         *            enable or disable logging
         * @param isInternalServer
         *            set to true if you want to make method calls purely local.
         *            This is for performance reasons (see
         *            {@link UnicastRemoteObject#getClientHost()}
         * @param port
         *            port the server is bound to (0 for default)
         * @throws RemoteException
         */
        public XuluServer(boolean configLogging, boolean isInternalServer, int port)
                        throws RemoteException {
                super();
                loggingEnabled = configLogging;
                this.isInternalServer = isInternalServer;
                initConfiguration();
                //the executor is used for multithreading
                executor = Executors.newCachedThreadPool();
                spmdTaskInstances = new HashMap<String, SPMDTask[]>(10);
                if (port != 0)
                        this.registryPort = port;
                bind();

                initializeMultiCasting();
                serverName = "unknown server";
                try {
                        if (isInternalServer)
                                serverName = "internal Server";
                        else
                                serverName = InetAddress.getLocalHost().getHostName();
                } catch (UnknownHostException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                if (port != 0)
                        serverName = serverName + " (port " + registryPort + ")";
                runBenchmark();
        }

        /**
         * <br>
         * This is used when a Server is running inside the Xulu-Client. It has
         * performance advantages (direct access - no TCP/IP)
         *
         * @param configLogging
         *            enable or disable logging
         * @param clientDataServer a local client for faster access
         * @throws RemoteException
         */
        public XuluServer(boolean configLogging, ClientDataServer clientDataServer)
                        throws RemoteException {
                this(configLogging, true, 0);
                this.localSPMDClient = clientDataServer;
        }

        /**
         * @param port
         *            the port to which the Server is bound
         * @throws RemoteException
         */
        public XuluServer(int port) throws RemoteException {
                this(true, false, port);
        }

        /**
         * Bind the remote object's stub in the registry. Creates a registry if no
         * running registry is found.
         */
        private void bind() throws RemoteException {
                String name = bindingName;
                Helper.bind(name, this, registryPort);
        }

        private boolean checkConnected(String callingHost) {

                if (callingHost.equals(connectedClient))
                        return true;
                LOG
                                .warn(callingHost
                                                + " has tried to execute a critical operation, but was not connected "
                                                + ". Actual connected client: " + connectedClient);
                return false;
        }

        /**
         * Only a connected client has access to all functionality. When connecting
         * or reconnecting, all data of the server and the corresponding
         * {@link PartitionDataServer} is reset!
         *
         * @see appl.parallel.ComputingResource#connect()
         */
        public synchronized boolean connect() throws RemoteException {
                /**
                 * determine the calling host. Internal Server requires special
                 * handling: notice that this happens very often in this class, but can
                 * not externalized due to the behavior of #getClientHost();
                 */
                String callingHost = "error";
                try {
                        callingHost = isInternalServer ? "localhost" : getClientHost();
                } catch (ServerNotActiveException e) {
                        e.printStackTrace();
                }
                /** ********************************************************************** */

                if (connectedClient == null || callingHost.equals(connectedClient)) {
                        if (connectedClient == null)
                                LOG.info("Client " + callingHost + " connected!");
                        else
                                LOG.info("Client " + connectedClient + " reconnected! ");
                        // reset data
                        reset();
                        connectedClient = callingHost;
                        // initalize event system & chainsaw
                        initEventSystem();
                        initChainsaw(connectedClient);
                        return true;
                } else if (connectedClient != null) {
                        LOG.warn(callingHost + " has tried to "
                                        + "connect to server, but was not connected, "
                                        + "because this server is in use by " + connectedClient);
                }

                return false;
        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.server.ComputingResource#createDataServer()
         */
        public PartitionDataServer createDataServer(String[] IPs)
                        throws RemoteException {
                /**
                 * determine the calling host. Internal Server requires special
                 * handling: notice that this happens very often in this class, but can
                 * not externalized due to the behavior of #getClientHost();
                 */
                String callingHost = "localhost";
                try {
                        callingHost = isInternalServer ? "localhost" : getClientHost();
                } catch (ServerNotActiveException e) {
                        e.printStackTrace();
                }
                /** ********************************************************************** */
                if (checkConnected(callingHost)) {
                        if (isInternalServer)
                                dataManager = new PartitionDataManager(IPs,
                                                remoteEventReceiver, getRegistryPort(), localSPMDClient);
                        else
                                dataManager = new PartitionDataManager(IPs,
                                                remoteEventReceiver, getRegistryPort());
                        return dataManager;
                }
                return null;
        }

        /* (non-Javadoc)
         * @see appl.parallel.server.ComputingResource#disconnect()
         */
        public synchronized void disconnect() throws RemoteException {
                /**
                 * determine the calling host. Internal Server requires special
                 * handling: notice that this happens very often in this class, but can
                 * not externalized due to the behavior of #getClientHost();
                 */
                String callingHost = "localhost";
                try {
                        callingHost = isInternalServer ? "localhost" : getClientHost();
                } catch (ServerNotActiveException e) {
                        e.printStackTrace();
                }
                /** ********************************************************************** */
                if (checkConnected(callingHost)) {
                        reset();
                        LOG.info("Client " + connectedClient
                                        + " successfully disconnected from Server");
                }
        }

        /**
         * @return a rating for the machine as discovered by the benchmark
         */
        public int getRating() {
                return machineRating;
        }

        /**
         * @return the registry port the server is bound to
         */
        public int getRegistryPort() {
                return registryPort;
        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.server.XuluServer#getResourceInformation()
         */
        public ComputingResourceProperties getResourceInformation()
                        throws RemoteException {
                return new XuluServerProperties(this, serverName);
        }

        /**
         * @return the time in s the server is running
         */
        int getUptime() {
                return (int) (System.currentTimeMillis() - starttime);
        }

        private void initChainsaw(String connectedClient) {
                if (chainsaw && connectedClient != null) {
                        chainsawAppender = new SocketAppender(connectedClient, 4445);
                        BasicConfigurator.resetConfiguration();
                        BasicConfigurator.configure(chainsawAppender);
                }
        }

        /**
         * inits task priority, ports and loglevel
         */
        private void initConfiguration() {
                XuluConfig config = XuluConfig.getXuluConfig();
                // a lower priority will run the server more in the background
                taskPriority = config.getIntProperty("XuluServer.priority");

                switch (taskPriority) {
                default:
                        taskPriority = Thread.NORM_PRIORITY;
                        break;
                case 1:
                        taskPriority = Thread.MIN_PRIORITY;
                        break;
                case 2:
                        taskPriority = Thread.NORM_PRIORITY - 1;
                        break;
                case 4:
                        taskPriority = Thread.NORM_PRIORITY + 1;
                        break;
                case 5:
                        taskPriority = Thread.MAX_PRIORITY;
                        break;
                }

                availableProcessors = Runtime.getRuntime().availableProcessors();
                // default: try to use one thread per processor
                toUseThreads = availableProcessors;
                // check if there is an entry in the XuluConfig saying how many threads
                // should be created.
                // (more threads than processors may be useful for the use of
                // hyperthreading)
                String configProz = config.getProperty("XuluServer.useThreads");
                if ((configProz != null) && !configProz.equals("max")) {
                        toUseThreads = config.getIntProperty("XuluServer.useThreads");
                        // error checking:
                        if (toUseThreads < 1 || toUseThreads > 128){
                                toUseThreads = availableProcessors;
                        System.out
                                        .println("Error: Number of threads must be between 1 and 128!");
                        }
                }
                // init correspondig arrays
                resultCalls = new Future[toUseThreads];

                int port = config.getIntProperty("XuluServer.registryport");
                if (port != 0)
                        registryPort = port;

                useCodeDownloading = config
                                .getBooleanProperty("XuluServer.useCodeDownloading");
                if (useCodeDownloading)
                        System.out.println("Code downloading is enabled");
                else
                        System.out.println("Code downloading is disabled");

                int multicastport = config.getIntProperty("XuluServer.multicastport");
                if (multicastport != 0)
                        multicastPort = multicastport;
                String IP = config.getProperty("XuluServer.multicastgroup");
                if (IP != null)
                        multiCastIP = IP;
                try {
                        multiCastGroup = InetAddress.getByName(multiCastIP);
                } catch (UnknownHostException e) {
                        e.printStackTrace();
                }
                if (loggingEnabled) {

                        String mode = config.getProperty("XuluServer.log4j.mode");
                        if (mode != null)
                                log4jConfig(mode);
                }
                String level = config.getProperty("XuluServer.log4j.logLevel");
                if (level != null)
                        log4jLevel(level.toLowerCase());
                else
                        log4jLevel("info");
        }

        /**
         * Connects to the RemoteEventReceiver at the calling client
         */
        private void initEventSystem() throws RemoteException {
                String lookupName = "rmi://" + connectedClient + "/RemoteEventReceiver";
                try {
                        int delay = XuluConfig.getXuluConfig().getIntProperty(
                                        "XuluServer.eventDelay");
                        System.out.println("looking up " + lookupName);
                        CommEventSink eventSink = (CommEventSink) Naming.lookup(lookupName);
                        if (remoteEventReceiver != null)
                                remoteEventReceiver.stopService();
                        remoteEventReceiver = new RemoteEventProxy(eventSink, delay);
                        remoteEventReceiver.startService();
                } catch (MalformedURLException e) {
                        e.printStackTrace();
                } catch (NotBoundException e) {
                        LOG.warn("Could not find the remote event receiver at "
                                        + lookupName, e);
                        System.out.println(e.getMessage());
                        remoteEventReceiver = new RemoteEventProxy(null, 0);
                }
        }

        /**
         * inits the multicast unit
         */
        private void initializeMultiCasting() {
                try {
                        MulticastSocket s = new MulticastSocket(multicastPort);
                        s.joinGroup(multiCastGroup);
                        // send hello message
                        String IP = XuluConfig.getXuluConfig().getProperty(
                                        "XuluServer.multicastgroup");
                        DatagramPacket answer = new DatagramPacket(helloFromServerMessage
                                        .getBytes(), helloFromServerMessage.length(), InetAddress
                                        .getByName(IP), multicastPort);
                        s.send(answer);
                        // start thread that waits on client messages
                        multicastThread = new ServerMulticastReceiver(s);
                        multicastThread.start();
                } catch (IOException e) {
                        // TODO Auto-generated catch block
                        LOG.warn("Could not initalize multicasting! Reason was "
                                        + e.getMessage(), e);

                }
        }

        /**
         * @return whether this server is available or in use by another client
         * @see appl.parallel.ComputingResource#isAvailable()
         */
        public boolean isAvailable() throws RemoteException {
                /**
                 * determine the calling host. Internal Server requires special
                 * handling: notice that this happens very often in this class, but can
                 * not externalized due to the behavior of #getClientHost();
                 */
                String callingHost = "localhost";
                try {
                        callingHost = isInternalServer ? "localhost" : getClientHost();
                } catch (ServerNotActiveException e) {
                        e.printStackTrace();
                }
                /** ********************************************************************** */
                if (callingHost.equals(connectedClient))
                        return true;

                if (connectedClient == null)
                        return true;
                return false;
        }

        /**
         * @return if a client is connected
         */
        public boolean isClientConnected() {
                return connected;

        }

        /**
         * Loads a {@link SPMDTask} from the specified URL and returns an array of
         * instances of this class. There are so many instances, as there are
         * available processors on this machine!. This class also makes sure that
         * this happens only one time per connection (else this would of course be a
         * performance killer in fine grained parallelization).
         *
         * @param location
         *            the URL of the rootDirectory/networkLocation
         * @param spmdTaskClassName
         *            the name of the SPMDTask for which the newest class should be
         *            found
         * @return the instance of the class or <code>null</code> if loading fails
         */
        private SPMDTask[] loadSPMDTasksfromURL(String location,
                        String spmdTaskClassName) {

                SPMDTask[] spmdClassInstances = (SPMDTask[]) spmdTaskInstances
                                .get(spmdTaskClassName);

                // if already loaded for this connection simply return the instances
                if (spmdClassInstances != null)
                        return (SPMDTask[]) spmdClassInstances;
                spmdClassInstances = new SPMDTask[toUseThreads];
                Class spmdClass = null;
                if (useCodeDownloading) {
                        try {
                                // lookup client and make sure that the newest class of the task
                                // is instantiated. Will avoid loading older cached or local
                                // filesystem version
                                URL[] locations = { new URL("http://" + location + "/") };
                                PreferredClassLoader classLoader = new PreferredClassLoader(
                                                locations, Thread.currentThread()
                                                                .getContextClassLoader(), null, false);
                                LOG.debug("Try to load " + spmdTaskClassName + " from "
                                                + location);
                                spmdClass = classLoader.loadClass(spmdTaskClassName);
                        } catch (Exception e) {
                                LOG.error("Could not load class for " + spmdTaskClassName
                                                + " from " + location, e);
                                e.printStackTrace();
                        }
                }
                // if retrieval failed for some reason or code downloading disabled
                // then use the local class
                try {
                        if (spmdClass == null) {
                                spmdClass = Class.forName(spmdTaskClassName);
                        }

                        // instantiate the classes
                        for (int i = 0; i < spmdClassInstances.length; i++) {
                                Object task = spmdClass.newInstance();
                                if (!(task instanceof SPMDTask)) {
                                        LOG.fatal(spmdTaskClassName
                                                        + " was not an instance of SPMDTask!");
                                        throw new UnsupportedOperationException(spmdTaskClassName
                                                        + " was not an instance of SPMDTask!");
                                }
                                spmdClassInstances[i] = (SPMDTask) task;
                        }

                        spmdTaskInstances.put(spmdTaskClassName, spmdClassInstances);
                        return spmdClassInstances;

                } catch (ClassNotFoundException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (InstantiationException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                } catch (IllegalAccessException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                }
                throw new UnsupportedOperationException("Loading of class "
                                + spmdTaskClassName
                                + " failed on serverside! Execution canceled");
        }

        /*
         * (non-Javadoc)
         *
         * @see appl.parallel.server.XuluServer#ping(java.lang.Object[])
         */
        public Object ping(Object... o) throws RemoteException {
                System.out.println("received ping");
                return o;
        }

        /**
         * deletes all client-specific data data, so that a newly connected client
         * can use a clean system
         */
        private void reset() {
                if (dataManager != null)
                        dataManager.stop();
                dataManager = null;
                connectedClient = null;
                spmdTaskInstances.clear();
        }

        /**
         * runs the benchmark defined in XuluServer.benchmarkclass
         */
        private void runBenchmark() {
                // see if the benchmark should be run

                boolean runbench = XuluConfig.getXuluConfig().getBooleanProperty(
                                "XuluServer.runbench");
                if (runbench) {
                        String classname = XuluConfig.getXuluConfig().getProperty(
                                        "XuluServer.benchmarkclass");
                        if (classname != null) {
                                try {
                                        // getBenchmarkClass
                                        Benchmark bench = (Benchmark) Class.forName(classname)
                                                        .newInstance();
                                        machineRating = bench.bench();
                                        System.out
                                                        .println("Successfully run benchmark. Machine Rating is "
                                                                        + machineRating);
                                } catch (Exception e) {
                                        System.err
                                                        .println("Could not load Benchmarkclass "
                                                                        + classname
                                                                        + ". Setting rating to 0 (which means average).  Reason was: "
                                                                        + e.getMessage());
                                        machineRating = 0;
                                }
                        } else
                                System.out.println("Benchmark disabled");
                }
        }

        /**
         * Every time {@link #runSPMDModelTask(String, int, Object[])} is called the
         * newest class is loaded from the client. For performance reasons this will
         * happen only one time per connection.
         *
         * @see appl.parallel.server.SPMDResource#runSPMDModelTask(String, int,
         *      Object[])
         */
        @SuppressWarnings("unchecked")
        public Object[] runSPMDModelTask(String spmdTaskName, int referenceID,
                        Object... parameters) throws RemoteException {
                /**
                 * determine the calling host. Internal Server requires special
                 * handling: notice that this happens very often in this class, but can
                 * not externalized due to the behavior of #getClientHost();
                 */
                String callingHost = "localhost";
                try {
                        callingHost = isInternalServer ? "localhost" : getClientHost();
                } catch (ServerNotActiveException e) {
                        e.printStackTrace();
                }
                /** ********************************************************************** */
                Thread.currentThread().setPriority(taskPriority);
                String clientIP = "<unknown Client>";
                long time = System.nanoTime();

                clientIP = callingHost;
                if (!clientIP.equals(connectedClient)) {
                        LOG.warn(clientIP
                                        + " has tried to run a Task, but was not connected. "
                                        + "This server is in use by " + connectedClient);
                        throw new RemoteException(
                                        "Run of SPMDTask failed! This server is in use by "
                                                        + connectedClient);
                }
                if (LOG.isDebugEnabled())
                        LOG.debug("received task from " + clientIP
                                        + ". Starting evaluation now...");
                // if no datamanager is found: exit
                if (dataManager == null)
                        throw new UnsupportedOperationException(
                                        "No DataManager found. Create one first using 'createDataManager' on this Server");

                // lookup newest version of the class from the server at the url
                // (or from local disk if remote class loading is disabled)
                SPMDTask[] tasks = loadSPMDTasksfromURL(clientIP, spmdTaskName);

                // The number of threads allowed for execution can be different
                // from the number of user assigned threads
                // because tasks may not support multithreadeding
                int allowedThreads = 1;
                if (tasks[0].supportsMultiThreading())
                        allowedThreads = toUseThreads;

                Object results[] = new Object[allowedThreads];

                // the following loop is only executed the first time a task is used!
                if (!tasks[0].isInitialized()) {
                        if (LOG.isInfoEnabled())
                                LOG.info("Trying to use " + allowedThreads
                                                + " threads for execution of "
                                                + tasks[0].getClass().getName());
                        // calculate splitting for multiple threads:
                        int splitMapPos = dataManager.getInfo(referenceID).getSplitMapPos();
                        SplitMap splitMap = dataManager.getInfo(referenceID).getSplitMap();
                        SplitMap1DVertical map1DVertical = new SplitMap1DVertical(splitMap
                                        .getPartitionCalculationBounds(splitMapPos).width, splitMap
                                        .getPartitionCalculationBounds(splitMapPos).height, 0,
                                        allowedThreads, NeighborhoodBoxingMode.outBoxing);

                        // create controllers and init the tasks
                        for (int i = 0; i < allowedThreads; i++) {
                                AdvancedSPMDServerController serverController = new AdvancedSPMDServerController(
                                                dataManager, referenceID);
                                // set first thread as master thread
                                serverController.setMasterThread(i == 0);
                                // now assign the calculation area. Because we have assumed that
                                // the (Thread)-calculation
                                // area begins at (0,0) we must move it relative to the real
                                // local calculation area
                                Rectangle calculationBounds = map1DVertical
                                                .getPartitionCalculationBounds(i);
                                int absolutX = (int) (serverController.getLocalCalcMinX() + calculationBounds
                                                .getMinX());
                                int absolutY = (int) (serverController.getLocalCalcMinY() + calculationBounds
                                                .getMinY());
                                calculationBounds.setLocation(absolutX, absolutY);
                                serverController.setLocalCalculationBounds(calculationBounds);
                                tasks[i].setSPMDServerController(serverController);
                                tasks[i].initialize();
                        }
                }
                if (allowedThreads == 1) // only for saving resources: no new thread
                { // if only one thread is used
                        Object executionResult = tasks[0].run(parameters);
                        results = new Object[] { executionResult };
                } else {
                        // for more than 1 processor execute the multiple tasks in separate
                        // threads
                        for (int i = 0; i < allowedThreads; i++) {
                                resultCalls[i] = executor.submit(new SimpleCallThread(tasks[i],
                                                parameters));
                        }
                        // wait for the Threads to finish
                        for (int i = 0; i < allowedThreads; i++) {
                                try {
                                        results[i] = resultCalls[i].get();
                                } catch (InterruptedException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                } catch (ExecutionException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                }
                        }
                }
                // generate a event for the execution
                if (remoteEventReceiver.isTimeMonitoringEnabled())
                        remoteEventReceiver.fireRemoteEvent(new TimeEvent((System
                                        .nanoTime() - time), serverName, "DataServer",
                                        CommType.REMOTE_EXECUTION));
                return results;
        }

        /**
         * This method frees all resources.<br>
         * Notice that this method is not remotely accessible!
         */
        public void stopServer() {
                unbind();
                if (dataManager != null)
                        dataManager.stop();
                dataManager = null;
                if (multicastThread != null)
                        multicastThread.stopThread();
        }
}