@Override public void tick(TimeLapse timeLapse) { if (clock.getClockMode() == ClockMode.REAL_TIME) { rtCounter++; } else { stCounter++; } }
RealtimeClockLogger(RealtimeClockController c) { log = new ArrayList<>(); clock = c; clock.getEventAPI().addListener(new Listener() { @Override public void handleEvent(Event e) { log.add(LogEntry.create(clock.getCurrentTime(), clock.getCurrentTime() + clock.getTickLength(), clock.getClockMode(), e.getEventType())); } }, SWITCH_TO_REAL_TIME, SWITCH_TO_SIM_TIME, STARTED, STOPPED); }
void checkRealtime() { if (clock != null) { checkState(clock.getClockMode() == ClockMode.REAL_TIME, "Clock must be in real-time mode, but is in %s mode.", clock.getClockMode()); // make sure we stay in rt LOGGER.debug("Check real time -> stay in real time."); clock.switchToRealTime(); } }
@Override public boolean register(Parcel element) { verify(clock.getClockMode() == ClockMode.REAL_TIME, "Problem detected at %s when registering %s, clock mode is %s.", clock.getCurrentTime(), element, clock.getClockMode()); problemHasChanged = true; return true; }
@Override public void handleEvent(Event e) { log.add(LogEntry.create(clock.getCurrentTime(), clock.getCurrentTime() + clock.getTickLength(), clock.getClockMode(), e.getEventType())); } }, SWITCH_TO_REAL_TIME, SWITCH_TO_SIM_TIME, STARTED, STOPPED);
if (!isComputing && clock.isTicking() && clock.getClockMode() == ClockMode.REAL_TIME) { if (prevComputing) { LOGGER.trace( LOGGER.debug( "not computing for two ticks -> request to switch to sim time"); clock.switchToSimulatedTime();
@Override public void handleEvent(Event e) { manager.checkExceptions(); LOGGER.debug("new parcel -> switch to real time"); clock.switchToRealTime(); } }, PDPModelEventType.NEW_PARCEL);
@Override public void tick(TimeLapse timeLapse) { if (timeLapse.getStartTime() == 200) { clock.switchToSimulatedTime(); } else if (timeLapse.getStartTime() == 600) { clock.switchToRealTime(); } }
verify(clock, times(0)).switchToRealTime(); verify(clock, times(0)).switchToSimulatedTime(); when(clock.isTicking()).thenReturn(true); verify(clock, times(1)).switchToRealTime(); solvers.get(0).getEventAPI().addListener(eventHistory, EventType.NEW_SCHEDULE); solvers.get(1).solve(SolveArgs.create()); verify(clock, times(2)).switchToRealTime(); assertThat(eventHistory.getHistory()).isEmpty(); verify(clock, times(2)).switchToRealTime(); verify(clock, times(0)).switchToSimulatedTime(); verify(clock, times(0)).switchToSimulatedTime(); model.manager.checkExceptions(); model.afterTick(TimeLapseFactory.ms(100, 200)); verify(clock, times(3)).switchToRealTime(); verify(clock, times(0)).switchToSimulatedTime(); verify(clock, times(3)).switchToRealTime(); verify(clock, times(1)).switchToSimulatedTime();
void doHandleEvent(Event e) { synchronized (computingSimSolvers) { final boolean isComputingBefore = isComputing(); LOGGER.trace("receive: {}, computing: {}, clock is ticking: {}, {}", e, isComputingBefore, clock.isTicking(), computingSimSolvers); if (e.getEventType() == EventType.START_COMPUTING) { if (!isComputingBefore) { LOGGER.debug("start computing -> switch to real time"); clock.switchToRealTime(); } computingSimSolvers.add((RtSimSolverSchedulerBridge) e.getIssuer()); } else if (e.getEventType() == EventType.DONE_COMPUTING) { // done computing checkState(computingSimSolvers.remove(e.getIssuer())); // if (!isComputing()) { // stop(); // } } else { throw new IllegalArgumentException("Unexpected event: " + e); } } }
@Override public void handleEvent(Event e) { log.add(logEntry(clock.getCurrentTime(), e.getEventType())); } }, RtClockEventType.values());
clock.switchToRealTime();
/** * Sets up a fake dependency provider and a working model instance. */ @Before public void setUp() { clock = spy((RealtimeClockController) TimeModel.builder() .withRealTime() .build(FakeDependencyProvider.empty())); doNothing().when(clock).switchToRealTime(); doNothing().when(clock).switchToSimulatedTime(); final RoadModelSnapshot planeSnapshot = RoadModelSnapshotTestUtil.createPlaneRoadModelSnapshot(new Point(0, 0), new Point(10, 10), SI.KILOMETER); final PDPRoadModel rm = mock(PDPRoadModel.class); when(rm.getSpeedUnit()).thenReturn(NonSI.KILOMETERS_PER_HOUR); when(rm.getDistanceUnit()).thenReturn(SI.KILOMETER); when(rm.getSnapshot()).thenReturn(planeSnapshot); dependencyProvider = FakeDependencyProvider.builder() .add(clock, RealtimeClockController.class) .add(rm, PDPRoadModel.class) .add(DefaultPDPModel.builder()) .build(); model = RtSolverModel.builder().build(dependencyProvider); ((TimeModel) clock).register(model); assertThat(model.mode).isEqualTo(Mode.UNKNOWN); TestUtil.testEnum(Mode.class); TestUtil.testEnum(RtSimSolver.EventType.class); }
void realtimeCheck() { checkState(clock.getClockMode() == ClockMode.REAL_TIME, "Clock must be in real-time mode before calling this method, but it " + "is in %s mode.", clock.getClockMode()); }
private void dispatchEvents(TimeLapse timeLapse) { TimedEvent e = null; while ((e = scenarioQueue.peek()) != null && e.getTime() <= timeLapse.getTime()) { scenarioQueue.poll(); if (status == null) { LOGGER.info("scenario started at virtual time:" + timeLapse.getTime()); status = EventType.SCENARIO_STARTED; disp.dispatchEvent(new Event(status, this)); } dispatch(e); } if ((e = scenarioQueue.peek()) != null && e.getTime() <= timeLapse.getTime() + timeLapse.getTickLength() && clock instanceof RealtimeClockController) { LOGGER.trace("Found an event in next tick, switch to RT"); ((RealtimeClockController) clock).switchToRealTime(); } if (e == null && status != EventType.SCENARIO_FINISHED) { status = EventType.SCENARIO_FINISHED; disp.dispatchEvent(new Event(status, this)); } }
RtSolverModel(RealtimeClockController c, PDPRoadModel rm, PDPModel pm, Mode m, int threads, boolean threadGrouping) { clock = c; roadModel = rm; pdpModel = pm; manager = new SimSolversManager(); executor = Optional.absent(); mode = m; threadGroupingEnabled = threadGrouping; threadPoolSize = threads; receivedEvents = Collections.synchronizedList(new ArrayList<Event>()); clock.getEventAPI().addListener(new Listener() { @Override public void handleEvent(Event event) { manager.checkExceptions(); shutdown(); } }, ClockEventType.STOPPED); pdpModel.getEventAPI().addListener(new Listener() { @Override public void handleEvent(Event e) { manager.checkExceptions(); LOGGER.debug("new parcel -> switch to real time"); clock.switchToRealTime(); } }, PDPModelEventType.NEW_PARCEL); initExecutor(); }
@Override public void run() { if (!canvas.isDisposed()) { if (clock.getTickLength() > TIME_FORMATTER_THRESHOLD) { final StringBuilder sb = new StringBuilder(); sb.append(FORMATTER.print(new Period(0, clock.getCurrentTime()))); if (isRealtime) { sb.append(SPACE); sb.append( ((RealtimeClockController) clock).getClockMode().name()); } timeLabel.setText(sb.toString()); } else { timeLabel.setText(Long.toString(clock.getCurrentTime())); } timeLabel.pack(); canvas.redraw(); } } });
private void dispatchEvents(TimeLapse timeLapse) { TimedEvent e = null; while ((e = scenarioQueue.peek()) != null && e.getTime() <= timeLapse.getTime()) { scenarioQueue.poll(); if (status == null) { LOGGER.info("scenario started at virtual time:" + timeLapse.getTime()); status = EventType.SCENARIO_STARTED; disp.dispatchEvent(new Event(status, this)); } dispatch(e); } if ((e = scenarioQueue.peek()) != null && e.getTime() <= timeLapse.getTime() + timeLapse.getTickLength() && clock instanceof RealtimeClockController) { LOGGER.trace("Found an event in next tick, switch to RT"); ((RealtimeClockController) clock).switchToRealTime(); } if (e == null && status != EventType.SCENARIO_FINISHED) { status = EventType.SCENARIO_FINISHED; disp.dispatchEvent(new Event(status, this)); } }
TimeTracker(RealtimeClockController c, boolean debugPrinting) { clock = c; beforeTimeStamps = new ArrayList<>(); afterTimeStamps = new ArrayList<>(); simTimeLapses = new ArrayList<>(); clockModes = new ArrayList<>(); if (debugPrinting) { clock.getEventAPI().addListener(new Listener() { @Override public void handleEvent(Event e) { final List<Double> beforeDurations = interArrivalTimes(beforeTimeStamps); final List<Double> afterDurations = interArrivalTimes(afterTimeStamps); for (int i = 0; i < simTimeLapses.size(); i++) { if (i > 0) { System.out.printf("\t %1.3f \t %1.3f\n", beforeDurations.get(i - 1), afterDurations.get(i - 1)); } System.out.println(simTimeLapses.get(i).lowerEndpoint() + "\t\t\t" + clockModes.get(i)); } } }, ClockEventType.STOPPED); } }
void notifySolverOfChange(TimeLapse timeLapse, boolean sleepAfterNotify) { LOGGER.trace("notifySolverOfChange {} sleepAfterNotify:{}", timeLapse, sleepAfterNotify); verify(clock.getClockMode() == ClockMode.REAL_TIME, "Problem detected at %s.", timeLapse); problemHasChanged = false; solver.solve(SolveArgs.create().useCurrentRoutes(getCurrentRoutes())); if (sleepAfterNotify) { try { Thread.sleep(timeLapse.getTickLength() / 2); } catch (final InterruptedException e) { throw new IllegalStateException(e); } } }