syncedclockscheduler.java

High performance DB query

/*
 * @(#)$Id: SyncedClockScheduler.java,v 1.5 2004/07/02 23:59:22 huebsch Exp $
 *
 * Copyright (c) 2001-2004 Regents of the University of California.
 * All rights reserved.
 *
 * This file is distributed under the terms in the attached BERKELEY-LICENSE
 * file. If you do not find these files, copies can be found by writing to:
 * Computer Science Division, Database Group, Universite of California,
 * 617 Soda Hall #1776, Berkeley, CA 94720-1776. Attention: Berkeley License
 *
 * Copyright (c) 2003-2004 Intel Corporation. All rights reserved.
 *
 * This file is distributed under the terms in the attached INTEL-LICENSE file.
 * If you do not find these files, copies can be found by writing to:
 * Intel Research Berkeley, 2150 Shattuck Avenue, Suite 1300,
 * Berkeley, CA, 94704.  Attention:  Intel License Inquiry.
 */


package simulator.schedulers.clock.synced;

import org.apache.log4j.Logger;
import services.Output;
import simulator.core.Event;
import simulator.core.NodeMap;
import simulator.core.Simulator;
import simulator.core.SimulatorClient;
import simulator.schedulers.clock.ClockClient;
import simulator.schedulers.clock.ClockScheduler;
import util.logging.LogMessage;

/**
 * Class SyncedClockScheduler
 *
 */
public class SyncedClockScheduler implements ClockScheduler, SimulatorClient {

    private static Logger logger = Logger.getLogger(SyncedClockScheduler.class);
    private Simulator theSimulator;
    private NodeMap theNodes;

    /**
     * Constructor SyncedClockScheduler
     *
     * @param theSimulator
     * @param theNodes
     */
    public SyncedClockScheduler(Simulator theSimulator, NodeMap theNodes) {
        this.theSimulator = theSimulator;
        this.theNodes = theNodes;
    }

    /**
     * Method scheduleEvent
     *
     * @param relativeTime
     * @param data
     * @param client
     * @param tracked
     * @return
     */
    protected SyncedClockEvent scheduleEvent(double relativeTime, Object data,
                                             ClockClient client,
                                             boolean tracked) {
        SyncedClockEvent event = SyncedClockEvent.allocate(this,
                                     getCurrentTime(),
                                     getCurrentTime() + relativeTime,
                                     theSimulator.getCurrentNodeNum(), client,
                                     tracked, data);

        theSimulator.schedule(event);

        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[]{"Adding event ", event}));
        }

        return event;
    }

    /**
     * Method descheduleEvent
     *
     * @param event
     */
    protected void descheduleEvent(SyncedClockEvent event) {
        theSimulator.deschedule(event);

        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[]{"Removing event ",
                                                     event}));
        }
    }

    /**
     * Method getCurrentTime
     * @return
     */
    protected double getCurrentTime() {
        return theSimulator.getCurrentTime();
    }

    /**
     * Method handleEvent
     *
     * @param theEvent
     */
    public void handleEvent(Event theEvent) {
        SyncedClockEvent theSCEvent = (SyncedClockEvent) theEvent;
        SyncedClockStub handler = (SyncedClockStub) theNodes.getNode(
                                      theSCEvent.getNodeNum()).getClockStub();

        handler.handleEvent(theSCEvent);

        if (Output.debuggingEnabled) {
            logger.debug(new LogMessage(new Object[]{"Processing event ",
                                                     theSCEvent}));
        }

        SyncedClockEvent.free(theSCEvent);
    }
}