ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [23/53] [abbrv] incubator-ignite git commit: IGNITE-49 Removed interface ClusterMetrics
Date Tue, 27 Jan 2015 16:40:43 GMT
IGNITE-49 Removed interface ClusterMetrics


Project: http://git-wip-us.apache.org/repos/asf/incubator-ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-ignite/commit/7f24d3cc
Tree: http://git-wip-us.apache.org/repos/asf/incubator-ignite/tree/7f24d3cc
Diff: http://git-wip-us.apache.org/repos/asf/incubator-ignite/diff/7f24d3cc

Branch: refs/heads/sprint-1
Commit: 7f24d3cc66e09c967bdc9954dd5a8d1825462349
Parents: f6a7abd
Author: nikolay_tikhonov <ntikhonov@gridgain.com>
Authored: Mon Jan 26 14:03:17 2015 +0300
Committer: nikolay_tikhonov <ntikhonov@gridgain.com>
Committed: Mon Jan 26 14:03:17 2015 +0300

----------------------------------------------------------------------
 .../org/apache/ignite/cluster/ClusterGroup.java |   2 +-
 .../apache/ignite/cluster/ClusterMetrics.java   | 539 -------------------
 .../ignite/cluster/ClusterNodeMetrics.java      |   1 -
 .../ignite/internal/ClusterGroupAdapter.java    |   2 +-
 .../internal/ClusterLocalNodeMetrics.java       |   1 +
 .../ignite/internal/ClusterMetricsImpl.java     | 504 ++++++-----------
 .../internal/ClusterNodeMetricsMxBean.java      | 238 --------
 .../org/apache/ignite/internal/GridKernal.java  |   8 +-
 .../ignite/internal/IgniteClusterAsyncImpl.java |   2 +-
 .../ignite/mbean/ClusterNodeMetricsMxBean.java  | 237 ++++++++
 .../ignite/internal/ClusterMetricsSelfTest.java | 128 +----
 ...idHadoopDefaultMapReducePlannerSelfTest.java |   2 +-
 12 files changed, 411 insertions(+), 1253 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
index 2237d9d..f3d0a08 100644
--- a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
+++ b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterGroup.java
@@ -252,5 +252,5 @@ public interface ClusterGroup {
      * @return Grid projection metrics snapshot.
      * @throws IgniteCheckedException If projection is empty.
      */
-    public ClusterMetrics metrics() throws IgniteCheckedException;
+    public ClusterNodeMetrics metrics() throws IgniteCheckedException;
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/cluster/ClusterMetrics.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterMetrics.java b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterMetrics.java
deleted file mode 100644
index 48a07f8..0000000
--- a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterMetrics.java
+++ /dev/null
@@ -1,539 +0,0 @@
-/*
- * 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.ignite.cluster;
-
-import java.io.*;
-
-/**
- * This interface defines cumulative metrics for the projection. Projection metrics are
- * defined as combined total, min, max, and average measurements from participating nodes'
- * metrics. Projection metrics are obtained by calling {@link ClusterGroup#metrics()}
- * method.
- * <p>
- * Note that these metrics already represent the current snapshot and can change from call
- * to call. If projection is dynamic the metrics snapshot will also change with changes
- * in participating nodes.
- * @see ClusterNodeMetrics
- * @see ClusterGroup#metrics()
- */
-public interface ClusterMetrics extends Serializable {
-    /**
-     * Gets minimum number of active jobs that concurrently run on nodes in the projection.
-     *
-     * @return Minimum number of active jobs.
-     */
-    public int getMinimumActiveJobs();
-
-    /**
-     * Gets maximum number of active jobs that concurrently run on nodes in the projection.
-     *
-     * @return Maximum number of active jobs.
-     */
-    public int getMaximumActiveJobs();
-
-    /**
-     * Gets average number of active jobs that concurrently run nodes in the projection.
-     *
-     * @return Average number of active jobs.
-     */
-    public float getAverageActiveJobs();
-
-    /**
-     * Gets minimum number of cancelled jobs that concurrently run on nodes in the projection.
-     *
-     * @return Minimum number of cancelled jobs.
-     */
-    public int getMinimumCancelledJobs();
-
-    /**
-     * Gets maximum number of cancelled jobs that concurrently run on nodes in the projection.
-     *
-     * @return Maximum number of cancelled jobs.
-     */
-    public int getMaximumCancelledJobs();
-
-    /**
-     * Gets average number of cancelled jobs that concurrently run nodes in the projection.
-     *
-     * @return Average number of cancelled jobs.
-     */
-    public float getAverageCancelledJobs();
-
-    /**
-     * Gets minimum number of rejected jobs that concurrently run on nodes in the projection.
-     *
-     * @return Minimum number of rejected jobs.
-     */
-    public int getMinimumRejectedJobs();
-
-    /**
-     * Gets maximum number of rejected jobs that concurrently run on nodes in the projection.
-     *
-     * @return Maximum number of rejected jobs.
-     */
-    public int getMaximumRejectedJobs();
-
-    /**
-     * Gets average number of rejected jobs that concurrently run nodes in the projection.
-     *
-     * @return Average number of rejected jobs.
-     */
-    public float getAverageRejectedJobs();
-
-    /**
-     * Gets minimum number of waiting jobs that concurrently run on nodes in the projection.
-     *
-     * @return Minimum number of waiting jobs.
-     */
-    public int getMinimumWaitingJobs();
-
-    /**
-     * Gets maximum number of waiting jobs that concurrently run on nodes in the projection.
-     *
-     * @return Maximum number of waiting jobs.
-     */
-    public int getMaximumWaitingJobs();
-
-    /**
-     * Gets average number of waiting jobs that concurrently run nodes in the projection.
-     *
-     * @return Average number of waiting jobs.
-     */
-    public float getAverageWaitingJobs();
-
-    /**
-     * Gets minimum job execution time for nodes in the projection.
-     *
-     * @return Minimum job execution time.
-     */
-    public long getMinimumJobExecuteTime();
-
-    /**
-     * Gets maximum job execution time for nodes in the projection.
-     *
-     * @return Maximum job execution time.
-     */
-    public long getMaximumJobExecuteTime();
-
-    /**
-     * Gets average job execution time for nodes in the projection.
-     *
-     * @return Average job execution time.
-     */
-    public double getAverageJobExecuteTime();
-
-    /**
-     * Gets minimum job wait time for nodes in the projection.
-     *
-     * @return Minimum job wait time.
-     */
-    public long getMinimumJobWaitTime();
-
-    /**
-     * Gets maximum job wait time for nodes in the projection.
-     *
-     * @return Maximum job wait time.
-     */
-    public long getMaximumJobWaitTime();
-
-    /**
-     * Gets average job wait time for nodes in the projection.
-     *
-     * @return Average job wait time.
-     */
-    public double getAverageJobWaitTime();
-
-    /**
-     * Gets minimum number of daemon threads for nodes in the projection.
-     *
-     * @return Minimum daemon thread count.
-     */
-    public int getMinimumDaemonThreadCount();
-
-    /**
-     * Gets maximum number of daemon threads for nodes in the projection.
-     *
-     * @return Maximum daemon thread count.
-     */
-    public int getMaximumDaemonThreadCount();
-
-    /**
-     * Gets average number of daemon threads for nodes in the projection.
-     *
-     * @return Average daemon thread count.
-     */
-    public float getAverageDaemonThreadCount();
-
-    /**
-     * Gets minimum number of threads for nodes in the projection.
-     *
-     * @return Minimum thread count.
-     */
-    public int getMinimumThreadCount();
-
-    /**
-     * Gets maximum number of threads for nodes in the projection.
-     *
-     * @return Maximum thread count.
-     */
-    public int getMaximumThreadCount();
-
-    /**
-     * Gets average number of threads for nodes in the projection.
-     *
-     * @return Average thread count.
-     */
-    public float getAverageThreadCount();
-
-    /**
-     * Gets minimum idle time for nodes in the projection.
-     *
-     * @return Minimum idle time.
-     */
-    public long getMinimumIdleTime();
-
-    /**
-     * Gets maximum idle time for nodes in the projection.
-     *
-     * @return Maximum idle time.
-     */
-    public long getMaximumIdleTime();
-
-    /**
-     * Gets average idle time for nodes in the projection.
-     *
-     * @return Average idle time.
-     */
-    public double getAverageIdleTime();
-
-    /**
-     * Gets percentage of time nodes in this projection are idling vs. executing jobs.
-     *
-     * @return Percentage of time nodes in this projection are idle (value is less than
-     *      or equal to {@code 1} and greater than or equal to {@code 0}).
-     */
-    public float getIdleTimePercentage();
-
-    /**
-     * Gets minimum busy time for nodes in the projection.
-     *
-     * @return Minimum busy time.
-     */
-    public float getMinimumBusyTimePercentage();
-
-    /**
-     * Gets maximum busy time for nodes in the projection.
-     *
-     * @return Maximum busy time.
-     */
-    public float getMaximumBusyTimePercentage();
-
-    /**
-     * Gets average busy time for nodes in the projection.
-     *
-     * @return Average busy time.
-     */
-    public float getAverageBusyTimePercentage();
-
-    /**
-     * Gets minimum CPU load for nodes in the projection.
-     *
-     * @return Minimum CPU load.
-     */
-    public double getMinimumCpuLoad();
-
-    /**
-     * Gets maximum CPU load for nodes in the projection.
-     *
-     * @return Maximum CPU load.
-     */
-    public double getMaximumCpuLoad();
-
-    /**
-     * Gets average CPU load for nodes in the projection.
-     *
-     * @return Average CPU load in <code>[0, 1]</code> range.
-     */
-    public double getAverageCpuLoad();
-
-    /**
-     * Gets minimum amount of committed heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of committed heap memory.
-     */
-    public long getMinimumHeapMemoryCommitted();
-
-    /**
-     * Gets maximum amount of committed heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of committed heap memory.
-     */
-    public long getMaximumHeapMemoryCommitted();
-
-    /**
-     * Gets average amount of committed heap memory for nodes in the projection.
-     *
-     * @return Average amount of committed heap memory.
-     */
-    public double getAverageHeapMemoryCommitted();
-
-    /**
-     * Gets minimum amount of used heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of used heap memory.
-     */
-    public long getMinimumHeapMemoryUsed();
-
-    /**
-     * Gets maximum amount of used heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of used heap memory.
-     */
-    public long getMaximumHeapMemoryUsed();
-
-    /**
-     * Gets average amount of used heap memory for nodes in the projection.
-     *
-     * @return Average amount of used heap memory.
-     */
-    public double getAverageHeapMemoryUsed();
-
-    /**
-     * Gets minimum amount of maximum heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of maximum heap memory.
-     */
-    public long getMinimumHeapMemoryMaximum();
-
-    /**
-     * Gets maximum amount of maximum heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of used heap memory.
-     */
-    public long getMaximumHeapMemoryMaximum();
-
-    /**
-     * Gets minimum amount of maximum heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of maximum heap memory.
-     */
-    public double getAverageHeapMemoryMaximum();
-
-    /**
-     * Gets minimum amount of initialized heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of initialized heap memory.
-     */
-    public long getMinimumHeapMemoryInitialized();
-
-    /**
-     * Gets maximum amount of initialized heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of initialized heap memory.
-     */
-    public long getMaximumHeapMemoryInitialized();
-
-    /**
-     * Gets average amount of initialized heap memory for nodes in the projection.
-     *
-     * @return Average amount of initialized heap memory.
-     */
-    public double getAverageHeapMemoryInitialized();
-
-    /**
-     * Gets minimum amount of committed non-heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of committed non-heap memory.
-     */
-    public long getMinimumNonHeapMemoryCommitted();
-
-    /**
-     * Gets maximum amount of committed non-heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of committed non-heap memory.
-     */
-    public long getMaximumNonHeapMemoryCommitted();
-
-    /**
-     * Gets average amount of committed non-heap memory for nodes in the projection.
-     *
-     * @return Average amount of committed non-heap memory.
-     */
-    public double getAverageNonHeapMemoryCommitted();
-
-    /**
-     * Gets minimum amount of used non-heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of used non-heap memory.
-     */
-    public long getMinimumNonHeapMemoryUsed();
-
-    /**
-     * Gets maximum amount of used non-heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of used non-heap memory.
-     */
-    public long getMaximumNonHeapMemoryUsed();
-
-    /**
-     * Gets average amount of used non-heap memory for nodes in the projection.
-     *
-     * @return Average amount of used non-heap memory.
-     */
-    public double getAverageNonHeapMemoryUsed();
-
-    /**
-     * Gets minimum amount of maximum non-heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of maximum non-heap memory.
-     */
-    public long getMinimumNonHeapMemoryMaximum();
-
-    /**
-     * Gets maximum amount of maximum non-heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of maximum non-heap memory.
-     */
-    public long getMaximumNonHeapMemoryMaximum();
-
-    /**
-     * Gets average amount of maximum non-heap memory for nodes in the projection.
-     *
-     * @return Average amount of maximum non-heap memory.
-     */
-    public double getAverageNonHeapMemoryMaximum();
-
-    /**
-     * Gets minimum amount of initialized non-heap memory for nodes in the projection.
-     *
-     * @return Minimum amount of initialized non-heap memory.
-     */
-    public long getMinimumNonHeapMemoryInitialized();
-
-    /**
-     * Gets maximum amount of initialized non-heap memory for nodes in the projection.
-     *
-     * @return Maximum amount of initialized non-heap memory.
-     */
-    public long getMaximumNonHeapMemoryInitialized();
-
-    /**
-     * Gets average amount of initialized non-heap memory for nodes in the projection.
-     *
-     * @return Average amount of initialized non-heap memory.
-     */
-    public double getAverageNonHeapMemoryInitialized();
-
-    /**
-     * Gets start time of the youngest node in the projection.
-     *
-     * @return Youngest node start time.
-     */
-    public long getYoungestNodeStartTime();
-
-    /**
-     * Gets start time of the oldest node in the projection.
-     *
-     * @return Oldest node start time.
-     */
-    public long getOldestNodeStartTime();
-
-    /**
-     * Gets minimum up time for nodes in the projection.
-     *
-     * @return Minimum up time.
-     */
-    public long getMinimumUpTime();
-
-    /**
-     * Gets maximum up time for nodes in the projection.
-     *
-     * @return Maximum up time.
-     */
-    public long getMaximumUpTime();
-
-    /**
-     * Gets average up time for nodes in the projection.
-     *
-     * @return Average up time.
-     */
-    public double getAverageUpTime();
-
-    /**
-     * Gets minimum number of available processors for nodes in the projection.
-     *
-     * @return Minimum number of available processors.
-     */
-    public int getMinimumCpusPerNode();
-
-    /**
-     * Gets maximum number of available processors for nodes in the projection.
-     *
-     * @return Maximum number of available processors.
-     */
-    public int getMaximumCpusPerNode();
-
-    /**
-     * Gets average number of available processors for nodes in the projection.
-     *
-     * @return Average number of available processors.
-     */
-    public float getAverageCpusPerNode();
-
-    /**
-     * Gets minimum number of nodes per host.
-     *
-     * @return Minimum number of nodes per host.
-     */
-    public int getMinimumNodesPerHost();
-
-    /**
-     * Gets maximum number of nodes per host.
-     *
-     * @return Maximum number of nodes per host.
-     */
-    public int getMaximumNodesPerHost();
-
-    /**
-     * Gets average number of nodes per host.
-     *
-     * @return Average number of nodes per host.
-     */
-    public float getAverageNodesPerHost();
-
-    /**
-     * Gets total number of available processors.
-     *
-     * @return Total number of available processors.
-     */
-    public int getTotalCpus();
-
-    /**
-     * Gets total number of hosts.
-     *
-     * @return Total number of hosts.
-     */
-    public int getTotalHosts();
-
-    /**
-     * Gets total number of nodes.
-     *
-     * @return Total number of nodes.
-     */
-    public int getTotalNodes();
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/cluster/ClusterNodeMetrics.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterNodeMetrics.java b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterNodeMetrics.java
index a9cc70a..e8212a8 100644
--- a/modules/core/src/main/java/org/apache/ignite/cluster/ClusterNodeMetrics.java
+++ b/modules/core/src/main/java/org/apache/ignite/cluster/ClusterNodeMetrics.java
@@ -36,7 +36,6 @@ import java.io.*;
  * any JMX management console. The simplest way is to use standard {@code jconsole}
  * that comes with JDK as it also provides ability to view any node parameter
  * as a graph.
- * @see org.apache.ignite.cluster.ClusterMetrics
  */
 public interface ClusterNodeMetrics extends Serializable {
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/ClusterGroupAdapter.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/ClusterGroupAdapter.java b/modules/core/src/main/java/org/apache/ignite/internal/ClusterGroupAdapter.java
index 36252b5..b733d67 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/ClusterGroupAdapter.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/ClusterGroupAdapter.java
@@ -254,7 +254,7 @@ public class ClusterGroupAdapter implements ClusterGroupEx, Externalizable {
     }
 
     /** {@inheritDoc} */
-    @Override public final ClusterMetrics metrics() throws IgniteCheckedException {
+    @Override public final ClusterNodeMetrics metrics() throws IgniteCheckedException {
         guard();
 
         try {

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/ClusterLocalNodeMetrics.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/ClusterLocalNodeMetrics.java b/modules/core/src/main/java/org/apache/ignite/internal/ClusterLocalNodeMetrics.java
index 470fa23..a3a4628 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/ClusterLocalNodeMetrics.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/ClusterLocalNodeMetrics.java
@@ -19,6 +19,7 @@ package org.apache.ignite.internal;
 
 import org.apache.ignite.cluster.*;
 import org.apache.ignite.internal.util.typedef.internal.*;
+import org.apache.ignite.mbean.*;
 
 /**
  * Local node metrics MBean.

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/ClusterMetricsImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/ClusterMetricsImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/ClusterMetricsImpl.java
index 18dbe94..5daec97 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/ClusterMetricsImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/ClusterMetricsImpl.java
@@ -27,23 +27,32 @@ import java.util.*;
 import static java.lang.Math.*;
 
 /**
- * Implementation for {@link org.apache.ignite.cluster.ClusterMetrics} interface.
+ * Implementation for {@link ClusterNodeMetrics ClusterNodeMetrics} interface.
  */
-class ClusterMetricsImpl implements ClusterMetrics {
+class ClusterMetricsImpl implements ClusterNodeMetrics {
     /** */
     private static final long serialVersionUID = 0L;
 
     /** */
-    private int minActJobs = Integer.MAX_VALUE;
+    private int totalExecutedTask;
 
     /** */
     private int maxActJobs = Integer.MIN_VALUE;
 
     /** */
+    private int curActJobs;
+
+    /** */
+    private int totalExecutedJobs;
+
+    /** */
     private float avgActJobs;
 
     /** */
-    private int minCancelJobs = Integer.MAX_VALUE;
+    private int curCancelJobs;
+
+    /** */
+    private int totalCancelJobs;
 
     /** */
     private int maxCancelJobs = Integer.MIN_VALUE;
@@ -52,7 +61,7 @@ class ClusterMetricsImpl implements ClusterMetrics {
     private float avgCancelJobs;
 
     /** */
-    private int minRejectJobs = Integer.MAX_VALUE;
+    private int curRejectJobs;
 
     /** */
     private int maxRejectJobs = Integer.MIN_VALUE;
@@ -61,16 +70,16 @@ class ClusterMetricsImpl implements ClusterMetrics {
     private float avgRejectJobs;
 
     /** */
-    private int minWaitJobs = Integer.MAX_VALUE;
+    private int totalRejectJobs;
 
     /** */
-    private int maxWaitJobs = Integer.MIN_VALUE;
+    private int curWaitJobs;
 
     /** */
-    private float avgWaitJobs;
+    private int maxWaitJobs = Integer.MIN_VALUE;
 
     /** */
-    private long minJobExecTime = Long.MAX_VALUE;
+    private float avgWaitJobs;
 
     /** */
     private long maxJobExecTime = Long.MIN_VALUE;
@@ -88,166 +97,91 @@ class ClusterMetricsImpl implements ClusterMetrics {
     private double avgJobWaitTime;
 
     /** */
-    private int minDaemonThreadCnt = Integer.MAX_VALUE;
-
-    /** */
-    private int maxDaemonThreadCnt = Integer.MIN_VALUE;
-
-    /** */
-    private float avgDaemonThreadCnt;
-
-    /** */
-    private int minThreadCnt = Integer.MAX_VALUE;
+    private int curDaemonThreadCnt;
 
     /** */
     private int maxThreadCnt = Integer.MIN_VALUE;
 
     /** */
-    private float avgThreadCnt;
+    private int curThreadCnt;
 
     /** */
-    private long minIdleTime = Long.MAX_VALUE;
+    private int totalStartedThreadCnt;
 
     /** */
-    private long maxIdleTime = Long.MIN_VALUE;
-
-    /** */
-    private double avgIdleTime;
+    private long minIdleTime = Long.MAX_VALUE;
 
     /** */
     private float avgIdleTimePercent;
 
     /** */
-    private float minBusyTimePerc = Float.POSITIVE_INFINITY;
-
-    /** */
-    private float maxBusyTimePerc = Float.NEGATIVE_INFINITY;
+    private int totalIdleTime;
 
     /** */
     private float avgBusyTimePerc;
 
     /** */
-    private double minCpuLoad = Double.POSITIVE_INFINITY;
-
-    /** */
-    private double maxCpuLoad = Double.NEGATIVE_INFINITY;
+    private int totalBusyTime;
 
     /** */
     private double avgCpuLoad;
 
     /** */
-    private long minHeapMemCmt = Long.MAX_VALUE;
-
-    /** */
-    private long maxHeapMemCmt = Long.MIN_VALUE;
-
-    /** */
-    private double avgHeapMemCmt;
-
-    /** */
-    private long minHeapMemUsed = Long.MAX_VALUE;
+    private long totalHeapMemCmt = Long.MIN_VALUE;
 
     /** */
-    private long maxHeapMemUsed = Long.MIN_VALUE;
-
-    /** */
-    private double avgHeapMemUsed;
-
-    /** */
-    private long minHeapMemMax = Long.MAX_VALUE;
+    private long totalHeapMemUsed;
 
     /** */
     private long maxHeapMemMax = Long.MIN_VALUE;
 
     /** */
-    private double avgHeapMemMax;
-
-    /** */
-    private long minHeapMemInit = Long.MAX_VALUE;
-
-    /** */
-    private long maxHeapMemInit = Long.MIN_VALUE;
-
-    /** */
-    private double avgHeapMemInit;
+    private long totalHeapMemInit;
 
     /** */
-    private long minNonHeapMemCmt = Long.MAX_VALUE;
+    private long totalNonHeapMemCmt;
 
     /** */
-    private long maxNonHeapMemCmt = Long.MIN_VALUE;
-
-    /** */
-    private double avgNonHeapMemCmt;
-
-    /** */
-    private long minNonHeapMemUsed = Long.MAX_VALUE;
-
-    /** */
-    private long maxNonHeapMemUsed = Long.MIN_VALUE;
-
-    /** */
-    private double avgNonHeapMemUsed;
-
-    /** */
-    private long minNonHeapMemMax = Long.MAX_VALUE;
+    private long totalNonHeapMemUsed;
 
     /** */
     private long maxNonHeapMemMax = Long.MIN_VALUE;
 
     /** */
-    private double avgNonHeapMemMax;
-
-    /** */
-    private long minNonHeapMemInit = Long.MAX_VALUE;
-
-    /** */
-    private long maxNonHeapMemInit = Long.MIN_VALUE;
-
-    /** */
-    private double avgNonHeapMemInit;
-
-    /** */
-    private long youngestNodeStartTime = Long.MIN_VALUE;
+    private long totalNonHeapMemInit;
 
     /** */
     private long oldestNodeStartTime = Long.MAX_VALUE;
 
     /** */
-    private long minUpTime = Long.MAX_VALUE;
-
-    /** */
     private long maxUpTime = Long.MIN_VALUE;
 
     /** */
-    private double avgUpTime;
+    private int totalCpus;
 
     /** */
-    private int minCpusPerNode = Integer.MAX_VALUE;
+    private int currentGcCpus;
 
     /** */
-    private int maxCpusPerNode = Integer.MIN_VALUE;
+    private long lastUpdateTime;
 
     /** */
-    private float avgCpusPerNode;
+    private long lastDataVersion = Long.MIN_VALUE;
 
     /** */
-    private int minNodesPerHost = Integer.MAX_VALUE;
+    private int sentMessagesCnt;
 
     /** */
-    private int maxNodesPerHost = Integer.MIN_VALUE;
+    private long sentBytesCnt;
 
     /** */
-    private float avgNodesPerHost;
+    private int receivedMessagesCnt;
 
     /** */
-    private int totalCpus;
+    private long receivedBytesCnt;
 
     /** */
-    private int totalHosts;
-
-    /** */
-    private int totalNodes;
+    private int outboundMessagesQueueSize;
 
     /**
      * @param p Projection to get metrics for.
@@ -262,23 +196,30 @@ class ClusterMetricsImpl implements ClusterMetrics {
         for (ClusterNode node : nodes) {
             ClusterNodeMetrics m = node.metrics();
 
-            minActJobs = min(minActJobs, m.getCurrentActiveJobs());
+            lastUpdateTime = max(lastUpdateTime, node.metrics().getLastUpdateTime());
+
+            curActJobs += m.getCurrentActiveJobs();
             maxActJobs = max(maxActJobs, m.getCurrentActiveJobs());
             avgActJobs += m.getCurrentActiveJobs();
+            totalExecutedJobs += m.getTotalExecutedJobs();
 
-            minCancelJobs = min(minCancelJobs, m.getCurrentCancelledJobs());
+            totalExecutedTask += m.getTotalExecutedTasks();
+
+            totalCancelJobs += m.getTotalCancelledJobs();
+            curCancelJobs += m.getCurrentCancelledJobs();
             maxCancelJobs = max(maxCancelJobs, m.getCurrentCancelledJobs());
             avgCancelJobs += m.getCurrentCancelledJobs();
 
-            minRejectJobs = min(minRejectJobs, m.getCurrentRejectedJobs());
+            totalRejectJobs += m.getTotalRejectedJobs();
+            curRejectJobs += m.getCurrentRejectedJobs();
+            totalRejectJobs += m.getTotalRejectedJobs();
             maxRejectJobs = max(maxRejectJobs, m.getCurrentRejectedJobs());
             avgRejectJobs += m.getCurrentRejectedJobs();
 
-            minWaitJobs = min(minWaitJobs, m.getCurrentWaitingJobs());
+            curWaitJobs += m.getCurrentJobWaitTime();
             maxWaitJobs = max(maxWaitJobs, m.getCurrentWaitingJobs());
             avgWaitJobs += m.getCurrentWaitingJobs();
 
-            minJobExecTime = min(minJobExecTime, m.getCurrentJobExecuteTime());
             maxJobExecTime = max(maxJobExecTime, m.getCurrentJobExecuteTime());
             avgJobExecTime += m.getCurrentJobExecuteTime();
 
@@ -286,66 +227,46 @@ class ClusterMetricsImpl implements ClusterMetrics {
             maxJobWaitTime = max(maxJobWaitTime, m.getCurrentJobWaitTime());
             avgJobWaitTime += m.getCurrentJobWaitTime();
 
-            minDaemonThreadCnt = min(minDaemonThreadCnt, m.getCurrentDaemonThreadCount());
-            maxDaemonThreadCnt = max(maxDaemonThreadCnt, m.getCurrentDaemonThreadCount());
-            avgDaemonThreadCnt += m.getCurrentDaemonThreadCount();
+            curDaemonThreadCnt += m.getCurrentDaemonThreadCount();
 
-            minThreadCnt = min(minThreadCnt, m.getCurrentThreadCount());
             maxThreadCnt = max(maxThreadCnt, m.getCurrentThreadCount());
-            avgThreadCnt += m.getCurrentThreadCount();
+            curThreadCnt += m.getCurrentThreadCount();
+            totalStartedThreadCnt += m.getTotalStartedThreadCount();
 
             minIdleTime = min(minIdleTime, m.getCurrentIdleTime());
-            maxIdleTime = max(maxIdleTime, m.getCurrentIdleTime());
-            avgIdleTime += m.getCurrentIdleTime();
             avgIdleTimePercent += m.getIdleTimePercentage();
+            totalIdleTime += m.getTotalIdleTime();
 
-            minBusyTimePerc = min(minBusyTimePerc, m.getBusyTimePercentage());
-            maxBusyTimePerc = max(maxBusyTimePerc, m.getBusyTimePercentage());
             avgBusyTimePerc += m.getBusyTimePercentage();
+            totalBusyTime += m.getTotalBusyTime();
 
-            minCpuLoad = min(minCpuLoad, m.getCurrentCpuLoad());
-            maxCpuLoad = max(maxCpuLoad, m.getCurrentCpuLoad());
             avgCpuLoad += m.getCurrentCpuLoad();
 
-            minHeapMemCmt = min(minHeapMemCmt, m.getHeapMemoryCommitted());
-            maxHeapMemCmt = max(maxHeapMemCmt, m.getHeapMemoryCommitted());
-            avgHeapMemCmt += m.getHeapMemoryCommitted();
+            totalHeapMemCmt += m.getHeapMemoryCommitted();
 
-            minHeapMemUsed = min(minHeapMemUsed, m.getHeapMemoryUsed());
-            maxHeapMemUsed = max(maxHeapMemUsed, m.getHeapMemoryUsed());
-            avgHeapMemUsed += m.getHeapMemoryUsed();
+            totalHeapMemUsed += m.getHeapMemoryUsed();
 
-            minHeapMemMax = min(minHeapMemMax, m.getHeapMemoryMaximum());
             maxHeapMemMax = max(maxHeapMemMax, m.getHeapMemoryMaximum());
-            avgHeapMemMax += m.getHeapMemoryMaximum();
 
-            minHeapMemInit = min(minHeapMemInit, m.getHeapMemoryInitialized());
-            maxHeapMemInit = max(maxHeapMemInit, m.getHeapMemoryInitialized());
-            avgHeapMemInit += m.getHeapMemoryInitialized();
+            totalHeapMemInit += m.getHeapMemoryInitialized();
 
-            minNonHeapMemCmt = min(minNonHeapMemCmt, m.getNonHeapMemoryCommitted());
-            maxNonHeapMemCmt = max(maxNonHeapMemCmt, m.getNonHeapMemoryCommitted());
-            avgNonHeapMemCmt += m.getNonHeapMemoryCommitted();
+            totalNonHeapMemCmt += m.getNonHeapMemoryCommitted();
 
-            minNonHeapMemUsed = min(minNonHeapMemUsed, m.getNonHeapMemoryUsed());
-            maxNonHeapMemUsed = max(maxNonHeapMemUsed, m.getNonHeapMemoryUsed());
-            avgNonHeapMemUsed += m.getNonHeapMemoryUsed();
+            totalNonHeapMemUsed += m.getNonHeapMemoryUsed();
 
-            minNonHeapMemMax = min(minNonHeapMemMax, m.getNonHeapMemoryMaximum());
             maxNonHeapMemMax = max(maxNonHeapMemMax, m.getNonHeapMemoryMaximum());
-            avgNonHeapMemMax += m.getNonHeapMemoryMaximum();
 
-            minNonHeapMemInit = min(minNonHeapMemInit, m.getNonHeapMemoryInitialized());
-            maxNonHeapMemInit = max(maxNonHeapMemInit, m.getNonHeapMemoryInitialized());
-            avgNonHeapMemInit += m.getNonHeapMemoryInitialized();
+            totalNonHeapMemInit += m.getNonHeapMemoryInitialized();
 
-            minUpTime = min(minUpTime, m.getUpTime());
             maxUpTime = max(maxUpTime, m.getUpTime());
-            avgUpTime += m.getUpTime();
 
-            minCpusPerNode = min(minCpusPerNode, m.getTotalCpus());
-            maxCpusPerNode = max(maxCpusPerNode, m.getTotalCpus());
-            avgCpusPerNode += m.getTotalCpus();
+            lastDataVersion = max(lastDataVersion, m.getLastDataVersion());
+
+            sentMessagesCnt += m.getSentMessagesCount();
+            sentBytesCnt += m.getSentBytesCount();
+            receivedMessagesCnt += m.getReceivedMessagesCount();
+            receivedBytesCnt += m.getReceivedBytesCount();
+            outboundMessagesQueueSize += m.getOutboundMessagesQueueSize();
         }
 
         avgActJobs /= size;
@@ -354,47 +275,18 @@ class ClusterMetricsImpl implements ClusterMetrics {
         avgWaitJobs /= size;
         avgJobExecTime /= size;
         avgJobWaitTime /= size;
-        avgDaemonThreadCnt /= size;
-        avgThreadCnt /= size;
-        avgIdleTime /= size;
         avgIdleTimePercent /= size;
         avgBusyTimePerc /= size;
         avgCpuLoad /= size;
-        avgHeapMemCmt /= size;
-        avgHeapMemUsed /= size;
-        avgHeapMemMax /= size;
-        avgHeapMemInit /= size;
-        avgNonHeapMemCmt /= size;
-        avgNonHeapMemUsed /= size;
-        avgNonHeapMemMax /= size;
-        avgNonHeapMemInit /= size;
-        avgUpTime /= size;
-        avgCpusPerNode /= size;
 
         if (!F.isEmpty(nodes)) {
-            youngestNodeStartTime = youngest(nodes).metrics().getNodeStartTime();
             oldestNodeStartTime = oldest(nodes).metrics().getNodeStartTime();
         }
 
         Map<String, Collection<ClusterNode>> neighborhood = U.neighborhood(nodes);
 
-        for (Collection<ClusterNode> neighbors : neighborhood.values()) {
-            minNodesPerHost = min(minNodesPerHost, neighbors.size());
-            maxNodesPerHost = max(maxNodesPerHost, neighbors.size());
-            avgNodesPerHost += neighbors.size();
-        }
-
-        if (!F.isEmpty(neighborhood))
-            avgNodesPerHost /= neighborhood.size();
-
+        currentGcCpus = gcCpus(neighborhood);
         totalCpus = cpus(neighborhood);
-        totalHosts = neighborhood.size();
-        totalNodes = nodes.size();
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getMinimumActiveJobs() {
-        return minActJobs;
     }
 
     /** {@inheritDoc} */
@@ -408,11 +300,6 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumCancelledJobs() {
-        return minCancelJobs;
-    }
-
-    /** {@inheritDoc} */
     @Override public int getMaximumCancelledJobs() {
         return maxCancelJobs;
     }
@@ -423,11 +310,6 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumRejectedJobs() {
-        return minRejectJobs;
-    }
-
-    /** {@inheritDoc} */
     @Override public int getMaximumRejectedJobs() {
         return maxRejectJobs;
     }
@@ -438,11 +320,6 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumWaitingJobs() {
-        return minWaitJobs;
-    }
-
-    /** {@inheritDoc} */
     @Override public int getMaximumWaitingJobs() {
         return maxWaitJobs;
     }
@@ -453,11 +330,6 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumJobExecuteTime() {
-        return minJobExecTime;
-    }
-
-    /** {@inheritDoc} */
     @Override public long getMaximumJobExecuteTime() {
         return maxJobExecTime;
     }
@@ -468,11 +340,6 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumJobWaitTime() {
-        return minJobWaitTime;
-    }
-
-    /** {@inheritDoc} */
     @Override public long getMaximumJobWaitTime() {
         return maxJobWaitTime;
     }
@@ -483,273 +350,208 @@ class ClusterMetricsImpl implements ClusterMetrics {
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumDaemonThreadCount() {
-        return minDaemonThreadCnt;
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getMaximumDaemonThreadCount() {
-        return maxDaemonThreadCnt;
-    }
-
-    /** {@inheritDoc} */
-    @Override public float getAverageDaemonThreadCount() {
-        return avgDaemonThreadCnt;
-    }
-
-    /** {@inheritDoc} */
-    @Override public int getMinimumThreadCount() {
-        return minThreadCnt;
-    }
-
-    /** {@inheritDoc} */
     @Override public int getMaximumThreadCount() {
         return maxThreadCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public float getAverageThreadCount() {
-        return avgThreadCnt;
-    }
-
-    /** {@inheritDoc} */
-    @Override public long getMinimumIdleTime() {
-        return minIdleTime;
-    }
-
-    /** {@inheritDoc} */
-    @Override public long getMaximumIdleTime() {
-        return maxIdleTime;
-    }
-
-    /** {@inheritDoc} */
-    @Override public double getAverageIdleTime() {
-        return avgIdleTime;
-    }
-
-    /** {@inheritDoc} */
     @Override public float getIdleTimePercentage() {
         return avgIdleTimePercent;
     }
 
     /** {@inheritDoc} */
-    @Override public float getMinimumBusyTimePercentage() {
-        return minBusyTimePerc;
-    }
-
-    /** {@inheritDoc} */
-    @Override public float getMaximumBusyTimePercentage() {
-        return maxBusyTimePerc;
-    }
-
-    /** {@inheritDoc} */
-    @Override public float getAverageBusyTimePercentage() {
-        return avgBusyTimePerc;
-    }
-
-    /** {@inheritDoc} */
-    @Override public double getMinimumCpuLoad() {
-        return minCpuLoad;
-    }
-
-    /** {@inheritDoc} */
-    @Override public double getMaximumCpuLoad() {
-        return maxCpuLoad;
-    }
-
-    /** {@inheritDoc} */
     @Override public double getAverageCpuLoad() {
         return avgCpuLoad;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumHeapMemoryCommitted() {
-        return minHeapMemCmt;
+    @Override public int getTotalCpus() {
+        return totalCpus;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumHeapMemoryCommitted() {
-        return maxHeapMemCmt;
+    @Override public long getLastUpdateTime() {
+        return lastUpdateTime;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageHeapMemoryCommitted() {
-        return avgHeapMemCmt;
+    @Override public int getCurrentActiveJobs() {
+        return curActJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumHeapMemoryUsed() {
-        return minHeapMemUsed;
+    @Override public int getCurrentWaitingJobs() {
+        return curWaitJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumHeapMemoryUsed() {
-        return maxHeapMemUsed;
+    @Override public int getCurrentRejectedJobs() {
+        return curRejectJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageHeapMemoryUsed() {
-        return avgHeapMemUsed;
+    @Override public int getTotalRejectedJobs() {
+        return totalRejectJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumHeapMemoryMaximum() {
-        return minHeapMemMax;
+    @Override public int getCurrentCancelledJobs() {
+        return curCancelJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumHeapMemoryMaximum() {
-        return maxHeapMemMax;
+    @Override public int getTotalCancelledJobs() {
+        return totalCancelJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageHeapMemoryMaximum() {
-        return avgHeapMemMax;
+    @Override public int getTotalExecutedJobs() {
+        return totalExecutedJobs;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumHeapMemoryInitialized() {
-        return minHeapMemInit;
+    @Override public long getCurrentJobWaitTime() {
+        return minJobWaitTime;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumHeapMemoryInitialized() {
-        return maxHeapMemInit;
+    @Override public long getCurrentJobExecuteTime() {
+        return maxJobExecTime;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageHeapMemoryInitialized() {
-        return avgHeapMemInit;
+    @Override public int getTotalExecutedTasks() {
+        return totalExecutedTask;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumNonHeapMemoryCommitted() {
-        return minNonHeapMemCmt;
+    @Override public long getTotalBusyTime() {
+        return totalBusyTime;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumNonHeapMemoryCommitted() {
-        return maxNonHeapMemCmt;
+    @Override public long getTotalIdleTime() {
+        return totalIdleTime;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageNonHeapMemoryCommitted() {
-        return avgNonHeapMemCmt;
+    @Override public long getCurrentIdleTime() {
+        return minIdleTime;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumNonHeapMemoryUsed() {
-        return minNonHeapMemUsed;
+    @Override public float getBusyTimePercentage() {
+        return avgBusyTimePerc;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumNonHeapMemoryUsed() {
-        return maxNonHeapMemUsed;
+    @Override public double getCurrentCpuLoad() {
+        return totalCpus;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageNonHeapMemoryUsed() {
-        return avgNonHeapMemUsed;
+    @Override public double getCurrentGcCpuLoad() {
+        return currentGcCpus;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumNonHeapMemoryMaximum() {
-        return minNonHeapMemMax;
+    @Override public long getHeapMemoryInitialized() {
+        return totalHeapMemInit;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumNonHeapMemoryMaximum() {
-        return maxNonHeapMemMax;
+    @Override public long getHeapMemoryUsed() {
+        return totalHeapMemUsed;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageNonHeapMemoryMaximum() {
-        return avgNonHeapMemMax;
+    @Override public long getHeapMemoryCommitted() {
+        return totalHeapMemCmt;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumNonHeapMemoryInitialized() {
-        return minNonHeapMemInit;
+    @Override public long getHeapMemoryMaximum() {
+        return maxHeapMemMax;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumNonHeapMemoryInitialized() {
-        return maxNonHeapMemInit;
+    @Override public long getNonHeapMemoryInitialized() {
+        return totalNonHeapMemInit;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageNonHeapMemoryInitialized() {
-        return avgNonHeapMemInit;
+    @Override public long getNonHeapMemoryUsed() {
+        return totalNonHeapMemUsed;
     }
 
     /** {@inheritDoc} */
-    @Override public long getYoungestNodeStartTime() {
-        return youngestNodeStartTime;
+    @Override public long getNonHeapMemoryCommitted() {
+        return totalNonHeapMemCmt;
     }
 
     /** {@inheritDoc} */
-    @Override public long getOldestNodeStartTime() {
-        return oldestNodeStartTime;
+    @Override public long getNonHeapMemoryMaximum() {
+        return maxNonHeapMemMax;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMinimumUpTime() {
-        return minUpTime;
+    @Override public long getUpTime() {
+        return maxUpTime;
     }
 
     /** {@inheritDoc} */
-    @Override public long getMaximumUpTime() {
-        return maxUpTime;
+    @Override public long getStartTime() {
+        return oldestNodeStartTime;
     }
 
     /** {@inheritDoc} */
-    @Override public double getAverageUpTime() {
-        return avgUpTime;
+    @Override public long getNodeStartTime() {
+        return oldestNodeStartTime;
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumCpusPerNode() {
-        return minCpusPerNode;
+    @Override public int getCurrentThreadCount() {
+        return curThreadCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public int getMaximumCpusPerNode() {
-        return maxCpusPerNode;
+    @Override public long getTotalStartedThreadCount() {
+        return totalStartedThreadCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public float getAverageCpusPerNode() {
-        return avgCpusPerNode;
+    @Override public int getCurrentDaemonThreadCount() {
+        return curDaemonThreadCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public int getMinimumNodesPerHost() {
-        return minNodesPerHost;
+    @Override public long getLastDataVersion() {
+        return lastDataVersion;
     }
 
     /** {@inheritDoc} */
-    @Override public int getMaximumNodesPerHost() {
-        return maxNodesPerHost;
+    @Override public int getSentMessagesCount() {
+        return sentMessagesCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public float getAverageNodesPerHost() {
-        return avgNodesPerHost;
+    @Override public long getSentBytesCount() {
+        return sentBytesCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public int getTotalCpus() {
-        return totalCpus;
+    @Override public int getReceivedMessagesCount() {
+        return receivedMessagesCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public int getTotalHosts() {
-        return totalHosts;
+    @Override public long getReceivedBytesCount() {
+        return receivedBytesCnt;
     }
 
     /** {@inheritDoc} */
-    @Override public int getTotalNodes() {
-        return totalNodes;
+    @Override public int getOutboundMessagesQueueSize() {
+        return outboundMessagesQueueSize;
     }
 
     /**
@@ -806,6 +608,20 @@ class ClusterMetricsImpl implements ClusterMetrics {
         return cpus;
     }
 
+    private static int gcCpus(Map<String, Collection<ClusterNode>> neighborhood) {
+        int cpus = 0;
+
+        for (Collection<ClusterNode> nodes : neighborhood.values()) {
+            ClusterNode first = F.first(nodes);
+
+            // Projection can be empty if all nodes in it failed.
+            if (first != null)
+                cpus += first.metrics().getCurrentGcCpuLoad();
+        }
+
+        return cpus;
+    }
+
     /** {@inheritDoc} */
     @Override public String toString() {
         return S.toString(ClusterMetricsImpl.class, this);

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/ClusterNodeMetricsMxBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/ClusterNodeMetricsMxBean.java b/modules/core/src/main/java/org/apache/ignite/internal/ClusterNodeMetricsMxBean.java
deleted file mode 100644
index 4f7c82e..0000000
--- a/modules/core/src/main/java/org/apache/ignite/internal/ClusterNodeMetricsMxBean.java
+++ /dev/null
@@ -1,238 +0,0 @@
-/*
- * 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.ignite.internal;
-
-import org.apache.ignite.cluster.*;
-import org.apache.ignite.mbean.*;
-
-/**
- * MBean for local node metrics.
- */
-@IgniteMBeanDescription("MBean that provides access to all local node metrics.")
-public interface ClusterNodeMetricsMxBean extends ClusterNodeMetrics {
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Last update time of this node metrics.")
-    public long getLastUpdateTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum number of jobs that ever ran concurrently on this node.")
-    public int getMaximumActiveJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Number of currently active jobs concurrently executing on the node.")
-    public int getCurrentActiveJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average number of active jobs concurrently executing on the node.")
-    public float getAverageActiveJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum number of waiting jobs this node had.")
-    public int getMaximumWaitingJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Number of queued jobs currently waiting to be executed.")
-    public int getCurrentWaitingJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average number of waiting jobs this node had queued.")
-    public float getAverageWaitingJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum number of jobs rejected at once during a single collision resolution operation.")
-    public int getMaximumRejectedJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Number of jobs rejected after more recent collision resolution operation.")
-    public int getCurrentRejectedJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average number of jobs this node rejects during collision resolution operations.")
-    public float getAverageRejectedJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription(
-        "Total number of jobs this node rejects during collision resolution operations since node startup.")
-    public int getTotalRejectedJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum number of cancelled jobs this node ever had running concurrently.")
-    public int getMaximumCancelledJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Number of cancelled jobs that are still running.")
-    public int getCurrentCancelledJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average number of cancelled jobs this node ever had running concurrently.")
-    public float getAverageCancelledJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Total number of cancelled jobs since node startup.")
-    public int getTotalCancelledJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Total number of jobs handled by the node.")
-    public int getTotalExecutedJobs();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum time a job ever spent waiting in a queue to be executed.")
-    public long getMaximumJobWaitTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Current wait time of oldest job.")
-    public long getCurrentJobWaitTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average time jobs spend waiting in the queue to be executed.")
-    public double getAverageJobWaitTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Time it took to execute the longest job on the node.")
-    public long getMaximumJobExecuteTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Longest time a current job has been executing for.")
-    public long getCurrentJobExecuteTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average time a job takes to execute on the node.")
-    public double getAverageJobExecuteTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Total number of tasks handled by the node.")
-    public int getTotalExecutedTasks();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Total time this node spent executing jobs.")
-    public long getTotalBusyTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Total time this node spent idling (not executing any jobs).")
-    public long getTotalIdleTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Time this node spend idling since executing last job.")
-    public long getCurrentIdleTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Percentage of time this node is busy executing jobs vs. idling.")
-    public float getBusyTimePercentage();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Percentage of time this node is idling vs. executing jobs.")
-    public float getIdleTimePercentage();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The number of CPUs available to the Java Virtual Machine.")
-    public int getTotalCpus();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The system load average; or a negative value if not available.")
-    public double getCurrentCpuLoad();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average of CPU load values over all metrics kept in the history.")
-    public double getAverageCpuLoad();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Average time spent in CG since the last update.")
-    public double getCurrentGcCpuLoad();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The initial size of memory in bytes; -1 if undefined.")
-    public long getHeapMemoryInitialized();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Current heap size that is used for object allocation.")
-    public long getHeapMemoryUsed();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The amount of committed memory in bytes.")
-    public long getHeapMemoryCommitted();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The maximum amount of memory in bytes; -1 if undefined.")
-    public long getHeapMemoryMaximum();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The initial size of memory in bytes; -1 if undefined.")
-    public long getNonHeapMemoryInitialized();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Current non-heap memory size that is used by Java VM.")
-    public long getNonHeapMemoryUsed();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Amount of non-heap memory in bytes that is committed for the JVM to use.")
-    public long getNonHeapMemoryCommitted();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Maximum amount of non-heap memory in bytes that can " +
-            "be used for memory management. -1 if undefined.")
-    public long getNonHeapMemoryMaximum();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Uptime of the JVM in milliseconds.")
-    public long getUpTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Start time of the JVM in milliseconds.")
-    public long getStartTime();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Current number of live threads.")
-    public int getCurrentThreadCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The peak live thread count.")
-    public int getMaximumThreadCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("The total number of threads started.")
-    public long getTotalStartedThreadCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Current number of live daemon threads.")
-    public int getCurrentDaemonThreadCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Last data version.")
-    public long getLastDataVersion();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Sent messages count.")
-    public int getSentMessagesCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Sent bytes count.")
-    public long getSentBytesCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Received messages count.")
-    public int getReceivedMessagesCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Received bytes count.")
-    public long getReceivedBytesCount();
-
-    /** {@inheritDoc} */
-    @IgniteMBeanDescription("Outbound messages queue size.")
-    public int getOutboundMessagesQueueSize();
-
-}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/GridKernal.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/GridKernal.java b/modules/core/src/main/java/org/apache/ignite/internal/GridKernal.java
index 9717173..39505c6 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/GridKernal.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/GridKernal.java
@@ -978,10 +978,12 @@ public class GridKernal extends ClusterGroupAdapter implements GridEx, IgniteMBe
                         int cpus = 0;
 
                         try {
-                            ClusterMetrics metrics = metrics();
+                            ClusterNodeMetrics metrics = metrics();
 
-                            hosts = metrics.getTotalHosts();
-                            nodes = metrics.getTotalNodes();
+                            Collection<ClusterNode> nodes0 = nodes();
+
+                            hosts = U.neighborhood(nodes0).size();
+                            nodes = nodes0.size();
                             cpus = metrics.getTotalCpus();
                         }
                         catch (IgniteCheckedException ignore) {

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/internal/IgniteClusterAsyncImpl.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/internal/IgniteClusterAsyncImpl.java b/modules/core/src/main/java/org/apache/ignite/internal/IgniteClusterAsyncImpl.java
index cbcc126..6f46b3f 100644
--- a/modules/core/src/main/java/org/apache/ignite/internal/IgniteClusterAsyncImpl.java
+++ b/modules/core/src/main/java/org/apache/ignite/internal/IgniteClusterAsyncImpl.java
@@ -233,7 +233,7 @@ public class IgniteClusterAsyncImpl extends IgniteAsyncSupportAdapter implements
     }
 
     /** {@inheritDoc} */
-    @Override public ClusterMetrics metrics() throws IgniteCheckedException {
+    @Override public ClusterNodeMetrics metrics() throws IgniteCheckedException {
         return grid.metrics();
     }
 }

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/main/java/org/apache/ignite/mbean/ClusterNodeMetricsMxBean.java
----------------------------------------------------------------------
diff --git a/modules/core/src/main/java/org/apache/ignite/mbean/ClusterNodeMetricsMxBean.java b/modules/core/src/main/java/org/apache/ignite/mbean/ClusterNodeMetricsMxBean.java
new file mode 100644
index 0000000..163df8d
--- /dev/null
+++ b/modules/core/src/main/java/org/apache/ignite/mbean/ClusterNodeMetricsMxBean.java
@@ -0,0 +1,237 @@
+/*
+ * 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.ignite.mbean;
+
+import org.apache.ignite.cluster.*;
+
+/**
+ * MBean for local node metrics.
+ */
+@IgniteMBeanDescription("MBean that provides access to all local node metrics.")
+public interface ClusterNodeMetricsMxBean extends ClusterNodeMetrics {
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Last update time of this node metrics.")
+    public long getLastUpdateTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum number of jobs that ever ran concurrently on this node.")
+    public int getMaximumActiveJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Number of currently active jobs concurrently executing on the node.")
+    public int getCurrentActiveJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average number of active jobs concurrently executing on the node.")
+    public float getAverageActiveJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum number of waiting jobs this node had.")
+    public int getMaximumWaitingJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Number of queued jobs currently waiting to be executed.")
+    public int getCurrentWaitingJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average number of waiting jobs this node had queued.")
+    public float getAverageWaitingJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum number of jobs rejected at once during a single collision resolution operation.")
+    public int getMaximumRejectedJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Number of jobs rejected after more recent collision resolution operation.")
+    public int getCurrentRejectedJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average number of jobs this node rejects during collision resolution operations.")
+    public float getAverageRejectedJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription(
+        "Total number of jobs this node rejects during collision resolution operations since node startup.")
+    public int getTotalRejectedJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum number of cancelled jobs this node ever had running concurrently.")
+    public int getMaximumCancelledJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Number of cancelled jobs that are still running.")
+    public int getCurrentCancelledJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average number of cancelled jobs this node ever had running concurrently.")
+    public float getAverageCancelledJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Total number of cancelled jobs since node startup.")
+    public int getTotalCancelledJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Total number of jobs handled by the node.")
+    public int getTotalExecutedJobs();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum time a job ever spent waiting in a queue to be executed.")
+    public long getMaximumJobWaitTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Current wait time of oldest job.")
+    public long getCurrentJobWaitTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average time jobs spend waiting in the queue to be executed.")
+    public double getAverageJobWaitTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Time it took to execute the longest job on the node.")
+    public long getMaximumJobExecuteTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Longest time a current job has been executing for.")
+    public long getCurrentJobExecuteTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average time a job takes to execute on the node.")
+    public double getAverageJobExecuteTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Total number of tasks handled by the node.")
+    public int getTotalExecutedTasks();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Total time this node spent executing jobs.")
+    public long getTotalBusyTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Total time this node spent idling (not executing any jobs).")
+    public long getTotalIdleTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Time this node spend idling since executing last job.")
+    public long getCurrentIdleTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Percentage of time this node is busy executing jobs vs. idling.")
+    public float getBusyTimePercentage();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Percentage of time this node is idling vs. executing jobs.")
+    public float getIdleTimePercentage();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The number of CPUs available to the Java Virtual Machine.")
+    public int getTotalCpus();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The system load average; or a negative value if not available.")
+    public double getCurrentCpuLoad();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average of CPU load values over all metrics kept in the history.")
+    public double getAverageCpuLoad();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Average time spent in CG since the last update.")
+    public double getCurrentGcCpuLoad();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The initial size of memory in bytes; -1 if undefined.")
+    public long getHeapMemoryInitialized();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Current heap size that is used for object allocation.")
+    public long getHeapMemoryUsed();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The amount of committed memory in bytes.")
+    public long getHeapMemoryCommitted();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The maximum amount of memory in bytes; -1 if undefined.")
+    public long getHeapMemoryMaximum();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The initial size of memory in bytes; -1 if undefined.")
+    public long getNonHeapMemoryInitialized();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Current non-heap memory size that is used by Java VM.")
+    public long getNonHeapMemoryUsed();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Amount of non-heap memory in bytes that is committed for the JVM to use.")
+    public long getNonHeapMemoryCommitted();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Maximum amount of non-heap memory in bytes that can " +
+            "be used for memory management. -1 if undefined.")
+    public long getNonHeapMemoryMaximum();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Uptime of the JVM in milliseconds.")
+    public long getUpTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Start time of the JVM in milliseconds.")
+    public long getStartTime();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Current number of live threads.")
+    public int getCurrentThreadCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The peak live thread count.")
+    public int getMaximumThreadCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("The total number of threads started.")
+    public long getTotalStartedThreadCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Current number of live daemon threads.")
+    public int getCurrentDaemonThreadCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Last data version.")
+    public long getLastDataVersion();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Sent messages count.")
+    public int getSentMessagesCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Sent bytes count.")
+    public long getSentBytesCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Received messages count.")
+    public int getReceivedMessagesCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Received bytes count.")
+    public long getReceivedBytesCount();
+
+    /** {@inheritDoc} */
+    @IgniteMBeanDescription("Outbound messages queue size.")
+    public int getOutboundMessagesQueueSize();
+
+}

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/core/src/test/java/org/apache/ignite/internal/ClusterMetricsSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/core/src/test/java/org/apache/ignite/internal/ClusterMetricsSelfTest.java b/modules/core/src/test/java/org/apache/ignite/internal/ClusterMetricsSelfTest.java
index 8247802..b932612 100644
--- a/modules/core/src/test/java/org/apache/ignite/internal/ClusterMetricsSelfTest.java
+++ b/modules/core/src/test/java/org/apache/ignite/internal/ClusterMetricsSelfTest.java
@@ -119,7 +119,7 @@ public class ClusterMetricsSelfTest extends GridCommonAbstractTest {
             // Wait until local node will have updated metrics.
             metricsUpdLock.await();
 
-            ClusterMetrics m = g.cluster().metrics();
+            ClusterNodeMetrics m = g.cluster().metrics();
 
             checkMetrics(m);
         }
@@ -135,156 +135,36 @@ public class ClusterMetricsSelfTest extends GridCommonAbstractTest {
      * @param m Metrics.
      */
     @SuppressWarnings({"FloatingPointEquality"})
-    private void checkMetrics(ClusterMetrics m) {
-        assert m.getTotalNodes() == NODES_CNT;
-        assert m.getTotalHosts() == 1;
-
-        assert m.getMinimumActiveJobs() == 0;
+    private void checkMetrics(ClusterNodeMetrics m) {
         assert m.getMaximumActiveJobs() == 0;
         assert m.getAverageActiveJobs() == 0;
 
-        assert m.getMinimumCancelledJobs() == 0;
         assert m.getMaximumCancelledJobs() == 0;
         assert m.getAverageCancelledJobs() == 0;
 
-        assert m.getMinimumRejectedJobs() == 0;
         assert m.getMaximumRejectedJobs() == 0;
         assert m.getAverageRejectedJobs() == 0;
 
-        assert m.getMinimumWaitingJobs() == 0;
         assert m.getMaximumWaitingJobs() == 0;
         assert m.getAverageWaitingJobs() == 0;
 
-        assert m.getMinimumJobExecuteTime() >= 0;
         assert m.getMaximumJobExecuteTime() >= 0;
         assert m.getAverageJobExecuteTime() >= 0;
 
-        assert m.getAverageJobExecuteTime() >= m.getMinimumJobExecuteTime() &&
-            m.getAverageJobExecuteTime() <= m.getMaximumJobExecuteTime();
+        assert m.getAverageJobExecuteTime() <= m.getMaximumJobExecuteTime();
 
-        assert m.getMinimumJobWaitTime() >= 0;
         assert m.getMaximumJobWaitTime() >= 0;
         assert m.getAverageJobWaitTime() >= 0;
 
-        assert m.getAverageJobWaitTime() >= m.getMinimumJobWaitTime() &&
-            m.getAverageJobWaitTime() <= m.getMaximumJobWaitTime();
-
-        assert m.getMinimumDaemonThreadCount() > 0;
-        assert m.getMaximumDaemonThreadCount() > 0;
-        assert m.getAverageDaemonThreadCount() > 0;
+        assert m.getAverageJobWaitTime() <= m.getMaximumJobWaitTime();
 
-        assert m.getAverageDaemonThreadCount() >= m.getMinimumDaemonThreadCount() &&
-            m.getAverageDaemonThreadCount() <= m.getMaximumDaemonThreadCount();
-
-        assert m.getMinimumThreadCount() > 0;
         assert m.getMaximumThreadCount() > 0;
-        assert m.getAverageThreadCount() > 0;
-
-        assert m.getAverageThreadCount() >= m.getMinimumThreadCount() &&
-            m.getAverageThreadCount() <= m.getMaximumThreadCount();
-
-        assert m.getMinimumIdleTime() >= 0;
-        assert m.getMaximumIdleTime() >= 0;
-        assert m.getAverageIdleTime() >= 0;
         assert m.getIdleTimePercentage() >= 0;
         assert m.getIdleTimePercentage() <= 1;
 
-        assert m.getAverageIdleTime() >= m.getMinimumIdleTime() && m.getAverageIdleTime() <= m.getMaximumIdleTime();
-
-        assert m.getMinimumBusyTimePercentage() > 0;
-        assert m.getMaximumBusyTimePercentage() > 0;
-        assert m.getAverageBusyTimePercentage() > 0;
-
-        assert m.getAverageBusyTimePercentage() >= m.getMinimumBusyTimePercentage() &&
-            m.getAverageBusyTimePercentage() <= m.getMaximumBusyTimePercentage();
-
-        assert m.getMinimumCpuLoad() >= 0 || m.getMinimumCpuLoad() == -1.0;
-        assert m.getMaximumCpuLoad() >= 0 || m.getMaximumCpuLoad() == -1.0;
         assert m.getAverageCpuLoad() >= 0 || m.getAverageCpuLoad() == -1.0;
 
-        assert m.getAverageCpuLoad() >= m.getMinimumCpuLoad() && m.getAverageCpuLoad() <= m.getMaximumCpuLoad();
-
-        assert m.getMinimumHeapMemoryCommitted() > 0;
-        assert m.getMaximumHeapMemoryCommitted() > 0;
-        assert m.getAverageHeapMemoryCommitted() > 0;
-
-        assert m.getAverageHeapMemoryCommitted() >= m.getMinimumHeapMemoryCommitted() &&
-            m.getAverageHeapMemoryCommitted() <= m.getMaximumHeapMemoryCommitted();
-
-        assert m.getMinimumHeapMemoryUsed() > 0;
-        assert m.getMaximumHeapMemoryUsed() > 0;
-        assert m.getAverageHeapMemoryUsed() > 0;
-
-        assert m.getAverageHeapMemoryUsed() >= m.getMinimumHeapMemoryUsed() &&
-            m.getAverageHeapMemoryUsed() <= m.getMaximumHeapMemoryUsed();
-
-        assert m.getMinimumHeapMemoryMaximum() > 0;
-        assert m.getMaximumHeapMemoryMaximum() > 0;
-        assert m.getAverageHeapMemoryMaximum() > 0;
-
-        assert m.getAverageHeapMemoryMaximum() >= m.getMinimumHeapMemoryMaximum() &&
-            m.getAverageHeapMemoryMaximum() <= m.getMaximumHeapMemoryMaximum();
-
-        assert m.getMinimumHeapMemoryInitialized() >= 0;
-        assert m.getMaximumHeapMemoryInitialized() >= 0;
-        assert m.getAverageHeapMemoryInitialized() >= 0;
-
-        assert m.getAverageHeapMemoryInitialized() >= m.getMinimumHeapMemoryInitialized() &&
-            m.getAverageHeapMemoryInitialized() <= m.getMaximumHeapMemoryInitialized();
-
-        assert m.getMinimumNonHeapMemoryCommitted() > 0;
-        assert m.getMaximumNonHeapMemoryCommitted() > 0;
-        assert m.getAverageNonHeapMemoryCommitted() > 0;
-
-        assert m.getAverageNonHeapMemoryCommitted() >= m.getMinimumNonHeapMemoryCommitted() &&
-            m.getAverageNonHeapMemoryCommitted() <= m.getMaximumNonHeapMemoryCommitted();
-
-        assert m.getMinimumNonHeapMemoryUsed() > 0;
-        assert m.getMaximumNonHeapMemoryUsed() > 0;
-        assert m.getAverageNonHeapMemoryUsed() > 0;
-
-        assert m.getAverageNonHeapMemoryUsed() >= m.getMinimumNonHeapMemoryUsed() &&
-            m.getAverageNonHeapMemoryUsed() <= m.getMaximumNonHeapMemoryUsed();
-
-        assert m.getMinimumNonHeapMemoryMaximum() > 0;
-        assert m.getMaximumNonHeapMemoryMaximum() > 0;
-        assert m.getAverageNonHeapMemoryMaximum() > 0;
-
-        assert m.getAverageNonHeapMemoryMaximum() >= m.getMinimumNonHeapMemoryMaximum() &&
-            m.getAverageNonHeapMemoryMaximum() <= m.getMaximumNonHeapMemoryMaximum();
-
-        assert m.getMinimumNonHeapMemoryInitialized() > 0;
-        assert m.getMaximumNonHeapMemoryInitialized() > 0;
-        assert m.getAverageNonHeapMemoryInitialized() > 0;
-
-        assert m.getAverageNonHeapMemoryInitialized() >= m.getMinimumNonHeapMemoryInitialized() &&
-            m.getAverageNonHeapMemoryInitialized() <= m.getMaximumNonHeapMemoryInitialized();
-
-        assert m.getYoungestNodeStartTime() > 0;
-        assert m.getOldestNodeStartTime() > 0;
-
-        assert m.getYoungestNodeStartTime() > m.getOldestNodeStartTime();
-
-        assert m.getMinimumUpTime() > 0;
-        assert m.getMaximumUpTime() > 0;
-        assert m.getAverageUpTime() > 0;
-
-        assert m.getAverageUpTime() >= m.getMinimumUpTime() && m.getAverageUpTime() <= m.getMaximumUpTime();
-
-        assert m.getMinimumCpusPerNode() > 0;
-        assert m.getMaximumCpusPerNode() > 0;
-        assert m.getAverageCpusPerNode() > 0;
-
-        assert m.getAverageCpusPerNode() == m.getMinimumCpusPerNode() &&
-            m.getAverageCpusPerNode() == m.getMaximumCpusPerNode();
-
-        assert m.getMinimumNodesPerHost() == NODES_CNT;
-        assert m.getMaximumNodesPerHost() == NODES_CNT;
-        assert m.getAverageNodesPerHost() == NODES_CNT;
-
         assert m.getTotalCpus() > 0;
-        assert m.getTotalHosts() == 1;
-        assert m.getTotalNodes() == NODES_CNT;
     }
 
     /**

http://git-wip-us.apache.org/repos/asf/incubator-ignite/blob/7f24d3cc/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/GridHadoopDefaultMapReducePlannerSelfTest.java
----------------------------------------------------------------------
diff --git a/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/GridHadoopDefaultMapReducePlannerSelfTest.java b/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/GridHadoopDefaultMapReducePlannerSelfTest.java
index d1932d8..ef112c9 100644
--- a/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/GridHadoopDefaultMapReducePlannerSelfTest.java
+++ b/modules/hadoop/src/test/java/org/apache/ignite/internal/processors/hadoop/GridHadoopDefaultMapReducePlannerSelfTest.java
@@ -1200,7 +1200,7 @@ public class GridHadoopDefaultMapReducePlannerSelfTest extends GridHadoopAbstrac
         }
 
         /** {@inheritDoc} */
-        @Override public ClusterMetrics metrics() throws IgniteCheckedException {
+        @Override public ClusterNodeMetrics metrics() throws IgniteCheckedException {
             return null;
         }
 


Mime
View raw message