Saltar a contenido

Profiling en Python e instrucciones AVX

Lo que se vio en la tercera sesión: dónde se va el tiempo de un programa en Python, con qué herramienta se averigua cada cosa, y qué hacer cuando el ciclo de Python es justamente el problema. Las diapositivas están en el Campus Virtual; aquí quedan las cuentas, las mediciones y el código que se corrió en clase.

Dos programas que se leen igual

Una matriz de 10 000 × 10 000 enteros, todos en 5. Dos maneras de llenarla:

for i in range(filas):
    for j in range(columnas):
        matriz[i, j] = 5    # 15,39 s

matriz.fill(5)              # 0,10 s

Las dos son \(O(n^2)\) y las dos producen el mismo arreglo. Entre una y otra hay un factor cercano a 150, y nada en el texto del programa lo anuncia: la única forma de saberlo es medir.

La diferencia está en quién hace el trabajo. La segunda baja a la capa de C de NumPy y llena la memoria de corrido; la primera paga el intérprete de Python cien millones de veces, y en Python cada número es un objeto, no un valor suelto.

Perfilar es recolectar y analizar métricas de un programa en ejecución para encontrar los puntos críticos, en tres frentes: gasto de memoria, tiempo de ejecución y uso de recursos del sistema. La sesión se queda en los dos primeros. El punto crítico no siempre está en el código propio: puede ser una API remota lenta, un disco lento o la red de la universidad, y perfilar también sirve para saber de quién es el problema.

Antes de optimizar, tres preguntas

La primera es si el código es correcto, porque optimizar un programa que entrega mal el resultado no arregla nada. La segunda es si está escrito de forma que otro pueda leerlo y modificarlo: un programa rápido que nadie entiende no se puede mantener. La tercera es dónde está el cuello de botella, y esa es la que responden las herramientas de esta sesión.

Hazlo funcionar, hazlo correcto, hazlo rápido

En ese orden, y la observación de Joe Armstrong es que cuando uno hace lo que hay que hacer, el 90 % de las veces el resultado ya es bonito y rápido. Elegir bien el algoritmo y la estructura de datos pesa más que cualquier micro-optimización posterior.

El principio de Pareto aplicado al código dice que optimizando el 20 % se obtiene el 80 % del beneficio, y la regla 90-10 que un programa típico gasta el 90 % del tiempo en el 10 % del código. Las herramientas de perfilado sirven para encontrar ese 10 %.

El techo lo pone Amdahl

La misma ley de la primera sesión, ahora sobre una optimización en vez de una paralelización: si una función se lleva el 70 % del tiempo y se hace el doble de rápida, el programa no queda el doble de rápido.

Con un programa de 20 s del que 14 s son acelerables: esos 14 pasan a 7, los 6 restantes no se mueven, y el total va de 20 s a 13 s. La relación es 20 / 13 = 1,54. Lo que no se toca fija el techo, y con aceleración infinita sobre esa parte el máximo sería 1 / (1 - 0,7) = 3,3.

De ahí sale el criterio para no optimizar: un script que corre una vez y se archiva, o uno que tarda cuatro minutos mientras uno se toma un café, no justifica el trabajo. Si optimizar cuesta más que ejecutar, no se optimiza. Es la misma cuenta de la deuda técnica: antes de pagarla hay que ver qué se gana. La deuda técnica funciona como el 4 × 1000, que entró como medida temporal después del terremoto del eje cafetero y sigue ahí: lo que se escribió con afán para salir del paso queda, y cada vez cuesta más quitarlo.

El ejercicio de la sesión fue una tabla de cuatro funciones sobre un programa de 20 s: expresiones regulares con 1 s, un ciclo con el 70 %, insertar el resultado con el 20 % y escribir el archivo con el 5 %. La candidata es el ciclo, no porque sea la más fea sino porque es la que más pesa; y la escritura del archivo queda fuera de la discusión aunque se viera lenta, porque ahí manda el disco y el código no lo acelera.

El ambiente: venv y requirements.txt

En las salas no se pueden instalar bibliotecas en el sistema, y eso no es un obstáculo: un ambiente virtual parte del Python instalado y arma un entorno propio donde sí se instala lo que haga falta.

python3 -m venv venv          # crear
source venv/bin/activate      # activar: el nombre aparece entre paréntesis
pip install numpy pyinstrument
pip freeze > requirements.txt # dejar registro de qué versión es cada cosa

Las bibliotecas quedan aisladas del sistema operativo; la versión del intérprete, no. Y el archivo de dependencias es el que hace que el programa vuelva a correr en otra máquina: dice qué biblioteca y en qué versión.

Eso importa por una razón que se ve más adelante en el curso, cuando el programa se empaqueta en un contenedor. El enfoque de infraestructura no es llevar todo a la última versión: es hacer que funcione con las versiones con las que se construyó. Si un proyecto corre con Python 3.9 y ciertas versiones de sus bibliotecas, el trabajo es proveer ese ambiente, no actualizarlo. Por eso los bancos siguen con COBOL, que no es un lenguaje congelado hace sesenta años sino uno con sesenta años de revisiones encima, y en procesos críticos eso pesa más que la novedad.

En la industria se usan herramientas como Conda o Micromamba, que automatizan la detección de dependencias en conflicto. Para el curso basta con venv.

Medir: time y timeit

Hay dos actividades distintas. El benchmarking mide cuánto tarda un fragmento; el perfilado dice en qué se gasta el tiempo. time y timeit hacen lo primero.

El módulo time trae cuatro relojes, y los dos que importan aquí miden cosas distintas:

Función Qué mide
perf_counter Reloj de pared, con la mayor resolución disponible
process_time Tiempo de procesador del proceso, sin contar esperas
monotonic Reloj que nunca retrocede, para intervalos
time Segundos desde el 1 de enero de 1970

La diferencia entre los dos primeros es la que delata una espera. Un programa que tarda veinte minutos de reloj y consume cinco de procesador pasó quince esperando algo: un archivo, una consulta, la red. Las dos corridas de la sesión lo dejan ver en dos líneas:

Fragmento perf_counter process_time
sleep(1.75) 1,75 s 0 s
Ciclo de cien millones de vueltas 2,5 s 2,5 s

El primero no gasta procesador: el proceso está dormido y el núcleo atiende otra cosa. El segundo gasta todo lo que dura. Con varios hilos el tiempo de procesador puede pasarse del de reloj, porque suma lo que consumió cada uno.

El problema de time es que entrega una sola medición por ejecución, y esa medición trae el ruido del estado de la caché y de lo que esté haciendo la máquina. timeit repite el fragmento muchas veces, apaga el recolector de basura mientras mide, usa el temporizador de mayor resolución y separa la preparación con el argumento setup.

import timeit
total = timeit.timeit(lambda: fib(30), number=100)
print(total / 100)            # el promedio se saca a mano

timeit devuelve el total, no el promedio, y la razón tiene que ver con los números en punto flotante. Un double no puede representar todos los reales: la máquina es finita, así que guarda el más cercano e introduce un error de truncamiento que se propaga al operar. Dividiendo una sola vez al final, ese error se paga una vez y no cien.

Con fib(30) y cien repeticiones la corrida dio 15,8 s, y la división da 0,158 s: 158 milisegundos por llamada. Ese es el número que se reporta, no los 15,8 s.

Los bancos no calculan en pesos

Calculan en centavos, con enteros, por esta misma razón. Un banco con veinte millones de clientes y un error de un centavo por cliente y por segundo pierde doscientos mil pesos por segundo. La regla para cualquier cálculo financiero es trabajar en la unidad entera mínima y dividir solo para mostrar.

El argumento setup es lo que separa la preparación de lo que se mide, y dejarlo por fuera arruina la medición. El caso que se trabajó: preparar los datos cuesta 5 ms y la operación que interesa, 0,2 ms, con mil repeticiones. Si la preparación queda dentro del fragmento medido, cada iteración reporta 5,2 ms y el resultado sale inflado veintiséis veces; en setup se paga una sola vez y las mil iteraciones suman 200 ms, que es lo que de verdad cuesta la operación.

Dónde se va el tiempo: cProfile

cProfile es un perfilador determinista: registra cada llamada a función. Viene en la biblioteca estándar, está implementado en C y su reporte trae, por función, cuántas veces se llamó (ncalls), el tiempo propio sin contar las llamadas que hace (tottime) y el acumulado que sí las cuenta (cumtime).

El encabezado distingue dos cuentas que conviene no confundir. Las llamadas totales son todas las invocaciones, incluidas las de la recursión. Las llamadas primitivas son las que entran a la función desde fuera de ella: una función recursiva invocada una vez desde el programa principal aporta una sola llamada primitiva, sin importar cuántos niveles baje.

Sobre fib(35) sin memoización:

9227465
   29860712 function calls (10 primitive calls) in 4.957 seconds

Diez llamadas primitivas contra casi treinta millones de llamadas totales: todo el trabajo está dentro de una sola recursión que recalcula los mismos valores una y otra vez. La cota es \(O(2^n)\), aunque el número exacto crece como \(\varphi^n\) con la razón áurea, y por eso da veintinueve millones y no treinta y cuatro mil millones.

Con números pequeños la cuenta se hace a mano y explica de dónde sale esa cifra. fib(4) gasta 9 llamadas, fib(5) gasta 15 y fib(6) gasta 25: cada una es la suma de las dos anteriores más uno, porque el árbol de fib(n) tiene el de fib(n-1) a la izquierda, el de fib(n-2) a la derecha y la llamada de la raíz. Siguiendo esa recurrencia hasta 35 se llega a 29 860 703 llamadas a fib; las nueve que faltan para el total del encabezado son del print y de la maquinaria del perfilador.

La corrección es memoizar: guardar cada resultado la primera vez que se calcula y devolverlo cuando lo vuelvan a pedir. functools.lru_cache lo hace sobre una tabla hash, y basta una línea encima de la función:

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n <= 1:
        return n
    return fib(n - 1) + fib(n - 2)

El arroba es un decorador: una función que recibe otra función y le cambia el comportamiento, como las anotaciones de Java. Aquí lo que agrega es memoria. El resultado:

9227465
         45 function calls (10 primitive calls) in 0.000 seconds

De veintinueve millones de llamadas a cuarenta y cinco. El algoritmo pasó de exponencial a lineal sin tocar la recursión. La caché guarda por los argumentos de la llamada, así que estos tienen que ser hashables: con un número funciona, con una lista o un diccionario como argumento no.

El perfilador cobra su parte

Registrar cada llamada cuesta: cProfile agrega del 30 al 45 % al tiempo de ejecución, y en programas con muchas llamadas cortas mucho más. Sobre fib(35) el sobrecosto es de más de un segundo.

Ese costo no se reparte parejo: pesa más sobre funciones pequeñas llamadas muchas veces, que son justamente las que uno quiere juzgar. Sirve para comparar funciones dentro de la misma corrida, no para reportar el tiempo real de un programa. Y no va en producción: allí solo agrega tiempo de ejecución. Su lugar es el banco de pruebas, cuando alguien reporta que algo tarda y hay que decir dónde.

Qué tiempo va en el informe

El del programa sin perfilador. En el ejemplo de la nube de puntos el encabezado de cProfile anuncia 2,963 s y el mismo programa cronometrado a secas tarda 1,382 s: la diferencia es el instrumento midiéndose a sí mismo. El perfilador dice dónde se va el tiempo; cuánto tarda el programa lo dice el cronómetro.

Muestrear en vez de registrar: Pyinstrument

Pyinstrument es un perfilador estadístico: en vez de anotar cada llamada, cada cierto intervalo guarda la pila de llamadas y después reconstruye el árbol. El sobrecosto baja a cerca del 5 %, y a cambio se pierde el conteo exacto de llamadas.

Para ver con confianza una función que consume el x % del tiempo hacen falta del orden de 100/x muestras, suponiendo que el programa se comporta parejo: una que pesa la mitad del tiempo se ve con dos, una que pesa el 10 % pide diez, y una que pesa el 1 % pide cien. De ahí sale el intervalo: si hay que ver algo que dura un segundo con cien muestras, el intervalo tiene que ser de diez milisegundos.

La cuenta al revés también sirve. fib(35) sin memoizar dura 4,64 s, y con un intervalo de 0,1 s el perfilador alcanza a tomar unas 46 muestras: pocas, pero suficientes para ver dónde está el peso. La misma función memoizada dura tan poco que el perfilador sale con cero muestras y el reporte queda en blanco, aunque la optimización haya funcionado. Lo que dura menos que el intervalo no aparece, y por eso la herramienta no sirve para programas muy cortos ni para programas erráticos, donde el muestreo puede caer siempre en el mismo sitio: ahí cProfile dice más.

El ejemplo de la sesión es la estimación de pi por Monte Carlo. Se tiran puntos al azar en un cuadrado con un círculo inscrito, y la proporción de los que caen dentro del círculo tiende a pi/4; entre más puntos, mejor la estimación.

13.2 <module>  MonteCarlos.py:1
└─ 13.2 estimate_pi  MonteCarlos.py:5
   ├─ 12.6 <genexpr>  MonteCarlos.py:6
   │  ├─ 8.2 point  MonteCarlos.py:13
   │  │  ├─ 4.2 Random.uniform  random.py:500
   │  │  │  ├─ 2.7 [self]  random.py
   │  │  │  └─ 1.5 Random.random  <built-in>
   │  │  └─ 4.0 [self]  MonteCarlos.py

De 13,2 s totales, Random.uniform se lleva 4,2 s, y de esos 2,7 s son [self]: trabajo de la propia función, escrita en Python. Solo 1,5 s bajan a Random.random, que está en C. uniform(0, 1) escala un número aleatorio a un rango, y ese escalado se paga en el intérprete.

Cambiar uniform por random es una línea, y el programa pasa de 13,2 s a 8,7 s. El nodo que costaba 4,2 s pasa a costar 1,9 s y desaparece el [self] de random.py. Un tercio del tiempo, por cambiar de función.

Nodo Con uniform Con random
Total del programa 13,2 s 8,7 s
point 8,2 s 3,2 s
Random.uniform 4,2 s —
Random.random 1,5 s 1,9 s

Ese es el tipo de decisión que el perfil hace visible y que leyendo el código no se ve: las dos versiones hacen lo mismo y se leen igual de bien.

Cuál usar para qué

time timeit cProfile Pyinstrument
Responde cuánto cuánto, con repeticiones dónde, por función dónde, por rama
Técnica cronómetro cronómetro repetido instrumentación muestreo
Sobrecosto mínimo mínimo 30–45 % o más ~5 %
Granularidad el fragmento el fragmento cada función lo que alcance el muestreo

Sobre el mismo programa, uno que busca para cada punto de una nube de dos mil el vecino más cercano y antes espera medio segundo simulando un sensor, las dos herramientas dicen cosas distintas. cProfile cuenta que distancia se llamó cuatro millones de veces y lista noventa y cinco funciones; Pyinstrument muestra el árbol, dónde está el medio segundo de espera y qué rama pesa, pero no dice cuántas veces se llamó nada.

El precio también difiere: sin perfilador el programa tarda 1,382 s de reloj y 0,870 s de CPU; con cProfile, 3,024 s; con Pyinstrument, 2,990 s. Que el perfilador estadístico cueste casi lo mismo tiene explicación: para decidir cada milisegundo si guarda la pila instala un enganche que se dispara en cada llamada, y con cuatro millones de llamadas diminutas ese enganche pesa tanto como instrumentarlas todas. Con la misma nube y la llamada por par eliminada, el programa hace 6 232 llamadas y los dos perfiladores desaparecen dentro del ruido de la medición.

Dos decisiones que salieron del perfil

La primera fue sacar la llamada a distancia del ciclo interno y comparar directamente: cuatro millones de llamadas se vuelven unos pocos miles.

La segunda es de cálculo numérico. Para comparar distancias no hace falta la raíz cuadrada: si una distancia es mayor que otra, su cuadrado también lo es, y las distancias nunca son negativas. Comparando cuadrados desaparece la raíz y, con ella, buena parte del trabajo en punto flotante. En cálculo numérico las operaciones con double son caras y arrastran error; cuando se pueda, conviene trabajar con enteros.

El flujo de trabajo completo es corto: verificar que el programa es correcto, medir para tener el punto de comparación, perfilar para encontrar el cuello de botella, optimizar ese 10 % crítico, y volver a perfilar para comprobar que el cuello se movió.

Cuando el ciclo de Python es el problema

Qué guarda una lista

En C, un arreglo es una reserva de memoria y arr[i] es azúcar sintáctico de *(arr + i): llegar a un elemento es sumar un desplazamiento a una dirección, y cuesta lo mismo sea cual sea el índice. Los arreglos bidimensionales no existen; son unidimensionales con la aritmética adentro.

int *arr = malloc(1000 * sizeof(int));
for (int i = 0; i < 1000; i++) {
  *(arr + i) = 10;   // idéntico a arr[i] = 10;
}

Una lista de Python es un arreglo por debajo, con capacidad reservada y un contador de cuántos elementos tiene. De ahí sale que append cueste \(O(1)\): escribe en la primera posición libre y mueve el contador. Insertar al principio, en cambio, corre todos los elementos: cuesta \(O(n)\), y un ciclo que inserta al principio se vuelve \(O(n^2)\) sin que nada lo anuncie. Invertir una lista poniendo el último al principio funciona y es de las formas más caras de hacerlo.

Lo caro de Python no es llegar al elemento, que también es \(O(1)\). Lo caro es lo que hay en cada posición: la lista guarda punteros a objetos, y cada número es un objeto con su envoltura. Un arreglo de NumPy guarda los valores contiguos, del mismo tipo y del mismo tamaño, tal como el arreglo de C.

Eso tiene una consecuencia que sorprende:

>>> a = np.full(10, 1)
>>> type(a[0])
<class 'numpy.int64'>     # no es un int de Python
>>> np.int64(2**62) * 4
0                         # desborda, como en C
>>> 2**62 * 4
18446744073709551616      # el entero de Python no tiene tope

El elemento que devuelve NumPy es una envoltura de un valor de C de 64 bits, con el desbordamiento de C incluido. El entero de Python no desborda porque no es un entero de máquina.

Y otra que muerde más seguido:

>>> matriz = [](<#>) * 10     # diez referencias a la MISMA lista
>>> matriz[0].append(2)
>>> matriz
[[2], [2], [2], [2], [2], [2], [2], [2], [2], [2]]

Como los objetos se guardan por referencia, las diez posiciones apuntan al mismo objeto. Con valores inmutables, en cambio, asignar en una posición sí la cambia solo a ella.

Cuatro formas de sumar lo mismo

Con diez millones de números, en la máquina de la sesión:

Forma Tiempo
Lista, recorriéndola con for x in xs 551 ms
Lista, indexando con xs[i] 852 ms
Arreglo de NumPy, indexando desde Python 2 197 ms
np.sum sobre el arreglo 13 ms

Indexar cuesta más que recorrer porque hay que calcular la posición, verificar los límites y se pierde la localidad espacial, el mismo efecto del recorrido de una matriz por columnas de la primera sesión. Y el arreglo de NumPy indexado desde Python es lo peor de los dos mundos: todo lo anterior más la conversión de cada int64 a un objeto de Python, que después hay que volver a desenvolver.

La regla que deja NumPy

Si aparece un for recorriendo un arreglo de NumPy, casi siempre existe una función vectorizada que hace lo mismo entre diez y cien veces más rápido. Preferir np.sum, np.dot, los operadores, las funciones matemáticas vectorizadas, el slicing y el broadcasting; evitar los ciclos, la indexación elemento por elemento y sacar los datos a listas.

Con las cadenas pasa lo mismo y por la misma razón. Las cadenas de Python son inmutables, así que armar uno grande a punta de += crea una cadena nueva en cada vuelta y copia lo que ya había. "".join(partes) recorre la lista una vez, suma los tamaños, reserva la memoria de una sola vez y copia cada pedazo a su sitio.

Instrucciones AVX

AVX, Advanced Vector Extensions, son instrucciones SIMD: una sola instrucción sobre varios datos. En vez de sumar un par de números por instrucción, el procesador carga varios en un registro ancho y los opera de una vez.

Es una diferencia de naturaleza con lo que se venía haciendo. Repartir en hilos es cosa del programa: alguien decide cuántos hilos hay y qué le toca a cada uno. Aquí el reparto lo hace el procesador dentro de una instrucción, y el programa ni se entera; lo único que se puede hacer es escribir el ciclo de forma que la biblioteca o el compilador puedan aprovecharlo. AVX está en los procesadores x86 desde 2010, así que un equipo que no lo traiga pasa de los quince años.

Registro float32 float64
128 bits (SSE) 4 2
256 bits (AVX/AVX2) 8 4
512 bits (AVX-512) 16 8

La cuenta que sale de ahí: sumar un arreglo de cinco millones de float64 con un registro de 256 bits, que carga cuatro dobles, necesita 1 250 000 instrucciones en vez de cinco millones. AVX es la familia de x86; ARM tiene NEON y SVE, y por eso la portabilidad la resuelve la biblioteca, no el programa: NumPy escoge la ruta según lo que reporte el procesador.

Para que los elementos puedan viajar juntos en un registro hacen falta cuatro condiciones: que sea la misma operación para todos, que los elementos sean independientes entre sí, que el acceso a memoria sea contiguo y regular, y que no haya bifurcaciones que dependan del dato dentro del ciclo.

Cinco patrones sobre el mismo arreglo de cinco millones de float64, en la máquina del deck:

Patrón Tiempo Factor Condición que rompe
Contiguo, a * 2.5 + 1.0 11,8 ms 1× Ninguna
Índices dispersos, a[idx] 63,6 ms 5,4× Acceso regular
np.where(a > 0.5, ...) 21,2 ms 1,8× Ninguna: la máscara reemplaza el salto
if dentro de un ciclo 1 578,3 ms 134× Bifurcación por dato
Recurrencia s[i] = 0.99*s[i-1] + a[i] 1 681,6 ms 142× Independencia

Los dos últimos quedan en el mismo orden de magnitud, y por motivos distintos. El if en bucle rompe la bifurcación, pero lo que lo hace catastrófico es el costo del intérprete recorriendo cinco millones de posiciones; np.where hace la misma decisión con una máscara vectorizada y cuesta 1,8×. La recurrencia no se vectoriza tal como está escrita: cada paso necesita el anterior, como la suma de prefijos de la sesión de estrategias. Y la salida es la misma de allá: calcular los totales por bloque, acumular los desplazamientos y rehacer cada bloque desde el suyo. Una dependencia no siempre es del problema; a veces es de cómo quedó escrita la solución.

El acceso disperso no rompe nada de la lógica, solo el orden: leer las posiciones salteadas deja de aprovechar la línea de caché y los elementos no llegan juntos.

Del registro a la GPU

Un registro AVX reparte una instrucción entre ocho carriles. Una GPU lleva eso al extremo con miles de carriles, con una diferencia: cada grupo tiene su propio contador de programa, por eso el modelo se llama SIMT. Cuando los carriles de un grupo toman caminos distintos, el grupo ejecuta los dos y la mitad queda esperando.

La GPU tiene memoria propia y mucho más ancho de banda que la CPU, pero los datos hay que llevarlos y traerlos por el bus PCIe, y ese viaje no hace ningún cálculo. La pregunta es cuántas operaciones se hacen por cada byte que viaja:

Operación Bytes Operaciones Op/byte ¿Se mueve?
a * 2.5 + 1.0 sobre 5 M float64 80 MB 10 Mflop 0,125 No
Producto de matrices 4000 × 4000 float32 192 MB 128 Gflop 667 Sí

La primera fila: cinco millones de float64 son 40 MB de ida y 40 de vuelta; a 12 GB/s el viaje solo cuesta 6,7 ms, y NumPy en la CPU resuelve la operación completa en 11,8 ms. No compensa. La segunda: tres matrices de 4000 × 4000 en float32 son 3 × 16 M × 4 B = 192 MB, y el producto hace \(2n^3\) = 128 Gflop, unas 667 operaciones por byte. Ahí sí.

Entre una fila y otra hay un factor de más de cinco mil en operaciones por byte, y el corte está cerca de diez. De ahí la práctica habitual: subir los datos una vez, encadenar sobre ellos todas las operaciones que se pueda, y bajar solo el resultado. Cada ida y vuelta intermedia se come la ganancia.

Desde Python el puente son CuPy y PyTorch, que replican la interfaz de NumPy y despachan a CUDA, el controlador de las tarjetas NVIDIA.

Los perfiladores de esta sesión no sirven para la GPU

La llamada retorna apenas encola el trabajo, antes de que la GPU lo termine, así que cProfile y Pyinstrument le atribuyen microsegundos a una operación que tardó milisegundos. Hay que sincronizar antes de detener el cronómetro, con torch.cuda.synchronize() o cp.cuda.runtime.deviceSynchronize(), o medir con las herramientas del fabricante.

Y por debajo de todo esto está lo mismo: NumPy no implementa álgebra lineal por su cuenta, delega en BLAS, LAPACK o MKL, que están escritas en C y Fortran y compiladas con las instrucciones vectoriales del procesador. Por eso Python sirve para cálculo numérico pese a ser lento: la sintaxis es de Python y el trabajo es de C.

Lo que sigue

Arrancar el intérprete es cargar cosas. globals() muestra el contexto en que uno está parado y dir(__builtins__) lista lo que viene puesto de fábrica: list, dict, int, min, max, map, zip, str. Nada de eso es palabra reservada del lenguaje; son objetos que el intérprete dejó cargados, y se pueden mirar uno por uno. Borrar ese contexto deja un Python que no sabe hacer una lista.

Ese contexto compartido es el que impide que dos hilos de Python ejecuten código del intérprete a la vez. El candado tiene nombre y es el tema de la sesión siguiente, junto con la diferencia entre repartir en hilos y repartir en procesos.