emacs - que - prender y apagar mas rapido windows 7

¿Cómo puedo hacer que Emacs arranque más rápido? (17)

"Tiendo a abrir y cerrar emacs mucho, porque me siento más cómodo usando la línea de comando bash para la manipulación y compilación de archivos / directorios".

Estás describiendo cómo se usa un editor como vim. Disparar adentro y afuera. Emacs generalmente se mantiene abierto, y casi todo se hace desde "dentro de él". hiena ya respondió cuál sería el enfoque correcto aquí.

Utilizo Emacs v. 22 (la versión de la consola, ya sea remotamente con PuTTY o localmente con Konsole ) como mi principal editor de texto en Linux. Sin embargo, lleva un tiempo cargar cada vez que lo comienzo, probablemente casi un segundo, aunque nunca lo cronometré. Tiendo a abrir y cerrar Emacs mucho, porque me siento más cómodo usando la línea de comandos de Bash para la manipulación y compilación de archivos / directorios.

¿Cómo puedo acelerar el tiempo de puesta en marcha?

Además de la solución de Adam Rosenfield , recomiendo usar Emacs en modo servidor . Puede agregar (server-start) a sus dotemacs y ejecutar emacsclient lugar de emacs siempre que desee abrir un archivo en Emacs. De esta forma, tendrá que pagar el costo de carga de Emacs solo una vez, luego los clientes aparecerán inmediatamente.

Editar

Tienes razón, v22 no crea un nuevo marco. Crea un script de shell que haga el truco:

#!/bin/bash # Argument: filename to open in new Emacs frame /usr/bin/emacsclient -e ''(let ((default-directory "`pwd`/")) (select-frame (make-frame)) (find-file "''$1''"))''

Emacs está diseñado para funcionar "todo el tiempo" (o al menos durante largos períodos de tiempo), por lo tanto, no se recomienda iniciar y detener Emacs varias veces durante un día.

Sugeriría usar la pantalla. Screen es un multiplexor de terminal que le brinda terminales virtuales ilimitados en una terminal.

Después de la instalación, simplemente escriba "screen emacs" en su terminal. Emacs se iniciará como de costumbre, pero al presionar "ca c" (que es presionar ctrl-a y luego c) se abrirá un nuevo terminal virtual. Puede volver a emacs presionando "ca ca" (eso es dos veces ctrl-a).

Incluso puede desconectarse de la sesión de la pantalla en ejecución, la secuencia de teclas es "ca d".

Vuelva a adjuntar a la sesión emitiendo "pantalla -R" y regresará a donde lo dejó. Esto le permite iniciar una sesión de emacs en el trabajo, desconectarse, irse a su casa y volverse a conectar desde su casa.

He estado ejecutando Emacs de esta manera durante meses seguidos.

Aquí está el sitio web oficial: http://www.gnu.org/software/screen/ pero intente buscar en Google tutoriales en pantalla y howtos

Estaba tratando de resolver el mismo problema, cuando me encontré con esta pregunta aquí. Solo quería agregar que el problema para mí no se debió al tiempo de carga de los paquetes de emacs lisp, sino al hecho de que el host no tenía un nombre de host totalmente resuelto

Para verificar el tiempo de carga de su paquete, haga

M-x emacs-init-time

Para mí fue 0,3 segundos, y sin embargo, el tiempo de carga fue extremadamente alto. Después de cambiar mi nombre de host correctamente, solucionó el problema.

Para configurar su nombre de host totalmente resuelto, edite / etc / hostname, y / etc / hostsfile con:

127.0.0.1 localhost localhost.localdomain 192.168.0.2 hostname hostname.domain

Intente utilizar la macro https://github.com/jwiegley/use-package para definir las cargas y personalizaciones de sus paquetes. Maneja la carga diferida de paquetes por usted, lo que hace que sea relativamente fácil obtener buenos tiempos de inicio incluso en presencia de un gran número de paquetes configurados. Tengo casi 100 paquetes referenciados en mis .emacs, pero mi tiempo de inicio es menos de 2 segundos en Linux y 2.2s en Mac.

La manera más rápida es perfilar sus .emacs . Reduje el tiempo de carga de> 3s a 1s en 5 minutos después de encontrar que 4 líneas particulares en mis .emacs ocupaban más del 80% del tiempo de carga.

No cierre Emacs cada vez que quiera usar el caparazón. Use Ctrl-Z para mover Emacs al fondo y el comando fg en Bash para moverlo nuevamente al primer plano.

Otros han cubierto el uso de gnuserve y emacsclient , y sugiero compilar dentro de emacs (es posible ganar errores de compilación).

Pero, específicamente, la aceleración de .emacs se puede hacer de la siguiente manera:

Byte compila el archivo .emacs, que puedes hacer automáticamente usando este fragmento de código
Reemplazando tantas de las instrucciones (require ''package) con la funcionalidad de autoload . Esto retrasará la carga de lisp hasta que realmente se requiera. Usar esta técnica me permitió acelerar mi inicio de> 6 segundos a <1. Esto requiere un poco de trabajo porque no todas las bibliotecas vienen marcadas de forma autoload .
Eliminando código / funcionalidad que ya no usa.
Intenta ejecutar emacs con la opción --no-site-file para evitar cargar paquetes innecesarios en la instalación del site-start.el .
Si habla en serio, puede lanzar sus propios emacs con su funcionalidad favorita ya cargada. Esto, por supuesto, significa que está más involucrado para hacer cambios a lo que tienes en tus .emacs porque es parte del binario. Siga el enlace para obtener información sobre cómo usar dump-emacs .
Compre una computadora más rápida y / o un disco más rápido.

Cómo determinar qué carga tu .emacs

Ahora, ¿cómo averiguas qué carga tu .emacs? ¿Con el objetivo de eliminar la funcionalidad o retrasarla? Verifica tu buffer *Messages* , que contiene líneas como:

Loading /home/tjackson/.emacs.tjackson.el (source)... Loading /home/tjackson/installed/emacs/lisp/loaddefs.el (source)...done Loading /user/tjackson/.elisp/source/loaddefs.el (source)...done Loading autorevert...done Loading /home/tjackson/.emacs.tjackson.el (source)...done

Si lo nota, las instrucciones de Loading pueden anidar: la primera .emacs.tjackson.el termina con ... y la última línea muestra que la carga de .emacs.tjackson.el está ...done . Todos esos otros archivos se cargan desde mi archivo .emacs.tjackson.el . Todas las otras cargas son atómicas.

Nota: Si tiene un .emacs grande, es posible que el búfer *Messages* pierda algunos de los mensajes porque solo mantiene una cantidad fija de información. Puede agregar esta configuración desde el principio a su .emacs para mantener todos los mensajes:

(setq message-log-max t)

Nota: ''load comando ''load suprimirá los mensajes si su cuarto argumento, nomessage es no-nil, por lo tanto, elimine dichas invocaciones (o, avise ''load y fuerce que el cuarto argumento sea nil ).

Puede usar benchmark-init para perfilar su inicio de Emacs. Hará un seguimiento de qué módulos se están cargando y cuánto tiempo se gasta en cada uno. Los resultados pueden presentarse en forma tabulada o como un árbol. El árbol facilita el seguimiento de quién carga qué, lo que puede ser útil cuando carga un paquete con muchas dependencias, y el formulario tabulado le ayuda a encontrar rápidamente dónde se está gastando la mayor parte del tiempo.

Una vez que tenga estos resultados intente averiguar si todos los módulos deben cargarse todo el tiempo o si puede cargar algunos de ellos a pedido. Por ejemplo, en mi configuración, solo cargo las extensiones de Emacs que son específicas de ciertos modos cuando ese modo está realmente activado, ya que la mayoría de las veces solo uso un pequeño subconjunto de ellos en una sesión. eval-after-load ganchos eval-after-load y mode serán tus amigos aquí.

Al aplicar este método mi Emacs se inicia en 3-4 segundos y tengo cerca de 200 extensiones instaladas. La mayor parte del tiempo lo paso cargando Helm, que siempre cargo ya que reemplaza find-file y otras funciones centrales que siempre son necesarias, y CEDET, ya que utilizo la última versión y debe cargarse antes de que Emacs intente cargar el antiguo versión incorporada.

Tenía alrededor de 120 segundos de tiempo de inicio. Pude encontrar la solución para instalar esto:

benchmark-init puesto encima de su init.el

(let ((benchmark-init.el "~/.emacs.d/el-get/benchmark-init/benchmark-init.el")) (when (file-exists-p benchmark-init.el) (load benchmark-init.el)))

una vez que tus emacs comenzaron, ejecuta:

Mx benchmark-init / show-durations-tree

Por mi parte, el problema fue de 127 segundos en tramp-loaddefs

Lo arreglé añadiendo

127.0.0.1 host.does.not.exist

a / etc / hosts y eso hizo mi inicio rápido

ver más aquí: https://github.com/emacs-helm/helm/issues/1045

Otra cosa que puede ser útil para usted: https://www.emacswiki.org/emacs/ProfileDotEmacs

Tendría que verificar mi personalización, pero hay un paquete llamado gnuserve o emacsclient. Migra mucho, por lo que tendrá que buscarlo en Google.

Ejecuta una sesión de emacs en segundo plano. Cualquier sesión adicional de emacs es esencialmente solo un nuevo fotograma de esa sesión. Una ventaja es el tiempo de inicio rápido para sus sesiones posteriores.

Un par de consejos:

Use autocarga
El uso de carga automática le ahorra cargar bibliotecas hasta que las use. Por ejemplo:
(if (locate-library "ediff-trees") (autoload ''ediff-trees "ediff-trees" "Start an tree ediff" t))
Compila tus .emacs
Le da un ligero aumento de velocidad, aunque hay riesgos si trabaja con control de versiones y su .emacs es más nuevo que .emacs.elc. Un truco común es:
(defun autocompile nil "compile itself if ~/.emacs" (interactive) (require ''bytecomp) (let ((dotemacs (file-truename user-init-file))) (if (string= (buffer-file-name) (file-chase-links dotemacs)) (byte-compile-file dotemacs)))) (add-hook ''after-save-hook ''autocompile)
Aprende a amar el servidor de emacs.
Ejecutar emacs como servidor significa nunca tener que cerrarlo. Sin embargo, observo que sigues usando emacs22. emacs23 es compatible con multi-tty, lo que hace que sea mucho más fácil ejecutar emacs en una sesión de pantalla y luego mostrar ventanas nuevas en otra terminal. Yo uso emacs para editar correos para mi cliente de correo (mutt) y emacsclient es fantástico para este tipo de ediciones rápidas.

Una cosa que me ayudó a reducir el tiempo de carga de mis .emacs , además de la autoload (como otros han sugerido), es eval-after-load . En el siguiente ejemplo, retrasar la llamada a sql-set-product ahorra tener que cargar sql en sus .emacs , lo que hace que las .emacs existentes en sql más efectivas.

(eval-after-load "sql" ''(progn (sql-set-product ''mysql) (setq sql-mysql-options ''("-C" "-t" "-f" "-n")) (setq sql-sqlite-program "sqlite3") ))

Por supuesto, para algunos paquetes habrá un hook disponible que puede hacer lo mismo, pero a veces no, o de lo contrario solo resulta más fácil pensar en ello.

Una cosa que otros no han mencionado es incluir las bibliotecas elisp que usa como parte del Emacs abandonado para mover el tiempo de carga de la biblioteca desde el inicio de Emacs a la compilación de Emacs. No es para los pusilánimes, pero si carga varias bibliotecas en .emacs , podría ganar unos segundos de tiempo de inicio.

Uno de

M-x shell M-x eshell M-x term M-x ansi-term

debe cumplir con sus necesidades de línea de comandos desde dentro de Emacs.

¡También puedes usar M-! (también conocido como Mx shell-command ) para ejecutar una línea sin caer al shell.

Verifique su archivo .emacs para ver si está cargando paquetes innecesarios. La carga de paquetes puede llevar una cantidad significativa de tiempo. Por ejemplo, es posible que solo desee cargar el paquete php-mode si está editando un archivo PHP. Puede hacerlo instalando un procedimiento de enlace, aunque no estoy seguro de los detalles.

También asegúrese de que los paquetes que esté cargando estén compilados (archivos .elc ). Puede compilar un archivo elisp ejecutando

emacs -batch -f batch-byte-compile thefile.el

Los paquetes compilados se cargan mucho más rápido que los paquetes no compilados.

Esto no responde la pregunta, pero es algo relevante

No sé cómo hacer que comience más rápido, pero hay algunas cosas que podría sugerir:

para la mayoría de las cosas que haces en la línea de comando, puedes hacerlas en emacs:
- compilar: Mx compila, luego escribe el comando que usas
- mi experiencia es solo con C ++, pero con g ++ puedes presionar Cx `para saltar a líneas sobre las que el compilador se queja
- Ejecutar comandos de shell: M- !, vuelca la salida en un buffer
- shell interactivo: shell Mx
alternativamente, podría ejecutar emacs así:
- emacs file.ext &
- que abre emacs en el fondo para que puedas usar el shell (esto funciona mejor con masilla y reenvío X con algo así como Xming)