B. Apéndice B

B. Apéndice B
Programas creados para automatizar las simulaciones
Aquí se detalla el contenido de los scripts usados en el estudio de dimensionamiento y
multiplexión, así como programas adicionales utilizados para el calcula de estadísticos como
medias, varianzas o intervalos de confianza.
Programas del estudio de multiplexión
simulacion.sh
__________________________________________________________________________
#! /bin/bash
# fichero para crear las simulaciones
fuentes=$1;
codec=$2;
alfa=$3;
inicio=10;
incremento=10;
fin=70;
f_entorno=entorno_mux;
[ ! -d estadisticas_N$fuentes$codec ] || (rm -r estadisticas_N$fuentes$codec; echo
"Borré el antiguo directorio \"estadisticas_N$fuentes$codec\" .")
mkdir estadisticas_N$fuentes$codec;
capacidad=`./capacidad $fuentes $codec $alfa | awk '{if($1=="Cap")print $2}'`;
for bufer in 1 `seq $inicio $incremento $fin`
do
# Borrará un archivo sólo si existe, si no existe sólo ejecuta la primera comparación
f_plot=N"$fuentes"_alfa"$alfa"_bufer"$bufer"_codec"$codec".plot
[ ! -f "$f_entorno$bufer.ef" ] || (rm -f $f_entorno$bufer; echo "Borré el antiguo
archivo \"$f_entorno$bufer.ef\" .")
#[ ! -f "$f_plot" ] || (rm -f $f_plot; echo "Borré el antiguo archivo \"$f_plot\" .")
# Guarda el tamano del bufer en bits
bufer_bits=`./parametros $fuentes $codec $alfa | awk -v bufer=$bufer
'{if(bufer==$1)print $2}'`;
cp $f_entorno.ef $f_entorno$bufer.ef;
echo "Creé el nuevo archivo \"$f_entorno$bufer.ef\" .";
awk -v valor=$bufer_bits -v capacidad=$capacidad -v fichero=$f_entorno$bufer.ef -f
entorno.awk $f_entorno.ef;
for seed in `seq 101 121`
do
f_ov=ov_N"$fuentes"_alfa"$alfa"_bufer"$bufer"_seed"$seed"
op_runsim -mem_optimize true -net_name voz_modificado-"$fuentes"fuentes$codec noprompt -ef $f_entorno$bufer
-seed $seed -ov_file $f_ov;
sh estadisticas.sh $f_ov $bufer $f_plot $fuentes $codec;
done
done;
# Hago limpieza
rm *.ot
rm /home/juan/*.ov
59
__________________________________________________________________________
estadisticas.sh
__________________________________________________________________________
# Maneja los ficheros de estadisticas .ov pasandolos a formanto ASCII
# e invocando a los programas que calculan la probabilidad de perdidas
f_salida=/home/juan/salida;
# nombre del fichero txt donde guardaremos las
estadisticas.
f_ov=$1;
# nombre del fichero .ov generado por opnet
bufer=$2;
f_plot=$3;
fuentes=$4;
codec=$5;
dir_project=/home/juan/op_models/voz_modificado.project/;
# directorio donde se
guardan los .ov
op_cvov -output_file_path $f_ov.txt -vector_data -vector_data_format S\# vector_patterns ...overflows ...busy -m $f_ov ;
cp $dir_project$f_ov.ov /home/juan/;
# Borrará un archivo sólo si existe, si no existe sólo
ejecuta la primera
comparación
[ ! -f "$dir_project$f_ov.ov" ] || (rm -f $dir_project$f_ov.ov; echo "Borré el antiguo
archivo \"$dir_project$f_ov.ov\" .")
awk -v bufer=$bufer -f estadisticas.awk $f_ov.txt >>
estadisticas_N$fuentes$codec/$f_plot ;
rm $f_ov.txt;
__________________________________________________________________________
grafica.sh
__________________________________________________________________________
# Fichero: grafica.sh
# Fecha : 2/02/08
#Autor : Juan I. Jimenez
#-------------------------------------------------------------------------#
DESCRIPCION
#-------------------------------------------------------------------------# Calcula el la probabilidad media de perdidas para cada valor del bufer
# en funcion de todos los puntos obtenidos con las distintas simulaciones.
# Posteriormente pinta las graficas usando gnuplot.
#
#-------------------------------------------------------------------------#-------------------------------------------------------------------------#
INVOCACION
#-------------------------------------------------------------------------#
#
sh grafica.sh <fuentes> <codec>
#-------------------------------------------------------------------------# BUG IMPORTANTE: SI FALTA ALGÚN DIRECTORIO DE LOS QUE BUSCA, LOS SIGUIENTES
# NO LO TENDRÁ EN CUENTA
#-------------------------------------------------------------------------# Argumentos que se pasan al script por linea de comandos
# para recorrer los directorios que contienen los ficheros con los puntos
# Tambien creamos una variable con el nombre base de los directorios
#
#-------------------------------------------------------------------------dir=estadisticas_N;
alfa=0.65;
#--------------------------------------------------------------------------
60
# Este bucle va recorriendo todos los directorios
#-------------------------------------------------------------------------for fuentes in 10 20 30 40 50
do
for codec in G729A G729AB
do
dir_act=$dir$fuentes$codec
# Voy cambiando de directorio si este existe
if [ -d $dir_act ]
then cd $dir_act; echo "Directorio actual $dir_act"
else
echo "no existe el directorio \"$dir_act\"."
fi
# Borro archivos antiguos que pueden existir de una ejecucion anterior del script
media=N"$fuentes"_alfa"$alfa"_codec"$codec".media
[ ! -f $media ] || (rm $media; echo "Borré el antiguo archivo \"$media\" .")
# Voy recorriendo los archivos del directorio actual
for bufer in 1 10 20 30 40 50 60 70
do
# Creo el nombre del archivo
if test $fuentes -eq 50
then alfa=0.60
fi
fichero=N"$fuentes"_alfa"$alfa"_bufer"$bufer"_codec"$codec".plot
# Creamos un fichero con la probabilidad media de perdidas y dibujamos el
intervalo de confianza de 90 %
[ ! -f $fichero ] || ( awk -f ../mediavar.awk $fichero | awk '{printf($3" 0.1 -intervalo %e %e",$8,$11)}' | awk -f ../tstudent.awk | awk -v x=$bufer -f ../error.awk
>> $media )
done
# Vuelvo al directorio original
cd ..
done
done
__________________________________________________________________________
El fichero parametros.c es usado por simulación.sh para diferentes cálculos.
parametros.c
__________________________________________________________________________
/**********************************************************************/
/* fichero: parametros.c
*/
/* Descripcion: Calcula el tamano max. y min. del buffer en funcion */
/*
del codec usado,del numero de fuentes y de la alfa.*/
/**********************************************************************/
/*********************** Invocacion ***********************************/
/*
calcula <numero_de_fuentes> <codec> <alfa>
*/
/**********************************************************************/
#include
#include
#include
#include
<stdio.h>
<math.h>
<stdlib.h>
<string.h>
int bufer_max(int N,float T,float alfa,float D);
int bufer_min(int N,float alfa);
int reg_salida(int reg_codec,int N, float alfa);
61
int main(int argc, char *argv[]){
int Rb;
/* regimen del codec en estado activo */
float T;
/* tiempo de trama del codec */
int cabecera = 8+12+20+7; /* rtp+udp+ip+ppp en bytes*/
int paquete_size;
/*tamano del paquete final en bits*/
long aux;
int bufer;
/* valores de interes para el bufer */
long bufer_bits;
int N;
int sizeACT;
float alfa;
float D = 0.05; /* Retraso max. permido a un paquete en el buffer */
if (argc == 4){
N=atoi(argv[1]); /* numero de fuentes multiplexadas */
alfa = (double)atof(argv[3]);
/* que tipo de codec se esta usando */
if((strcmp(argv[2],"G729A")==0)||(strcmp(argv[2],"G729AB")==0)){
Rb=8000;
sizeACT=10;
T=0.01;
}
else if (strcmp(argv[2],"AMR475")==0){
Rb=4750;
T=0.02;
sizeACT=12; /* Puede calcularse como ceil(Rb*T/8) */
}
else if(strcmp(argv[2],"AMR122")==0){
Rb=12200;
T=0.02;
sizeACT=31;
}
else{
printf ("Codec desconocido\n");
exit(1);
}
/*Calculo el tamaño del paquete ACT */
paquete_size=(sizeACT+cabecera)*8;
aux=bufer_max(N,T,alfa,D);
bufer_bits =(long)aux*paquete_size;
printf("%d\t%ld\n",1,paquete_size);
for (bufer=10;bufer<80;bufer+=10){
printf("%d\t%ld\n",bufer,(long)bufer*paquete_size);
}
}
else
printf("Invocacion incorrecta: calcula <numero_de_fuentes> <codec> <alfa>");
return 0;
}
int bufer_max(int N,float T,float alfa,float D){
float m;
m=D*alfa*N/T;
m = floor(m);
return m;
}
int reg_salida(int reg_codec,int N, float alfa){
/* Para conseguir precision */
62
alfa = alfa*100;
alfa=roundf(alfa);
return alfa*N*reg_codec/100
;
}
int bufer_min(int N,float alfa){
float m= (alfa*N)-1;
return ceil(m);
}
__________________________________________________________________________
El programa entorno.awk se usa para crear el archivo de entorno de la simulación con los
parámetros adecuados.
entorno.awk
_____________________________________________________________________________
# cambia el fichero de entorno del opnet de donde lee los parametros
BEGIN{
printf "\"Office network.router.ppp_tx_05_0.channel [0].bit capacity\" :
\"%d\"\n",valor >> fichero;
printf "\"Office network.router <-> destino.data rate\" : \"%d\"\n",capacidad >>
fichero;
}
estadisticas.awk
sirve para filtrar los ficheros de estadísticas que obtenemos de OPNET.
estadisticas.awk
__________________________________________________________________________
BEGIN{
desbordamiento=0;
paquetes=0;
}
{
# Esta linea indica el comienzo de los datos estadisticos : 0 seg. 0 estad.
(para el tiempo 0 el estadistico siempre vale cero).
if (($1==0) && ($2==0)){
inicio =1;
}
}
{
if($1 ~ /Statistic/)
{
estadistica = $3;
if(estadistica ~ /overflows/)
desbordamiento=1;
if(estadistica ~ /busy/)
paquetes=1;
}
}
{
63
if ($1 ~ /Number/){
valor=$4;
if(desbordamiento==1){
# Al numero total de valores hay que quitarle los tomados en 0.0 seg. y fin_simulation
ya que valen siempre 0.
desbord_total = valor -2;
#
printf "desbordamientos=%d\n",desbord_total;
desbordamiento =0;
}
}
}
{
# Se ha llegado a los datos y estos son de el estadistico paquetes
if ((paquetes==1) && (inicio==1)){
# Si no se ha llegado al final de los datos
if($0 !~ /Vector end/)
suma +=$2;
}
}
# Para calcula el numero de paquetes real hay que restar los que no sean de voz, que
siempre son 2 del protocolo RIP.
END{
paquetes_no_voz=2;
# printf "paquetes=%d\n",suma-paquetes_no_voz;
printf "%d\t%e\n",bufer,desbord_total/(suma+desbord_total-paquetes_no_voz);
}
__________________________________________________________________________
Programas del estudio de dimensionamiento
simulacion.sh
__________________________________________________________________________
#! /bin/bash
#-------------------------------------------------------------------------------#
DESCRIPCION
#-------------------------------------------------------------------------------#
# Script para invocar las simulaciones de opnet con los parametros alfa,capacidad
del enlace de salida del router
# y tamano del bufer adecuados.
#
# Autor : Juan I. Jimenez Anguiano
# Fecha : 05/02/08
#
#-------------------------------------------------------------------------------#--------------------------------- INVOCACION ----------------------------------#
#
sh simulacion.sh <fuentes>
#
#--------------------------------------------------------------------------------# Los parametros que recibe el script a traves de la linea de comandos son el
numero de fuentes y el tipo de codec. #
# Tambien se definen algunas constantes que se usaran a lo largo del script.
#--------------------------------------------------------------------------------fuentes=$1;
codec=$2;
64
#--------------------------------------------------------------------------------# En primer lugar creamos un entorno de trabajo a partir del directorio
$HOME/dimensionamiento.
#
# Despues se crea el fichero de entorno que debe recibir el comando op_runsim como
parametro.Algunos valores de éste #
# iran variando en las distintas simulaciones. En concreto, la capacidad del
enlace de salida y el tamano del bufer. #
# Se creará un directorio para organizar los ficheros de cada simulacion. Si el
directorio ya existia de una
#
# ejecucion anterior de este programa,será borrado.
#
#------------------------------------------------------------------------------ #
if [ ! -d $HOME/dimensionamiento ]
then
mkdir $HOME/dimensionamiento
else
cd $HOME/dimensionamiento
fi
f_entorno=dim ;
[ ! -d estadisticas_N$fuentes ] || (rm -r estadisticas_N$fuentes; echo Borré el
antiguo directorio \"estadisticas_N$fuentes\" .)
mkdir $HOME/dimensionamiento/estadisticas_N$fuentes;
for codec in
do
G729A G729AB
#--------------------------------------------------------------------------------# Se crean varios bucles for anidados para llamar a op_runsim. Para cada alfa se
ejecutaran n(20) simulaciones con
#
# semillas distintas. Para variar las alfas en las simulaciones lo que hemos es
cambiar la capacidad del enlace
#
# de salida del router.El tamano del bufer dependera de alfa y del numero de
fuentes de la simulacion.
#
#--------------------------------------------------------------------------------for alfa in 0.55 0.57 0.59 0.61 0.63 0.65 0.67 0.69 0.71 0.73 0.75
do
#--------------------------------------------------------------------------------# El fichero "f_perdidas" guardará la probabilidad de perdidas de paquetes de las
20 simulaciones hechas para un mismo N y alfa. #
# Se borran ficheros antiguos de entorno que pueda haber de ejecuciones anteriores
del script.
#
# -------------------------------------------------------------------------------f_perdidas=N"$fuentes"_alfa"$alfa"_codec"$codec".pp
[ ! -f $f_entorno"N"$fuentes.ef ] || (rm -f $f_entorno"N"$fuentes.ef; echo
Borré el antiguo archivo \"$f_entorno"N"$fuentes.ef\" .)
#--------------------------------------------------------------------------------# Se llama al programa capacidad que calcula el tamano del bufer y la capacidad
del enlace de salida del router para un alfa,#
# un codec concreto y un numero de fuentes. Posteriormente se crea el nuevo
fichero de entorno que se modifica adecuadamente #
# con el programa entorno.awk.
#
#--------------------------------------------------------------------------------bufer=`./capacidad $fuentes $codec $alfa | awk '{if($1=="m")print $2}'`;
capacidad=`./capacidad $fuentes $codec $alfa | awk '{if($1=="Cap")print
$2}'`;
cp $f_entorno.ef $f_entorno"N"$fuentes.ef;
echo Creé el nuevo archivo \"$f_entorno"N"$fuentes.ef\" .;
awk -v bufer=$bufer -v capacidad=$capacidad -v
fichero=$f_entorno"N"$fuentes.ef -f entorno.awk $f_entorno"N"$fuentes.ef;
65
#--------------------------------------------------------------------------------# Bucle que ejecuta 20 simulaciones del mismo escenario, es decir,mismo alfa,mismo
codec y mismo numero de fuentes.Lo unico
#
# que cambia es la semilla que recibe op_runsim como parametro.
#
# El fichero de estadistica que se genera se guarda en el fichero "f_ov" que se
tratará para poder manejarlo.Esto se hace
#
# en el script estadisticas.sh.
#--------------------------------------------------------------------------------for seed in `seq 101 120`
do
f_ov=ov_N"$fuentes"_alfa"$alfa"_codec"$codec"_seed"$seed"
op_runsim -mem_optimize true -net_name voz_modificado"$fuentes"fuentes$codec -noprompt -ef $f_entorno"N"$fuentes -seed $seed -ov_file
$f_ov;
echo Ejecutando \"sh estadisticas.sh $f_ov $f_perdidas $fuentes $codec
\"... ;
sh estadisticas.sh $f_ov $f_perdidas $fuentes $codec;
echo Terminado sh estadisticas.sh $f_ov $f_perdidas $fuentes $codec;
done
done;
done
# Finalmente hago limpieza de algunos ficheros intermedios creados que son
innecesarios
#rm *.ot
#rm $HOME/*.ov
__________________________________________________________________________
estadisticas.sh
__________________________________________________________________________
#-------------------------------DESCRIPCION--------------------------------------#
# Script que maneja los ficheros de estadisticas .ov pasandolos a formanto ASCII.
# Invoca a los programas que calculan la probabilidad de perdidas.
#
#
Autor : Juan I. Jimenez Anguiano
#
Fecha : 05/02/08
#
#--------------------------------------------------------------------------------#-------------------------------------------------------------------------------#
# Estos son los argumentos que recibe el script por linea de comandos. Ademas se
define el #
# valor de algunas varibles que vamos a necesitar más adelante.
#
#--------------------------------------------------------------------------------#
f_ov=$1;
# nombre del fichero .ov generado por OPNET
f_perdidas=$2;
fuentes=$3;
codec=$4;
dir_project=$HOME/op_models/voz_modificado.project;
# directorio donde se
guardan los .ov
#----------------------------------------------------------------------------#
# op_cvov es una herramienta que proporciona OPNET que permite pasar las
estadisticas de #
# la simulacion, almacenadas en archivo .ov a un fichero .txt
#
66
#---------------------------------------------------------------------------#
echo Ejecutandose op_cvov -output_file_path $f_ov.txt -vector_data vector_data_format S\# -vector_patterns ...overflows ...busy -m $f_ov ... ;
op_cvov -output_file_path $f_ov.txt -vector_data -vector_data_format S\# vector_patterns ...overflows ...busy -m $f_ov ;
#----------------------------------------------------------------------------#
# Borrará el archivo .ov que se guarda en el directorio del proyecto sólo si
existe.
#
# Estos ficheros se borran porque ya son innecesarios, ademas ocupan mucho espacio
y
#
# pueden acumularse.
#
# El programa estadisticas.awk devuelve la probabilidad de perididas a partir del
#
# fichero de estadisticas que obtuvimos.
#
#-------------------------------------------------------------------------------#
[ ! -f $dir_project/$f_ov.ov ] || (rm -f $dir_project/$f_ov.ov; echo Borré el
antiguo archivo \"$dir_project/$f_ov.ov\" .)
awk -f estadisticas.awk $f_ov.txt >> estadisticas_N$fuentes/$f_perdidas ;
rm $f_ov.txt;
__________________________________________________________________________
grafica.sh
__________________________________________________________________________
#-------------------------------DESCRIPCION -------------------------------#
# Calcula el la probabilidad media de perdidas para cada valor del bufer
# en funcion de todos los puntos obtenidos con las distintas simulaciones.
# Posteriormente pinta las graficas usando gnuplot.
#
#
Autor : Juan I. Jimenez
#
Fecha : 05/02/08
#
#-------------------------------------------------------------------------#--------------------------INVOCACION
----------------------#
#
sh grafica.sh
#--------------------------------------------------------------------------#-------------------------------------------------------------------------# Argumentos que se pasan al script por linea de comandos
# para recorrer los directorios que contienen los ficheros con los puntos
# Tambien creamos una variable con el nombre base de los directorios
#------------------------------------------------------------------------#--------------------------------------------------------------------# Directorio desde donde debemos empezar
#-------------------------------------------------------------------cd $HOME/dimensionamiento
dir=estadisticas_N;
#--------------------------------------------------------------------# Este bucle va recorriendo todos los directorios
#----------------------------------------------------------------------
for fuentes in 10 20 30 40
67
do
dir_act=$dir$fuentes
# Voy cambiando de directorio si este existe
if [ -d $dir_act ]
then cd $dir_act; echo "Directorio actual: \"$dir_act\" ."
else
echo "no existe el directorio \"$dir_act\"."
fi
for codec in G729A G729AB
do
# Borro archivos antiguos que pueden existir de una ejecucion anterior del script
media=N"$fuentes"_codec"$codec".media
[ ! -f $media ] || (rm $media; echo "Borré el antiguo archivo \"$media\" .")
# Voy recorriendo los archivos del directorio actual
for alfa in 0.55 0.57 0.59 0.61 0.63 0.65 0.67 0.69 0.71 0.73 0.75
do
# Creamos el nombre del archivo
fichero=N"$fuentes"_alfa"$alfa"_codec"$codec".pp
# preparamos el fichero para que pueda ser procesado por mediavar.awk .
awk -v alfa=$alfa '{printf "%.2f\t%e\n",alfa,$1}' $fichero > out;
# Creamos un fichero con la probabilidad media de perdidas y dibujamos el
intervalo de confianza de 95 %
[ ! -f out ] || ( awk -f ../mediavar.awk out | awk '{printf($3" 0.05 -intervalo %e %e",$8,$11)}' | awk -f ../tstudent.awk | awk -v x=$alfa -f
../error.awk >> $media)
done
# Vuelvo al directorio original
done
cd $HOME/dimensionamiento
done
__________________________________________________________________________
capacidad
es un programa usado por simulacion.sh.
capacidad.c
__________________________________________________________________________
/**********************************************************************/
/* fichero: capacidad.c
*/
/* Descripcion: Calcula la capacidad del enlace de salida en funcion */
/*
del codec usado,del numero de fuentes y de la alfa.
*/
/*
Tambien calcula el tamano de buffer necesario para
*/
/*
que existe un retraso max. determinado en funcion de */
/*
el numero de fuentes y de alfa.
*/
/**********************************************************************/
/*********************** Invocacion ***********************************/
/*
calcula <numero_de_fuentes> <codec> <alfa>
*/
/**********************************************************************/
#include
#include
#include
#include
<stdio.h>
<math.h>
<stdlib.h>
<string.h>
int bufer_max(int N,float T,float alfa,float D);
int bufer_min(int N,float alfa);
68
int reg_salida(int paquete, float T,int N, float alfa);
int main(int argc, char *argv[]){
int Rb;
float T;
int cabecera = 8+12+20+7;
int paquete_size;
long aux;
long bufer_bits;
int N;
int sizeACT;
float alfa;
float D = 0.05;
buffer */
if (argc == 4){
/*
/*
/*
/*
/*
regimen del codec en estado activo */
tiempo de trama del codec */
rtp+udp+ip+ppp en bytes */
tamano del paquete final en bits */
variable auxiliar para guardar resultados */
/* numero de fuentes */
/* Retraso max. permido a un paquete en el
N=atoi(argv[1]); /* numero de fuentes multiplexadas */
alfa = (double)atof(argv[3]);
/* que tipo de codec se esta usando */
if(strcmp(argv[2],"G729A")==0 || strcmp(argv[2],"G729AB")==0){
Rb=8000;
sizeACT=10;
T=0.01;
}
else if (strcmp(argv[2],"AMR475")==0){
Rb=4750;
T=0.02;
sizeACT=12; /* Puede calcularse como ceil(Rb*T/8) */
}
else if(strcmp(argv[2],"AMR122")==0){
Rb=12200;
T=0.02;
sizeACT=31;
}
else{
printf ("Codec desconocido");
exit(1);
}
/*Calculo el tamaño del paquete ACT */
paquete_size=(sizeACT+cabecera)*8;
aux=bufer_max(N,T,alfa,D);
bufer_bits =(long)aux*paquete_size;
printf("m\t%ld\n",bufer_bits);
printf("Cap\t%d\n",reg_salida(paquete_size,T,N,alfa));
}
else
printf("Invocacion incorrecta: calcula <numero_de_fuentes> <codec> <alfa>");
return 0;
__________________________________________________________________________
estadisticas.awk
__________________________________________________________________________
#------------------------------
DESCRIPCION -----------------------------------#
69
# Lee los ficheros estadisticas generados en la simulacion y a partir de los
estadisticos:
# numero de desbordamientos y numero total de paquetes, calcula la probabilidad de
# perdidas de un paquete en el router.
#
# Autor : Juan I. Jimenez Anguiano
# Fecha : 05/02/08
#
#-------------------------------------------------------------------------------BEGIN{
desbordamiento=0;
paquetes=0;
}
{
#-------------------------------------------------------------------------------# Esta linea indica el comienzo de los datos estadisticos : 0 seg. 0 estadistico
# (para el tiempo 0 el estadistico siempre vale cero).
#------------------------------------------------------------------------------------if (($1==0) && ($2==0)){
inicio =1;
}
}
{
if($1 ~ /Statistic/)
{
estadistica = $3;
if(estadistica ~ /overflows/)
desbordamiento=1;
if(estadistica ~ /busy/)
paquetes=1;
}
}
{
if ($1 ~ /Number/){
valor=$4;
if(desbordamiento==1){
#---------------------------------------------------------------------------------# Al numero total de valores hay que quitarle los tomados en 0.0 seg. y fin_simulation
ya que valen siempre 0.
#-----------------------------------------------------------------------------------desbord_total = valor -2;
desbordamiento =0;
}
}
}
{
#--------------------------------------------------------------------------# Se ha llegado a los datos y estos son de el estadistico paquetes
#-------------------------------------------------------------------------if ((paquetes==1) && (inicio==1)){
# Si no se ha llegado al final de los datos
if($0 !~ /Vector end/)
suma +=$2;
}
}
#-------------------------------------------------------------------------------------
70
# Para calcula el numero de paquetes real hay que restar los que no sean de voz, que
siempre son 2 del protocolo RIP.
#------------------------------------------------------------------------------------END{
paquetes_no_voz=2;
printf "%s\t%e\n",codec,desbord_total/(suma-paquetes_no_voz+desbord_total);
}
__________________________________________________________________________
entorno.awk
__________________________________________________________________________
# cambia el fichero de entorno del opnet de donde lee los parametros
BEGIN{
printf "\"Office network.router.ppp_tx_05_0.channel [0].bit capacity\" :
\"%d\"\n",bufer >> fichero;
printf "\"Office network.router <-> destino.data rate\" :
\"%d\"\n",capacidad >>
fichero;
}
__________________________________________________________________________
Programas comunes a multiplexión y dimensionamiento
mediavar.awk
__________________________________________________________________________
BEGIN {
#
# Simple awk script to compute mean and variance
# of a value list
# Input file: lines with pairs <time, value>
#
TRANSIT=0
n = 0;
m = 0;
variance = 0;
maximum = 0;
minimum =0;
}
{
if ($1 >= TRANSIT){
x = $2;
oldnum = n;
n = n + 1.0;
tmp = x - m;
m = m + (tmp / n);
if ( 1 == n ){
maximum = x;
minimum = x;
variance = 0;
}
else{
if (x > maximum)
maximum = x;
else if (x < minimum)
minimum = x;
71
variance = (oldnum-1)/oldnum * variance + tmp*tmp / n;
}
}
}
END{
printf("n = %e", n);
if (n > 0) {
printf(" [%e ..", minimum);
printf("%e] ", maximum);
printf("m = %e", m);
}
if (n > 2){
printf(" var = %e", variance);
}
printf("\n");
}
__________________________________________________________________________
tstudent.awk
__________________________________________________________________________
function abs(val)
{
if (val > 0){
return val;
}
else {
return -val;
}
}
function gammln(xx)
{
##
double x,y,tmp,ser;
##
int j;
y=x=xx;
tmp=x+5.5;
tmp -= (x+0.5)*log(tmp);
ser=1.000000000190015;
for (j=0;j<=5;j++){
ser += cof[j]/++y;
}
return -tmp+log(2.5066282746310005*ser/x);
}
function alfa(a, b, x)
#
{
Returns the incomplete beta function Ix(a; b).
#
float bt;
if (x < 0.0 || x > 1.0) {
printf("Bad x in routine alfa");
}
if (x == 0.0 || x == 1.0) {
bt=0.0;
}
else {
# Factors in front of the continued fraction.
bt=exp(gammln(a+b)-gammln(a)-gammln(b)+a*log(x)+b*log(1.0-x));
}
if (x < (a+1.0)/(a+b+2.0)){
# Use continued fraction directly.
72
return bt*betacf(a,b,x)/a;
}
else {
# Use continued fraction after making the symmetry transformation.
return 1.0-bt*betacf(b,a,1.0-x)/b;
}
}
function betacf(a, b, x)
# Used by alfa: Evaluates continued fraction for incomplete beta function
# by modfied Lentz's method (x5.2).
{
# int m,m2;
# float aa,c,d,del,h,qab,qam,qap;
qab=a+b;
# These q's will be used in factors that occur
# in the coficients (6.4.6).
qap=a+1.0;
qam=a-1.0;
c=1.0;
#
First step of Lentz's method.
d=1.0-qab*x/qap;
if (abs(d) < FPMIN){
d=FPMIN;
}
d=1.0/d;
h=d;
for (m=1;m<=MAXIT;m++) {
m2=2*m;
aa=m*(b-m)*x/((qam+m2)*(a+m2));
d=1.0+aa*d;
# One step (the even one) of the recurrence.
if (abs(d) < FPMIN){
d=FPMIN;
}
c=1.0+aa/c;
if (abs(c) < FPMIN){
c=FPMIN;
}
d=1.0/d;
h *= d*c;
aa = -(a+m)*(qab+m)*x/((a+m2)*(qap+m2));
d=1.0+aa*d;
# Next step of the recurrence (the odd one).
if (abs(d) < FPMIN){
d=FPMIN;
}
c=1.0+aa/c;
if (abs(c) < FPMIN) {
c=FPMIN;
}
d=1.0/d;
del=d*c;
h *= del;
if (abs(del-1.0) < EPS) {
break;
# Are we done?
}
}
if (m > MAXIT) {
73
printf("a or b too big, or MAXIT too small in betacf");
}
return h;
}
function invstudent (n, alf) {
# v: grados de libertad
v = n - 1;
a = v/2;
b = 0.5;
alfabuscada = alf;
t = 0;
do {
t = t + step;
x = v / ( v + t * t );
} while ( alfabuscada < alfa(a, b, x));
return t;
}
BEGIN{
MAXIT = 100;
EPS = 3.0e-7;
FPMIN = 1.0e-30;
cof[0]=76.18009172947146;
cof[1]=-86.50532032941677;
cof[2]= 24.01409824083091;
cof[3]=-1.231739572450155;
cof[4]= 0.1208650973866179e-2;
cof[5]=-0.5395239384953e-5;
step = 0.0001;
getline ;
if ($1=="--help"){
printf ("num alfa : Devuelve t(n-1,alfa/2)\n");
printf ("num alfa \"--intervalo\" media varianza: Devuelve el intervalo de
confianza\n");
}
else {
t = invstudent($1, $2);
if ($3=="--intervalo"){
m = $4;
s = $5;
width = sqrt(s/$1)*t;
printf ("%g < mu < %g anchura = %g\n", m - width, m + width, 2*width);
}
else {
printf("DISTR.T.INV(n-1=%f, alfa=%f) = %f\n" , $1 -1, $2, t);
}
}
}
__________________________________________________________________________
error.awk
__________________________________________________________________________
#autor : Juan Ignacio Jimenez Anguiano
# fichero para poder pintar las graficas con error.
{
74
v_menor=$1;
v_mayor=$5;
anchura=$8;
y=(v_menor + v_mayor)/2;
delta=(anchura)/2;
printf ("%d %f %f\n",x,y,delta) ;
}
__________________________________________________________________________
75