Skip to content

unit AlarmMgr

em.utils/AlarmMgr.em
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
package em.utils

from em.hal import WakeupTimerI

import EpochTime
import FiberMgr

module AlarmMgr
            #   ^|
    proxy WakeupTimer: WakeupTimerI
            #   ^|
    type Alarm: opaque
            #   ^|        
        host function initH(fiber: FiberMgr.Fiber&)
            #   ^|        
        function active(): bool
            #   ^|        
        function cancel()
            #   ^|        
        function wakeup(secs256: uint32)
            #   ^|        
        function wakeupAt(secs256: uint32)
            #   ^|        
    end

    host function createH(fiber: FiberMgr.Fiber&): Alarm&
            #   ^|
private:

    def opaque Alarm
        fiber: FiberMgr.Fiber&
        thresh: uint32
        ticks: uint32
        function id(): uint8
        function setup(ticks: uint32)
    end

    function update(deltaTicks: uint32)
    function wakeupHandler: WakeupTimer.Handler

    var alarmTab: Alarm[..]
    var curAlarm: Alarm&

end

def createH(fiber)
    var alarm: Alarm& = alarmTab[alarmTab.length++]
    alarm.initH(fiber)
    return alarm
end

def update(deltaTicks)
    auto thresh = deltaTicks ? curAlarm.thresh : 0
    WakeupTimer.disable()
    auto nxtAlarm = <Alarm&>null
    var maxTicks: uint32 = ~0       # largest uint32
    for a in alarmTab
        continue if a.ticks == 0    # inactive alarm
        a.ticks -= deltaTicks
        if a.thresh <= thresh        # expired alarm
            %%[a]
            a.fiber.post()
        elif a.ticks < maxTicks
            nxtAlarm = a
            maxTicks = a.ticks         
        end
    end
    return if nxtAlarm == null      # no active alarms
    curAlarm = nxtAlarm
    WakeupTimer.enable(curAlarm.thresh, wakeupHandler)
end

def wakeupHandler()
    update(curAlarm.ticks)
end

def Alarm.initH(fiber)
    this.fiber = fiber
    this.ticks = 0
end

def Alarm.active()
    return this.ticks != 0
end

def Alarm.cancel()
    this.ticks = 0
    update(0)
end

def Alarm.id()
    return <uint8>(this - &alarmTab[0])
end

def Alarm.setup(ticks)
#    %%[>ticks]
#    %%[a+]
    this.thresh = WakeupTimer.ticksToThresh(ticks)
#    %%[a-]
#    %%[>this.id()]
#    %%[>this.thresh]
    this.ticks = ticks
    update(0)
end

def Alarm.wakeup(secs256)
    auto ticks = WakeupTimer.secs256ToTicks(secs256)
    this.setup(ticks)
end

def Alarm.wakeupAt(secs256)
    var etSubs: uint32
    auto etSecs = EpochTime.getCurrent(&etSubs)
    auto etTicks = WakeupTimer.timeToTicks(etSecs, etSubs)
    auto ticks = WakeupTimer.secs256ToTicks(secs256)
#    %%[a:this.id()]
#    %%[>etSecs]
#    %%[>etSubs]
#    %%[>etTicks]
#    %%[>ticks]
    this.setup(ticks - (etTicks % ticks))
end