MetricsTimeVaryingRate.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:6k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.metrics.util;
  19. import org.apache.hadoop.metrics.MetricsRecord;
  20. import org.apache.hadoop.util.StringUtils;
  21. import org.apache.commons.logging.Log;
  22. import org.apache.commons.logging.LogFactory;
  23. /**
  24.  * The MetricsTimeVaryingRate class is for a rate based metric that
  25.  * naturally varies over time (e.g. time taken to create a file).
  26.  * The rate is averaged at each interval heart beat (the interval
  27.  * is set in the metrics config file).
  28.  * This class also keeps track of the min and max rates along with 
  29.  * a method to reset the min-max.
  30.  *
  31.  */
  32. public class MetricsTimeVaryingRate extends MetricsBase {
  33.   private static final Log LOG =
  34.     LogFactory.getLog("org.apache.hadoop.metrics.util");
  35.   static class Metrics {
  36.     int numOperations = 0;
  37.     long time = 0;  // total time or average time
  38.     void set(final Metrics resetTo) {
  39.       numOperations = resetTo.numOperations;
  40.       time = resetTo.time;
  41.     }
  42.     
  43.     void reset() {
  44.       numOperations = 0;
  45.       time = 0;
  46.     }
  47.   }
  48.   
  49.   static class MinMax {
  50.     long minTime = -1;
  51.     long maxTime = 0;
  52.     
  53.     void set(final MinMax newVal) {
  54.       minTime = newVal.minTime;
  55.       maxTime = newVal.maxTime;
  56.     }
  57.     
  58.     void reset() {
  59.       minTime = -1;
  60.       maxTime = 0;
  61.     }
  62.     void update(final long time) { // update min max
  63.       minTime = (minTime == -1) ? time : Math.min(minTime, time);
  64.       minTime = Math.min(minTime, time);
  65.       maxTime = Math.max(maxTime, time);
  66.     }
  67.   }
  68.   private Metrics currentData;
  69.   private Metrics previousIntervalData;
  70.   private MinMax minMax;
  71.   
  72.   
  73.   /**
  74.    * Constructor - create a new metric
  75.    * @param nam the name of the metrics to be used to publish the metric
  76.    * @param registry - where the metrics object will be registered
  77.    */
  78.   public MetricsTimeVaryingRate(final String nam, final MetricsRegistry registry, final String description) {
  79.     super(nam, description);
  80.     currentData = new Metrics();
  81.     previousIntervalData = new Metrics();
  82.     minMax = new MinMax();
  83.     registry.add(nam, this);
  84.   }
  85.   
  86.   /**
  87.    * Constructor - create a new metric
  88.    * @param nam the name of the metrics to be used to publish the metric
  89.    * @param registry - where the metrics object will be registered
  90.    * A description of {@link #NO_DESCRIPTION} is used
  91.    */
  92.   public MetricsTimeVaryingRate(final String nam, MetricsRegistry registry) {
  93.     this(nam, registry, NO_DESCRIPTION);
  94.   }
  95.   
  96.   
  97.   /**
  98.    * Increment the metrics for numOps operations
  99.    * @param numOps - number of operations
  100.    * @param time - time for numOps operations
  101.    */
  102.   public synchronized void inc(final int numOps, final long time) {
  103.     currentData.numOperations += numOps;
  104.     currentData.time += time;
  105.     long timePerOps = time/numOps;
  106.     minMax.update(timePerOps);
  107.   }
  108.   
  109.   /**
  110.    * Increment the metrics for one operation
  111.    * @param time for one operation
  112.    */
  113.   public synchronized void inc(final long time) {
  114.     currentData.numOperations++;
  115.     currentData.time += time;
  116.     minMax.update(time);
  117.   }
  118.   
  119.   
  120.   private synchronized void intervalHeartBeat() {
  121.      previousIntervalData.numOperations = currentData.numOperations;
  122.      previousIntervalData.time = (currentData.numOperations == 0) ?
  123.                              0 : currentData.time / currentData.numOperations;
  124.      currentData.reset();
  125.   }
  126.   
  127.   /**
  128.    * Push the delta  metrics to the mr.
  129.    * The delta is since the last push/interval.
  130.    * 
  131.    * Note this does NOT push to JMX
  132.    * (JMX gets the info via {@link #getPreviousIntervalAverageTime()} and
  133.    * {@link #getPreviousIntervalNumOps()}
  134.    *
  135.    * @param mr
  136.    */
  137.   public synchronized void pushMetric(final MetricsRecord mr) {
  138.     intervalHeartBeat();
  139.     try {
  140.       mr.incrMetric(getName() + "_num_ops", getPreviousIntervalNumOps());
  141.       mr.setMetric(getName() + "_avg_time", getPreviousIntervalAverageTime());
  142.     } catch (Exception e) {
  143.       LOG.info("pushMetric failed for " + getName() + "n" +
  144.           StringUtils.stringifyException(e));
  145.     }
  146.   }
  147.   
  148.   /**
  149.    * The number of operations in the previous interval
  150.    * @return - ops in prev interval
  151.    */
  152.   public synchronized int getPreviousIntervalNumOps() { 
  153.     return previousIntervalData.numOperations;
  154.   }
  155.   
  156.   /**
  157.    * The average rate of an operation in the previous interval
  158.    * @return - the average rate.
  159.    */
  160.   public synchronized long getPreviousIntervalAverageTime() {
  161.     return previousIntervalData.time;
  162.   } 
  163.   
  164.   /**
  165.    * The min time for a single operation since the last reset
  166.    *  {@link #resetMinMax()}
  167.    * @return min time for an operation
  168.    */
  169.   public synchronized long getMinTime() {
  170.     return  minMax.minTime;
  171.   }
  172.   
  173.   /**
  174.    * The max time for a single operation since the last reset
  175.    *  {@link #resetMinMax()}
  176.    * @return max time for an operation
  177.    */
  178.   public synchronized long getMaxTime() {
  179.     return minMax.maxTime;
  180.   }
  181.   
  182.   /**
  183.    * Reset the min max values
  184.    */
  185.   public synchronized void resetMinMax() {
  186.     minMax.reset();
  187.   }
  188. }