inputlog.java

fortran并行计算包

/*
 *  (C) 2001 by Argonne National Laboratory
 *      See COPYRIGHT in top-level directory.
 */

/*
 *  @author  Anthony Chan
 */

package logformat.clog2TOdrawable;

import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
import java.lang.reflect.*;
import java.io.*;

import base.drawable.*;
import logformat.clog2.*;

public class InputLog extends logformat.clog2.InputLog
                      implements base.drawable.InputAPI
{
    private int                    next_avail_kindID;
    private TopologyIterator       itr_topo;
    private ContentIterator        itr_objdef_dobj;
    private YCoordMapIterator      itr_ycoordmap;
    private boolean                isFirstPeekForCategory;

    public InputLog( String pathname )
    {
        super( pathname );
        itr_topo         = null;
        itr_ycoordmap    = null;
        itr_objdef_dobj  = null;
        this.initialize();
    }

    private void initialize()
    {
        itr_topo = new TopologyIterator( Kind.TOPOLOGY_ID );
        // Initialize boolean variable, isFirstPeekForCategory
        isFirstPeekForCategory = true;
    }

    public Kind peekNextKind()
    {
        switch ( next_avail_kindID ) {
            case Kind.TOPOLOGY_ID :
                if ( itr_topo.hasNext() )
                    return Kind.TOPOLOGY;
                itr_objdef_dobj  = new ContentIterator( Kind.PRIMITIVE_ID );
                    return Kind.CATEGORY;  /* return the Arrow Category */
            case Kind.CATEGORY_ID :
            case Kind.PRIMITIVE_ID :
            case Kind.COMPOSITE_ID :
                if ( itr_objdef_dobj.hasNext() ) {
                    switch ( next_avail_kindID ) {
                        case Kind.CATEGORY_ID:
                            return Kind.CATEGORY;
                        case Kind.PRIMITIVE_ID:
                            return Kind.PRIMITIVE;
                        case Kind.COMPOSITE_ID:
                            return Kind.COMPOSITE;
                    }
                }
                itr_ycoordmap  = new YCoordMapIterator( Kind.YCOORDMAP_ID );
            case Kind.YCOORDMAP_ID :
                if ( itr_ycoordmap.hasNext() )
                    return Kind.YCOORDMAP;
            case Kind.EOF_ID:
                return Kind.EOF;
            default:
                System.err.println( "InputLog.peekNextKind(): Error!\n"
                                  + "\tUnknown Kind ID: " + next_avail_kindID );
                break;
        }
        return null;
    }

    public Topology getNextTopology()
    {
        return (Topology) itr_topo.next();
    }

    // getNextCategory() is called after peekNextKind() returns Kind.CATEGORY
    public Category getNextCategory()
    {
        if ( isFirstPeekForCategory ) {
            isFirstPeekForCategory  = false;
            return itr_objdef_dobj.getArrowCategory();
        }
        else
            return (Category) itr_objdef_dobj.next();
    }

    // getNextYCoordMap() is called after peekNextKind() returns Kind.YCOORDMAP
    public YCoordMap getNextYCoordMap()
    {
        return (YCoordMap) itr_ycoordmap.next();
    }

    // getNextPrimitive() is called after peekNextKind() returns Kind.PRIMITIVE
    public Primitive getNextPrimitive()
    {
        return (Primitive) itr_objdef_dobj.next();
    }

    // getNextComposite() is called after peekNextKind() returns Kind.COMPOSITE
    public Composite getNextComposite()
    {
        return (Composite) itr_objdef_dobj.next();
    }

    public void close()
    {
        super.close();
    }

    public long getNumberOfUnMatchedEvents()
    {
        return itr_objdef_dobj.getNumberOfUnMatchedEvents();
    }

    public long getTotalBytesRead()
    {
        return itr_objdef_dobj.getTotalBytesRead();
    }




    private class TopologyIterator implements Iterator
    {
        private int  num_topology_returned;

        public TopologyIterator( int kindID )
        {
             InputLog.this.next_avail_kindID  = kindID;
             num_topology_returned  = 0;
        }

        public boolean hasNext()
        {
             return num_topology_returned < 3;
        }

        public Object next()
        {
            switch ( num_topology_returned ) {
                case 0:
                    num_topology_returned = 1;
                    return Topology.EVENT;
                case 1:
                    num_topology_returned = 2;
                    return Topology.STATE;
                case 2:
                    num_topology_returned = 3;
                    return Topology.ARROW;
                default:
                    System.err.println( "All Topologies have been returned." );
            }
            return null;
        }

        public void remove() {}
    }


    private class YCoordMapIterator implements Iterator
    {
        private Iterator      ycoordmap_itr;
        private YCoordMap     next_ycoordmap;

        public YCoordMapIterator( int kindID )
        {
            InputLog.this.next_avail_kindID  = kindID;

            List  ycoordmaps;
            ycoordmaps     = InputLog.this.itr_objdef_dobj.getYCoordMapList();
            ycoordmap_itr  = ycoordmaps.iterator();
            if ( ycoordmap_itr.hasNext() )
                next_ycoordmap = (YCoordMap) ycoordmap_itr.next();
            else
                next_ycoordmap = null;
        }

        public boolean hasNext()
        {
            return  next_ycoordmap != null;
        }

        public Object next()
        {
            YCoordMap  loosen_ycoordmap  = next_ycoordmap;
            if ( ycoordmap_itr.hasNext() )
                next_ycoordmap = (YCoordMap) ycoordmap_itr.next();
            else
                next_ycoordmap = null;
            return loosen_ycoordmap;
        }

        public void remove() {}
    }



private class ContentIterator implements Iterator
{
    private MixedDataInputStream   blk_ins;
    private long                   total_bytesize;

    private CommProcThdIDMap       cptIDmap;
    private Map                    evtdefs;
    private List                   topos;
    private ObjDef                 statedef;
    private ObjDef                 arrowdef;
    private ObjDef                 eventdef;
    private ObjDef                 dobjdef;
    private Primitive              drawobj;

    private RecHeader              header  ;
    private RecDefState            staterec;
    private RecDefEvent            eventrec;
    private RecDefConst            constrec;
    private RecBare                bare    ;
    private RecCargo               cargo   ;
    private RecMsg                 msg     ;
    private RecColl                coll    ;
    private RecComm                comm    ;
    private RecSrc                 src     ;
    private RecTshift              tshift  ;

    private Topo_Event             eventform;
    private Topo_Arrow             arrowform;
    private Topo_State             stateform;
    private ObjMethod              obj_fn;
    private Object[]               arglist;

    public ContentIterator( int kindID )
    {
        int max_thread_count = InputLog.super.getPreamble().getMaxThreadCount();
        // Map to hold (CommProcThdID's gthdLineID, CommProcThdID) pairs. 
        cptIDmap  = new CommProcThdIDMap( max_thread_count );
        cptIDmap.initialize();

        InputLog.this.next_avail_kindID  = kindID;

        // Stack event matching object function list, evtdefs.
        evtdefs   = new HashMap();

        // drawable's topology list of objdefs, ie.statedef, arrowdef & eventdef
        topos = new ArrayList();

        ColorNameMap.initMapFromRGBtxt( "jumpshot.colors" );
        ObjDef.setFirstNextCategoryIndex( 0 );

        int def_idx;
        // Create the stack event matching object functions, evtdefs[],
        // for Topo_Arrow
        // Save ObjDef of arrowform to be returned by getNextCategory()
        // Set the labels for arrowdef, hence expect 2 arguments from CLOG
        arrowform = new Topo_Arrow();
        def_idx   = ObjDef.getNextCategoryIndex();
        arrowdef  = new ObjDef( def_idx, new RecDefMsg(), arrowform, 3 );
        arrowdef.setColor( new ColorAlpha( arrowdef.getColor(),
                                           ColorAlpha.OPAQUE ) );
        arrowform.setCategory( arrowdef );
        evtdefs.put( arrowdef.start_evt,
                     arrowform.getStartEventObjMethod() );
        evtdefs.put( arrowdef.final_evt,
                     arrowform.getFinalEventObjMethod() );

        List      defs;
        Iterator  itr;
        // Gather all the known (i.e. MPI's, internal MPE/CLOG's) and
        // user-defined undefined RecDefStates, i.e. CLOG_Rec_StateDef_t.
        defs = InputLog.super.getKnownUndefinedInitedStateDefs();
        defs.addAll( InputLog.super.getUserUndefinedInitedStateDefs() );

        // Convert statedef[] to the appropriate categories
        // and corresponding stack event matching object functions.
        itr = defs.iterator();
        while ( itr.hasNext() ) {
            staterec = ( RecDefState ) itr.next();

            stateform = new Topo_State();
            def_idx   = ObjDef.getNextCategoryIndex();
            statedef  = new ObjDef( def_idx, staterec, stateform, 1 );
            stateform.setCategory( statedef );
            evtdefs.put( statedef.start_evt,
                         stateform.getStartEventObjMethod() );
            evtdefs.put( statedef.final_evt,
                         stateform.getFinalEventObjMethod() );
        }

        // Add all the known and user-defined undefined RecDefEvents,
        // CLOG_Rec_EventDef_t.
        defs = InputLog.super.getKnownUndefinedInitedEventDefs();
        defs.addAll( InputLog.super.getUserUndefinedInitedEventDefs() );

        // Convert eventdef[] to the appropriate categories
        // and corresponding stack event matching object functions.
        itr = defs.iterator();
        while ( itr.hasNext() ) {
            eventrec = ( RecDefEvent ) itr.next();

            eventform = new Topo_Event();
            def_idx   = ObjDef.getNextCategoryIndex();
            eventdef  = new ObjDef( def_idx, eventrec, eventform, 1 );
            eventform.setCategory( eventdef );
            evtdefs.put( eventdef.start_evt,
                         eventform.getEventObjMethod() );
        }