Un metodo più veloce per ottenere `line-number-at-pos` in buffer di grandi dimensioni

La funzione line-number-at-pos(se ripetuta circa 50 volte) sta causando un notevole rallentamento nei buffer semi-grandi - ad esempio, 50.000 linee - quando il punto è vicino alla fine del buffer. Per rallentamento, intendo un totale combinato di circa 1,35 secondi.

Invece di usare una funzionalità al 100% elispper contare le righe e andare in cima al buffer, sarei interessato a un metodo ibrido che attinge alle abilità C integrate responsabili del numero di riga che appare sulla linea di modalità. Il numero di riga che appare sulla riga di modalità viene visualizzato alla velocità della luce, indipendentemente dalle dimensioni del buffer.

Ecco una funzione di test:

(defmacro measure-time (&rest body)
"Measure the time it takes to evaluate BODY.
http://lists.gnu.org/archive/html/help-gnu-emacs/2008-06/msg00087.html"
  `(let ((time (current-time)))
     ,@body
     (message "%.06f" (float-time (time-since time)))))

(measure-time
  (let* (
      line-numbers
      (window-start (window-start))
      (window-end (window-end)))
    (save-excursion
      (goto-char window-end)
      (while
        (re-search-backward "\n" window-start t)
        (push (line-number-at-pos) line-numbers)))
    line-numbers))

Provare

(string-to-number (format-mode-line "%l"))

Puoi estrarre altre informazioni usando % -Constructs descritte nel Manuale Emacs Lisp.

Avvertimento:

Oltre alle limitazioni evidenziate da wasamasa e Stefan (vedere i commenti di seguito), ciò non funziona per i buffer che non vengono visualizzati.

Prova questo:

(with-temp-buffer
  (dotimes (i 10000)
    (insert (format "%d\n" i)))
  (string-to-number (format-mode-line "%l")))

e confronta con

(with-temp-buffer
  (dotimes (i 10000)
    (insert (format "%d\n" i)))
  (line-number-at-pos))

nlinum.el utilizza quanto segue:

(defvar nlinum--line-number-cache nil)
(make-variable-buffer-local 'nlinum--line-number-cache)

;; We could try and avoid flushing the cache at every change, e.g. with:
;;   (defun nlinum--before-change (start _end)
;;     (if (and nlinum--line-number-cache
;;              (< start (car nlinum--line-number-cache)))
;;         (save-excursion (goto-char start) (nlinum--line-number-at-pos))))
;; But it's far from clear that it's worth the trouble.  The current simplistic
;; approach seems to be good enough in practice.

(defun nlinum--after-change (&rest _args)
  (setq nlinum--line-number-cache nil))

(defun nlinum--line-number-at-pos ()
  "Like `line-number-at-pos' but sped up with a cache."
  ;; (assert (bolp))
  (let ((pos
         (if (and nlinum--line-number-cache
                  (> (- (point) (point-min))
                     (abs (- (point) (car nlinum--line-number-cache)))))
             (funcall (if (> (point) (car nlinum--line-number-cache))
                          #'+ #'-)
                      (cdr nlinum--line-number-cache)
                      (count-lines (point) (car nlinum--line-number-cache)))
           (line-number-at-pos))))
    ;;(assert (= pos (line-number-at-pos)))
    (setq nlinum--line-number-cache (cons (point) pos))
    pos))

con la seguente configurazione aggiuntiva nella funzione mode:

(add-hook 'after-change-functions #'nlinum--after-change nil t)