/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.cassandra.metrics;


import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

import static java.lang.Math.exp;
import com.codahale.metrics.Clock;

A meter metric which measures mean throughput as well as fifteen-minute and two-hour
exponentially-weighted moving average throughputs.
This is based heavily on the Meter and EWMA classes from codahale/yammer metrics.
See Also:
EMA/**
 * A meter metric which measures mean throughput as well as fifteen-minute and two-hour
 * exponentially-weighted moving average throughputs.
 *
 * This is based heavily on the Meter and EWMA classes from codahale/yammer metrics.
 *
 * @see <a href="http://en.wikipedia.org/wiki/Moving_average#Exponential_moving_average">EMA</a>
 */
public class RestorableMeter
{
    private static final long TICK_INTERVAL = TimeUnit.SECONDS.toNanos(5);
    private static final double NANOS_PER_SECOND = TimeUnit.SECONDS.toNanos(1);

    private final RestorableEWMA m15Rate;
    private final RestorableEWMA m120Rate;

    private final AtomicLong count = new AtomicLong();
    private final long startTime;
    private final AtomicLong lastTick;
    private final Clock clock = Clock.defaultClock();

    
Creates a new, uninitialized RestorableMeter.
/**
     * Creates a new, uninitialized RestorableMeter.
     */
    public RestorableMeter()
    {
        this.m15Rate = new RestorableEWMA(TimeUnit.MINUTES.toSeconds(15));
        this.m120Rate = new RestorableEWMA(TimeUnit.MINUTES.toSeconds(120));
        this.startTime = this.clock.getTick();
        this.lastTick = new AtomicLong(startTime);
    }

    
Restores a RestorableMeter from the last seen 15m and 2h rates.
Params:
lastM15Rate – the last-seen 15m rate, in terms of events per second
lastM120Rate – the last seen 2h rate, in terms of events per second/**
     * Restores a RestorableMeter from the last seen 15m and 2h rates.
     * @param lastM15Rate the last-seen 15m rate, in terms of events per second
     * @param lastM120Rate the last seen 2h rate, in terms of events per second
     */
    public RestorableMeter(double lastM15Rate, double lastM120Rate)
    {
        this.m15Rate = new RestorableEWMA(lastM15Rate, TimeUnit.MINUTES.toSeconds(15));
        this.m120Rate = new RestorableEWMA(lastM120Rate, TimeUnit.MINUTES.toSeconds(120));
        this.startTime = this.clock.getTick();
        this.lastTick = new AtomicLong(startTime);
    }

    
Updates the moving averages as needed.
/**
     * Updates the moving averages as needed.
     */
    private void tickIfNecessary()
    {
        final long oldTick = lastTick.get();
        final long newTick = clock.getTick();
        final long age = newTick - oldTick;
        if (age > TICK_INTERVAL)
        {
            final long newIntervalStartTick = newTick - age % TICK_INTERVAL;
            if (lastTick.compareAndSet(oldTick, newIntervalStartTick))
            {
                final long requiredTicks = age / TICK_INTERVAL;
                for (long i = 0; i < requiredTicks; i++)
                {
                    m15Rate.tick();
                    m120Rate.tick();
                }
            }
        }
    }

    
Mark the occurrence of an event.
/**
     * Mark the occurrence of an event.
     */
    public void mark()
    {
        mark(1);
    }

    
Mark the occurrence of a given number of events.
Params:
n – the number of events/**
     * Mark the occurrence of a given number of events.
     *
     * @param n the number of events
     */
    public void mark(long n)
    {
        tickIfNecessary();
        count.addAndGet(n);
        m15Rate.update(n);
        m120Rate.update(n);
    }

    
Returns the 15-minute rate in terms of events per second.  This carries the previous rate when restored.
/**
     * Returns the 15-minute rate in terms of events per second.  This carries the previous rate when restored.
     */
    public double fifteenMinuteRate()
    {
        tickIfNecessary();
        return m15Rate.rate();
    }

    
Returns the two-hour rate in terms of events per second.  This carries the previous rate when restored.
/**
     * Returns the two-hour rate in terms of events per second.  This carries the previous rate when restored.
     */
    public double twoHourRate()
    {
        tickIfNecessary();
        return m120Rate.rate();
    }

    
The total number of events that have occurred since this object was created.  Note that the previous count
is *not* carried over when a RestorableMeter is restored.
/**
     * The total number of events that have occurred since this object was created.  Note that the previous count
     * is *not* carried over when a RestorableMeter is restored.
     */
    public long count()
    {
        return count.get();
    }

    
Returns the mean rate of events per second since this object was created.  Note that the mean rate
does *not* carry over when a RestorableMeter is restored, so the mean rate is only a measure since
this object was created.
/**
     * Returns the mean rate of events per second since this object was created.  Note that the mean rate
     * does *not* carry over when a RestorableMeter is restored, so the mean rate is only a measure since
     * this object was created.
     */
    public double meanRate()
    {
        if (count() == 0)
        {
            return 0.0;
        } else {
            final long elapsed = (clock.getTick() - startTime);
            return (count() / (double) elapsed) * NANOS_PER_SECOND;
        }
    }

    static class RestorableEWMA
    {
        private volatile boolean initialized = false;
        private volatile double rate = 0.0; // average rate in terms of events per nanosecond

        private final AtomicLong uncounted = new AtomicLong();
        private final double alpha, interval;

        
Create a new, uninitialized EWMA with a given window.
Params:
windowInSeconds – the window of time this EWMA should average over, expressed as a number of seconds/**
         * Create a new, uninitialized EWMA with a given window.
         *
         * @param windowInSeconds the window of time this EWMA should average over, expressed as a number of seconds
         */
        public RestorableEWMA(long windowInSeconds)
        {
            this.alpha = 1 - exp((-TICK_INTERVAL / NANOS_PER_SECOND) / windowInSeconds);
            this.interval = TICK_INTERVAL;
        }

        
Restore an EWMA from a last-seen rate and a given window.
Params:
intervalInSeconds – the window of time this EWMA should average over, expressed as a number of seconds/**
         * Restore an EWMA from a last-seen rate and a given window.
         *
         * @param intervalInSeconds the window of time this EWMA should average over, expressed as a number of seconds
         */
        public RestorableEWMA(double lastRate, long intervalInSeconds)
        {
            this(intervalInSeconds);
            this.rate = lastRate / NANOS_PER_SECOND;
            this.initialized = true;
        }

        
Update the moving average with a new value.
/**
         * Update the moving average with a new value.
         */
        public void update(long n)
        {
            uncounted.addAndGet(n);
        }

        
Mark the passage of time and decay the current rate accordingly.
/**
         * Mark the passage of time and decay the current rate accordingly.
         */
        public void tick()
        {
            final long count = uncounted.getAndSet(0);
            final double instantRate = count / interval;
            if (initialized)
            {
                rate += (alpha * (instantRate - rate));
            }
            else
            {
                rate = instantRate;
                initialized = true;
            }
        }

        
Returns the rate in terms of events per second.
/**
         * Returns the rate in terms of events per second.
         */
        public double rate()
        {
            return rate * NANOS_PER_SECOND;
        }
    }
}