#include <single_timer_executor.h>

Inheritance diagram for SingleTimerExecutor:

Collaboration diagram for SingleTimerExecutor:

[legend]

Public Member Functions
	SingleTimerExecutor ()

void	schedule (const char msg, scheduling_s scheduling, efitick_t timeNt, action_s const &action) override
	Schedule an action to be executed in the future.

void	cancel (scheduling_s *scheduling) override
	Cancel the specified scheduling_s so that, if currently scheduled, it does not execute.

void	onTimerCallback ()

Data Fields
int	timerCallbackCounter = 0

int	scheduleCounter = 0

int	maxExecuteCounter = 0

int	executeCounter

int	executeAllPendingActionsInvocationCounter = 0

Private Member Functions
void	executeAllPendingActions ()

void	scheduleTimerCallback ()

Private Attributes
EventQueue	queue

bool	reentrantFlag = false

Detailed Description

Definition at line 13 of file single_timer_executor.h.

Constructor & Destructor Documentation

◆ SingleTimerExecutor()

SingleTimerExecutor::SingleTimerExecutor ( )

Definition at line 42 of file single_timer_executor.cpp.

    : queue(US2NT(8))
{
}

Member Function Documentation

◆ cancel()

void SingleTimerExecutor::cancel ( scheduling_s * scheduling )

overridevirtual

Cancel the specified scheduling_s so that, if currently scheduled, it does not execute.

Parameters

scheduling The scheduling_s to cancel.

Implements Scheduler.

Definition at line 76 of file single_timer_executor.cpp.

                                                         {
    // Lock for queue removal - we may already be locked, but that's ok
    chibios_rt::CriticalSectionLocker csl;
 
    queue.remove(scheduling);
}

Referenced by TriggerScheduler::scheduleEventsUntilNextTriggerTooth().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ executeAllPendingActions()

void SingleTimerExecutor::executeAllPendingActions ( )

private

Let's execute actions we should execute at this point. reentrantFlag takes care of the use case where the actions we are executing are scheduling further invocations

in real life it could be that while we executing listeners time passes and it's already time to execute next listeners. TODO: add a counter & figure out a limit of iterations?

Definition at line 95 of file single_timer_executor.cpp.

                                                   {
    ScopePerf perf(PE::SingleTimerExecutorDoExecute);
 
    executeAllPendingActionsInvocationCounter++;
    /**
     * Let's execute actions we should execute at this point.
     * reentrantFlag takes care of the use case where the actions we are executing are scheduling
     * further invocations
     */
    reentrantFlag = true;
 
    /**
     * in real life it could be that while we executing listeners time passes and it's already time to execute
     * next listeners.
     * TODO: add a counter & figure out a limit of iterations?
     */
 
    // starts at -1 because do..while will run a minimum of once
    executeCounter = -1;
 
    bool didExecute;
    do {
        efitick_t nowNt = getTimeNowNt();
        didExecute = queue.executeOne(nowNt);
 
        // if we're stuck in a loop executing lots of events, panic!
        if (executeCounter++ == 500) {
            firmwareError(ObdCode::CUSTOM_ERR_LOCK_ISSUE, "Maximum scheduling run length exceeded - CPU load too high");
        }
 
    } while (didExecute);
 
    maxExecuteCounter = maxI(maxExecuteCounter, executeCounter);
 
    if (!isLocked()) {
        firmwareError(ObdCode::CUSTOM_ERR_LOCK_ISSUE, "Someone has stolen my lock");
        return;
    }
    reentrantFlag = false;
}

Referenced by onTimerCallback(), and schedule().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ onTimerCallback()

void SingleTimerExecutor::onTimerCallback ( )

Definition at line 83 of file single_timer_executor.cpp.

                                          {
    timerCallbackCounter++;
 
    chibios_rt::CriticalSectionLocker csl;
 
    executeAllPendingActions();
    scheduleTimerCallback();
}

Referenced by globalTimerCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ schedule()

void SingleTimerExecutor::schedule	(	const char *	msg,
		scheduling_s *	scheduling,
		efitick_t	targetTime,
		action_s const &	action
	)

overridevirtual

Schedule an action to be executed in the future.

scheduleByAngle is useful if you want to schedule something in terms of crank angle instead of time.

Parameters

msg	Name of this event to use for logging in case of an error.
scheduling	Storage to use for the scheduled event. If null, one will be used from the pool.
targetTime	When to execute the specified action. If this time is in the past or very near future, it may execute immediately.
action	An action to execute at the specified time.

Implements Scheduler.

Definition at line 48 of file single_timer_executor.cpp.

                                                                                                                  {
    ScopePerf perf(PE::SingleTimerExecutorScheduleByTimestamp);
 
#if EFI_ENABLE_ASSERTS
    efidur_t deltaTimeNt = nt - getTimeNowNt();
 
    if (deltaTimeNt >= TOO_FAR_INTO_FUTURE_NT) {
        // we are trying to set callback for too far into the future. This does not look right at all
        int32_t intDeltaTimeNt = (int32_t)deltaTimeNt;
        firmwareError(ObdCode::RUNTIME_CRITICAL_TASK_TIMER_OVERFLOW, "schedule() too far: %ld %s", intDeltaTimeNt, msg);
        return;
    }
#endif
 
    scheduleCounter++;
 
    // Lock for queue insertion - we may already be locked, but that's ok
    chibios_rt::CriticalSectionLocker csl;
 
    bool needToResetTimer = queue.insertTask(scheduling, nt, action);
    if (!reentrantFlag) {
        executeAllPendingActions();
        if (needToResetTimer) {
            scheduleTimerCallback();
        }
    }
}

Referenced by fireSparkAndPrepareNextSchedule(), runBench(), scheduleByAngle(), scheduleSparkEvent(), triggerScopeGetBuffer(), validateHardwareTimer(), and watchDogBuddyCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ scheduleTimerCallback()

void SingleTimerExecutor::scheduleTimerCallback ( )

private

This method is always invoked under a lock

Let's grab fresh time value

Definition at line 139 of file single_timer_executor.cpp.

                                                {
    ScopePerf perf(PE::SingleTimerExecutorScheduleTimerCallback);
 
    /**
     * Let's grab fresh time value
     */
    efitick_t nowNt = getTimeNowNt();
    expected<efitick_t> nextEventTimeNt = queue.getNextEventTime(nowNt);
 
    if (!nextEventTimeNt) {
        return; // no pending events in the queue
    }
 
    efiAssertVoid(ObdCode::CUSTOM_ERR_6625, nextEventTimeNt.Value > nowNt, "setTimer constraint");
 
    setHardwareSchedulerTimer(nowNt, nextEventTimeNt.Value);
}