Wie verhindere ich, dass extrem lange Zeilen den Emacs langsam machen?

Ich sehe eine sehr unterschiedliche Leistung, abhängig davon, wie viele Zeilen in der Datei sind, die ich besuche.

Hier ist ein Beispiel. Ich habe zwei JSON-Dateien:

$ wget https://github.com/Wilfred/ReVo-utilities/blob/a4bdc40dd2656c496defc461fc19c403c8306d9f/revo-export/dictionary.json?raw=true -O one_line.json
$ python -m json.tool <one_line.json >pretty_printed.json

Dies sind zwei JSON-Dateien mit demselben Inhalt. one_line.jsonist 18 MB JSON ohne Zeilenumbruch. pretty_printed.jsonNewlines und Whitespace hinzugefügt, so dass es 41MiB.

Die über viele Zeilen verteilte größere Datei lässt sich jedoch in Emacs sowohl im JavaScript-Modus als auch im Fundamental-Modus viel schneller öffnen.

Warum hat Emacs bei langen Leitungen eine so schlechte Leistung, weil es eigentlich weniger Bytes sind? Kann ich die Leistung verbessern, ohne die Daten außerhalb von Emacs neu zu formatieren?

Emacs 'Umgang mit langen Schlangen ist nicht sehr gut optimiert. Für eine Reihe von Operationen muss Emacs die gesamte Zeile wiederholt scannen. Um beispielsweise eine Linie anzuzeigen, muss Emacs die Höhe der Linie ermitteln. Dazu muss die gesamte Linie gescannt werden, um die höchste Glyphe zu finden. Darüber hinaus nimmt das Scannen nach bidirektionaler Anzeige viel Zeit in Anspruch. Sie können einige zusätzliche Informationen erhalten, z. B. in der Dokumentzeichenfolge von cache-long-line-scans( cache-long-scansin 24.4 umbenannt ).

Sie können versuchen und sehen , ob Einstellung bidi-paragraph-directionauf left-to-rightdie Geschwindigkeit für Sie verbessert [Einstellung bidi-display-reorderingzu nil, tut mehr oder weniger das gleiche , sondern nur für den internen / Debug - Zwecke gedacht]. Dies entfernt einen signifikanten Beitrag zu Linienscans, aber leider nicht den einzigen.

Die beste Option ist das Hinzufügen von Zeilenumbrüchen. Sie können eine JSON-Datei python -c 'import json, sys ; json.dump(json.load(sys.stdin), sys.stdout, indent=2)'weiterleiten, um z. B. neue Zeilen hinzuzufügen und die Lesbarkeit zu verbessern.

Ich habe einige kurze Experimente mit einer verkleinerten Kopie von jquery durchgeführt. font-lock-modeund flycheck-modebeide trugen zur Langsamkeit, wie tat js2-mode, und prettify-symbols-mode. line-number-modeund column-number-modehatte geringe Wirkung. Einmal hatte ich die verschiedenen Modi ausgeschaltet, obwohl die Leistung relativ bissig war. Verwenden C-h mund deaktivieren Sie verschiedene aktivierte Modi, oder wechseln Sie einfach zu fundamental-mode.

Interessanterweise hexl-modekonnte ich die Datei ohne Probleme durchfliegen, obwohl die Spalten offensichtlich ziemlich kurz waren. Leider visual-line-modesehr verlangsamt.

Ich vermute, dass die Syntaxtabelle die Verarbeitung gerne an den Zeilenenden unterbricht, und wenn alles in einer Zeile steht, muss sie bei jedem Update alles neu analysieren.

Ich habe http://www.emacswiki.org/emacs/OverLongLineMode hochgeladen

Mit dieser Bibliothek können Sie einfache Schwellenwerte für die Zeilenlänge festlegen, ab denen fundamental-modeanstelle des normalen Modus eine Variante von für eine Datei verwendet wird (nur für Programmiermodi).

Möglicherweise könnte Emacs standardmäßig etwas in diese Richtung hinzugefügt werden. Dies kann jedoch eine vorläufige Lösung für das Hauptproblem sein, dass Emacs beim Auffinden einer solchen Datei langsamer kriecht.

nb Dies ist eine Verbesserung gegenüber dem Code, den ich ursprünglich in dieser Antwort gepostet habe, aber immer noch in Arbeit. Das Testen war minimal. Kommentare sind willkommen.

Vorschläge für andere (außer css-mode) nicht- prog-modeabgeleitete Hauptmodi, die standardmäßig unterstützt werden, werden ebenfalls begrüßt.

Ich nehme an, Sie werden feststellen, dass der Unterschied darauf zurückzuführen ist font-lock. Wenn die Schrift an der im Fenster sichtbaren Teilmenge der Datei vorgenommen werden soll, wird zunächst der Schriftbereich so erweitert, dass er vollständige semantische Einheiten enthält. Siehe dazu den font-lock-extend-region-functionsCode. Es ist üblich, die Region auf vollständige Zeilen zu erweitern. Wenn die Zeilen extrem lang sind, kann dies dazu führen, dass die Fontifizierung über einen sehr viel größeren Teil des Inhalts ausgeführt wird, als tatsächlich sichtbar ist.

Wenn Zeilenumbrüche selbst semantische Informationen enthalten, kann ihre Abwesenheit manchmal dazu führen, dass reguläre Ausdrücke für die Schriftsperre weiter gescannt werden müssen, um festzustellen, ob sie übereinstimmen oder nicht.

Normalerweise löse ich lange Zeilen auf und rücke nach Tags ein (wie HTML, XML, JSON).

Um eine solche Operation zu ermöglichen, füge ich hinzu:

(setq line-number-display-limit large-file-warning-threshold)
(setq line-number-display-limit-width 200)

(defun my--is-file-large ()
  "If buffer too large and my cause performance issue."
  (< large-file-warning-threshold (buffer-size)))

(define-derived-mode my-large-file-mode fundamental-mode "LargeFile"
  "Fixes performance issues in Emacs for large files."
  ;; (setq buffer-read-only t)
  (setq bidi-display-reordering nil)
  (jit-lock-mode nil)
  (buffer-disable-undo)
  (set (make-variable-buffer-local 'global-hl-line-mode) nil)
  (set (make-variable-buffer-local 'line-number-mode) nil)
  (set (make-variable-buffer-local 'column-number-mode) nil) )

(add-to-list 'magic-mode-alist (cons #'my--is-file-large #'my-large-file-mode))

I gespalten Linie durch regex, für XML es: C-M-% >< RET >NL< RET !.

Nachdem Emacs lange Zeilen geteilt hat, können Sie viele *-modesCodes aktivieren und neu einrücken.

Zum Hinweis: Wie kann eine Verlangsamung verhindert werden, wenn ein minderwertiger Prozess lange Schlangen erzeugt?

Ich habe hier meine eigene Lösung für dieses Problem erstellt: https://github.com/rakete/too-long-lines-mode

Ich war nicht zufrieden mit der phils-Lösung, die einen Puffer mit sehr langen Zeilen in den Fundamental-Modus versetzt. Ich wollte eine Lösung, mit der ich Syntax-Hervorhebungen und andere Hauptfeatures des Modus beibehalten kann. Deshalb habe ich einen Nebenmodus erstellt, der Überlagerungen verwendet, um die meisten Zeichen übermäßig langer Zeilen auszublenden.

Das umgeht das Problem und macht den Emacs auch in Puffern mit sehr langen Zeilen einsetzbar, ohne auf den Fundamental-Modus zurückgreifen zu müssen.

In meinem Emacs-Setup habe ich einen Modus mit benutzerdefinierter Schriftart, dh wo ich festgelegt habe font-lock-defaults. Eine einzelne Seite nach unten würde 30 Sekunden benötigen, um einen Teil der 30000-Zeichenzeile anzuzeigen. Diese Verlangsamung wurde behoben, indem das Regexp-Backtracking reduziert wurde. Anstatt von:

  (". * endete mit einem unvollständigen Befehl *" 0 font-lock-comment-face)

mach das

  ("^. \ {1,80 \} endete mit einem unvollständigen Befehl *" 0 font-lock-comment-face)

In meinen Shell-Mode-Puffern (Mx-Shell) muss ich Pipes verwenden sed -r 's/(.{2000}).*/\1/' -u, um lange Zeilen zu vermeiden.

Ich benutze die folgende Funktion zum Öffnen in dired-modegroßen Dateien mit langen Zeilen:

(defun dired-find-file-conservatively ()
   (interactive)
   (let ((auto-mode-alist nil))
     (dired-find-file)
     ;; disable costly modes
     (fundamental-mode)
     (setq-local bidi-display-reordering nil)
     (when (boundp 'smartparens-mode)
       (smartparens-mode -1))))

(define-key dired-mode-map (kbd "S-<return>") 'dired-find-file-conservatively)

Hier ist eine Problemumgehung aus Emacs-Devel :

(add-hook 'find-file-hook
          (defun my-find-file-care-about-long-lines ()
            (save-excursion
              (goto-char (point-min))
              (when (and (not (eq major-mode 'image-mode))
                         (search-forward-regexp ".\\{2000\\}" 50000 t)
                         (y-or-n-p "Very long lines detected - enable 
longlines-mode? "))
                (require 'longlines)
                (longlines-mode +1)))))