¿Cuándo se cargan los comandos integrados en la memoria?

Digamos si escribo cden mi shell. ¿Se cdcarga desde la memoria en ese momento? Mi intuición es que estos comandos incorporados se cargan previamente en la memoria del sistema después de que se haya cargado el kernel, pero alguien insistió en que se carguen solo cuando invoco el comando (presione enter en un shell). ¿Podría decirme si hay una referencia que explique esto?

Digamos si escribo cd en mi shell. ¿Se carga el cd desde la memoria en ese momento? Mi intuición es que estos comandos incorporados se cargan previamente en la memoria del sistema después de que se haya cargado el núcleo, pero alguien insistió en que se carguen solo cuando invoco el comando ...

En términos generales, las otras respuestas son correctas: los incorporados se cargan con el shell, los independientes se cargan cuando se invocan. Sin embargo, un "alguien" muy comadrejo podría decir que no es tan simple.

Esta discusión es algo acerca de cómo funciona el sistema operativo, y los diferentes sistemas operativos funcionan de diferentes maneras, pero creo que, en general, lo siguiente es probablemente cierto para todos los * * * * * * * * * * * * * * *

Primero, "cargado en la memoria" es una frase ambigua; En realidad, a lo que nos referimos es a su espacio de direcciones virtuales mapeado en la memoria . Esto es significativo porque el "espacio de direcciones virtuales" se refiere a cosas que pueden necesitar colocarse en la memoria, pero de hecho no lo es inicialmente: principalmente lo que realmente se carga en la memoria es el mapa en sí , y el mapa no es el territorio. El "territorio" sería el ejecutable en el disco (o en la caché del disco) y, de hecho, la mayor parte de eso probablemente no se carga en la memoria cuando invoca un ejecutable.

Además, gran parte de "el territorio" son referencias a otros territorios (bibliotecas compartidas), y nuevamente, el hecho de que se haya hecho referencia a ellas tampoco significa que estén realmente cargadas. No se cargan hasta que se usan realmente, y luego solo las piezas que realmente necesitan cargarse para que cualquier "uso" tenga éxito.

Por ejemplo, aquí hay un fragmento de topsalida en Linux que se refiere a una bashinstancia:

VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                  
113m 3672 1796 S  0.0  0.1   0:00.07 bash   

El 113 MB VIRT es el espacio de dirección virtual, que se asigna en la RAM. Pero RES es la cantidad real de RAM consumida por el proceso, solo 3.7 kB. Y de eso, parte es parte del territorio compartido mencionado anteriormente: 1.8 kB SHR. Pero mi /bin/bashdisco es de 930 kB, y la biblioteca básica a la que se vincula (una biblioteca compartida) es dos veces más grande.

Ese caparazón no está haciendo nada en este momento. Digamos que invoco un comando incorporado, que dijimos anteriormente ya estaba "cargado en la memoria" junto con el resto del shell. El kernel ejecuta cualquier código que esté involucrado comenzando en un punto del mapa, y cuando alcanza una referencia al código que realmente no se ha cargado, lo carga, desde una imagen ejecutable en el disco , aunque sea de forma más informal. En este sentido, ese ejecutable (ya sea el shell, una herramienta independiente o una biblioteca compartida) ya estaba "cargado en la memoria".

Esto se llama paginación de demanda .

Mientras espero que venga uno de los pesos pesados ​​y brinde una perspectiva histórica completa, le daré mi comprensión más limitada.

Una función de comandos como alias, cd, echoetc, son parte de su cáscara ( bash, zsh, ksho lo que sea). Se cargan al mismo tiempo que el shell es y son simplemente funciones internas de ese shell.

Hice el siguiente experimento para mostrar que los comandos incorporados de hecho están cargados como parte del ejecutable bash . De ahí por qué se llaman builtins, pero una demostración es siempre la mejor manera de probar algo.

Ejemplo

1. Inicie un nuevo bashshell y observe su ID de proceso (PID):

   $ bash
   $ echo $$
   6402
   

2. En un segundo terminal, ejecute el pscomando para que podamos observar y ver si bashcomienza a ocupar memoria adicional:

   $ watch "ps -Fp 6402"
   

   El resultado se ve así:

   Every 2.0s: ps -Fp 6402                        Sat Sep 14 14:40:49 2013
   
   UID        PID  PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
   saml      6402  6349  0 28747  6380   1 14:33 pts/38   00:00:00 bash
   

   NOTA: El uso de la memoria se muestra con las columnas SZ y RSS aquí.

3. Comience a ejecutar comandos en el shell (pid 6402):

   A medida que cdpase, notará que la memoria aumenta, pero esto no se debe a que el ejecutable cdse carga en la memoria, sino porque la estructura del directorio en el disco se está cargando en la memoria. Si sigue cdingresando en otros directorios, verá que aumenta progresivamente.

   Every 2.0s: ps -Fp 30208                        Sat Sep 14 15:11:22 2013
   
   UID        PID  PPID  C    SZ   RSS PSR STIME TTY          TIME CMD
   saml     30208  6349  0 28780  6492   0 15:09 pts/38   00:00:00 bash
   

   Puedes hacer pruebas más elaboradas como esta:

   $ for i in `seq 1000`; do cd ..; cd 90609;done
   

   Este comando subirá un nivel y luego regresará al directorio 90609 1000 veces. Mientras ejecuta esto, si monitorea el uso de memoria en la psventana, notará que no cambia. Mientras se ejecuta algo como esto, no se debe notar el uso de memoria adicional.

4. strace

   Aquí hay otro mensaje de que estamos tratando con una función incorporada en bashlugar de un ejecutable real. Cuando intente ejecutar strace cd .., recibirá el siguiente mensaje:

   $ strace cd ..
   strace: cd: command not found
   

"comando incorporado" se refiere a los comandos integrados en el shell, en lugar de como programas separados. ls, por ejemplo, en realidad no es un comando incorporado sino un programa separado. Se cargará en la RAM cuando se invoque, a menos que ya esté en la caché del disco.

Un ejemplo de un comando incorporado sería printfocd . Estos son parte del shell y se cargan junto con el resto del shell.

No hay comandos cargados previamente de forma predeterminada, aunque se han creado sistemas para hacer esto.