Julio de 2020
Calendario de artículos de de 2020
| lu | ma | mi | ju | vi | sá | do |
|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | ||
| 6 | 7 | 8 | 9 | 10 | 11 | 12 |
| 13 | 14 | 15 | 16 | 17 | 18 | 19 |
| 20 | 21 | 22 | 23 | 24 | 25 | 26 |
| 27 | 28 | 29 | 30 | 31 | ||
Para eso no hacía falta un estudio
2020-07-31
No falla: la prensa habla sobre algún estudio científico que
confirma una idea popular y alguien tiene que afirmar que para esto
no hacía falta un estudio
, ya que se trataba de algo supuestamente
conocido. Sucede que la ciencia no funciona a base de anécdotas,
«cultura general» (que no es tan general ni es tanta cultura) y
«sentido común» (que no es tan común y no es más que una heurística
que ocasionalmente da buenos resultados); el rigor es lo que nos
separa de la superstición y las meras opiniones. ¡Por supuesto que sí
hacía falta un estudio!
Categorías: Miscelánea
Permalink: https://sgcg.es/articulos/2020/07/31/para-eso-no-hacia-falta-un-estudio/
Píxeles de papel electrónico
2020-07-29
Aquí hay otra fotografía píxeles, esta vez de un lector de libros electrónicos.
Píxeles vistos de cerca.
Anteriormente, píxeles:
- de un televisor;
- de un teléfono móvil;
- de otro televisor;
- de otro televisor;
- de un monitor de ordenador.
Categorías: Fotografía
Permalink: https://sgcg.es/articulos/2020/07/29/pixeles-de-papel-electronico/
Estrella fugaz
2020-07-28
He aquí una fotografía de una estrella fugaz. No es muy buena, pero me gusta porque la cacé de casualidad con una exposición de ocho segundos. La estrella fugaz es la ténue línea recta del centro.
Fotografía de una estrella
fugaz. Más
grande.
Categorías: Fotografía
Permalink: https://sgcg.es/articulos/2020/07/28/estrella-fugaz/
Flores (8)
2020-07-27
He aquí una fotografía de una flor tomada con una lente con mucha aberración esférica que provoca un efecto resplandeciente, etéreo.
Fotografía de una flor tomada con una lente con mucha aberración
esférica. Más
grande.
Categorías: Fotografía
Privacidad supuestamente importante
2020-07-23
Esta escena es muy común últimamente: entramos en una
página web y nos vemos asaltados por un ridículo cartel que
afirma una mentira por el estilo de tu privacidad es importante
y nos obliga a dar algún tipo de consentimiento (que normalmente
será de
mentirijillas) para
que cientos
de empresas se dediquen a,
esencialmente, ejecutar
un spyware en nuestro ordenador. ¿Nuestra privacidad es
importante? ¡Es que no se trata de
nuestro derecho
a la privacidad lo que es importante, son importantes nuestros
dulces y jugosos datos privados igual que para el mosquito es
importante nuestra sangre!
Categorías: Derechos
Permalink: https://sgcg.es/articulos/2020/07/23/privacidad-supuestamente-importante/
Jugando con la carga del sistema (4)
2020-07-19
Vimos que la carga de un sistema *nix es, de forma resumida, la cantidad promedio de procesos en ejecución en un intervalo de tiempo. Se da normalmente a un minuto, cinco minutos y quince minutos. Tras una primera herramienta con control de tipo todo o nada, una segunda herramienta con control de tipo proporcional e integral y una tercera herramienta con control en lazo abierto, por diversión, vamos a diseñar la cuarta pequeña herramienta que permite alcanzar una carga del sistema elegida a base de consumir tiempo de procesador de forma controlada.
Diseño básico
Si queremos alcanzar un cierta carga C, necesitamos al menos C procesos trabajando simultáneamente. En general, C no es un número entero, así que el número de procesos ha de ser, como poco, C redondeado a entero hacia arriba; llamaremos P a este número.
Nuestra herramienta va a tener un control en lazo cerrado proporcional e integral modificado: sobre la actuación del control en lazo abierto se hace una modificación con control en lazo cerrado proporcional e integral. El punto de trabajo básico dicta que los procesos se mantienen ocupados una fracción de tiempo suficiente que permitiría alcanzar la carga deseada si no hubiera más procesos en ejecución; en general, la carga alcanzada será distinta de la deseada, con lo que esta actuación se perturba con una contribución que suma de una componente proporcional al error en la carga alcanzada y una componente proporcional a la integral en el tiempo de dicho error. La componente integral otorga al controlador una memoria que sirve para que converja con el tiempo.
Detalles
Escribiremos la herramienta en el lenguaje de programación C. Esta
herramienta podrá funcionar en sistemas *nix modernos que cuentan con
la función getloadavg (que sirve para obtener la carga
del sistema), además de las funciones estándar de entrada y salida,
creación de procesos y demás.
El programa es muy sencillo. Toma un único argumento, la carga
deseada, que interpreta con una llamada a atof. Después,
crea múltiples subprocesos con llamadas a fork de manera
que, entre estos subprocesos y el proceso principal, la cantidad de
procesos es igual a la carga deseada redondeada a entero hacia arriba.
Cada proceso entra en un bucle que se repite diez veces por segundo y,
en cada uno de los ciclos de una décima de segundo, el tiempo se
reparte entre una fracción de tiempo de alto consumo del procesador y
una fracción de tiempo de bajo consumo (durmiendo). La fracción de
tiempo con alto consumo de procesador es igual a la carga deseada
dividida entre el número de procesos más una corrección proporcional
al error en la carga del sistema y una corrección proporcional a la
integral en el tiempo de dicho error.
Más allá de verificar que el usuario pasa una cantidad correcta de argumentos, el programa no comprueba si hay errores. ¡No es más que un juguete hecho en escasos minutos!
Los parámetros del sistema de control están escogidos a voleo, así que es muy probable que haya una combinación mejor que permita converger rápidamente a la carga deseada sin apenas sobrepasarla.
El programa
El código fuente está disponible
a
través de este enlace. Para compilarlo en un sistema compatible,
basta con usar el compilador de C:
cc -o load-modified-pi load-modified-pi.c
El programa necesita un argumento: la carga deseada. Por ejemplo,
para pedir que la carga sea 3, podemos ejecutarlo así desde el mismo
directorio en el que lo tenemos:
./load-modified-pi 3
Con la orden anterior, el programa tratará de mantener la carga a 3 hasta que lo detengamos.
El programa, por supuesto, es software libre y se distribuye bajo la licencia GPLv3.
Categorías: Informática
Permalink: https://sgcg.es/articulos/2020/07/19/jugando-con-la-carga-del-sistema-4/
Jugando con la carga del sistema (3)
2020-07-18
Vimos que la carga de un sistema *nix es, de forma resumida, la cantidad promedio de procesos en ejecución en un intervalo de tiempo. Se da normalmente a un minuto, cinco minutos y quince minutos. Tras una primera herramienta con control de tipo todo o nada y una segunda herramienta con control de tipo proporcional e integral, por diversión, vamos a diseñar la tercera pequeña herramienta que permite alcanzar una carga del sistema elegida a base de consumir tiempo de procesador de forma controlada.
Diseño básico
Si queremos alcanzar un cierta carga C, necesitamos al menos C procesos trabajando simultáneamente. En general, C no es un número entero, así que el número de procesos ha de ser, como poco, C redondeado a entero hacia arriba; llamaremos P a este número.
Nuestra herramienta va a tener un control en lazo abierto: los procesos se mantienen ocupados una fracción de tiempo suficiente que permitiría alcanzar la carga deseada si no hubiera más procesos en ejecución. Como no se dará tal caso, este programa no responde a las perturbaciones y la carga alcanzada normalmente no será la deseada.
Detalles
Escribiremos la herramienta en el lenguaje de programación C. Esta
herramienta podrá funcionar en sistemas *nix modernos que cuentan con
la función getloadavg (que sirve para obtener la carga
del sistema), además de las funciones estándar de entrada y salida,
creación de procesos y demás.
El programa es muy sencillo. Toma un único argumento, la carga
deseada, que interpreta con una llamada a atof. Después,
crea múltiples subprocesos con llamadas a fork de manera
que, entre estos subprocesos y el proceso principal, la cantidad de
procesos es igual a la carga deseada redondeada a entero hacia arriba.
Cada proceso entra en un bucle que se repite diez veces por segundo y,
en cada uno de los ciclos de una décima de segundo, el tiempo se
reparte entre una fracción de tiempo de alto consumo del procesador y
una fracción de tiempo de bajo consumo (durmiendo). La fracción de
tiempo con alto consumo de procesador es igual a la carga deseada
dividida entre el número de procesos.
Más allá de verificar que el usuario pasa una cantidad correcta de argumentos, el programa no comprueba si hay errores. ¡No es más que un juguete hecho en escasos minutos!
El programa
El código fuente está disponible
a
través de este enlace. Para compilarlo en un sistema compatible,
basta con usar el compilador de C:
cc -o load-open load-open.c
El programa necesita un argumento: la carga deseada. Por ejemplo,
para pedir que la carga sea 3, podemos ejecutarlo así desde el mismo
directorio en el que lo tenemos:
./load-open 3
Con la orden anterior, el programa tratará de mantener la carga a 3 hasta que lo detengamos.
El programa, por supuesto, es software libre y se distribuye bajo la licencia GPLv3.
Categorías: Informática
Permalink: https://sgcg.es/articulos/2020/07/18/jugando-con-la-carga-del-sistema-3/
Jugando con la carga del sistema (2)
2020-07-17
Vimos que la carga de un sistema *nix es, de forma resumida, la cantidad promedio de procesos en ejecución en un intervalo de tiempo. Se da normalmente a un minuto, cinco minutos y quince minutos. Tras una primera herramienta, por diversión, vamos a diseñar la segunda pequeña herramienta que permite alcanzar una carga del sistema elegida a base de consumir tiempo de procesador de forma controlada.
Diseño básico
Si queremos alcanzar un cierta carga C, necesitamos al menos C procesos trabajando simultáneamente. En general, C no es un número entero, así que el número de procesos ha de ser, como poco, C redondeado a entero hacia arriba; llamaremos P a este número.
Nuestra herramienta va a tener un control de tipo PI (proporcional e integral): los procesos se mantienen ocupados una fracción de tiempo con dos contribuciones, una proporcional a la desviación de la carga objetivo y la carga real y otra proporcional a la integral en el tiempo de esa desviación. La contribución integral le da una memoria al bucle de control con el fin de que acabe convergiendo a la carga deseada.
Detalles
Escribiremos la herramienta en el lenguaje de programación C. Esta
herramienta podrá funcionar en sistemas *nix modernos que cuentan con
la función getloadavg (que sirve para obtener la carga
del sistema), además de las funciones estándar de entrada y salida,
creación de procesos y demás.
El programa es muy sencillo. Toma un único argumento, la carga
deseada, que interpreta con una llamada a atof. Después,
crea múltiples subprocesos con llamadas a fork de manera
que, entre estos subprocesos y el proceso principal, la cantidad de
procesos es igual a la carga deseada redondeada a entero hacia arriba.
Cada proceso entra en un bucle que se repite diez veces por segundo y
en el que, en cada iteración, se llama a getloadavg para
obtener la carga promedio del sistema a un minuto; la desviación entre
la carga deseada y la carga real pasa al controlador proporcional e
integral para decidir el nivel de ocupación de cada proceso. Cada
ciclo de una décima de segundo se reparte, de acuerdo con la ley de
control, entre una fracción de tiempo de alto consumo del procesador y
una fracción de tiempo de bajo consumo (durmiendo).
Más allá de verificar que el usuario pasa una cantidad correcta de argumentos, el programa no comprueba si hay errores. ¡No es más que un juguete hecho en escasos minutos!
Los parámetros del sistema de control están escogidos a voleo, así que es muy probable que haya una combinación mejor que permita converger rápidamente a la carga deseada sin apenas sobrepasarla.
El programa
El código fuente está disponible
a
través de este enlace. Para compilarlo en un sistema compatible,
basta con usar el compilador de C:
cc -o load-pi load-pi.c
El programa necesita un argumento: la carga deseada. Por ejemplo,
para pedir que la carga sea 3, podemos ejecutarlo así desde el mismo
directorio en el que lo tenemos:
./load-pi 3
Con la orden anterior, el programa tratará de mantener la carga a 3 hasta que lo detengamos.
El programa, por supuesto, es software libre y se distribuye bajo la licencia GPLv3.
Categorías: Informática
Permalink: https://sgcg.es/articulos/2020/07/17/jugando-con-la-carga-del-sistema-2/
Jugando con la carga del sistema (1)
2020-07-14
Vimos que la carga de un sistema *nix es, de forma resumida, la cantidad promedio de procesos en ejecución en un intervalo de tiempo. Se da normalmente a un minuto, cinco minutos y quince minutos. Por diversión, vamos a diseñar una pequeña herramienta que permite alcanzar una carga del sistema elegida a base de consumir tiempo de procesador de forma controlada.
Diseño básico
Si queremos alcanzar un cierta carga C, necesitamos al menos C procesos trabajando simultáneamente. En general, C no es un número entero, así que el número de procesos ha de ser, como poco, C redondeado a entero hacia arriba; llamaremos P a este número.
Nuestra herramienta va a tener un control de tipo todo o nada, como un termostato: en todo momento, si la carga del sistema es inferior a la deseada, los P procesos se mantienen ocupados; si la carga es superior a la deseada, los P procesos duermen la mayor parte del tiempo, de forma que solamente despiertan una fracción insignificante del tiempo para comprobar la carga del sistema.
Detalles
Escribiremos la herramienta en el lenguaje de programación C. Esta
herramienta podrá funcionar en sistemas *nix modernos que cuentan con
la función getloadavg (que sirve para obtener la carga
del sistema), además de las funciones estándar de entrada y salida,
creación de procesos y demás.
El programa es muy sencillo. Toma un único argumento, la carga
deseada, que interpreta con una llamada a atof. Después,
crea múltiples subprocesos con llamadas a fork de manera
que, entre estos subprocesos y el proceso principal, la cantidad de
procesos es igual a la carga deseada redondeada a entero hacia arriba.
Cada proceso entra en un bucle en el que, en cada iteración, se llama
a getloadavg para obtener la carga promedio del sistema a
un minuto; si esta carga es superior a la deseada, el proceso duerme
durante un segundo (con lo que deja de estar en ejecución y no aumenta
la carga) para volver a iterar en el bucle; en caso contraro, el
proceso sigue iterando en el bucle tan rápido como puede (con lo que
está en ejecución y aumenta la carga).
Más allá de verificar que el usuario pasa una cantidad correcta de argumentos, el programa no comprueba si hay errores. ¡No es más que un juguete hecho en escasos minutos!
El programa
El código fuente está disponible
a
través de este enlace. Para compilarlo en un sistema compatible,
basta con usar el compilador de C:
cc -o load-thermostat load-thermostat.c
El programa necesita un argumento: la carga deseada. Por ejemplo,
para pedir que la carga sea 3, podemos ejecutarlo así desde el mismo
directorio en el que lo tenemos:
./load-thermostat 3
Con la orden anterior, el programa tratará de mantener la carga a 3 hasta que lo detengamos.
El programa, por supuesto, es software libre y se distribuye bajo la licencia GPLv3.
Categorías: Informática
Permalink: https://sgcg.es/articulos/2020/07/14/jugando-con-la-carga-del-sistema-1/
La carga en sistemas *nix
2020-07-09
La carga promedio («load average») de un sistema *nix es una medida habitual de cómo de utilizado está un ordenador. Los sistemas *nix manejan múltiples procesos de manera que, en un determinado momento, puede haber uno o varios procesos en ejecución y puede haber más procesos en cola listos para ser ejecutados. El número medio de procesos en ejecución y listos para la ejecución en un intervalo de tiempo es la carga promedio en dicho intervalo de tiempo. La carga se da normalmente como media móvil ponderada a un minuto, cinco minutos y quince minutos.
El sistema operativo reparte los procesos entre los diferentes núcleos de los procesadores y, además, fracciona el tiempo en intervalos cortos que reparte también entre los procesos, de manera que es posible ejecutar múltiples procesos de forma auténticamente simultánea en máquinas con múltiples núcleos y, además, es posible generar la ilusión de que se ejecutan múltiples procesos simultáneamente a base de alternar entre ellos rápidamente en los intervalos cortos en los que se fracciona el tiempo. Por este motivo, si la carga del sistema es inferior al número de núcleos, en principio hay tiempo de procesador libre para ejecutar más procesos sin dejar ninguno esperando, mientras que si la carga del sistema es superior al número de núcleos, en principio no hay tiempo de procesador suficiente para atender a todos los procesos que necesitan ejecutarse y las tareas empiezan a retrasarse. En general, la carga empieza a ser motivo de preocupación cuando es una fracción próxima a la unidad del número de núcleos y, si llega a ser mucho más grande que el número de núcleos, es habitual que el sistema se vuelva inmanejable.
El núcleo de Linux incluye en el factor de carga no solamente los procesos en ejecución y listos para ejecutarse, sino también los que están durmiendo de forma no interrumpible (lo que a menudo significa a la espera en llamadas de entrada y salida). Es por esto que los usuarios de sistemas basados en el núcleo de Linux pueden encontrarse con que un mismo valor numérico elevado de la carga puede a veces suponer que el sistema usa mucho el procesador y otras veces lo usa poco. Un sistema con un valor numérico de carga elevado debido mayoritariamente a procesos que están a la espera de ciertas llamadas de entrada y salida puede responder bien a nuevos intentos de interacción por parte del usuario, mientras que el mismo sistema con el mismo valor numérico de carga, esta vez dominado por el uso de procesador, puede no responder a los intentos desesperados del usuario por retomar el control y corregir la situación. Esto es un lío, por supuesto, ya que el hecho de que los procesos estén bloqueados en entrada y salida no implica necesariamente que una carga elevada sea tolerable y, de cualquier manera, esta carga elevada sí significa que los procesos bloqueados van a un tiempo excesivo en ejecutarse.
Categorías: Informática
Permalink: https://sgcg.es/articulos/2020/07/09/la-carga-en-sistemas-unix/
Airbus anuncia aproximadamente 15000 despidos
2020-07-05
Airbus ha anunciado el plan de despedir a aproximadamente 15000 trabajadores: unos 14000 (de los que unos 900 se darían en España) debido al impacto de la crisis sanitaria y cerca de 1000 adicionales en Alemania por motivos no relacionados con la crisis sanitaria. Estos números dejan pequeña la propuesta de febrero de reducir la plantilla de defensa y espacio en cerca de 2400 empleos (630 en España).
Categorías: Actualidad, Aeroespacio
Permalink: https://sgcg.es/articulos/2020/07/05/airbus-anuncia-aproximadamente-15000-despidos/
