wrappedinputlog.java

fortran并行计算包

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

/*
 *  @author  Anthony Chan
 */

package logformat.slog2.update;

import java.util.Map;
import java.util.HashMap;
import java.awt.Color;

import old_logformat.slog2.pipe.PipedInputLog;

import base.io.MixedDataIO;
import base.drawable.InfoType;
import base.drawable.Method;
import base.drawable.ColorAlpha;
import base.drawable.Kind;
import base.drawable.Topology;
import base.drawable.Category;
import base.drawable.Drawable;
import base.drawable.Primitive;
import base.drawable.Composite;
import base.drawable.YCoordMap;
import base.drawable.InputAPI;
import logformat.slog2.LineIDMap;

/*
   Since old_logformat.slog2.pipe.PipedInputLog has already extended from 
   old_base.drawable.InputAPI which is similar to base.drawable.InputAPI.
   If this class extends old_logformat.slog2.pipe.PipedInputLog and implements
   base.drawable.InputAPI, this class essentially extends both
   base.drawable.InputAPI and old_base.drawable.InputAPI which are conflicting
   to each other, e.g. getNextKind() is returning both old_base.drawable.Kind
   as well as base.drawable.Kind.  Since old_base.drawable.InputAPI is
   being implemented first in the class hierarchy, old_base.drawable.InputAPI
   will be the one found when compiling this class.  The causes compilation
   failure.
   
   public class WrappedInputLog extends PipedInputLog
                                implements InputAPI
*/

public class WrappedInputLog implements InputAPI
{
    private int                   MEM_PIPE_RESIZE_MAX  = 10;
    private int                   KILOBYTES            = 1024;

    private PipedInputLog         old_dobj_ins;

    // The following map could be made static ?
    private Map                   kind_map;
    private Map                   topo_map;

    private MemoryPipedStream     mem_pipe;
    private int                   mem_pipe_resize_count;

    /*
       updateObject()'s mem_pipe receives old_obj as input and
       spits new_obj as output.  Since the mechanism relies on MixedDataIO
       interface, the output new_obj will be corrected as long as
       the beginning portion of the memory layout done by the writeObject()
       matches that done by the readObject().
    */
    private void updateObject( final old_base.io.MixedDataIO  old_obj,
                                     MixedDataIO              new_obj )
    {
        mem_pipe.reset();
        try {
            old_obj.writeObject( mem_pipe.output );
            new_obj.readObject( mem_pipe.input );
        } catch ( java.io.EOFException eoferr ) {
            if ( mem_pipe_resize_count < MEM_PIPE_RESIZE_MAX ) {
                mem_pipe.resizeBuffer( mem_pipe.getBufferSize() * 2 );
                mem_pipe_resize_count++;
                updateObject( old_obj, new_obj );
            }
            else {
                System.err.println( "WrappedInputLog.updateObject(): "
                                  + "Resizing of memory pipe has exceeded "
                                  + MEM_PIPE_RESIZE_MAX + " times. "
                                  + "The memory pipe's buffer size is "
                                  + mem_pipe.getBufferSize() + " bytes." );
                eoferr.printStackTrace();
                System.exit( 1 );
            }
        } catch ( java.io.IOException ioerr ) {
            System.err.println( "WrappedInputLog.updateObject(): "
                              + "Composite conversion fails! " );
            ioerr.printStackTrace();
            System.exit( 1 );
        }
    }

    public WrappedInputLog( String pathname )
    {
        old_dobj_ins  = new PipedInputLog( pathname );
        /*
           Using Map to convert old to new is slow,
           but avoid exposing the internal of the classes.
        */
        kind_map      = new HashMap();
        kind_map.put( old_base.drawable.Kind.TOPOLOGY,  Kind.TOPOLOGY );
        kind_map.put( old_base.drawable.Kind.EOF,       Kind.EOF );
        kind_map.put( old_base.drawable.Kind.PRIMITIVE, Kind.PRIMITIVE );
        kind_map.put( old_base.drawable.Kind.COMPOSITE, Kind.COMPOSITE );
        kind_map.put( old_base.drawable.Kind.CATEGORY,  Kind.CATEGORY );
        kind_map.put( old_base.drawable.Kind.YCOORDMAP, Kind.YCOORDMAP );

        topo_map      = new HashMap();
        topo_map.put( old_base.drawable.Topology.EVENT, Topology.EVENT );
        topo_map.put( old_base.drawable.Topology.STATE, Topology.STATE );
        topo_map.put( old_base.drawable.Topology.ARROW, Topology.ARROW );
    }

    public boolean isSLOG2()
    { return old_dobj_ins.isSLOG2(); }

    public String getCompatibleHeader()
    { return old_dobj_ins.getCompatibleHeader(); }

    public static void stdoutConfirmation()
    { PipedInputLog.stdoutConfirmation(); }

    public int getTreeLeafByteSize()
    { return old_dobj_ins.getTreeLeafByteSize(); }

    public short getNumChildrenPerNode()
    { return old_dobj_ins.getNumChildrenPerNode(); }

    public void initialize()
    {
        int  buf_size;

        old_dobj_ins.initialize();
        // Make sure the byte[] won't be too small.
        buf_size = Math.max( old_dobj_ins.getTreeLeafByteSize(), KILOBYTES );
        mem_pipe = new MemoryPipedStream( buf_size );
        mem_pipe_resize_count = 0;
    }

    public Kind peekNextKind()
    {
        return (Kind) kind_map.get( old_dobj_ins.peekNextKind() );
    }

    public Topology getNextTopology()
    {
        return (Topology) topo_map.get( old_dobj_ins.getNextTopology() );
    }

    public Category getNextCategory()
    {
        old_base.drawable.Category    old_type;
        Category                      new_type;

        old_type  = old_dobj_ins.getNextCategory();
        new_type  = new Category();
        updateObject( old_type, new_type );

        return new_type;
    }

    public YCoordMap getNextYCoordMap()
    {
        old_base.drawable.YCoordMap   old_ymap;
        YCoordMap                     new_ymap;
        old_logformat.slog2.LineIDMap old_lidmap;
        LineIDMap                     new_lidmap;

        old_ymap   = old_dobj_ins.getNextYCoordMap();
        old_lidmap = new old_logformat.slog2.LineIDMap( old_ymap );
        new_lidmap = new LineIDMap();
        updateObject( old_lidmap, new_lidmap );
        new_ymap   = new_lidmap.toYCoordMap();

        return new_ymap;
    }

    public Primitive getNextPrimitive()
    {
        old_base.drawable.Primitive  old_prime;
        Primitive                    new_prime;

        old_prime  = old_dobj_ins.getNextPrimitive();
        new_prime  = new Primitive();
        updateObject( old_prime, new_prime );

        return new_prime;
    }

    public Composite getNextComposite()
    {
        old_base.drawable.Composite  old_cmplx;
        Composite                    new_cmplx;

        old_cmplx  = old_dobj_ins.getNextComposite();
        new_cmplx  = new Composite();
        updateObject( old_cmplx, new_cmplx );

        return new_cmplx;
    }

    public void close()
    {
        old_dobj_ins.close();
        try {
            mem_pipe.close();
        } catch ( java.io.IOException ioerr ) {
            System.err.println( "WrappedInputLog.close(): "
                              + "Memory pipe fails to close() " );
            ioerr.printStackTrace();
            System.exit( 1 );
        }
    }
}