resfailureex02.java

中間件開發详细说明：清华大学J2EE教程讲义（ppt）-Tsinghua University J2EE tutorial lectures (ppt) [上载源码成为会员下载此源码] [成为VIP会

/*
 * Title:        GridSim Toolkit
 * Description:  GridSim (Grid Simulation) Toolkit for Modeling and Simulation
 *               of Parallel and Distributed Systems such as Clusters and Grids
 *               An example of how to use the failure functionality.
 * Licence:      GPL - http://www.gnu.org/copyleft/gpl.html
 *
 * Author: Agustin Caminero and Anthony Sulistio
 * Organization: UCLM (Spain)
 * Created on: August 2007
 */

import gridsim.resFailure.*;
import gridsim.*;
import gridsim.net.*;
import java.util.*;
import gridsim.util.NetworkReader;
import gridsim.util.HyperExponential;


/**
 * This example shows a basic topology with 20 users, 6 resources and 1 GIS.
 * All of them are connected by a router.
 * There is only one VO in this example.
 * @author       Agustin Caminero and Anthony Sulistio
 * @since        GridSim Toolkit 4.1
 */
public class ResFailureEx02
{
    public static void main(String[] args)
    {
        System.out.println("Starting failure example 2...");

        try
        {
            if (args.length < 1)
            {
                System.out.println("Usage: java ResFailureEx02 network_ex02.txt");
                return;
            }


            //////////////////////////////////////////
            // First step: Initialize the GridSim package. It should be called
            // before creating any entities. We can't run this example without
            // initializing GridSim first. We will get a run-time exception
            // error.

            // a flag that denotes whether to trace GridSim events or not.
            boolean trace_flag = false;  // dont use SimJava trace
            int num_user = 20; //  number of grid users
            Calendar calendar = Calendar.getInstance();

            // Initialize the GridSim package
            System.out.println("Initializing GridSim package");
            GridSim.init(num_user, calendar, trace_flag);
            trace_flag = true;


            //////////////////////////////////////////
            // Second step: Builds the network topology among Routers.

            String filename = args[0];  // get the network topology
            System.out.println("Reading network from " + filename);
            LinkedList routerList = NetworkReader.createFIFO(filename);


            //////////////////////////////////////////
            // Third step: Creates one RegionalGISWithFailure entity,
            // linked to a router in the topology

            Router router = null;
            double baud_rate = 100000000;   // 100Mbps, i.e. baud rate of links
            double propDelay = 10;      // propagation delay in milliseconds
            int mtu = 1500;             // max. transmission unit in byte
            int totalMachines = 16;     // num of machines each resource has

            String NAME = "Ex02_";  // a common name
            String gisName = NAME + "Regional_GIS";  // GIS name

            // a network link attached to this regional GIS entity
            Link link = new SimpleLink(gisName + "_link", baud_rate,
                                       propDelay, mtu);


            // HyperExponential: mean, standard deviation, stream
            // how many resources will fail
            HyperExponential failureNumResPattern =
                    new HyperExponential(totalMachines / 2, totalMachines, 4);

            // when they will fail
            HyperExponential failureTimePattern =
                    new HyperExponential(25, 100, 4);

            // how long the failure will be
            HyperExponential failureLengthPattern =
                    new HyperExponential(20, 25, 4); // big test: (20, 100, 4);


            // creates a new Regional GIS entity that generates a resource
            // failure message according to these patterns.
            RegionalGISWithFailure gis = new RegionalGISWithFailure(gisName,
                              link, failureNumResPattern, failureTimePattern,
                              failureLengthPattern);
            gis.setTrace(trace_flag);   // record this GIS activity

            // link these GIS to a router
            router = NetworkReader.getRouter("Router0", routerList);
            linkNetwork(router, gis);

            // print some info messages
            System.out.println("Created a REGIONAL GIS with name " + gisName +
                    " and id = " + gis.get_id() + ", connected to " +
                    router.get_name() );


            //////////////////////////////////////////
            // Fourth step: Creates one or more GridResourceWithFailure
            // entities, linked to a router in the topology

            String sched_alg = "SPACE";  // use space-shared policy
            int totalResource = 6; // number of resources
            ArrayList resList = new ArrayList(totalResource);

            // Each resource may have different baud rate,
            // totalMachine, rating, allocation policy and the router to
            // which it will be connected. However, in this example, we assume
            // all have the same properties for simplicity.
            int totalPE = 4;        // num of PEs each machine has
            int rating = 49000;     // rating (MIPS) of PEs
            int GB = 1000000000;    // 1 GB in bits
            baud_rate = 2.5 * GB;

            for (int i = 0; i < totalResource; i++)
            {
                // gets the router object from the list
                router = NetworkReader.getRouter("Router0", routerList);

                // creates a new grid resource
                String resName = NAME + "Res_" + i;
                GridResourceWithFailure res = createGridResource(resName,
                            baud_rate, propDelay, mtu, totalPE, totalMachines,
                            rating, sched_alg);

                // add a resource into a list
                resList.add(res);
                res.setRegionalGIS(gis);    // set the regional GIS entity
                res.setTrace(trace_flag);   // record this resource activity

                // link a resource to this router object
                linkNetwork(router, res);

                System.out.println("Created a RESOURCE (" + totalMachines +
                    " machines, each with " + totalPE + " PEs) with name = " +
                    resName + " and id = " + res.get_id() +
                    ", connected to router " + router.get_name() +
                    " and registered to " + gis.get_name() );
            }


            //////////////////////////////////////////
            // Fifth step: Creates one or more GridUserFailure entities,
            // linked to a router of the topology

            int totalGridlet = 5;    // total jobs
            double pollTime = 100;   // time between polls
            int glSize = 100000;     // the size of gridlets (input/output)
            int glLength = 42000000; // the length (MI) of gridlets

            // gets the router object from the list
            router = NetworkReader.getRouter("Router0", routerList);

            for (int i = 0; i < num_user; i++)
            {
                String userName = NAME + "User_" + i;

                // a network link attached to this entity
                Link link2 = new SimpleLink(userName + "_link", baud_rate,
                                            propDelay, mtu);

                // only keeps track activities from User_0
                if (i != 0) {
                    trace_flag = false;
                }

                GridUserFailureEx02 user = new GridUserFailureEx02(userName, link2,
                        pollTime, glLength, glSize, glSize, trace_flag);

                user.setRegionalGIS(gis); // set the regional GIS entity
                user.setGridletNumber(totalGridlet);

                // link a resource to this router object
                linkNetwork(router, user);

                System.out.println("Created a USER with name " + userName +
                        " and id = " + user.get_id() + ", connected to " +
                        router.get_name() + ", and with " + totalGridlet +
                        " gridlets. Registered to " + gis.get_name() );
            }
            System.out.println();

            //////////////////////////////////////////
            // Sixth step: Starts the simulation
            GridSim.startGridSimulation();
            System.out.println("\nFinish failure example 2... \n");
        }
        catch (Exception e)
        {
            e.printStackTrace();
            System.out.println("Unwanted errors happen");
        }
    }

    /**
     * Links a particular entity with a given Router.
     *
     * @param router    a Router object
     * @param obj       a GridSim entity to be attached to the Router
     */
    private static void linkNetwork(Router router, GridSimCore obj) throws Exception
    {
        if (router == null) {
            System.out.println("Error - router is NULL.");
            return;
        }

        // get the baud rate of a link
        double baud_rate = obj.getLink().getBaudRate();

        // create the packet scheduler for this link
        PacketScheduler pktObj = new FIFOScheduler(router.get_name() +
                                                   "_to_" + obj.get_name() );

        // attach this GridSim entity to a Router
        router.attachHost(obj, pktObj);
    }

    /**
     * Creates one Grid resource. A Grid resource contains one or more
     * Machines. Similarly, a Machine contains one or more PEs (Processing
     * Elements or CPUs).
     * <p>
     * In this simple example, we are simulating one Grid resource with three
     * Machines that contains one or more PEs.
     *
     * @param name          a Grid Resource name
     * @param baud_rate     the bandwidth of this entity
     * @param delay         the propagation delay
     * @param MTU           Maximum Transmission Unit
     * @param totalPE       number of PE per machine
     * @param totalMachine  number of machines in this resources
     * @param rating        rating of mahcines in this resource
     * @param sched_alg     the scheduling algorithm of this resource
     * @return a GridResource object
     */
    private static GridResourceWithFailure createGridResource(String name,
                        double baud_rate, double delay, int MTU, int totalPE,
                        int totalMachine, int rating, String sched_alg)
    {
        // Here are the steps needed to create a Grid resource:
        // 1. We need to create an object of MachineList to store one or more
        //    Machines
        MachineList mList = new MachineList();
        for (int i = 0; i < totalMachine; i++)
        {
            // 2. A Machine contains one or more PEs or CPUs. Therefore, should
            //    create an object of PEList to store these PEs before creating
            //    a Machine.
            PEList peList = new PEList();

            // 3. Create PEs and add these into an object of PEList.
            for (int k = 0; k < totalPE; k++)
            {
                // need to store PE id and MIPS Rating
                peList.add( new PE(k, rating) );
            }

            // 4. Create one Machine with its id and list of PEs or CPUs
            mList.add( new Machine(i, peList) );
        }


        // 5. Create a ResourceCharacteristics object that stores the
        //    properties of a Grid resource: architecture, OS, list of
        //    Machines, allocation policy: time- or space-shared, time zone
        //    and its price (G$/PE time unit).
        String arch = "Sun Ultra";      // system architecture
        String os = "Solaris";          // operating system
        double time_zone = 9.0;         // time zone this resource located
        double cost = 3.0;              // the cost of using this resource

        // we create Space_Shared_failure or Time_Shared_failure schedulers
        int scheduling_alg = 0;         // space_shared or time_shared
        if (sched_alg.equals("SPACE") == true) {
            scheduling_alg = ResourceCharacteristics.SPACE_SHARED;
        }
        else if (sched_alg.equals("TIME") == true) {
            scheduling_alg = ResourceCharacteristics.TIME_SHARED;
        }

        ResourceCharacteristics resConfig = new ResourceCharacteristics(
                arch, os, mList, scheduling_alg, time_zone, cost);


        // 6. Finally, we need to create a GridResource object.
        long seed = 11L*13*17*19*23+1;
        double peakLoad = 0.0;        // the resource load during peak hour
        double offPeakLoad = 0.0;     // the resource load during off-peak hr
        double holidayLoad = 0.0;     // the resource load during holiday

        // incorporates weekends so the grid resource is on 7 days a week
        LinkedList Weekends = new LinkedList();
        Weekends.add(new Integer(Calendar.SATURDAY));
        Weekends.add(new Integer(Calendar.SUNDAY));

        // incorporates holidays. However, no holidays are set in this example
        LinkedList Holidays = new LinkedList();
        GridResourceWithFailure gridRes = null;
        try
        {
            // creates a GridResource with a link
            gridRes = new GridResourceWithFailure(name,
                new SimpleLink(name + "_link", baud_rate, delay, MTU),
                seed, resConfig, peakLoad, offPeakLoad, holidayLoad,
                Weekends, Holidays);
        }
        catch (Exception e) {
            e.printStackTrace();
        }

        return gridRes;
    }

} // end class