/**
* Copyright 2013, Big Switch Networks, Inc.
*
* Licensed 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 net.floodlightcontroller.util;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import net.floodlightcontroller.core.annotations.LogMessageDocs;
import net.floodlightcontroller.core.annotations.LogMessageDoc;
public class LoadMonitor implements Runnable {
public enum LoadLevel {
OK,
HIGH,
VERYHIGH,
}
public LoadLevel getLoadLevel() {
return loadlevel ;
}
public double getLoad() {
return load ;
}
public static final int LOADMONITOR_SAMPLING_INTERVAL = 1000; // mili-sec
public static final double THRESHOLD_HIGH = 0.90;
public static final double THRESHOLD_VERYHIGH = 0.95;
public static final int MAX_LOADED_ITERATIONS = 5;
public static final int MAX_LOAD_HISTORY = 5;
protected volatile double load;
protected volatile LoadLevel loadlevel;
protected int itersLoaded;
protected boolean isLinux;
protected int numcores;
protected int jiffyNanos;
protected long[] lastNanos;
protected long[] lastIdle;
protected Logger log;
public LoadMonitor(Logger log_) {
log = log_;
loadlevel = LoadLevel.OK;
load = 0.0;
itersLoaded = 0;
lastNanos = new long[MAX_LOAD_HISTORY];
lastIdle = new long[MAX_LOAD_HISTORY];
for (int i=0 ; i<MAX_LOAD_HISTORY ; i++) {
lastNanos[i] = 0L;
lastIdle[i] = 0L;
}
isLinux = System.getProperty("os.name").equals("Linux");
numcores = 1;
jiffyNanos = 10 * 1000 * 1000;
if (isLinux) {
try {
numcores = Integer.parseInt(
this.runcmd("/usr/bin/nproc"));
jiffyNanos = (1000 * 1000 * 1000) / Integer.parseInt(
this.runcmd("/usr/bin/getconf CLK_TCK"));
}
catch (NumberFormatException ex) {
if (log != null) {
// Log message documented on runcmd function
log.error("Exception in inializing load monitor ", ex);
}
else {
ex.printStackTrace();
}
}
}
}
@Override
@LogMessageDocs({
@LogMessageDoc(
message="System under very heavy load, dropping some packet-ins",
explanation="We detcted that the system was under very heavy" +
" load, dropping some packet-ins temporarily"),
@LogMessageDoc(
message="System under heavy load, dropping some new flows",
explanation="We detcted that the system was under heavy load," +
" dropping some new flows temporarily")
})
public void run() {
if (!isLinux) return;
long currNanos = System.nanoTime();
long currIdle = this.readIdle();
for (int i=0 ; i < (MAX_LOAD_HISTORY - 1) ; i++) {
lastNanos[i] = lastNanos[i+1];
lastIdle[i] = lastIdle[i+1];
}
lastNanos[MAX_LOAD_HISTORY - 1] = currNanos;
lastIdle[MAX_LOAD_HISTORY - 1] = currIdle;
if (itersLoaded >= MAX_LOADED_ITERATIONS) {
loadlevel = LoadLevel.OK;
itersLoaded = 0;
return;
}
long nanos = lastNanos[MAX_LOAD_HISTORY - 1] - lastNanos[0];
long idle = lastIdle[MAX_LOAD_HISTORY - 1] - lastIdle[0];
load =
1.0 - ((double)(idle * jiffyNanos) / (double)(nanos * numcores));
if (load > THRESHOLD_VERYHIGH) {
loadlevel = LoadLevel.VERYHIGH;
itersLoaded += 1;
String msg = "System under very heavy load, dropping packet-ins.";
if (log != null) {
log.error(msg);
}
else {
System.out.println(msg);
}
return;
}
if (load > THRESHOLD_HIGH) {
loadlevel = LoadLevel.HIGH;
itersLoaded += 1;
String msg = "System under heavy load, dropping new flows.";
if (log != null) {
log.error(msg);
}
else {
System.out.println(msg);
}
return;
}
loadlevel = LoadLevel.OK;
itersLoaded = 0;
return;
}
@LogMessageDoc(
message="Exception in reading load monitor params, using defaults",
explanation="There was an error in inializing load monitor's props," +
" using default parameters")
protected String runcmd(String cmd) {
String line;
StringBuilder ret = new StringBuilder();
try {
Process p = Runtime.getRuntime().exec(cmd);
BufferedReader input =
new BufferedReader(
new InputStreamReader(p.getInputStream()));
while ((line = input.readLine()) != null) {
ret.append(line);
}
input.close();
p.waitFor();
}
catch (InterruptedException ex) {
if (log != null) {
log.error("Exception in inializing load monitor ", ex);
}
else {
ex.printStackTrace();
}
}
catch (IOException ex) {
if (log != null) {
log.error("Exception in inializing load monitor ", ex);
}
else {
ex.printStackTrace();
}
}
return ret.toString();
}
protected long readIdle() {
long idle = 0;
FileInputStream fs = null;
BufferedReader reader = null;
try {
try {
fs = new FileInputStream("/proc/stat");
reader = new BufferedReader(new InputStreamReader(fs));
String line = reader.readLine();
if (line == null) throw new IOException("Empty file");
idle = Long.parseLong(line.split("\\s+")[4]);
} finally {
if (reader != null)
reader.close();
if (fs != null)
fs.close();
}
} catch (IOException ex) {
log.error("Error reading idle time from /proc/stat", ex);
}
return idle;
}
public ScheduledFuture<?> startMonitoring(ScheduledExecutorService ses)
{
ScheduledFuture<?> monitorTask =
ses.scheduleAtFixedRate(
this, 0,
LOADMONITOR_SAMPLING_INTERVAL, TimeUnit.MILLISECONDS);
return monitorTask;
}
/*
* For testing
*/
public ScheduledFuture<?> printMonitoring(ScheduledExecutorService ses)
{
final LoadMonitor mon = this;
ScheduledFuture<?> monitorTask =
ses.scheduleAtFixedRate(
new Runnable() {
public void run() {
System.out.println(mon.getLoad());
}
}, LOADMONITOR_SAMPLING_INTERVAL/2,
LOADMONITOR_SAMPLING_INTERVAL, TimeUnit.MILLISECONDS);
return monitorTask;
}
public static void main(String[] args) {
final LoadMonitor monitor = new LoadMonitor(null);
final ScheduledExecutorService scheduler =
Executors.newScheduledThreadPool(1);
final ScheduledFuture<?> monitorTask =
monitor.startMonitoring(scheduler);
final ScheduledFuture<?> printTask =
monitor.printMonitoring(scheduler);
// Run the tasks for 2 minutes
scheduler.schedule(
new Runnable() {
public void run() {
monitorTask.cancel(true);
printTask.cancel(true);
}
}, 5*60, TimeUnit.SECONDS);
}
}