Speedtest per Konsole

Nachfolgendes Skript testet auf Openwrt-Systemen die Down-/Upload Geschwindigkeit eines Knotens. Das besondere hierbei ist, dass mehrere Verbindungen gleichzeitig verwendet werden, um den Durchsatz ans physische Maximum zu bringen und eine verlässliche Aussage zu bekommen.

Bitte keine Glaubens- oder Notwendigkeitsfragen. Ich stelle nur das Know-How vor. Handlung auf eigene Gefahr - Keine Verantwortung für etwaige Schäden am Gerät.

Bevor Ihr lustig Skripte und APPs installiert, bedenkt bitte, dass der Flashspeicher vom 841 SEHR knapp ist. Bei völliger Belegung des Speichers, kann das Gerät unbenutzbar werden. Prüft vorher mit df -h die Belegung
Vor der installation:
344.0K von 576K frei
Nach der Installation
184.0K von 576K frei

Dies Skript (betterspeedtest.sh) stammt von GitHub - richb-hanover/CeroWrtScripts: A set of scripts spawned by the CeroWrt project http://bufferbloat.net/projects/cerowrt und ist nur eines von einer handvoll weiteren Skripten.

folgendes Skript habe ich kopiert und direkt den EU Server voreingestellt.

Vorbereitung per SSH auf der Konsole des Routers:

opkg update
opkg install netperf
vi speedtest
(script unten kopieren)
(per „i“ in den insert-mode wechseln)
strg+v
esc
:wq! <enter>
chmod +x speedtest
./speedtest -6  (startet den Test)

Usage: sh betterspeedtest.sh [-4 -6] [ -H netperf-server ] [ -t duration ] [ -p host-to-ping ] [ -n simultaneous-streams ]

Options: If options are present:

 -H | --host:   DNS or Address of a netperf server (default - netperf.bufferbloat.net)
                Alternate servers are netperf-east (east coast US), netperf-west (California), 
                and netperf-eu (Denmark)
 -4 | -6:       enable ipv4 or ipv6 testing (ipv4 is the default)
 -t | --time:   Duration for how long each direction's test should run - (default - 60 seconds)
 -p | --ping:   Host to ping to measure latency (default - gstatic.com)
 -n | --number: Number of simultaneous sessions (default - 5 sessions)

betterspeedtest.sh

#!/bin/sh
​
# betterspeedtest.sh - Script to simulate http://speedtest.net
# Start pinging, then initiate a download, let it finish, then start an upload
# Output the measured transfer rates and the resulting ping latency
# It's better than 'speedtest.net' because it measures latency *while* measuring the speed.
​
# Usage: sh betterspeedtest.sh [-4 -6] [ -H netperf-server ] [ -t duration ] [ -p host-to-ping ] [ -n simultaneous-streams ]
​
# Options: If options are present:
#
# -H | --host:   DNS or Address of a netperf server (default - netperf.bufferbloat.net)
#                Alternate servers are netperf-east (east coast US), netperf-west (California), 
#                and netperf-eu (Denmark)
# -4 | -6:       enable ipv4 or ipv6 testing (ipv4 is the default)
# -t | --time:   Duration for how long each direction's test should run - (default - 60 seconds)
# -p | --ping:   Host to ping to measure latency (default - gstatic.com)
# -n | --number: Number of simultaneous sessions (default - 5 sessions)
​
# Copyright (c) 2014 - Rich Brown rich.brown@blueberryhillsoftware.com
# GPLv2
​
# Summarize the contents of the ping's output file to show min, avg, median, max, etc.
# 	input parameter ($1) file contains the output of the ping command
​
summarize_pings() {			
	
	# Process the ping times, and summarize the results
	# grep to keep lines that have "time=", then sed to isolate the time stamps, and sort them
	# awk builds an array of those values, and prints first & last (which are min, max) 
	#	and computes average.
	# If the number of samples is >= 10, also computes median, and 10th and 90th percentile readings
	sed 's/^.*time=\([^ ]*\) ms/\1/' < $1 | grep -v "PING" | sort -n | \
	awk 'BEGIN {numdrops=0; numrows=0;} \
		{ \
			if ( $0 ~ /timeout/ ) { \
			   	numdrops += 1; \
			} else { \
				numrows += 1; \
				arr[numrows]=$1; sum+=$1; \
			} \
		} \
		END { \
			pc10="-"; pc90="-"; med="-"; \
			if (numrows == 0) {numrows=1} \
			if (numrows>=10) \
			{ 	ix=int(numrows/10); pc10=arr[ix]; ix=int(numrows*9/10);pc90=arr[ix]; \
				if (numrows%2==1) med=arr[(numrows+1)/2]; else med=(arr[numrows/2]); \
			}; \
			pktloss = numdrops/(numdrops+numrows) * 100; \
			printf("  Latency: (in msec, %d pings, %4.2f%% packet loss)\n      Min: %4.3f \n    10pct: %4.3f \n   Median: %4.3f \n      Avg: %4.3f \n    90pct: %4.3f \n      Max: %4.3f\n", numrows, pktloss, arr[1], pc10, med, sum/numrows, pc90, arr[numrows] )\
		 }'
}
​
# Print a line of dots as a progress indicator.
​
print_dots() {
	while : ; do
		printf "."
		sleep 1s
	done
}
​
# Stop the current print_dots() process
​
kill_dots() {
	# echo "Pings: $ping_pid Dots: $dots_pid"
	kill -9 $dots_pid
	wait $dots_pid 2>/dev/null
	dots_pid=0
}
​
# Stop the current ping process
​
kill_pings() {
	# echo "Pings: $ping_pid Dots: $dots_pid"
	kill -9 $ping_pid 
	wait $ping_pid 2>/dev/null
	ping_pid=0
}
​
# Stop the current pings and dots, and exit
# ping command catches (and handles) first Ctrl-C, so you have to hit it again...
kill_pings_and_dots_and_exit() {
	kill_dots
	echo "\nStopped"
	exit 1
}
​
# ------------ Measure speed and ping latency for one direction ----------------
#
# Called with measure_direction "Download" $TESTHOST $TESTDUR $PINGHOST
​
measure_direction() {
​
	# Create temp files
	PINGFILE=`mktemp /tmp/measurepings.XXXXXX` || exit 1
	SPEEDFILE=`mktemp /tmp/netperfUL.XXXXXX` || exit 1
	
	# Start dots
	print_dots &
	dots_pid=$!
	# echo "Dots PID: $dots_pid"
​
	# Start Ping
	if [ $TESTPROTO -eq "-4" ]
	then
		ping $4 > $PINGFILE &
	else
		ping6 $4 > $PINGFILE &
	fi
	ping_pid=$!
	# echo "Ping PID: $ping_pid"
	
	# Start netperf with the proper direction
	if [ $1 = "Download" ]; then
		dir="TCP_MAERTS"
	else
		dir="TCP_STREAM"
	fi
	
	# Start $MAXSESSIONS datastreams between netperf client and the netperf server
	# netperf writes the sole output value (in Mbps) to stdout when completed
	for i in $( seq $MAXSESSIONS )
	do
		netperf $TESTPROTO -H $TESTHOST -t $dir -l $TESTDUR -v 0 -P 0 >> $SPEEDFILE &
		#echo "Starting $!"
	done
	
	# Wait until each of the background netperf processes completes 
	# echo "Process is $$"
	# echo `pgrep -P $$ netperf `
​
	for i in `pgrep -P $$ netperf `		# gets a list of PIDs for child processes named 'netperf'
	do
		#echo "Waiting for $i"
		wait $i
	done
​
	# Print TCP Download speed
	echo ""
	echo " $1: " `awk '{s+=$1} END {print s}' $SPEEDFILE` Mbps
​
	# When netperf completes, stop the dots and the pings
	kill_pings
	kill_dots
​
	# Summarize the ping data
	summarize_pings $PINGFILE
​
	rm $PINGFILE
	rm $SPEEDFILE
}
​
# ------- Start of the main routine --------
​
# Usage: sh betterspeedtest.sh [ -4 -6 ] [ -H netperf-server ] [ -t duration ] [ -p host-to-ping ] [ -n simultaneous-sessions ]
​
# “H” and “host” DNS or IP address of the netperf server host (default: netperf.bufferbloat.net)
# “t” and “time” Time to run the test in each direction (default: 60 seconds)
# “p” and “ping” Host to ping for latency measurements (default: gstatic.com)
# "n" and "number" Number of simultaneous upload or download sessions (default: 5 sessions;
#       5 sessions chosen empirically because total didn't increase much after that number)
​
# set an initial values for defaults
TESTHOST="netperf-eu.bufferbloat.net"
TESTDUR="60"
PINGHOST="gstatic.com"
MAXSESSIONS="5"
TESTPROTO=-4
​
# read the options
​
# extract options and their arguments into variables.
while [ $# -gt 0 ] 
do
    case "$1" in
	    -4|-6) TESTPROTO=$1 ; shift 1 ;;
        -H|--host)
            case "$2" in
                "") echo "Missing hostname" ; exit 1 ;;
                *) TESTHOST=$2 ; shift 2 ;;
            esac ;;
        -t|--time) 
        	case "$2" in
        		"") echo "Missing duration" ; exit 1 ;;
                *) TESTDUR=$2 ; shift 2 ;;
            esac ;;
        -p|--ping)
            case "$2" in
                "") echo "Missing ping host" ; exit 1 ;;
                *) PINGHOST=$2 ; shift 2 ;;
            esac ;;
        -n|--number)
        	case "$2" in
        		"") echo "Missing number of simultaneous sessions" ; exit 1 ;;
        		*) MAXSESSIONS=$2 ; shift 2 ;;
        	esac ;;
        --) shift ; break ;;
        *) echo "Usage: sh betterspeedtest.sh [-4 -6] [ -H netperf-server ] [ -t duration ] [ -p host-to-ping ] [ -n simultaneous-sessions ]" ; exit 1 ;;
    esac
done
​
# Start the main test
​
if [ $TESTPROTO -eq "-4" ]
then
	PROTO="ipv4"
else
	PROTO="ipv6"
fi
DATE=`date "+%Y-%m-%d %H:%M:%S"`
echo "$DATE Testing against $TESTHOST ($PROTO) with $MAXSESSIONS simultaneous sessions while pinging $PINGHOST ($TESTDUR seconds in each direction)"
​
# Catch a Ctl-C and stop the pinging and the print_dots
trap kill_pings_and_dots_and_exit HUP INT TERM
​
measure_direction "Download" $TESTHOST $TESTDUR $PINGHOST $MAXSESSIONS
measure_direction "  Upload" $TESTHOST $TESTDUR $PINGHOST $MAXSESSIONS
7 Likes

Funktioniert ganz gut @gomaaz . Zwei Anmerkungen hätte ich noch.
Das Paket heißt netperf zumindest hat er kein nperf gefunden.
Und wenn ich das hier aus dem Browser (Chrome) kopiere hat er bei mir da wohl bei jeder Leerzeile ein unsichtbares Steuerzeichen stehen was beim Scriptablauf dafür sorgt das dort steht "line xxx : not found " aber soweit nicht stört.
Habe es in Notpad++ kopiert und in jeder Leerzeile das Steuerzeichen gelöscht.
Und schön läuft es auch optisch sauer durch.

Danke

…hast recht. Habe ich korrigiert…war schon zu spät gestern…

dann kannst du auch das File von Github ziehen

wie gesagt, habe nur den EU Server eingestellt.

Was meinst du mit EU, ein Server in der europäischen Union? OK, jetzt habe ich es auch gefunden, netperf-eu.bufferbloat.net damit ist die Frage schon beantwortet.

Könnte man sowas auch auf einem der Fastd Server einrichten innerhalb des FF Netz um nur den Router zu belasten und nicht noch den Exit? Oder um ggf. Vergleichsmessungen zu machen?

innerhalb des Netzes kannst du ./speedtest -6 aufrufen, dann wird ein ipv6 test gemacht
Wenn du FF rausfallen lassen willst um die Anbindung zu checken: -4 für ipv4

steht in Dänemark lt. Doku und nicht in Übersee

Du kannst die default-werte auch für dich anpassen, dann führst du nur noch ./speedtest aus

Ich benutze was sehr Primitives, größere des Paketes muss ich selbst einschätzen vor dem Start:

START=$(date +%s);  wget -O /dev/null http://ovh.net/files/100Mio.dat; END=$(date +%s); echo $((END-START))| awk '{print int(800/$1)}'

START=$(date +%s);  wget -O /dev/null http://ovh.net/files/1Gio.dat; END=$(date +%s); echo $((END-START))| awk '{print int(8000/$1)}'

START=$(date +%s);  wget -O /dev/null http://ovh.net/files/10Gio.dat; END=$(date +%s); echo $((END-START))| awk '{print int(80000/$1)}'
1 Like

Dann kommt man an den oben vorgeschlagenen Lösungen kaum vorbei, wenn es wirklich auf der ssh-Konsole passieren soll.

Nur leider ist auf den 4MB-Flash-Geräten nur noch sehr, sehr wenig Platz, um Dinge nachzuinstallieren.
Selbst ein iperf passt da in der Regel nimmer.

Wir haben dahinter ein Rechner gestellt und dann Traffic darüber geleitet. Entspricht mehr dem normalen Einsatz einer node.

schon klar, das dass das bessere Szenario ist.
Aber wenn es nur darum geht, zu schauen, was denn zumindest minimal aus dem DSL/Docsis grade herauskommen kann, dann ist es schonmal ein Anhalt, insbesondere auf Futro & Co.

Da es im anderen Thread Zweifel an der syntaktischen Richtigkeit (?) gab, zumindest hier geht’s mit Gluon 2016.1.4

So schaut das bei mir aus: