Coverage Report

Coverage Report - org.apache.giraph.counters.GiraphStats

Classes in this File

0/47

0/2

 /*
  * 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.giraph.counters;
 
 import org.apache.hadoop.mapreduce.Mapper.Context;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 
 /**
  * Hadoop Counters in group "Giraph Stats". General statistics about job.
  */
 public class GiraphStats extends HadoopCountersBase {
   /** Counter group name for the Giraph statistics */
   public static final String GROUP_NAME = "Giraph Stats";
   /** superstep counter name */
   public static final String SUPERSTEP_NAME = "Superstep";
   /** aggregate vertices counter name */
   public static final String VERTICES_NAME = "Aggregate vertices";
   /** aggregate finished vertices counter name */
   public static final String FINISHED_VERTICES_NAME =
       "Aggregate finished vertices";
   /** aggregate edges counter name */
   public static final String EDGES_NAME = "Aggregate edges";
   /** sent messages counter name */
   public static final String SENT_MESSAGES_NAME = "Sent messages";
   /** sent message bytes counter name */
   public static final String SENT_MESSAGE_BYTES_NAME = "Sent message bytes";
   /** aggregate sent messages counter name */
   public static final String AGGREGATE_SENT_MESSAGES_NAME
     = "Aggregate sent messages";
   /** aggregate sent messages bytes counter name */
   public static final String AGGREGATE_SENT_MESSAGE_BYTES_NAME
     = "Aggregate sent message bytes";
   /** workers counter name */
   public static final String CURRENT_WORKERS_NAME = "Current workers";
   /** current master partition task counter name */
   public static final String CURRENT_MASTER_PARTITION_TASK_NAME =
       "Current master task partition";
   /** last checkpointed superstep counter name */
   public static final String LAST_CHECKPOINTED_SUPERSTEP_NAME =
       "Last checkpointed superstep";
   /** aggregate bytes loaded from local disks in out-of-core */
   public static final String OOC_BYTES_LOADED_NAME =
       "Aggregate bytes loaded from local disks (out-of-core)";
   /** aggregate bytes stored to local disks in out-of-core */
   public static final String OOC_BYTES_STORED_NAME =
       "Aggregate bytes stored to local disks (out-of-core)";
   /** lowest percentage of graph in memory throughout the execution */
   public static final String LOWEST_GRAPH_PERCENTAGE_IN_MEMORY_NAME =
       "Lowest percentage of graph in memory so far (out-of-core)";
 
   /** Singleton instance for everyone to use */
   private static GiraphStats INSTANCE;
 
   /** Superstep counter */
   private static final int SUPERSTEP = 0;
   /** Vertex counter */
   private static final int VERTICES = 1;
   /** Finished vertex counter */
   private static final int FINISHED_VERTICES = 2;
   /** Edge counter */
   private static final int EDGES = 3;
   /** Sent messages counter */
   private static final int SENT_MESSAGES = 4;
   /** Workers on this superstep */
   private static final int CURRENT_WORKERS = 5;
   /** Current master task partition */
   private static final int CURRENT_MASTER_TASK_PARTITION = 6;
   /** Last checkpointed superstep */
   private static final int LAST_CHECKPOINTED_SUPERSTEP = 7;
   /** Sent message bytes counter */
   private static final int SENT_MESSAGE_BYTES = 8;
   /** Aggregate sent messages counter */
   private static final int AGG_SENT_MESSAGES = 9;
   /** Aggregate sent message bytes counter */
   private static final int AGG_SENT_MESSAGE_BYTES = 10;
   /** Aggregate OOC loaded bytes counter */
   private static final int OOC_BYTES_LOADED = 11;
   /** Aggregate OOC stored bytes counter */
   private static final int OOC_BYTES_STORED = 12;
   /** Lowest percentage of graph in memory over time */
   private static final int LOWEST_GRAPH_PERCENTAGE_IN_MEMORY = 13;
   /** Number of counters in this class */
   private static final int NUM_COUNTERS = 14;
 
   /** All the counters stored */
   private final GiraphHadoopCounter[] counters;
 
   /**
    * Create with Hadoop Context.
    *
    * @param context Hadoop Context to use.
    */
   private GiraphStats(Context context) {
     super(context, GROUP_NAME);
     counters = new GiraphHadoopCounter[NUM_COUNTERS];
     counters[SUPERSTEP] = getCounter(SUPERSTEP_NAME);
     counters[VERTICES] = getCounter(VERTICES_NAME);
     counters[FINISHED_VERTICES] = getCounter(FINISHED_VERTICES_NAME);
     counters[EDGES] = getCounter(EDGES_NAME);
     counters[SENT_MESSAGES] = getCounter(SENT_MESSAGES_NAME);
     counters[SENT_MESSAGE_BYTES] = getCounter(SENT_MESSAGE_BYTES_NAME);
     counters[CURRENT_WORKERS] = getCounter(CURRENT_WORKERS_NAME);
     counters[CURRENT_MASTER_TASK_PARTITION] =
         getCounter(CURRENT_MASTER_PARTITION_TASK_NAME);
     counters[LAST_CHECKPOINTED_SUPERSTEP] =
         getCounter(LAST_CHECKPOINTED_SUPERSTEP_NAME);
     counters[AGG_SENT_MESSAGES] =
         getCounter(AGGREGATE_SENT_MESSAGES_NAME);
     counters[AGG_SENT_MESSAGE_BYTES] =
         getCounter(AGGREGATE_SENT_MESSAGE_BYTES_NAME);
     counters[OOC_BYTES_LOADED] = getCounter(OOC_BYTES_LOADED_NAME);
     counters[OOC_BYTES_STORED] = getCounter(OOC_BYTES_STORED_NAME);
     counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY] =
         getCounter(LOWEST_GRAPH_PERCENTAGE_IN_MEMORY_NAME);
     counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY].setValue(100);
   }
 
   /**
    * Initialize with Hadoop Context.
    *
    * @param context Hadoop Context to use.
    */
   public static void init(Context context) {
     INSTANCE = new GiraphStats(context);
   }
 
   /**
    * Get singleton instance.
    *
    * @return GiraphStats singleton
    */
   public static GiraphStats getInstance() {
     return INSTANCE;
   }
 
 
   /**
    * Get a map of counter names, and values
    * To be used by the master to send to the job client
    *
    * @return Map of counter names and values
    */
   public List<CustomCounter> getCounterList() {
     List<CustomCounter> counterList = new ArrayList<>();
     for (int i = 0; i < counters.length; i++) {
       counterList.add(new CustomCounter(GROUP_NAME,
               counters[i].getDisplayName(),
               CustomCounter.Aggregation.SUM, counters[i].getValue()));
     }
     return counterList;
   }
 
   /**
    * Get SuperstepCounter counter
    *
    * @return SuperstepCounter counter
    */
   public GiraphHadoopCounter getSuperstepCounter() {
     return counters[SUPERSTEP];
   }
 
   /**
    * Get Vertices counter
    *
    * @return Vertices counter
    */
   public GiraphHadoopCounter getVertices() {
     return counters[VERTICES];
   }
 
   /**
    * Get FinishedVertexes counter
    *
    * @return FinishedVertexes counter
    */
   public GiraphHadoopCounter getFinishedVertexes() {
     return counters[FINISHED_VERTICES];
   }
 
   /**
    * Get Edges counter
    *
    * @return Edges counter
    */
   public GiraphHadoopCounter getEdges() {
     return counters[EDGES];
   }
 
   /**
    * Get SentMessages counter
    *
    * @return SentMessages counter
    */
   public GiraphHadoopCounter getSentMessages() {
     return counters[SENT_MESSAGES];
   }
 
   /**
    * Get SentMessageBytes counter
    *
    * @return SentMessageBytes counter
    */
   public GiraphHadoopCounter getSentMessageBytes() {
     return counters[SENT_MESSAGE_BYTES];
   }
 
   /**
    * Get AggregateSentMessages counter
    *
    * @return AggregateSentMessages counter
    */
   public GiraphHadoopCounter getAggregateSentMessages() {
     return counters[AGG_SENT_MESSAGES];
   }
 
   /**
    * Get AggregateSentMessageBytes counter
    *
    * @return AggregateSentMessageBytes counter
    */
   public GiraphHadoopCounter getAggregateSentMessageBytes() {
     return counters[AGG_SENT_MESSAGE_BYTES];
   }
 
   /**
    * Get CurrentWorkers counter
    *
    * @return CurrentWorkers counter
    */
   public GiraphHadoopCounter getCurrentWorkers() {
     return counters[CURRENT_WORKERS];
   }
 
   /**
    * Get CurrentMasterTaskPartition counter
    *
    * @return CurrentMasterTaskPartition counter
    */
   public GiraphHadoopCounter getCurrentMasterTaskPartition() {
     return counters[CURRENT_MASTER_TASK_PARTITION];
   }
 
   /**
    * Get LastCheckpointedSuperstep counter
    *
    * @return LastCheckpointedSuperstep counter
    */
   public GiraphHadoopCounter getLastCheckpointedSuperstep() {
     return counters[LAST_CHECKPOINTED_SUPERSTEP];
   }
 
   /**
    * Get OOCBytesLoaded counter
    *
    * @return OOCBytesLoaded counter
    */
   public GiraphHadoopCounter getAggregateOOCBytesLoaded() {
     return counters[OOC_BYTES_LOADED];
   }
 
   /**
    * Get OOCBytesStored counter
    *
    * @return OOCBytesStored counter
    */
   public GiraphHadoopCounter getAggregateOOCBytesStored() {
     return counters[OOC_BYTES_STORED];
   }
 
   public GiraphHadoopCounter getLowestGraphPercentageInMemory() {
     return counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY];
   }
 
   @Override
   public Iterator<GiraphHadoopCounter> iterator() {
     return Arrays.asList(counters).iterator();
   }
 }

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
19		package org.apache.giraph.counters;
20
21		import org.apache.hadoop.mapreduce.Mapper.Context;
22
23		import java.util.ArrayList;
24		import java.util.Arrays;
25		import java.util.Iterator;
26		import java.util.List;
27
28		/**
29		* Hadoop Counters in group "Giraph Stats". General statistics about job.
30		*/
31		public class GiraphStats extends HadoopCountersBase {
32		/** Counter group name for the Giraph statistics */
33		public static final String GROUP_NAME = "Giraph Stats";
34		/** superstep counter name */
35		public static final String SUPERSTEP_NAME = "Superstep";
36		/** aggregate vertices counter name */
37		public static final String VERTICES_NAME = "Aggregate vertices";
38		/** aggregate finished vertices counter name */
39		public static final String FINISHED_VERTICES_NAME =
40		"Aggregate finished vertices";
41		/** aggregate edges counter name */
42		public static final String EDGES_NAME = "Aggregate edges";
43		/** sent messages counter name */
44		public static final String SENT_MESSAGES_NAME = "Sent messages";
45		/** sent message bytes counter name */
46		public static final String SENT_MESSAGE_BYTES_NAME = "Sent message bytes";
47		/** aggregate sent messages counter name */
48		public static final String AGGREGATE_SENT_MESSAGES_NAME
49		= "Aggregate sent messages";
50		/** aggregate sent messages bytes counter name */
51		public static final String AGGREGATE_SENT_MESSAGE_BYTES_NAME
52		= "Aggregate sent message bytes";
53		/** workers counter name */
54		public static final String CURRENT_WORKERS_NAME = "Current workers";
55		/** current master partition task counter name */
56		public static final String CURRENT_MASTER_PARTITION_TASK_NAME =
57		"Current master task partition";
58		/** last checkpointed superstep counter name */
59		public static final String LAST_CHECKPOINTED_SUPERSTEP_NAME =
60		"Last checkpointed superstep";
61		/** aggregate bytes loaded from local disks in out-of-core */
62		public static final String OOC_BYTES_LOADED_NAME =
63		"Aggregate bytes loaded from local disks (out-of-core)";
64		/** aggregate bytes stored to local disks in out-of-core */
65		public static final String OOC_BYTES_STORED_NAME =
66		"Aggregate bytes stored to local disks (out-of-core)";
67		/** lowest percentage of graph in memory throughout the execution */
68		public static final String LOWEST_GRAPH_PERCENTAGE_IN_MEMORY_NAME =
69		"Lowest percentage of graph in memory so far (out-of-core)";
70
71		/** Singleton instance for everyone to use */
72		private static GiraphStats INSTANCE;
73
74		/** Superstep counter */
75		private static final int SUPERSTEP = 0;
76		/** Vertex counter */
77		private static final int VERTICES = 1;
78		/** Finished vertex counter */
79		private static final int FINISHED_VERTICES = 2;
80		/** Edge counter */
81		private static final int EDGES = 3;
82		/** Sent messages counter */
83		private static final int SENT_MESSAGES = 4;
84		/** Workers on this superstep */
85		private static final int CURRENT_WORKERS = 5;
86		/** Current master task partition */
87		private static final int CURRENT_MASTER_TASK_PARTITION = 6;
88		/** Last checkpointed superstep */
89		private static final int LAST_CHECKPOINTED_SUPERSTEP = 7;
90		/** Sent message bytes counter */
91		private static final int SENT_MESSAGE_BYTES = 8;
92		/** Aggregate sent messages counter */
93		private static final int AGG_SENT_MESSAGES = 9;
94		/** Aggregate sent message bytes counter */
95		private static final int AGG_SENT_MESSAGE_BYTES = 10;
96		/** Aggregate OOC loaded bytes counter */
97		private static final int OOC_BYTES_LOADED = 11;
98		/** Aggregate OOC stored bytes counter */
99		private static final int OOC_BYTES_STORED = 12;
100		/** Lowest percentage of graph in memory over time */
101		private static final int LOWEST_GRAPH_PERCENTAGE_IN_MEMORY = 13;
102		/** Number of counters in this class */
103		private static final int NUM_COUNTERS = 14;
104
105		/** All the counters stored */
106		private final GiraphHadoopCounter[] counters;
107
108		/**
109		* Create with Hadoop Context.
110		*
111		* @param context Hadoop Context to use.
112		*/
113		private GiraphStats(Context context) {
114	0	super(context, GROUP_NAME);
115	0	counters = new GiraphHadoopCounter[NUM_COUNTERS];
116	0	counters[SUPERSTEP] = getCounter(SUPERSTEP_NAME);
117	0	counters[VERTICES] = getCounter(VERTICES_NAME);
118	0	counters[FINISHED_VERTICES] = getCounter(FINISHED_VERTICES_NAME);
119	0	counters[EDGES] = getCounter(EDGES_NAME);
120	0	counters[SENT_MESSAGES] = getCounter(SENT_MESSAGES_NAME);
121	0	counters[SENT_MESSAGE_BYTES] = getCounter(SENT_MESSAGE_BYTES_NAME);
122	0	counters[CURRENT_WORKERS] = getCounter(CURRENT_WORKERS_NAME);
123	0	counters[CURRENT_MASTER_TASK_PARTITION] =
124	0	getCounter(CURRENT_MASTER_PARTITION_TASK_NAME);
125	0	counters[LAST_CHECKPOINTED_SUPERSTEP] =
126	0	getCounter(LAST_CHECKPOINTED_SUPERSTEP_NAME);
127	0	counters[AGG_SENT_MESSAGES] =
128	0	getCounter(AGGREGATE_SENT_MESSAGES_NAME);
129	0	counters[AGG_SENT_MESSAGE_BYTES] =
130	0	getCounter(AGGREGATE_SENT_MESSAGE_BYTES_NAME);
131	0	counters[OOC_BYTES_LOADED] = getCounter(OOC_BYTES_LOADED_NAME);
132	0	counters[OOC_BYTES_STORED] = getCounter(OOC_BYTES_STORED_NAME);
133	0	counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY] =
134	0	getCounter(LOWEST_GRAPH_PERCENTAGE_IN_MEMORY_NAME);
135	0	counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY].setValue(100);
136	0	}
137
138		/**
139		* Initialize with Hadoop Context.
140		*
141		* @param context Hadoop Context to use.
142		*/
143		public static void init(Context context) {
144	0	INSTANCE = new GiraphStats(context);
145	0	}
146
147		/**
148		* Get singleton instance.
149		*
150		* @return GiraphStats singleton
151		*/
152		public static GiraphStats getInstance() {
153	0	return INSTANCE;
154		}
155
156
157		/**
158		* Get a map of counter names, and values
159		* To be used by the master to send to the job client
160		*
161		* @return Map of counter names and values
162		*/
163		public List<CustomCounter> getCounterList() {
164	0	List<CustomCounter> counterList = new ArrayList<>();
165	0	for (int i = 0; i < counters.length; i++) {
166	0	counterList.add(new CustomCounter(GROUP_NAME,
167	0	counters[i].getDisplayName(),
168	0	CustomCounter.Aggregation.SUM, counters[i].getValue()));
169		}
170	0	return counterList;
171		}
172
173		/**
174		* Get SuperstepCounter counter
175		*
176		* @return SuperstepCounter counter
177		*/
178		public GiraphHadoopCounter getSuperstepCounter() {
179	0	return counters[SUPERSTEP];
180		}
181
182		/**
183		* Get Vertices counter
184		*
185		* @return Vertices counter
186		*/
187		public GiraphHadoopCounter getVertices() {
188	0	return counters[VERTICES];
189		}
190
191		/**
192		* Get FinishedVertexes counter
193		*
194		* @return FinishedVertexes counter
195		*/
196		public GiraphHadoopCounter getFinishedVertexes() {
197	0	return counters[FINISHED_VERTICES];
198		}
199
200		/**
201		* Get Edges counter
202		*
203		* @return Edges counter
204		*/
205		public GiraphHadoopCounter getEdges() {
206	0	return counters[EDGES];
207		}
208
209		/**
210		* Get SentMessages counter
211		*
212		* @return SentMessages counter
213		*/
214		public GiraphHadoopCounter getSentMessages() {
215	0	return counters[SENT_MESSAGES];
216		}
217
218		/**
219		* Get SentMessageBytes counter
220		*
221		* @return SentMessageBytes counter
222		*/
223		public GiraphHadoopCounter getSentMessageBytes() {
224	0	return counters[SENT_MESSAGE_BYTES];
225		}
226
227		/**
228		* Get AggregateSentMessages counter
229		*
230		* @return AggregateSentMessages counter
231		*/
232		public GiraphHadoopCounter getAggregateSentMessages() {
233	0	return counters[AGG_SENT_MESSAGES];
234		}
235
236		/**
237		* Get AggregateSentMessageBytes counter
238		*
239		* @return AggregateSentMessageBytes counter
240		*/
241		public GiraphHadoopCounter getAggregateSentMessageBytes() {
242	0	return counters[AGG_SENT_MESSAGE_BYTES];
243		}
244
245		/**
246		* Get CurrentWorkers counter
247		*
248		* @return CurrentWorkers counter
249		*/
250		public GiraphHadoopCounter getCurrentWorkers() {
251	0	return counters[CURRENT_WORKERS];
252		}
253
254		/**
255		* Get CurrentMasterTaskPartition counter
256		*
257		* @return CurrentMasterTaskPartition counter
258		*/
259		public GiraphHadoopCounter getCurrentMasterTaskPartition() {
260	0	return counters[CURRENT_MASTER_TASK_PARTITION];
261		}
262
263		/**
264		* Get LastCheckpointedSuperstep counter
265		*
266		* @return LastCheckpointedSuperstep counter
267		*/
268		public GiraphHadoopCounter getLastCheckpointedSuperstep() {
269	0	return counters[LAST_CHECKPOINTED_SUPERSTEP];
270		}
271
272		/**
273		* Get OOCBytesLoaded counter
274		*
275		* @return OOCBytesLoaded counter
276		*/
277		public GiraphHadoopCounter getAggregateOOCBytesLoaded() {
278	0	return counters[OOC_BYTES_LOADED];
279		}
280
281		/**
282		* Get OOCBytesStored counter
283		*
284		* @return OOCBytesStored counter
285		*/
286		public GiraphHadoopCounter getAggregateOOCBytesStored() {
287	0	return counters[OOC_BYTES_STORED];
288		}
289
290		public GiraphHadoopCounter getLowestGraphPercentageInMemory() {
291	0	return counters[LOWEST_GRAPH_PERCENTAGE_IN_MEMORY];
292		}
293
294		@Override
295		public Iterator<GiraphHadoopCounter> iterator() {
296	0	return Arrays.asList(counters).iterator();
297		}
298		}