26.12.03
Obtención de estadísticas del sistema en Prolog
Días atrás se planteó en la lista de distribución
Prolog
y programación lógica de Hispalinux,
la duda de cómo calcular el intervalo de tiempo transcurrido a fin
de comparar en Prolog la ejecución de dos programas.
El actual estándar ISO
Prolog ("ISO/IEC
13211-1:1995 Prolog -
Part
1: General core" e "ISO/IEC 13211-2:2000 Prolog - Part
2: Modules") no contempla ningún
procedimiento para obtener las estadísticas del sistema del usuario,
los tiempos de ejecución y otros procesos referidos al programa
o programas compilados, común a todas las implementaciones de este
lenguaje, de modo que esta cuestión queda a expensas de la solución
que cada sistema Prolog en particular halla implementado para dar soporte
a esta funcionalidad.
Los borradores de trabajo, en formato TeX [1]
[2] y PS,
del estándar ISO Prolog se pueden descargar desde esta
dirección FTP,
o bien desde el directorio lang/prolog/doc/standard/
del CMU
Artificial Intelligence Repository. En la primera
ubicación únicamente se puede descargar una versión
de trabajo del estándar ISO correspondiente a diciembre de 1991,
por lo que es más recomendable acceder a los documentos localizados
en el segundo
directorio. Concretamente, el archivo comprimido d8.tgz
contiene los documentos de la versión preliminar del estándar
ISO Prolog correspondiente a marzo de 1993.
Indagando en el tema planteado, se muestran a continuación una
serie de sencillos ejemplos, relacionados con el uso de variables referidas
a la fecha y hora del sistema, utilizando a tal efecto una serie de predicados
predefinidos, soportados en este caso por la implementación
SWI-Prolog
(aunque mencionaremos de pasada algún otro sistema), a los que nos
referiremos en primer lugar: cputime/0, statistics/0 y statistics/2, get_time/1,
convert_time/2 y convert_time/8, time_file/2 y time/1.
Recordemos antes de nada que la notación functor/aridad
representa un término o predicado cuyo functor es el nombre expresado
en primer lugar, mientras que el número entero que figura tras la
barra oblicua (/) indica su aridad o número de argumentos (el 0
-cero- indica la inexistencia de argumentos).
Así mismo, en la mención de la sintaxis de utilización
de un predicado, el signo "+" (más) expresa que el argumento
que sigue es una variable de entrada, mientras que el signo "-" (menos)
denota que se trata de un argumento o variable de salida. Un tercer signo,
"?" (interrogación), sirve para indicar que el argumento expresado
a continuación es reversible, es decir, puede funcionar tanto como
variable de entrada, como de salida.
cputime/0 - esta función
aritmética proporciona el tiempo de la CPU,
en segundos, transcurrido desde la carga del programa compilado. Su valor,
en formato de coma flotante, debe instanciarse con una variable para poder
ser manejado, para lo cual se puede utilizar, por ejemplo, el operador
infijo de evaluación aritmética is/2:
?- X is cputime.
X = 5.66
Un ejemplo muy sencillo e intrascendente de utilización práctica
de cputime/0: si el tiempo transcurrido desde la carga del programa es
mayor a 0 segundos, cerrar/0 fuerza la salida del intérprete, funcionando
como un contador, que permite ejecutar el comando "halt" pasado un tiempo
predeterminado (en el ejemplo cualquiera mayor a 0 segundos); en este caso
la llamada se produce de forma inmediata, al realizarse la comparación
aritmética del valor de cputime/0 (que será siempre mayor
que 0) con el valor 0 (cero), por lo que viene a ser como ejecutar directamente
el predicado predeterminado halt/0 en el "shell" del intérprete:
cerrar :-
cputime > 0, halt. % equivalente a ejecutar
la orden "?- halt."
Una variación de ese mismo planteamiento de uso de cputime/0 viene
definida por la siguiente regla, encargada de cerrar el intérprete
si han transcurrido más de 15 segundos desde el inicio de la compilación
del archivo. En caso contrario, muestra un mensaje en pantalla.
cerrar :-
X is cputime,
X > 15, !, halt;
nl, write('Todavía no han pasado 15 segundos.').
La regla tiempo/0 mostrada a continuación es otro ejemplo muy sencillo
de utilización de la función cputime/0 para mostrar en pantalla
el tiempo transcurrido desde la compilación del programa de forma
"amigable":
tiempo :-
X is cputime, nl,
write('Tiempo transcurrido desde la carga del programa:
'),
write(X), write(' segundos').
La ejecución de tiempo/0 en el "shell" del intérprete presenta
el siguiente aspecto:
?- tiempo.
Tiempo transcurrido desde la carga del programa: 22.46 segundos
Otro ejemplo, muy similar al anterior, es el que se muestra a continuación;
escribe en pantalla un mensaje indicando el tiempo, en segundos, que lleva
funcionando el programa.
tiempo :-
X is cputime,
Tiempo is X/60,
nl, write('Este programa lleva funcionando '),
write(Tiempo), write(' minutos '), write('('),
write(X), write(' segundos).').
Nótese que para transformar el tiempo de segundos a minutos, se
ha utilizado una sencilla y poco depurada función aritmética,
"Tiempo is X/60", ya que lo correcto sería redondear el número
de decimales resultante.
?- tiempo.
Este programa lleva funcionando 3.44483 minutos (206.69 segundos).
En todo caso es posible diferenciar la variable minutos de la variable
segundos, entre otras, utilizando otros predicados que se verán
más adelante.
El valor del tiempo transcurrido desde la carga del programa en ejecución,
proporcionado por cputime/0 en segundos, puede ser también instanciado
con una variable utilizando el predicado statistics/2,
que admite varias claves de uso, siendo cputime/0 una de ellas, de la siguiente
forma:
?- statistics(cputime,X).
X = 42.29
El predicado statistics/2 permite obtener estadísticas tanto referidas
al sistema donde se ejecuta el intérprete, como a la ejecución
del programa compilado en particular, y presenta la siguiente sintaxis:
statistics(+Clave,-Valor)
Cada estadística en particular se asocia con una clave, representada
por el primer argumento de entrada (Clave) del predicado, y su valor
se instancia con una variable de salida (Valor). Los valores de estas claves
se pueden visualizar en pantalla conjuntamente, mediante una presentación tabulada,
utilizando el predicado statistics/0 (sin argumentos):
?- statistics.
449.95 seconds cpu time for 210,774 inferences
4,831 atoms, 2,320 functors, 2,233 predicates, 53 modules, 82,144 VM-codes
Limit Allocated In
use
Heap :
1,013,552 Bytes
Local stack : 2,048,000
12,288 704 Bytes
Global stack : 4,096,000
20,480 2,156 Bytes
Trail stack : 4,096,000
8,192 588 Bytes
1 threads, 0 finished threads used 0.00 seconds.
Este predicado no ofrece la posibilidad de instanciar cada uno de los valores de las claves
mencionadas con la correspondiente variable, como si permite hacer statistics/2.
Las claves y su descripción están explicadas en el correspondiente
apartado del manual
de referencia de SWI-Prolog. SICStus
Prolog también soporta el predicado
statistics/2, sin embargo las claves son diferentes; así, para
obtener el tiempo transcurrido de ejecución del programa, se usa
runtime/0 (tiempo transcurrido menos el invertido en ciertos procesos)
y walltime/0 (tiempo absoluto) en vez de cputime/0; el valor se obtiene
en milisegundos en vez de en segundos. Estas dos mismas claves de uso (runtime/0
y walltime/0), al objeto de obtener los tiempos de ejecución, dentro
de los modos existentes de utilización del predicado statistics/2,
se utilizan en la implementación
CIAO
Prolog (ver "PREDICATE:
statistics/2 --> Usage 1", y también time_option/1).
El compilador GNU Prolog
contempla así mismo el uso de los predicados predefinidos statistics/0
y statistics/2, variando en el caso del segundo los nombres utilizados
como claves de uso. De esta forma, cputime/0 es sustituido por cpu_time/0,
y se puede utilizar indistintamente runtime/0 o user_time/0 para el mismo
caso de uso. cpu_time/0 puede utilizarse como predicado, siendo en este
caso su sintaxis de uso cpu_time(Tiempo), donde la variable Tiempo se unifica
con el valor del tiempo de la CPU transcurrido, en milisegundos, desde
el comienzo de la ejecución del intérprete o de compilación
del programa en particular, según el caso.
El predicado statistics/2
bajo SWI-Prolog soporta, por cuestiones de compatibilidad con la implementación
Quintus
Prolog, (desarrollada, al igual que SICStus Prolog, por el SICS)
la utilización, entre otras, de las claves runtime/0, system_time/0
y real_time/0 (equivalente esta última a walltime/0) para obtener
desde diversos enfoques de uso el tiempo de ejecución del programa
compilado, medido dicho tiempo en milisegundos en las dos primeras claves,
y en segundos en el caso de la tercera. Sin embargo, runtime/0 no puede
utilizarse, a diferencia de cputime/0, como función aritmética
independiente para unificar su valor con una variable, fuera del predicado
statistics/2.
Adviértase que runtime/0 y walltime/0 proporcionan dos rangos de
tiempo en milisegundos, formando parte de una lista [X,Y] compuesta por
dos elementos, referidos a:
[tiempo desde la carga del programa, tiempo desde la última
estadística]
como puede comprobarse en el siguiente objetivo lanzado en la interfaz
de consulta de SWI-Prolog:
?- statistics(runtime,X), length(X,Y).
X = [653780, 28230]
Y = 2
get_time/1 - el predicado predefinido get_time/1,
presenta la siguiente sintaxis (recordemos que el signo "+" denota un argumento
de entrada y "-" de salida): get_time(-Tiempo), y devuelve el número
de segundos transcurridos desde las 0 horas del año 1970.
?- get_time(X).
X = 1.07141e+009
Es posible convertir esta variable temporal en la fecha y hora actual del sistema
del usuario empleando los predicados convert_time/2 y convert_time/8, como
se explica a continuación.
convert_time/2 y convert_time/8 - el predicado convert_time/2,
presenta la siguiente sintaxis: convert_time(+Tiempo, -Cadena), y convierte
la variable obtenida mediante get_time/1 (Tiempo) en una representación
de la fecha y hora del sistema en formato de cadena de caracteres alfanuméricos
(Cadena). Por ejemplo:
?- get_time(X), convert_time(X,Y).
X = 1.07141e+009
Y = "Sun Dec 14 14:10:15 2003"
Ejemplo de utilización de este predicado en una regla:
fecha_y_hora01 :-
get_time(X),
convert_time(X,Fecha),
nl, write('Fecha: '), write(Fecha).
Proporciona la siguiente salida:
?- fecha_y_hora01.
Fecha: Mon Dec 15 00:41:25 2003
Por su parte, convert_time/8
consta de los siguientes argumentos:
convert_time(+Time, -Year, -Month, -Day, -Hour, -Minute, -Second,
-MilliSecond)
Este predicado convierte la variable Time obtenida mediante get_time/1
en una serie de variables independientes que representan de forma individualizada
el Año, Mes, Día, Hora, Minuto, Segundo y Milisegundo de
la fecha y hora del sistema del usuario. El modo de utilización
de este predicado está implementado en las reglas fecha_y_hora02/0
y fecha_y_hora03/0, definidas más adelante; permiten representar
la fecha y hora del sistema, respectivamente, con el siguiente formato:
?- fecha_y_hora02.
Año: 2003
Mes: 12
Día: 15
Hora: 00
Minutos: 43
Segundos: 08
Yes
?- fecha_y_hora03.
Fecha: 15 de diciembre de 2003
Hora: 00:43:17
La función aritmética cputime/0, procedente de las primeras
implementaciones Prolog derivadas del Prolog de Edimburgo (por ejemplo,
C-Prolog),
también es soportada por otros sistema Prolog, además de
SWI-Prolog, tal es el caso, por ejemplo, de Amzi!
Prolog (ver, en la referencia
y guía del usuario, el apartado "Built-in
Mathematical Atoms").
time_file/2 - presenta la siguiente sintaxis: time_file(+Fichero,
-Tiempo), y unifica la fecha de la última modificación
de un fichero Fichero con la variable Tiempo, que representa el tiempo
expresado en los segundos transcurridos desde el 1 de enero de 1970.
time/1 - este predicado, cuya sintaxis de uso es time(+Objetivo),
llama al objetivo Objetivo, imprimiendo además el tiempo invertido
en satisfacerlo, el número de inferencias lógicas
llevadas a cabo en el proceso de resolución, y el número de lips o inferencias lógicas
por segundo.
?- time(write('Hola Mundo!')).
Hola Mundo!
% 1 inferences, 0.00 CPU in 0.00 seconds (?% CPU, Infinite Lips)
En el caso de objetivos muy sencillos como el del ejemplo anterior, el
tiempo de computación invertido es prácticamente instantáneo,
razón por la cual se indican tiempos de proceso iguales a 0 ("0.00
CPU in 0.00 seconds") y tasas de ocupación de la CPU indeterminables
("?% CPU").
A continuación mostraremos algunos ejemplos de reglas definidas
haciendo uso de los anteriores predicados. Las reglas sin cabeza, es decir,
aquellas que no contienen nombre de functor (ni sus correspondientes argumentos,
si hubiere lugar a ellos) antes del operador ":-", se cargan automáticamente
al compilar el programa en el intérprete. Así por ejemplo,
la siguiente regla:
:- get_time(X),
convert_time(X,Fecha),
nl, write('¡Bienvenido!'),
nl, write('Fecha y hora de entrada: '), write(Fecha),
nl, nl.
Muestra en pantalla un saludo de bienvenida y a continuación la
fecha y hora de entrada en el intérprete:
¡Bienvenido!
Fecha y hora de entrada: Sun Dec 14 20:36:49 2003
Una versión más elaborada de la regla que se acaba de mostrar,
también sin cabeza (se carga por tanto automáticamente al
inicio de la compilación del programa en el intérprete) es
la que se explica a continuación. Esta regla hace uso de otras que
definiremos más adelante. Tras obtener la fecha del sistema, utilizando
get_time/1, y convertirla mediante el predicado convert_time/8 en una serie
de variables independientes, el programa escribe en pantalla un saludo,
diferente según se trate de la mañana, la tarde, la noche
o la noche-madrugada (llamando para ello al predicado escribir_saludo/1
al que pasa la variable Hour). La última variable de salida del predicado
convert_time/8, Milisegundos, la significamos como una variable anónima,
mediante la notación "_" (guión bajo), ya que en este caso
no nos interesa su valor. A continuación, el programa llama al predicado
escribir_hora_y_fecha/6, al que pasa las variables Hour, Minute, Second,
Day, Month y Year, que es el que finalmente escribe en pantalla la fecha
y hora corriente del sistema, invocando a su vez a otras reglas.
:- get_time(X),
convert_time(X,Year,Month,Day,Hour,Minute,Second,_), nl, nl,
escribir_saludo(Hour), nl,
escribir_hora_y_fecha(Hour,Minute,Second,Day,Month,Year),
nl, nl, nl.
Para obtener más información sobre el funcionamiento de la
regla escribir_hora_y_fecha/6, se remite a la correspondiente explicación,
unas cuantas líneas más adelante. En cualquier caso esta
nueva versión de la regla sin cabeza muestra en pantalla un mensaje
como el que sigue:
¡Buenas noches!
Son las 20:42:10 horas del día 14 de diciembre del año
2003
La regla saludo/0 ejecuta exactamente los mismos pasos que la que acabamos
de definir, pero en este caso se ejecuta lanzando desde la línea
de órdenes del intérprete el objetivo "?- saludo.", siendo
idéntico el resultado mostrado en pantalla.
saludo :-
get_time(X),
convert_time(X,Year,Month,Day,Hour,Minute,Second,_), nl,
escribir_saludo(Hour), nl,
escribir_hora_y_fecha(Hour,Minute,Second,Day,Month,Year).
Los predicados invocados por la regla sin cabeza que utiliza el predicado
convert_time/8, y por saludo/0 (ambas idénticas en cuanto a su proceso
de inferencia) son, secuencialmente, escribir_saludo/1 y escribir_hora_y_fecha/6.
La regla escribir_saludo/1, genera como resultado un saludo diferente
según de que hora del día se trate en el momento de ser llamada
(mañana, tarde, noche y noche-madrugada), tomando como parámetro
de entrada la variable Hour instanciada previamente por get_time/1.
escribir_saludo(Hour) :-
Hour >= 0, Hour < 7, !, write('¡Buenas noches
- madrugadas!');
Hour >= 7, Hour =< 12, !, write('¡Buenos días!');
Hour > 12, Hour < 20, !, write('¡Buenas tardes!');
write('¡Buenas noches!').
Nótese la utilización, al igual que se hará posteriormente,
del predicado predefinido de el
corte (!/0), en conjunción con el operador ";" (punto y coma,
equivalente al "or" lógico), corte que en este caso sirve para delimitar
condiciones mutuamente excluyentes y prevenir de esta forma posibles reevaluaciones
en el proceso de inferencia "hacia atrás" que Prolog lleva a cabo
por defecto (backtracking).
Por su parte, la regla escribir_hora_y_fecha/6 escribe la hora, minuto,
segundo, día, mes y año correspondientes a la hora y fecha
del sistema. Esas variables son instanciadas en este predicado por la regla
saludo/0 y la regla (sin cabeza) que se carga al inicio de la compilación
del programa, que a su vez obtienen la fecha y hora del sistema mediante
los predicados get_time/1 y convert_time/8, como ya dijimos anteriormente.
Además, se ha implementado un sistema de comprobación
para añadir a las cifras de la hora del sistema un cero delante
cuando consten de un solo dígito. Así por ejemplo, obtenemos
09 por 9, 02 por 2, etc.
escribir_hora_y_fecha(Hour,Minute,Second,Day,Month,Year) :-
write(' Son las '),
(
Hour =< 9, !, write('0'), write(Hour);
write(Hour)
),
write(':'),
(
Minute =< 9, !, write('0'), write(Minute);
write(Minute)
),
write(':'),
(
Second =< 9, !, write('0'), write(Second);
write(Second)
),
write(' horas del día '),
write(Day), write(' de '),
calcular_mes(Month),
write(' del año '), write(Year).
Como puede observarse, escribir_hora_y_fecha/6, hace uso a su vez de una
nueva regla, calcular_mes/1, que tiene un único parámetro
de entrada, la variable Month asociada al mes. En función del valor
concreto de esta variable, que puede tomar valores comprendidos entre 1
y 12, ambos inclusive, el predicado calcular_mes/1 transforma la notación
numérica del mes a una notación de carácter textual. Así,
se obtiene "abril" por el mes 4, "agosto" por el 8, etc.
calcular_mes(Month) :-
Month =:= 1, !, write('enero');
Month =:= 2, !, write('febrero');
Month =:= 3, !, write('marzo');
Month =:= 4, !, write('abril');
Month =:= 5, !, write('mayo');
Month =:= 6, !, write('junio');
Month =:= 7, !, write('julio');
Month =:= 8, !, write('agosto');
Month =:= 9, !, write('septiembre');
Month =:= 10, !, write('octubre');
Month =:= 11, !, write('noviembre');
Month =:= 12, write('diciembre').
Otro ejemplo: la regla salir/1 permite mostrar en pantalla, en primer lugar,
el tiempo que lleva funcionando el programa compilado (para lo cual llama
a una segunda regla, tiempo_de_trabajo/0, que es la realmente encargada
de proporcionar ese tiempo) y a continuación preguntar al usuario
si desea salir o no del intérprete, leyendo la respuesta mediante
el predicado predefinido read/1, en función de la cual se cerrará
o bien continuará abierto.
salir :-
tiempo_de_trabajo, nl, nl,
write('¿Desea realmente salir del programa?'),
tab(1),
read(X),
(
X == si, !, halt;
X == no, !, nl, write('Continua la ejecución del
programa.');
nl, write('Por favor, responda si/no, '),
write_ln('escriba un punto y pulse "intro".'), salir
).
tiempo_de_trabajo :-
X is cputime,
Tiempo is X/60,
nl, write('Lleva trabajando con este programa '),
write(Tiempo), write(' minutos '), write('('),
write(X), write(' segundos).').
Por su parte, fecha_y_hora02/0, regla que mencionábamos anteriormente,
proporciona la fecha y hora del sistema diferenciando las variables, utilizando
de nuevo el predicado convert_time/8:
fecha_y_hora02 :-
get_time(X),
convert_time(X,Year,Month,Day,Hour,Minute,Second,_), nl,
write('Año: '), write(Year), nl,
write('Mes: '), write(Month), nl,
write('Día: '), write(Day), nl,
write('Hora: '),
(
Hour =< 9, !, write('0'), write(Hour);
write(Hour)
),
nl,write('Minutos: '),
(
Minute =< 9, !, write('0'), write(Minute);
write(Minute)
),
nl, write('Segundos: '),
(
Second =< 9, !, write('0'), write(Second);
write(Second)).
El formato de salida queda de la siguiente forma:
?- fecha_y_hora02.
Año: 2003
Mes: 12
Día: 15
Hora: 01
Minutos: 18
Segundos: 39
Como último ejemplo, la regla fecha_y_hora03/0 se define de la siguiente
manera:
fecha_y_hora03 :-
get_time(X),
convert_time(X,Year,Month,Day,Hour,Minute,Second,_), nl,
write('Fecha: '), write(Day),
write(' de '), calcular_mes(Month),
write(' de '), write(Year), nl,
tab(1), write('Hora: '),
(
Hour =< 9, !, write('0'), write(Hour);
write(Hour)
),
write(':'),
(
Minute =< 9, !, write('0'), write(Minute);
write(Minute)
),
write(':'),
(
Second =< 9, !, write('0'), write(Second);
write(Second)).
y muestra la fecha y hora del sistema del usuario con un formato más
práctico y legible que el proporcionado por la regla fecha_y_hora02/0:
?- fecha_y_hora03.
Fecha: 15 de diciembre de 2003
Hora: 01:23:13
Para pasar la representación numérica de los meses a una
notación en forma de texto (enero, febrero, etc.), fecha_y_hora03/0
hace uso del predicado calcular_mes/1 definido anteriormente. También
incluye una serie de condiciones para añadir un cero delante de
los números correspondientes a la hora, los minutos y los segundos
cuando estos tienen una sola cifra, y además se escriben dos puntos
entre horas/minutos y minutos/segundos, para que el formato de 24h presente
la forma "hh:mm:ss".
Los ejemplos que se han expuesto son muy sencillos, y se pueden complicar tanto
como la imaginación y/o conocimientos del programador lo posibiliten,
y los requerimientos del programa lo precisen. Los nombres de las reglas,
muy largos en los ejemplos expuestos a fin de denotar de la forma más
clara posible su función, y los de las variables, son arbitrarios,
por lo que pueden tomar la forma de otros más cortos y manejables,
manteniendo en todo caso un criterio consistente en la asignación
de dichos nombres a lo largo de todo el programa.
[0] comentarios | # | lista |
