パフォーマンスについてはマニュアルに少し記載があります。

Performance (Magit User Manual)

Windows向けのGitの設定。

git config --global core.preloadindex true   # default since v2.1
git config --global core.fscache true        # default since v2.8
git config --global gc.auto 256

コミット時にdiffを自動的に表示しない設定。

(remove-hook 'server-switch-hook 'magit-commit-diff)
(remove-hook 'with-editor-filter-visit-hook 'magit-commit-diff)

もちろんこれらを試してみましたが、まだまだ全然遅いです。

Magitのバッファからc cを押すと実行されるのが magit-commit-create です。この関数(コマンド)は基本的に git commit を非同期で実行するだけです。

この部分の面白いところは with-editor という仕組み(マクロ)を使用している点です。 with-editor は、Emacsから外部コマンド(今回の場合は git commit)を呼び出してそのコマンドがエディタを起動するときに自身がそのエディタになる(コマンドを呼び出したEmacsのプロセスでファイルを開くようにする)ための仕掛けです。具体的には次のような流れになります。

1. Emacsサーバを起動します。
2. 環境変数GIT_EDITORにemacsclientを指定します。1で起動したサーバの情報も付け加えて確実にemacsclientがそのサーバと接続出来るようにします。
3. 非同期でgit commitを起動します。git-commit-createはすぐに終了します。
4. gitはコミットメッセージを求めてエディタを起動します。起動するのはGIT_EDITORに書かれているemacsclientです。エディタへの引数としてコミットメッセージを書くためのファイル(.git/COMMIT_EDITMSG)を指定します。
5. emacsclientはEmacsサーバに接続してCOMMIT_EDITMSGを開くよう要求します。
6. gitを起動したEmacs側では、Emacsサーバがその要求を認識してCOMMIT_EDITMSGを開きます。

こんなまどろっこしいことをしなくてもgit起動時に直接コミットメッセージを渡せば良いと思うかもしれませんが、gitはCOMMIT_EDITMSGに色々な情報をコメントで付け加えてからエディタを起動するので、その情報が欲しいと言うことなのでしょう。

実はここまでであればそれほど遅くはありません。試しにまだmagitが読み込まれていない状態で M-: (progn (require 'with-editor) (with-editor "GIT_EDITOR" (start-process "git-proc-name" "git-output-buffer" "git" "commit"))) などと実行すると割とすぐ(1秒くらい?)にCOMMIT_EDITMSGファイルが開きます。問題はどうもその後にあるようです。

magitが読み込まれていると、サーバがCOMMIT_EDITMSGを開く段階で次の関数(主にgit-commit.el内)が実行されます。

• git-commit-setup (global-git-commit-modeによってfind-file-hookにadd-hookされる関数)
• git-commit-setup-font-lock (git-commit.elロード時にafter-change-major-mode-hookにadd-hookされる関数)
• magit-auto-revert-mode-enable-in-buffers (magit-auto-revert-modeによってafter-change-major-mode-hookにadd-hookされる関数)

どれもファイルを開いた事によるフックによって自動的に呼び出されます。

なのでこれらの関数をフックから外してしまえばその処理は行われません。

(with-eval-after-load "git-commit"
  (global-git-commit-mode -1)
  (remove-hook 'after-change-major-mode-hook #'git-commit-setup-font-lock-in-buffer))
(with-eval-after-load "magit"
  (magit-auto-revert-mode -1))

結果、c cでコミットメッセージを書くバッファが開くまでの時間が大幅に短縮されました。めでたしめでたし。

と終わっても良いのですが、これだと色々な機能が利用できなくなってしまいます。

これらの関数が中で何をするのかもう少し調べてみます。

トレースと計測のためにmy-profiler.elを作りました。

まずは全体的な流れを把握。

;; 調査用コード
(require 'my-profiler)
(my-profiler-instrument-all
 '((magit-commit-create . start) ;;ここで計測開始
   (server-execute . stop) ;;ここで計測終了
   magit-commit-diff
   git-commit-setup
   (git-commit-setup-font-lock-in-buffer . short)
   (magit-auto-revert-mode-enable-in-buffers . short)
   normal-mode))
(progn
  (switch-to-buffer "magit: my-test-git-repository") ;;既に開いてstageしてあるMagitのバッファを表に出す。
  (magit-commit-create)) ;;そのバッファ上でmagit-commit-createを実行する。

TM startからの経過時間 前計測点からの経過時間 関数内の滞在時間
TM	     0.014	+     0.014	          	Enter #<subr magit-commit-create>
TM	   806.706	+   806.692	   806.641	Leave #<subr magit-commit-create>
TM	   988.713	+   182.007	          	Enter #<subr server-execute>
TM	   996.355	+     7.642	          	Enter  #<subr normal-mode>
TM	  1209.287	+   212.932	   212.859	Eval    #<subr git-commit-setup-font-lock-in-buffer>
TM	  1675.698	+   466.411	   466.354	Eval    #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  1896.232	+   220.534	   217.599	Eval    #<subr git-commit-setup-font-lock-in-buffer>
TM	  2364.570	+   468.338	   468.274	Eval    #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  2365.017	+     0.447	  1368.649	Leave  #<subr normal-mode>
TM	  2365.066	+     0.049	          	Enter  #<subr git-commit-setup>
TM	  2365.100	+     0.034	          	Enter   #<subr normal-mode>
TM	  2587.760	+   222.660	   222.564	Eval     #<subr git-commit-setup-font-lock-in-buffer>
TM	  3060.027	+   472.267	   472.190	Eval     #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  3325.810	+   265.783	   262.448	Eval     #<subr git-commit-setup-font-lock-in-buffer>
TM	  3782.673	+   456.863	   456.770	Eval     #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  3783.060	+     0.387	  1417.947	Leave   #<subr normal-mode>
TM	  4899.085	+  1116.025	  2533.975	Leave  #<subr git-commit-setup>
TM	  4899.128	+     0.043	     0.001	Eval   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  5122.180	+   223.052	          	Enter  #<subr magit-commit-diff>
TM	  7588.585	+  2466.405	     0.001	Eval    #<subr git-commit-setup-font-lock-in-buffer>
TM	  7588.614	+     0.029	     0.003	Eval    #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  7821.368	+   232.754	  2699.136	Leave  #<subr magit-commit-diff>
TM	  7822.309	+     0.941	  6833.551	Leave #<subr server-execute>

1. まずmagit-commit-createが終わるまでに800msかかります。
2. serverがemacsclientからの要求を受けてserver-executeを実行するのが約1s経過時点。以下server-executeの中で6.8sかかります。
3. ファイルを開いてメジャーモードが切り替わるので、normal-mode関数によってafter-change-major-mode-hookが実行されます。フックに設定されているgit-commit-setup-font-lock-in-bufferとmagit-auto-revert-mode-enable-in-buffersが呼ばれます。一回のnormal-modeで二回も。
4. git-commit-setupに入る時点で既に2.3s経過。
5. git-commit-major-modeの設定に従ってメジャーモードを変更するのでまたafter-change-major-mode-hookが実行されます。
6. そしてgit-commit-diffでdiffを出力し、終わるのが開始から7.8s後。

どの関数でも数百msもの時間がかかっています。

また、計上されていない時間もあり状況がよく分かりません。なのでそれらの関数の中身を読んで詳しく調べました。

すると多数のgitコマンドの実行が見つかりました。例えばgit-commit-setup-font-lock関数内には次のようなコードがあります。

    (setq-local comment-start
                (or (with-temp-buffer
                      (and (zerop
                            (call-process
                             (git-commit-executable) nil (list t nil) nil
                             "config" "core.commentchar")) ;;←ここ★
                           (not (bobp))
                           (progn
                             (goto-char (point-min))
                             (buffer-substring (point) (line-end-position)))))
                    "#"))

このコードは git config core.commentchar を実行してコメントに使う文字をgitから取得しています。

また、git-commit-setup関数内には次のようなコードがあります。

  (let ((default-directory
         (or (and (not (file-exists-p ".dir-locals.el"))
                  ;; When $GIT_DIR/.dir-locals.el doesn't exist,
                  ;; fallback to $GIT_WORK_TREE/.dir-locals.el,
                  ;; because the maintainer can use the latter
                  ;; to enforce conventions, while s/he has no
                  ;; control over the former.
                  (fboundp 'magit-toplevel)  ; silence byte-compiler
                  (magit-toplevel)) ;;←ここ★
             default-directory)))

ここでは(magit-toplevel)という関数が使われています。この関数はリポジトリの最上位のディレクトリを返しますが、内部で git rev-parse --show-toplevel というコマンドを実行しています。

このようにあちこちから気軽にgitコマンドが実行されているので全てを把握するのが困難です。

そこで次のような計測を行ってcall-processの呼び出し状況を調べてみました。

;; 調査用コード
(require 'my-profiler)
(my-profiler-instrument-all
 '((magit-commit-create . start)
   (server-execute . stop)
   magit-commit-diff
   git-commit-setup
   git-commit-setup-font-lock-in-buffer
   magit-auto-revert-mode-enable-in-buffers
   normal-mode
   (call-process . short))) ;;←これを追加
(progn
  (switch-to-buffer "magit: my-test-git-repository") ;;既に開いてstageしてあるMagitのバッファを表に出す。
  (magit-commit-create)) ;;そのバッファ上でmagit-commit-createを実行する。

TM	     0.067	+     0.067	          	Enter magit-commit-create
TM	   165.595	+   165.528	   128.970	Eval   call-process
TM	   276.355	+   110.760	   110.152	Eval   call-process
TM	   383.838	+   107.483	   106.953	Eval   call-process
TM	   492.492	+   108.654	   108.011	Eval   call-process
TM	   597.941	+   105.449	   103.835	Eval   call-process
TM	   702.018	+   104.077	   103.379	Eval   call-process
TM	   806.025	+   104.007	   103.550	Eval   call-process
TM	   818.413	+    12.388	   818.277	Leave magit-commit-create
TM	   998.803	+   180.390	          	Enter server-execute
TM	  1006.222	+     7.419	          	Enter  normal-mode
TM	  1006.265	+     0.043	          	Enter   git-commit-setup-font-lock-in-buffer
TM	  1116.712	+   110.447	   110.347	Eval     call-process
TM	  1225.767	+   109.055	   108.696	Eval     call-process
TM	  1226.047	+     0.280	   219.770	Leave   git-commit-setup-font-lock-in-buffer
TM	  1226.065	+     0.018	          	Enter   magit-auto-revert-mode-enable-in-buffers
TM	  1350.425	+   124.360	   114.586	Eval     call-process
TM	  1457.264	+   106.839	   106.571	Eval     call-process
TM	  1569.336	+   112.072	   111.709	Eval     call-process
TM	  1683.220	+   113.884	   113.402	Eval     call-process
TM	  1683.250	+     0.030	   457.178	Leave   magit-auto-revert-mode-enable-in-buffers
TM	  1686.554	+     3.304	          	Enter   git-commit-setup-font-lock-in-buffer
TM	  1794.665	+   108.111	   107.975	Eval     call-process
TM	  1910.274	+   115.609	   115.262	Eval     call-process
TM	  1910.601	+     0.327	   224.034	Leave   git-commit-setup-font-lock-in-buffer
TM	  1910.632	+     0.031	          	Enter   magit-auto-revert-mode-enable-in-buffers
TM	  2039.771	+   129.139	   119.084	Eval     call-process
TM	  2154.799	+   115.028	   114.813	Eval     call-process
TM	  2263.058	+   108.259	   107.883	Eval     call-process
TM	  2374.596	+   111.538	   111.138	Eval     call-process
TM	  2374.652	+     0.056	   464.004	Leave   magit-auto-revert-mode-enable-in-buffers
TM	  2375.022	+     0.370	  1368.786	Leave  normal-mode
TM	  2375.053	+     0.031	          	Enter  git-commit-setup
TM	  2375.080	+     0.027	          	Enter   normal-mode
TM	  2375.131	+     0.051	          	Enter    git-commit-setup-font-lock-in-buffer
TM	  2481.555	+   106.424	   106.317	Eval      call-process
TM	  2590.186	+   108.631	   108.101	Eval      call-process
TM	  2590.481	+     0.295	   215.338	Leave    git-commit-setup-font-lock-in-buffer
TM	  2590.498	+     0.017	          	Enter    magit-auto-revert-mode-enable-in-buffers
TM	  2714.161	+   123.663	   113.784	Eval      call-process
TM	  2825.484	+   111.323	   111.140	Eval      call-process
TM	  2931.823	+   106.339	   105.959	Eval      call-process
TM	  3046.016	+   114.193	   113.908	Eval      call-process
TM	  3046.080	+     0.064	   455.567	Leave    magit-auto-revert-mode-enable-in-buffers
TM	  3048.839	+     2.759	          	Enter    git-commit-setup-font-lock-in-buffer
TM	  3159.395	+   110.556	   110.437	Eval      call-process
TM	  3269.152	+   109.757	   109.407	Eval      call-process
TM	  3269.528	+     0.376	   220.675	Leave    git-commit-setup-font-lock-in-buffer
TM	  3269.548	+     0.020	          	Enter    magit-auto-revert-mode-enable-in-buffers
TM	  3398.770	+   129.222	   119.693	Eval      call-process
TM	  3504.807	+   106.037	   105.769	Eval      call-process
TM	  3615.480	+   110.673	   110.212	Eval      call-process
TM	  3727.668	+   112.188	   111.808	Eval      call-process
TM	  3727.712	+     0.044	   458.142	Leave    magit-auto-revert-mode-enable-in-buffers
TM	  3728.222	+     0.510	  1353.118	Leave   normal-mode
TM	  3843.396	+   115.174	   114.663	Eval    call-process
TM	  3954.347	+   110.951	   110.736	Eval    call-process
TM	  4063.458	+   109.111	   108.434	Eval    call-process
TM	  4173.732	+   110.274	   109.117	Eval    call-process
TM	  4277.008	+   103.276	   101.671	Eval    call-process
TM	  4386.951	+   109.943	   109.613	Eval    call-process
TM	  4496.227	+   109.276	   102.939	Eval    call-process
TM	  4607.267	+   111.040	   110.903	Eval    call-process
TM	  4735.445	+   128.178	   123.408	Eval    call-process
TM	  4846.907	+   111.462	   110.492	Eval    call-process
TM	  4847.823	+     0.916	  2472.720	Leave  git-commit-setup
TM	  4847.862	+     0.039	          	Enter  magit-auto-revert-mode-enable-in-buffers
TM	  4847.882	+     0.020	     0.012	Leave  magit-auto-revert-mode-enable-in-buffers
TM	  4957.249	+   109.367	   105.964	Eval   call-process
TM	  5071.761	+   114.512	   114.348	Eval   call-process
TM	  5075.277	+     3.516	          	Enter  magit-commit-diff
TM	  5190.165	+   114.888	   114.456	Eval    call-process
TM	  5299.389	+   109.224	   108.968	Eval    call-process
TM	  5406.564	+   107.175	   106.868	Eval    call-process
TM	  5523.598	+   117.034	   116.481	Eval    call-process
TM	  5628.045	+   104.447	   104.183	Eval    call-process
TM	  5733.773	+   105.728	   105.326	Eval    call-process
TM	  5854.707	+   120.934	   118.859	Eval    call-process
TM	  5961.210	+   106.503	   106.278	Eval    call-process
TM	  6074.760	+   113.550	   112.966	Eval    call-process
TM	  6204.416	+   129.656	   129.186	Eval    call-process
TM	  6320.894	+   116.478	   116.091	Eval    call-process
TM	  6426.537	+   105.643	   105.306	Eval    call-process
TM	  6531.705	+   105.168	   104.829	Eval    call-process
TM	  6653.648	+   121.943	   121.594	Eval    call-process
TM	  6766.164	+   112.516	   112.064	Eval    call-process
TM	  6883.633	+   117.469	   116.855	Eval    call-process
TM	  6996.202	+   112.569	   112.346	Eval    call-process
TM	  7105.460	+   109.258	   108.693	Eval    call-process
TM	  7223.988	+   118.528	   117.887	Eval    call-process
TM	  7330.973	+   106.985	   106.761	Eval    call-process
TM	  7475.212	+   144.239	   143.927	Eval    call-process
TM	  7595.205	+   119.993	   118.270	Eval    call-process
TM	  7595.306	+     0.101	          	Enter   git-commit-setup-font-lock-in-buffer
TM	  7595.332	+     0.026	     0.019	Leave   git-commit-setup-font-lock-in-buffer
TM	  7595.346	+     0.014	          	Enter   magit-auto-revert-mode-enable-in-buffers
TM	  7595.362	+     0.016	     0.010	Leave   magit-auto-revert-mode-enable-in-buffers
TM	  7701.903	+   106.541	   106.110	Eval    call-process
TM	  7825.783	+   123.880	   123.021	Eval    call-process
TM	  7827.148	+     1.365	  2751.850	Leave  magit-commit-diff
TM	  7828.413	+     1.265	  6829.588	Leave server-execute

非常に多くのcall-processが呼ばれていることが分かります。その数なんと67回(この数は現在開いているファイルなどEmacs全体の状態によって多少変わります)。

1回につきだいたい100msは持って行かれています。それが67回ですから、そりゃ遅いわけです。

どのような引数でcall-processが呼ばれているのかを詳しく調査してみます。

call-processに細工をして、渡された引数と処理時間を出力できるようにしました。

;; 調査用コード
(defun my-watch-call-process (orig-func program infile destination display &rest args)
  (let* ((start-time (current-time))
         (result (apply orig-func program infile destination display args))
         (end-time (current-time))
         (str (format "%10.3f\tcall %s dir=%s args:%s infile=%s dest=%s display=%s"
                      (* 1000.0 (float-time (time-subtract end-time start-time)))
                      program
                      (expand-file-name default-directory)
                      args
                      infile
                      destination
                      display)))
    ;;(message "%s" str)
    (with-current-buffer (get-buffer-create "*Watch Call Process*")
      (insert str "\n"))
    result))
(advice-add #'call-process :around #'my-watch-call-process)
(progn
  (switch-to-buffer "magit: my-test-git-repository") ;;既に開いてstageしてあるMagitのバッファを表に出す。
  (magit-commit-create)) ;;そのバッファ上でmagit-commit-createを実行する。
;; (advice-remove #'call-process #'my-watch-call-process)

実行結果:

  127.805	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --quiet --cached --) infile=nil dest=nil display=nil
  107.044	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  107.562	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  112.606	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  110.020	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  109.413	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  107.641	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  104.655	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
  108.715	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
  115.636	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  109.609	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  111.605	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  112.741	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 ls-files --error-unmatch c:/my-test-git-repository/.git/COMMIT_EDITMSG) infile=nil dest=nil display=nil
  111.269	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
  114.393	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
  116.784	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  106.856	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  111.306	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  113.603	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 ls-files --error-unmatch c:/my-test-git-repository/.git/COMMIT_EDITMSG) infile=nil dest=nil display=nil
  110.811	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
  108.250	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
  123.924	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  111.405	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  114.570	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  113.685	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 ls-files --error-unmatch c:/my-test-git-repository/.git/COMMIT_EDITMSG) infile=nil dest=nil display=nil
  103.513	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
  109.157	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
  112.987	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  106.662	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  104.755	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  117.193	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 ls-files --error-unmatch c:/my-test-git-repository/.git/COMMIT_EDITMSG) infile=nil dest=nil display=nil
  119.297	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  107.351	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  108.289	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  114.332	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse HEAD) infile=nil dest=(t nil) display=nil
  103.471	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
  111.284	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
  108.283	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-files -c -z -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
  109.082	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-tree --name-only -z HEAD -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
  113.619	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager remote get-url upstream) infile=nil dest=t display=nil
  107.181	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager remote get-url origin) infile=nil dest=t display=nil
  114.011	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-files -c -z -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
  108.958	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-tree --name-only -z HEAD -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
  118.451	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  112.981	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  105.087	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  121.276	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  104.412	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  109.560	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  116.268	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  111.705	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  106.008	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  122.337	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --quiet --cached --) infile=nil dest=nil display=nil
  118.292	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  117.703	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  107.558	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  122.989	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --quiet --) infile=nil dest=nil display=nil
  114.488	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  110.997	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  113.395	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  107.008	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  115.545	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  124.748	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
  113.055	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
  116.179	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 config -z --get-all magit.extension) infile=nil dest=(t nil) display=nil
  117.604	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
  126.063	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --ita-visible-in-index -p --no-prefix --numstat --cached --stat --no-ext-diff --) infile=nil dest=(t nil) display=nil

同じ引数のものをまとめてみます。

回数	平均時間	引数
1	 126.063	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --ita-visible-in-index -p --no-prefix --numstat --cached --stat --no-ext-diff --) infile=nil dest=(t nil) display=nil
1	 116.179	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 config -z --get-all magit.extension) infile=nil dest=(t nil) display=nil
1	 122.989	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --quiet --) infile=nil dest=nil display=nil
1	 107.181	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager remote get-url origin) infile=nil dest=t display=nil
1	 113.619	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager remote get-url upstream) infile=nil dest=t display=nil
2	 109.020	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-tree --name-only -z HEAD -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
2	 111.147	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager ls-files -c -z -- .git/COMMIT_EDITMSG) infile=nil dest=(t nil) display=nil
1	 114.332	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse HEAD) infile=nil dest=(t nil) display=nil
4	 114.305	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 ls-files --error-unmatch c:/my-test-git-repository/.git/COMMIT_EDITMSG) infile=nil dest=nil display=nil
11	 108.982	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --is-bare-repository) infile=nil dest=(t nil) display=nil
5	 110.360	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 --no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 for-each-ref --format=%(refname:short) refs/heads) infile=nil dest=(t nil) display=nil
5	 106.744	call git-encwrapper dir=c:/my-test-git-repository/ args:(config core.commentchar) infile=nil dest=(t nil) display=nil
13	 111.840	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --git-dir) infile=nil dest=(t nil) display=nil
17	 114.632	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 rev-parse --show-toplevel) infile=nil dest=(t nil) display=nil
2	 125.071	call git-encwrapper dir=c:/my-test-git-repository/ args:(--no-pager --literal-pathspecs -c core.preloadindex=true -c log.showSignature=false -c color.ui=false -c color.diff=false -c i18n.logOutputEncoding=UTF-8 diff --quiet --cached --) infile=nil dest=nil display=nil

• 合計で7535.042ms(call-processの中だけで)
• 呼び出し回数は67回
• 平均で一回あたり112.463ms
• パターンは15種類
• 実行時間はどれも大差なし
• infileは全てnil(入力無し)
• destinationはnil, t, (t nil)のいずれか(破棄、標準出力とエラー出力をミックス、エラーだけ破棄のいずれか)
• displayは全てnil

とにかくプロセスの起動が多すぎます。それも同じ情報を10回以上問い合わせている箇所が3件もあります。

それにしてもプロセスの起動に100msというのはかなり遅いです。いったいどうなっているのでしょうか。

様々な方法でプロセスを起動してみてその実行時間を計測してみました。計測は次のコードで行い、100回繰り返したときの平均時間を求めました。

(benchmark-run 100 (call-process "git-encwrapper" nil (list t nil) nil "config" "core.commentchar"))

結果は平均106.37ms。私のEmacsはプロセスの起動まわりに色々細工をしてあるのでemacs -Qで起動したものでも試してみたところ平均104.78msでした。

git-encwrapperでは無く素のgitで試してみたところ、平均76.60ms(emacs -Qで76.22ms)。

私が使っているGitはGit for Windowsですが、Git/cmd(またはGit/bin)にあるgit.exeとGit/mingw64/binにあるgit.exeが別物です。前者は後者を呼び出すラッパーとなっています。通常PATHが通っているのは前者なので、後者を直接起動してみたところ、平均56.76msまで縮まりました(emacs -Qで55.19ms)。このラッパーには色々な役割があって、環境変数の調整なども行っているようなので直接呼び出して大丈夫なのかは分かりません。

以上はEmacsを経由して起動した場合の時間です。

Windowsはプロセスの起動が遅いとはよく言われていることです。しかし本当にWindowsだけの問題なのでしょうか。Emacs側には問題は無いのでしょうか。試しに次のようなバッチファイルを作成してcmd.exeから起動してみました。

echo %TIME%
>"test.log" (for /L %%a in (1,1,100) do "git.exe" config core.commentchar)
echo %TIME%

結果:

• git-encwrapper 67.1ms
• git.exe 31.4ms
• mingw64/bin/git.exe 17.1ms

こうしてみるとプロセス起動が遅い原因を全てWindowsのせいにして良いのか疑問が湧いてきます。git-encwrapperが遅いのは、まぁ、私のせいです(笑)。とはいっても文字エンコーディングが複数混在しているプロジェクトで素のGitやMagitが使いづらいのは私のせいではありません。Emacsとcmd.exeの差(約40ms)を見るに、Emacs自体にも何か遅くなる原因がありそうです。Git for windowsのラッパーは意外に大きな差を生んでいます(約20ms)。GitにせよEmacsにせよUNIX系のOSで使われている物を無理矢理Windows上に持ってきているので色々と調整のためのコードが挟まっているのかもしれません。

ちなみにVirtualBoxに入っていたUbuntu 21とEmacs27.1で試したところ、2.1msくらいでした。10倍くらいの差があります。実際の所Windowsのプロセス起動がLinuxと比べて遅いのは確かです。

私の所限定の話になりますが、diffとapplyのとき以外はgit-encwrapperは必要ないので直接gitを呼び出して構いません。概ね次のようなコードで切り替えられそうです。

(defun my-call-process-for-bypassing-git-encwrapper (original-call-process program infile destination display &rest args)
  (when (and (equal program "git-encwrapper")
             ;; ↓オプション内にdiffやapplyという文字列が含まれていると誤判定するが、遅くなるだけで実害は無い。
             (not (and (member "diff" args) destination)) ;;diffでも出力を捨てる場合は素のgitで良い
             (not (member "apply" args)))
    (setq program "git"))
  (apply original-call-process program infile destination display args))
(advice-add #'call-process :around #'my-call-process-for-bypassing-git-encwrapper)
;;(advice-remove #'call-process #'my-call-process-for-bypassing-git-encwrapper)

Git/mingw64/bin/git.exeを直接呼ぶかどうかはGit/cmd/git.exeが何をしているかをよく調査してから判断すべきでしょう。ソースは MINGW-packages/git-wrapper.c at main · git-for-windows/MINGW-packages にあるようです。環境変数を事前に調整してやれば直接呼べるかもしれません。

プロセスの起動が遅いというのはとりあえず受け入れるとして、それならどうすれば良いでしょうか。

もちろん起動する回数を減らすよりありません。幸い同じ情報を何度も問い合わせている箇所があり、それらをまとめれば大幅な時間短縮が望めそうです。

一番手っ取り早いのはcall-process自体にキャッシュ機能を付けてしまうことでしょう。call-processの書式は次の通りです(Synchronous Processes (GNU Emacs Lisp Reference Manual)より)。

(call-process program &optional infile destination display &rest args)

programがgit(またはmagit-git-executableの値)のときに、default-directory(カレントディレクトリ)とargs、destinationをキーにして、結果となる終了ステータスとバッファに出力された文字列をキャッシュします。

もちろん結果は常に一定とは限りません。何か変更操作をした後は結果が変化するでしょう。どのタイミングでキャッシュをフラッシュ(クリア)するかが悩み所です。

とはいえ、コミットメッセージを入力する部分だけに限定するのであれば、その間に変更操作は無いのでクリアせずにずっと保持してしまって大丈夫でしょう。

というわけで作ったのが次のEmacs Lispです。

my-magit-speedup-for-windows/my-magit-process-cache.el at main · misohena/my-magit-speedup-for-windows

基本的な使い方:

• my-magit-process-cache-turn-on でキャッシュを有効化(+キャッシュをクリア)
• my-magit-process-cache-turn-off でキャッシュを無効化(+キャッシュをクリア)
• my-magit-process-cache-clear-cache-all でキャッシュをクリア

これだけだと使い物にならないのでグローバルモードにしてみました。

もし一回のプロセス起動で複数の情報を取得出来たらかなりの高速化が望めそうです。Gitにそのような機能はあるのでしょうか。またはlibgitを使えばそのようなプログラムを作成できるでしょうか。全ての操作をスクリプト化して一回の呼び出しで実行できればかなり速くなるでしょう。

また、libgitをdynamic module化してEmacsに組み込んでしまう試みが存在するようです。これならそもそもプロセスの呼び出し自体が必要ありません。

magit/libegit2: Emacs bindings for libgit2

ただし問題も多く優先順位も低いためあまり進んでいないようです。

Implement an Elisp binding for libgit2 · Issue #2959 · magit/magit

試してみようと思ったのですが、Emacs Lispからの呼び出し部分が出来ていないように見えます。

ここまででかなりの数のプロセス起動を削減できましたが、まだ1回のコミットメッセージを書くまでに16回のプロセス起動が残っています。

実行されたgitコマンドだけ見てもそれが何のための物なのか分からないので、呼び出し元をbacktraceで表示させてみました。

;; 調査用コード
(require 'backtrace)
(defun my-watch-call-process-with-backtrace (orig-func program infile destination display &rest args)
  (let* ((trace (let ((after-change-major-mode-hook nil))
                  (backtrace-to-string)))
         (str (format "call dir=%s from=\n%s"
                      (expand-file-name default-directory)
                      (replace-regexp-in-string
                       "\\`\\(.\\|\n\\)*?\n\\(  call-process\\)" "\\2"
                       trace))))
    ;;(message "%s" str)
    (with-current-buffer (get-buffer-create "*Watch call-process with backtrace*")
      (insert str "\n"))
    )
  (apply orig-func program infile destination display args))
(advice-add #'call-process :around #'my-watch-call-process-with-backtrace)
(progn
  (switch-to-buffer "magit: my-test-git-repository") ;;既に開いてstageしてあるMagitのバッファを表に出す。
  (magit-commit-create) ;;そのバッファ上でmagit-commit-createを実行する。
  )
;;(advice-remove #'call-process #'my-watch-call-process-with-backtrace)

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  magit-process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  magit-process-git(nil (("diff" "--quiet" "--cached" nil "--" nil)))
  magit-git-exit-code(("diff" "--quiet" "--cached" nil "--" nil))
  magit-git-failure("diff" "--quiet" "--cached" nil "--" nil)
  magit-anything-staged-p()
  magit-commit-assert(nil)
  #<subr magit-commit-create>()
  apply(#<subr magit-commit-create> nil)
  (let ((result (apply original-fun args))) (if result nil (my-magit-process-cache--commit-create-end)) result)
  my-magit-process-cache--commit-create(#<subr magit-commit-create>)
  apply(my-magit-process-cache--commit-create #<subr magit-commit-create> nil)
  magit-commit-create()
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  magit-process-git((t nil) ("rev-parse" "--show-toplevel"))
  magit-git-str("rev-parse" "--show-toplevel")
  magit-rev-parse-safe("--show-toplevel")
  magit-toplevel()
  #<subr magit-commit-create>()
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  magit-process-git((t nil) ("rev-parse" "--git-dir"))
  magit-git-str("rev-parse" "--git-dir")
  magit-rev-parse-safe("--git-dir")
  magit-git-dir()
  magit--record-separated-gitdir()
  magit-run-git-with-editor("commit" ("--"))
  #<subr magit-commit-create>()
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "config" "core.commentchar")
  git-commit-setup-font-lock()
  git-commit-setup-font-lock-in-buffer()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  find-file-noselect-1(#<buffer COMMIT_EDITMSG> "c:/my-test-git-repository/.git/COMMIT_EDITMSG" nil nil "c:/my-test-git-repository/.git/COMMIT_EDITMSG" (341992096703475215 1121764838))
  find-file-noselect("C:/my-test-git-repository/.git/COMMIT_EDITMSG")
  #<subr server-visit-files>((("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) #<process server23432 <127.0.0.1:64200>> nil)
  apply(#<subr server-visit-files> ((("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) #<process server23432 <127.0.0.1:64200>> nil))
  server-visit-files((("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) #<process server23432 <127.0.0.1:64200>> nil)
  server-execute(#<process server23432 <127.0.0.1:64200>> (("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) nil nil t nil nil)
  #f(compiled-function () #<bytecode -0x1bd4f2f840dbc4c>)()
  server-execute-continuation(#<process server23432 <127.0.0.1:64200>>)
  server-process-filter(#<process server23432 <127.0.0.1:64200>> "-auth [m:TL:<;51aiw67(FyI/O,\\{$|yUxQ0>:kv|IC?b~Kg&...")

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "for-each-ref" "--format=%(refname:short)" "refs/heads")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "for-each-ref" "--format=%(refname:short)" "refs/heads")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "for-each-ref" "--format=%(refname:short)" "refs/heads")
  magit-process-git((t nil) ("--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "for-each-ref" "--format=%(refname:short)" "refs/heads"))
  magit-git-insert("for-each-ref" "--format=%(refname:short)" nil "refs/heads")
  magit-git-lines("for-each-ref" "--format=%(refname:short)" nil "refs/heads")
  magit-list-refs("refs/heads" "%(refname:short)")
  magit-list-refnames("refs/heads")
  magit-list-local-branch-names()
  git-commit-setup-font-lock()
  git-commit-setup-font-lock-in-buffer()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--show-toplevel")
  magit-process-git((t nil) ("rev-parse" "--show-toplevel"))
  magit-git-str("rev-parse" "--show-toplevel")
  magit-rev-parse-safe("--show-toplevel")
  magit-toplevel()
  magit-turn-on-auto-revert-mode-if-desired()
  magit-auto-revert-mode-enable-in-buffers()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--git-dir")
  magit-process-git((t nil) ("rev-parse" "--git-dir"))
  magit-git-str("rev-parse" "--git-dir")
  magit-rev-parse-safe("--git-dir")
  magit-toplevel()
  magit-turn-on-auto-revert-mode-if-desired()
  magit-auto-revert-mode-enable-in-buffers()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--is-bare-repository")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--is-bare-repository")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "--is-bare-repository")
  magit-process-git((t nil) ("rev-parse" "--is-bare-repository"))
  magit-git-output(("rev-parse" ("--is-bare-repository")))
  magit-git-true("rev-parse" ("--is-bare-repository"))
  magit-rev-parse-true("--is-bare-repository")
  magit-bare-repo-p()
  magit-toplevel()
  magit-turn-on-auto-revert-mode-if-desired()
  magit-auto-revert-mode-enable-in-buffers()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  magit-process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  magit-process-git(nil (("ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG")))
  magit-git-exit-code(("ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG"))
  magit-git-success("ls-files" "--error-unmatch" "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  magit-file-tracked-p("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  magit-turn-on-auto-revert-mode-if-desired()
  magit-auto-revert-mode-enable-in-buffers()
  run-hooks(change-major-mode-after-body-hook after-change-major-mode-hook)
  normal-mode(t)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "HEAD")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "HEAD")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "HEAD")
  magit-process-git((t nil) ("--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "rev-parse" "HEAD"))
  magit-git-insert("rev-parse" "HEAD")
  magit-git-string("rev-parse" "HEAD")
  magit-rev-parse("HEAD")
  git-commit-setup()
  git-commit-setup-check-buffer()
  run-hooks(find-file-hook)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "ls-files" "-c" "-z" "--" ".git/COMMIT_EDITMSG")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "ls-files" "-c" "-z" "--" ".git/COMMIT_EDITMSG")
  vc-git--call((t nil) "ls-files" "-c" "-z" "--" ".git/COMMIT_EDITMSG")
  vc-git--out-ok("ls-files" "-c" "-z" "--" ".git/COMMIT_EDITMSG")
  vc-git-registered("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-call-backend(Git registered "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  #f(compiled-function (b) #<bytecode 0x14704c4aaf6471f6>)(Git)
  mapc(#f(compiled-function (b) #<bytecode 0x14704c4aaf6471f6>) (RCS CVS SVN SCCS SRC Bzr Git Hg))
  vc-registered("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-backend("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-responsible-backend("c:/my-test-git-repository/.git/COMMIT_EDITMSG" t)
  bug-reference-try-setup-from-vc()
  run-hook-with-args-until-success(bug-reference-try-setup-from-vc)
  bug-reference--run-auto-setup()
  bug-reference-mode()
  run-hooks(git-commit-setup-hook)
  git-commit-setup()
  git-commit-setup-check-buffer()
  run-hooks(find-file-hook)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "ls-tree" "--name-only" "-z" "HEAD" "--" ".git/COMMIT_EDITMSG")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "ls-tree" "--name-only" "-z" "HEAD" "--" ".git/COMMIT_EDITMSG")
  vc-git--call((t nil) "ls-tree" "--name-only" "-z" "HEAD" "--" ".git/COMMIT_EDITMSG")
  vc-git--out-ok("ls-tree" "--name-only" "-z" "HEAD" "--" ".git/COMMIT_EDITMSG")
  vc-git-registered("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-call-backend(Git registered "c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  #f(compiled-function (b) #<bytecode 0x14704c4aaf6471f6>)(Git)
  mapc(#f(compiled-function (b) #<bytecode 0x14704c4aaf6471f6>) (RCS CVS SVN SCCS SRC Bzr Git Hg))
  vc-registered("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-backend("c:/my-test-git-repository/.git/COMMIT_EDITMSG")
  vc-responsible-backend("c:/my-test-git-repository/.git/COMMIT_EDITMSG" t)
  bug-reference-try-setup-from-vc()
  run-hook-with-args-until-success(bug-reference-try-setup-from-vc)
  bug-reference--run-auto-setup()
  bug-reference-mode()
  run-hooks(git-commit-setup-hook)
  git-commit-setup()
  git-commit-setup-check-buffer()
  run-hooks(find-file-hook)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil t nil "--no-pager" "remote" "get-url" "upstream")
  process-file("git-encwrapper" nil t nil "--no-pager" "remote" "get-url" "upstream")
  vc-do-command(#<buffer  *temp*-514073> 0 "git-encwrapper" nil "--no-pager" "remote" "get-url" "upstream")
  vc-git-command(#<buffer  *temp*-514073> 0 nil "remote" "get-url" "upstream")
  vc-git-repository-url("c:/my-test-git-repository/.git/COMMIT_EDITMSG" "upstream")
  vc-call-backend(Git repository-url "c:/my-test-git-repository/.git/COMMIT_EDITMSG" "upstream")
  #f(compiled-function (remote) #<bytecode 0xc87372323b60bec>)("upstream")
  #f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>)("upstream")
  mapc(#f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>) ("upstream" nil))
  seq-do(#f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>) ("upstream" nil))
  seq-some(#f(compiled-function (remote) #<bytecode 0xc87372323b60bec>) ("upstream" nil))
  bug-reference-try-setup-from-vc()
  run-hook-with-args-until-success(bug-reference-try-setup-from-vc)
  bug-reference--run-auto-setup()
  bug-reference-mode()
  run-hooks(git-commit-setup-hook)
  git-commit-setup()
  git-commit-setup-check-buffer()
  run-hooks(find-file-hook)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil t nil "--no-pager" "remote" "get-url" "origin")
  process-file("git-encwrapper" nil t nil "--no-pager" "remote" "get-url" "origin")
  vc-do-command(#<buffer  *temp*-332582> 0 "git-encwrapper" nil "--no-pager" "remote" "get-url" "origin")
  vc-git-command(#<buffer  *temp*-332582> 0 nil "remote" "get-url" "origin")
  vc-git-repository-url("c:/my-test-git-repository/.git/COMMIT_EDITMSG" nil)
  vc-call-backend(Git repository-url "c:/my-test-git-repository/.git/COMMIT_EDITMSG" nil)
  #f(compiled-function (remote) #<bytecode 0xc87372323b60bec>)(nil)
  #f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>)(nil)
  mapc(#f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>) ("upstream" nil))
  seq-do(#f(compiled-function (elt) #<bytecode 0xd0e31d85bc76844>) ("upstream" nil))
  seq-some(#f(compiled-function (remote) #<bytecode 0xc87372323b60bec>) ("upstream" nil))
  bug-reference-try-setup-from-vc()
  run-hook-with-args-until-success(bug-reference-try-setup-from-vc)
  bug-reference--run-auto-setup()
  bug-reference-mode()
  run-hooks(git-commit-setup-hook)
  git-commit-setup()
  git-commit-setup-check-buffer()
  run-hooks(find-file-hook)
  after-find-file(nil t)
  ...略

call dir=c:/my-test-git-repository/.git/ from=
  call-process("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  magit-process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--cached" "--")
  magit-process-git(nil (("diff" "--quiet" "--cached" nil "--" nil)))
  magit-git-exit-code(("diff" "--quiet" "--cached" nil "--" nil))
  magit-git-failure("diff" "--quiet" "--cached" nil "--" nil)
  magit-anything-staged-p()
  magit-commit-diff-1()
  #<subr magit-commit-diff>()
  apply(#<subr magit-commit-diff> nil)
  magit-commit-diff()
  run-hooks(server-switch-hook)
  server-execute(#<process server23432 <127.0.0.1:64200>> (("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) nil nil t nil nil)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--")
  process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--")
  magit-process-file("git-encwrapper" nil nil nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--quiet" "--")
  magit-process-git(nil (("diff" "--quiet" nil "--" nil)))
  magit-git-exit-code(("diff" "--quiet" nil "--" nil))
  magit-git-failure("diff" "--quiet" nil "--" nil)
  magit-anything-unstaged-p()
  magit-commit-diff-1()
  #<subr magit-commit-diff>()
  apply(#<subr magit-commit-diff> nil)
  magit-commit-diff()
  run-hooks(server-switch-hook)
  server-execute(#<process server23432 <127.0.0.1:64200>> (("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) nil nil t nil nil)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "config" "-z" "--get-all" "magit.extension")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "config" "-z" "--get-all" "magit.extension")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "config" "-z" "--get-all" "magit.extension")
  magit-process-git((t nil) ("--no-pager" "--literal-pathspecs" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "config" "-z" "--get-all" "magit.extension"))
  magit-git-insert("config" nil "-z" "--get-all" "magit.extension")
  magit-git-items("config" nil "-z" "--get-all" "magit.extension")
  magit-get-all("magit.extension")
  magit-load-config-extensions()
  run-hooks(change-major-mode-after-body-hook special-mode-hook magit-section-mode-hook magit-mode-hook magit-diff-mode-hook)
  apply(run-hooks (change-major-mode-after-body-hook special-mode-hook magit-section-mode-hook magit-mode-hook magit-diff-mode-hook))
  run-mode-hooks(magit-diff-mode-hook)
  magit-diff-mode()
  magit-setup-buffer-internal(magit-diff-mode nil ((magit-buffer-range nil) (magit-buffer-typearg "--cached") (magit-buffer-diff-args ("--stat" "--no-ext-diff")) (magit-buffer-diff-files nil) (magit-buffer-diff-files-suspended nil)))
  magit-diff-setup-buffer(nil "--cached" ("--stat" "--no-ext-diff") nil)
  magit-commit-diff-1()
  #<subr magit-commit-diff>()
  apply(#<subr magit-commit-diff> nil)
  magit-commit-diff()
  run-hooks(server-switch-hook)
  server-execute(#<process server23432 <127.0.0.1:64200>> (("C:/my-test-git-repository/.git/COMMIT_EDITMSG")) nil nil t nil nil)
  ...略

call dir=c:/my-test-git-repository/ from=
  call-process("git-encwrapper" nil (t nil) nil "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--")
  process-file("git-encwrapper" nil (t nil) nil "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--")
  magit-process-file("git-encwrapper" nil (t nil) nil "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--")
  magit-process-git((t nil) ("--no-pager" "-c" "core.preloadindex=true" "-c" "log.showSignature=false" "-c" "color.ui=false" "-c" "color.diff=false" "-c" "i18n.logOutputEncoding=UTF-8" "diff" "--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--"))
  magit-git-insert(("diff" "--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--"))
  magit-git-wash(magit-diff-wash-diffs "diff" ("--ita-visible-in-index" "-p" "--no-prefix" "--numstat" "--cached" "--stat" "--no-ext-diff" "--"))
  magit--insert-diff("diff" nil "-p" "--no-prefix" "--numstat" "--cached" ("--stat" "--no-ext-diff") "--" nil)
  magit-insert-diff()
  magit-run-section-hook(magit-diff-sections-hook)
  magit-diff-refresh-buffer()
  magit-refresh-buffer()
  magit-setup-buffer-internal(magit-diff-mode nil ((magit-buffer-range nil) (magit-buffer-typearg "--cached") (magit-buffer-diff-args ("--stat" "--no-ext-diff")) (magit-buffer-diff-files nil) (magit-buffer-diff-files-suspended nil)))
  magit-diff-setup-buffer(nil "--cached" ("--stat" "--no-ext-diff") nil)
  magit-commit-diff-1()
  #<subr magit-commit-diff>()
  apply(#<subr magit-commit-diff> nil)
  magit-commit-diff()
  run-hooks(server-switch-hook)
  ...略

まとめると次のようになります。

それぞれのgitコマンドが何のために呼ばれているのかを調べ、一段階高い視点から削減を試みます。

というわけで最終計測です。最初の方で実行したcall-processを含んだ方法で計測します。call-processが削減されたことも確認したいので。

;; 調査用コード
(require 'my-profiler)
(my-profiler-instrument-all
 '((magit-commit-create . start)
   magit-commit-diff
   (server-execute . stop)
   git-commit-setup
   git-commit-setup-font-lock-in-buffer
   magit-auto-revert-mode-enable-in-buffers
   normal-mode
   (call-process . short)
))
(progn
  (switch-to-buffer "magit: my-test-git-repository") ;;既に開いてstageしてあるMagitのバッファを表に出す。
  (magit-commit-create) ;;そのバッファ上でmagit-commit-createを実行する。
)

一回目はconfigやrev-parseのキャッシュが済んでいないのでやや遅くなります。

TM	     0.023	+     0.023	          	Enter #[128 \300\301\302^C#\207 [apply my-magit-process-cache--commit-create #<subr magit-commit-create> nil] 5 nil (byte-code ^C\203
\0\301\302 BC\207\302 C\207 [current-prefix-arg --amend magit-commit-arguments] 2)]
TM	    90.752	+    90.729	    90.361	Eval   #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   170.682	+    79.930	    79.417	Eval   #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   250.379	+    79.697	    78.845	Eval   #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   347.523	+    97.144	    75.891	Eval   #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   347.642	+     0.119	          	Enter  #<subr git-commit-setup-font-lock-in-buffer>
TM	   347.666	+     0.024	     0.017	Leave  #<subr git-commit-setup-font-lock-in-buffer>
TM	   347.678	+     0.012	          	Enter  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   347.698	+     0.020	     0.014	Leave  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   360.608	+    12.910	   360.541	Leave #[128 \300\301\302^C#\207 [apply my-magit-process-cache--commit-create #<subr magit-commit-create> nil] 5 nil (byte-code ^C\203
\0\301\302 BC\207\302 C\207 [current-prefix-arg --amend magit-commit-arguments] 2)]
TM	   360.700	+     0.092	          	Enter #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   360.726	+     0.026	     0.014	Leave #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   534.973	+   174.247	          	Enter #<subr server-execute>
TM	   542.818	+     7.845	          	Enter  #<subr normal-mode>
TM	   542.860	+     0.042	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   617.753	+    74.893	    74.777	Eval     #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   618.189	+     0.436	    75.309	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   618.229	+     0.040	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   712.136	+    93.907	    84.548	Eval     #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   789.723	+    77.587	    77.278	Eval     #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   866.628	+    76.905	    76.519	Eval     #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   866.940	+     0.312	   248.700	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   871.546	+     4.606	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   872.208	+     0.662	     0.643	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   872.240	+     0.032	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   881.868	+     9.628	     9.617	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   882.129	+     0.261	   339.300	Leave  #<subr normal-mode>
TM	   882.152	+     0.023	          	Enter  #<subr git-commit-setup>
TM	   967.860	+    85.708	    84.202	Eval    #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   973.618	+     5.758	    91.407	Leave  #<subr git-commit-setup>
TM	   973.642	+     0.024	          	Enter  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   973.660	+     0.018	     0.011	Leave  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   977.661	+     4.001	          	Enter  #<subr magit-commit-diff>
TM	   984.019	+     6.358	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   984.049	+     0.030	     0.022	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   984.078	+     0.029	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   984.107	+     0.029	     0.023	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	  1110.370	+   126.263	   125.311	Eval    #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	  1111.088	+     0.718	   133.404	Leave  #<subr magit-commit-diff>
TM	  1113.181	+     2.093	   578.189	Leave #<subr server-execute>

問題は二回目以降です。

TM	     0.023	+     0.023	          	Enter #[128 \300\301\302^C#\207 [apply my-magit-process-cache--commit-create #<subr magit-commit-create> nil] 5 nil (byte-code ^C\203
\0\301\302 BC\207\302 C\207 [current-prefix-arg --amend magit-commit-arguments] 2)]
TM	    87.735	+    87.712	    87.139	Eval   #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   103.653	+    15.918	   103.562	Leave #[128 \300\301\302^C#\207 [apply my-magit-process-cache--commit-create #<subr magit-commit-create> nil] 5 nil (byte-code ^C\203
\0\301\302 BC\207\302 C\207 [current-prefix-arg --amend magit-commit-arguments] 2)]
TM	   296.154	+   192.501	          	Enter #<subr server-execute>
TM	   303.936	+     7.782	          	Enter  #<subr normal-mode>
TM	   303.981	+     0.045	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   304.298	+     0.317	     0.307	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   304.312	+     0.014	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   314.016	+     9.704	     9.693	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   316.569	+     2.553	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   316.849	+     0.280	     0.270	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   316.863	+     0.014	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   326.005	+     9.142	     9.132	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   326.220	+     0.215	    22.274	Leave  #<subr normal-mode>
TM	   326.240	+     0.020	          	Enter  #<subr git-commit-setup>
TM	   405.085	+    78.845	    77.140	Eval    #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   409.544	+     4.459	    83.276	Leave  #<subr git-commit-setup>
TM	   409.580	+     0.036	          	Enter  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   409.598	+     0.018	     0.010	Leave  #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   413.333	+     3.735	          	Enter  #<subr magit-commit-diff>
TM	   418.831	+     5.498	          	Enter   #<subr git-commit-setup-font-lock-in-buffer>
TM	   418.852	+     0.021	     0.014	Leave   #<subr git-commit-setup-font-lock-in-buffer>
TM	   418.864	+     0.012	          	Enter   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   418.882	+     0.018	     0.012	Leave   #<subr magit-auto-revert-mode-enable-in-buffers>
TM	   543.655	+   124.773	   123.842	Eval    #[128 \300\301\302^C#\207 [apply my-call-process-for-bypassing-git-encwrapper #[128 \300\301\302^C#\207 [apply my-procargfix-advice--call-process #<subr call-process> ((depth . 99))] 5 nil] nil] 5 nil]
TM	   544.376	+     0.721	   131.027	Leave  #<subr magit-commit-diff>
TM	   546.288	+     1.912	   250.112	Leave #<subr server-execute>

546ms！　全く引っかかりが無いとは言えませんが、実用上ほとんど問題ない程度になったと思います。元が7822msでしたから元の6.98%にまで減ったことになります。

もちろん三回目以降も同じような時間になりますし、Magitのバッファを削除して再度magit-statusを実行してから計測すると、一回目の時間になります。キャッシュのクリアも機能しています。

ここまではコミットメッセージを書けるようになるまでの時間を改善してきましたが、それ以外の部分でも改善の余地がありました。

プロセスの起動回数を削減することでコミットログを編集するまでに約8秒かかっていたものが約0.5秒まで短縮できました。

その代わりに細かい制限が増えていますが私の使用状況ではほとんど支障は無い程度です。

MagitがWindowsで遅い原因には次のようなものがあります。

• Magitの設計がごく短時間でプロセスを起動できるOSを前提にしたものになっていてWindowsがそうではない
• EmacsやGitにもWindows版には多少のオーバーヘッドがある

開発者は問題を認識しており、様々な対策を講じてきたようです。特にlibgitを使ったアプローチは魅力的です。しかしlibgitを使うことで生じる問題や、何よりこの改善がWindowsユーザーしか喜ばない点でなかなか進まないようです。

いつかはより根本的な対策がなされると思いますが、それまではこのような小手先の改善で回避していく方が現実的かもしれません。

最終的なコードは次の場所に配置してあります。

misohena/my-magit-speedup-for-windows: My setup files for Magit on MS-Windows.

調べたところ三つの原因が見つかりました。

• CreateProcessA(ANSI版、非UNICODE版)を使っている
• コマンドライン引数の文字エンコーディングが間違っている場合がある
• Emacsの引数のエスケープ処理に問題がある

一つ目は、Emacsが子プロセスを起動するのにWin32APIのCreateProcessAを使っていることです。CreateProcessAはANSI文字列版(MBCS版)であり、CreateProcessWというWide文字列版(UNICODE版)ではありません。なのでどう逆立ちしても(CP65001でも使わない限り)UNICODEは使用できません。現在のコードページに沿った文字エンコーディング(日本の場合はCP932、ほぼShift_JIS)で表現できる範囲の文字しか引数として使用できません。

二つ目は、Emacsの設定によってはCreateProcessAにUTF-8等の間違った文字エンコーディングの文字列が渡されてしまうことです。ただ、私は普段CP932をデフォルトにしているのでこの原因で問題が起きたことはありません。

三つ目は、Emacsのコマンドライン引数処理に複数の問題があることです。マルチバイト文字を考慮していないため、2バイト目が5Cである文字(いわゆるダメ文字)に反応して余計な\(バックスラッシュ)を挿入してしまいます。また、Cygwin向けのエスケープ処理にも不十分なところがあります。

この辺りの処理はEmacsのソースコードの emacs/src/w32proc.c にあります。

emacs/w32proc.c at 5a223c7f2ef4c31abbd46367b6ea83cd19d30aa7 · emacs-mirror/emacs

一つ目の問題を直そうと思ったらEmacsのソースコードを修正してCreateProcessWを使うようにすべきでしょう。自分でビルドせず配布されているバイナリを使いたいのであれば諦めるよりありません。無理矢理何とかする方法も思いつかなくはないですが(他のプログラム、DLLを経由するとか、@でファイルの中身を引数に挿入する仕組みを使うとか)、止めておきます。

二つ目の問題は、事前に文字列をCP932に変換することで回避できます。

三つ目の問題は、 w32-quote-process-args をnilにしてEmacsの問題のある引数処理を抑制しつつ自分で引数を処理することで回避できます。

一つ目はともかく、二つ目と三つ目はEmacs Lispのレベルで何とかできそうです。

Webを探したところ、次のようなページが見つかりました。

UTF-8 をベースとして利用するための設定 - NTEmacs @ ウィキ - atwiki（アットウィキ）

「UTF-8をベースとして」ということですが、CP932のままで使用しようとした場合も結局は同じ問題が発生します(特にダメ文字問題)。

というわけで、そのページの下の方で紹介されているコードを試したところ、概ね問題が解消しました。

「概ね」と書いたのは完全には解消していなかったからです。

そのコードを詳しく見てみると、肝心のコマンドライン引数処理の部分が非常にシンプルな正規表現置換でした。「はて、本当にそれで良いのかな？」と思って色々調べたところ少しだけ改善の余地がありました。

その辺りとともに全体的に自分なりに整理して沢山コメントを入れたのが次のコードです。

;;;; 子プロセスに渡すコマンドライン引数を修正する(NTEmacs用 28.1で確認)

;; Windows版のEmacsで子プロセスを起動するときのコマンドライン引数に関する
;; 二つの問題を修正する。
;;
;; - 文字エンコーディングの問題
;; - エスケープ処理(quoting)の問題

;; Emacsが何をしているのかは emacs/src/w32proc.c の sys_spawnve 関数を
;; 見ること。

;;;;; Cygwinプログラム判定

;; 引数の変換処理方式はCygwinのプログラムかどうかで変える必要がある。
;; Cygwinのプログラムかどうかはexeがcygwin1.dllを必要としているかで判別する。

(defun my-procargfix-cygwin-program-p-no-cache (filename)
  "FILENAMEがCygwinのプログラムならtを返します。(キャッシュ不使用)"
  ;; cygwin1.dllを使っているかで判定する。
  ;; emacs/src/w32proc.c の w32_executable_type も似たような事をしている。
  (with-temp-buffer
    (let ((w32-quote-process-args nil)) ;;lddのCygwin判定(再帰)を抑制する。
      (when (eq (call-process "ldd" nil t nil (concat "\"" filename "\""))
                0)
        (goto-char (point-min))
        (number-or-marker-p
         (re-search-forward "cygwin[0-9]+\.dll" nil t))))))

(defvar my-procargfix-fullpath-cache nil) ;;2022-11-18追加
(defvar my-procargfix-ldd-cache nil)

(defun my-procargfix-cygwin-program-p (filename)
  "FILENAMEがCygwinのプログラムならtを返します。(キャッシュ使用)"
  (let ((abs-fname (and (stringp filename)
                        ;;(executable-find filename) ;;9ms! Very Slow!! ;;2022-11-18削除
                        (or (cdr (assoc filename my-procargfix-fullpath-cache))
                            (cdar (push (cons filename (executable-find filename)) my-procargfix-fullpath-cache))) ;;2022-11-18追加
                        )))
    (when abs-fname
      (or
       (cdr (assoc abs-fname my-procargfix-ldd-cache))
       (let ((cyg-p (my-procargfix-cygwin-program-p-no-cache abs-fname)))
         (push (cons abs-fname cyg-p) my-procargfix-ldd-cache)
         cyg-p)))))

;;2022-11-18追記: executable-findは滅茶苦茶遅いのでキャッシュするようにした。しかしファイルを移動したときはキャッシュのクリアが必要になってしまった。
(defun my-procargfix-clear-cache ()
  (interactive)
  (setq my-procargfix-fullpath-cache nil)
  (setq my-procargfix-ldd-cache nil)) ;;2022-11-18追加


;;;;; 引数の変換処理

;; CreateProcessにコマンドライン引数を引き渡すとき、全ての引数を一つの
;; 文字列に結合しなければならない。
;; そのために各引数を二重引用符で囲み範囲を明確にする必要がある。
;; 特殊な意味に用いられる文字はエスケープしなければならない。
;; また、CreateProcessAを使用しているので確実にCP932(日本であれば)
;; でエンコードする必要がある。

(defun my-procargfix-quote-for-cygwin (arg)
  "Cygwinプログラムへの引数ARGを二重引用符で囲みます。"

  ;; Cygwinが渡された引数をどのように展開するかは次のソースを参照すること。
  ;; https://github.com/mirror/newlib-cygwin/blob/master/winsup/cygwin/dcrt0.cc

  ;; 基本的には \ と " をエスケープする。
  ;;  \ => \\
  ;;  " => \"
  (cond
   ;; ただし変換後(囲った後)が "\\server\..." の形式になると
   ;; Cygwin側でエスケープシーケンスの処理が抑制されてしまう。
   ;; 例えばgrepで \sXXX\s と書くと変換後の "\\sXXX\\s" は
   ;; この形式にマッチしてしまう。
   ;; こうなるとCygwin側に渡したときに元の文字列に戻らない。
   ;; なので、変換後の先頭が\二文字になるのを避ける。
   ;; 変換前の先頭に\が一文字ならば、それはエスケープしないようにする。
   ;; 変換後が "\sXXX\\s" ならば \sXXX\s に戻る。
   ((and (>= (length arg) 2)
         (= (elt arg 0) ?\\)
         (/= (elt arg 1) ?\\)
         (/= (elt arg 1) ?\")) ;;is_dos_pathの後半部分に相当
    (concat "\""
            (substring arg 0 2)
            ;; 最初の2文字より後は通常通りエスケープする。
            (replace-regexp-in-string "[\\\\\"]" "\\\\\\&" arg t nil nil 2)
            "\""))
   ;; また、同様に "C:..." の形式でも
   ;; Cygwin側でエスケープシーケンスの処理が抑制されてしまう。
   ;; 例えばgrepで A:\sXXX\s と書くと変換後の "A:\\sXXX\\s" は
   ;; この形式にマッチしてしまう。
   ;; 先頭のアルファベットを二重引用符の外に出すことで回避する。
   ;; 変換後が A":\\sXXX\\s" ならば A:\sXXX\s に戻る。
   ((and (>= (length arg) 2)
         (or (<= ?A (elt arg 0) ?Z)
             (<= ?a (elt arg 0) ?z))
         (= (elt arg 1) ?:)) ;;isdriveに相当
    (concat (substring arg 0 1)
            "\""
            ;; 最初の1文字より後は通常通りエスケープする。
            (replace-regexp-in-string "[\\\\\"]" "\\\\\\&" arg t nil nil 1)
            "\""))
   ;; 通常のケース。
   ;;  \ => \\
   ;;  " => \"
   (t
    (concat "\""
            (replace-regexp-in-string "[\\\\\"]" "\\\\\\&" arg t)
            "\"")))
  ;; 注意: CYGWIN=noglobの場合はサポートしない。
  ;; noglobが指定されると、単に二重引用符の間がそのまま出力されるようになる。
  ;; その時二重引用符は強制的に消される(quoted関数、winshell=0時の動作)。
  ;; 二重引用符の中に""や\"を書いても特別扱いされない。
  ;; "ABC""DEF" => ABCDEF
  ;; "ABC\"DEF" => ABC\DEF
  ;; こうなると二重引用符を再現するのはどうやっても不可能となる。
  )

(defun my-procargfix-quote-for-windows (arg)
  "通常のWindowsプログラムへの引数ARGを二重引用符で囲みます。"
  ;; 通常のWindowsプログラムがコマンドライン引数をどのように展開するかは
  ;; 次のページを参照すること。
  ;; https://docs.microsoft.com/ja-jp/cpp/c-language/parsing-c-command-line-arguments?view=msvc-170

  ;; 二重引用符で囲った上で、
  ;; 0個以上の\の後に"が来るケースだけ処理すれば十分なはず。
  ;; \{0..n個}" => \{n*2個}\"
  (concat "\""
          (replace-regexp-in-string "\\(\\\\*\\)\"" "\\1\\1\\\\\"" arg)
          "\""))

(defun my-procargfix-convert-prog-args (prog-name prog-args)
  "コマンドPROG-NAMEに引き渡す引数リストPROG-ARGSを変換します。"
  ;; 独自のエスケープ処理をする。
  (setq prog-args
        ;;この中からcall-processが呼ばれる場合があることに注意
        (mapcar (if (my-procargfix-cygwin-program-p prog-name)
                    #'my-procargfix-quote-for-cygwin
                  #'my-procargfix-quote-for-windows)
                prog-args))

  ;; 確実にCP932にする。
  ;; CreateProcessA(ASCII版)に引き渡すコマンドライン引数のエンコーディングは
  ;; 現在のコードページのものでなければならない。
  ;; 最終的にUTF-16に変換されてサブプロセスに渡されるので、
  ;; どのみち自由なバイト列は指定できない。
  (setq prog-args
        (mapcar (lambda (arg)
                  (if (multibyte-string-p arg)
                      (encode-coding-string arg 'cp932)
                    arg))
                prog-args))
  prog-args)

;;;;; 子プロセス起動関数の書き替え

;; call-process、call-process-region、start-processにadviceを仕掛ける。
;; コマンドライン引数部分を事前に変換する。

(defun my-procargfix-apply (orig-fun fun-args prog-pos args-pos)
  "子プロセスを呼び出す関数をコマンド引数部分を修正して呼び出します。

呼び出す関数はORIG-FUN、その関数に引き渡す引数はFUN-ARGS、プログ
ラム名はFUN-ARGSのPROG-POS番目、コマンド引数部分はFUN-ARGSの
ARGS-POS番目以降です。"
  ;; 関数引数リスト(fun-args)のコマンド引数部分(args-pos以降)を加工する。
  ;; すでにw32-quote-process-argsがnilのときは余計なことはしない。
  (when w32-quote-process-args
    (setf (nthcdr args-pos fun-args)
          (my-procargfix-convert-prog-args
           (nth prog-pos fun-args)
           (nthcdr args-pos fun-args))))

  ;; (2023-05-08追記: 空白を含む実行ファイル(Program Files)を起動したときに引数列がおかしくなる問題に対処した)
  ;; 実行ファイルパスを加工する。
  ;; w32-quote-process-argsをnilにすると実行ファイルパスが二重引用符で
  ;; 囲まれなくなる。そうすると空白を含む実行ファイルパスが正しく呼び
  ;; 出し先のargv[0]に設定されなくなる。
  ;; w32-quote-process-argsをnilにする以上どうしようも無いので、
  ;; 空白文字を含む場合はショートファイル名にして回避する。
  ;; ただし、exeやbatが省略された場合はうまく行かないかもしれない。
  (when w32-quote-process-args
    (let ((prog-name (nth prog-pos fun-args)))
      (when (seq-contains-p prog-name ?  #'eq)
        (setf (nth prog-pos fun-args)
              (or (w32-short-file-name prog-name) prog-name)))))

  ;; Emacsのエスケープ処理を抑制して元の関数を呼び出す。
  ;;(message "args=%s" fun-args)
  (let ((w32-quote-process-args nil))
    (apply orig-fun fun-args)))

(defmacro my-procargfix-add-advice (target-func prog-pos args-pos)
  (let ((ad-func
         (intern (format "my-procargfix-advice--%s" target-func))))
    `(progn
       (defun ,ad-func (orig-fun &rest fun-args)
         (my-procargfix-apply orig-fun fun-args ,prog-pos ,args-pos))
       (advice-add (quote ,target-func)
                   :around
                   (quote ,ad-func)
                   '((depth . 99))))))

(my-procargfix-add-advice call-process        0 4)
(my-procargfix-add-advice call-process-region 2 6)
(my-procargfix-add-advice start-process       2 3)
;;@todo make-processには対応していない。

テスト:

// コマンドライン引数をそのまま表示するだけのプログラム。
// echoargs-cyg.exe : Cygwinのg++でビルドした物。
// echoargs-vc.exe : VC++でビルドした物。
#include <iostream>

int main(int argc, char *argv[])
{
    for(int i = 0; i < argc; ++i){
        std::cout << i << ":" << argv[i] << std::endl;
    }
}

(defun my-procargfix-test-exec (program arg)
  "PROGRAMをコマンドライン引数としてARGを与えて起動する。表示された引数文字列を回収してリストで返す。"
  (let (;;(coding-system-for-read 'utf-8-dos)
        (coding-system-for-read 'cp932-dos)
        (buffer (get-buffer-create "*Output*")))
    (with-current-buffer buffer
      (delete-region (point-min) (point-max))
      (call-process (expand-file-name program) nil buffer t arg)
      (goto-char (point-min))
      (cl-loop while (re-search-forward "^[0-9]+:\\(.*\\)$" nil t)
               collect (match-string 1)))))

(defun my-procargfix-test-exec-exam (program arg)
  (equal (cdr (my-procargfix-test-exec program arg))
         (list arg)))

;; 実行して元に戻るかを確認する。
(let ((test-cases
       '("abc"
         "Program Files"
         "abc\"\" \\\\\\\""
         "abc\"def\"\"ghi\"\"\"jkl\"\"\"\"mno"
         "abc\\def\\\\ghi\\\\\\jkl\\\\\\\\mno"
         "abc'def''ghi'''jkl''''mno"
         ;; 先頭がネットワークパスになりかねないケース
         "\\sABC\\s"
         "\\sABC"
         "\\\"sABC"
         "\\\\sABC"
         ;; ドライブレターで始まるケース
         "c:\\sABC\\s\"DEF\""
         ;; 空
         ""
         ;; ダメ文字
         "表示"
         "\\表\\示"
         ;; GLOBっぽい文字列
         "*.el"
         "~/"
         ))
      (ok 0)
      (ng 0))
  (dolist (program '("echoargs-vc.exe" "echoargs-cyg.exe"))
    (dolist (arg test-cases)
      (if (my-exec-test program arg)
          (cl-incf ok)
        (cl-incf ng)
        (message "Fail %s" arg))))
  (message "OK:%s, NG:%s" ok ng))

Emacsからgrepを使ったときに問題が起きることがあるのは昔から気がついていました。ただ、色々と工夫するとたいていの場合問題を回避できてしまうのであまり深く追求することはありませんでした。

そもそも素のgrepはCP932に対応していないので普段あまり使っていません。日本で使われている複数の文字エンコーディングに対応したgrepとして昔はlv(をlgrepにリネームした物。Emacsのlgrepコマンドと紛らわしいので以下単にlv)を使用していました。しかしlvはGNU grepよりも機能が劣るため、grepの設定(grep-command等)を流用するパッケージでたまに問題が起きました(grepにあるオプションが存在しない等)。そこで最近はlvをエンコーディング変換にのみ使用してgrepとパイプで繋げるスクリプト(lvgrep)を作成して使っていました。そうこうするうちにCounselでripgrepを使うようになりました。なので外部のgrepコマンドはripgrepで統一してしまおうとgrep-commandにrgを指定したのですが様々な問題が発生しました。そのうちの一つが今回のダメ文字によって引数が壊れるというものでした。

正直ここまで面倒くさいことになるとは思いませんでした。たかがgrepを完全に動作させたいだけなのに。Emacsは(Windowsでは)grepもまともに使えないエディタなんです。

だいたいM-x grepのインタフェースは原始的すぎますよね。他にもlgrepとかrgrepとかzgrepとかzrgrep(rzgrep)とかgrep-find(find-grep)とかfind-grep-diredとかgrepと名の付くものはいったいEmacsに幾つ入っているのか調べてしまいましたよ。Emacsの機能だけを使ったgrepも悪くないと思うんですけどね。moccur-grepとか。外部のコマンドに依存しないのでWindowsでも安定して動きます。まぁ、速度は多少遅いかもしれませんが。diredからA(dired-do-find-regexp)とかQ(dired-do-find-regexp-and-replace)とかも結構便利だったりします。最近はconsult-ripgrepを使ってみています。Embarkで検索結果を普通のgrepのように別バッファに移したりも出来ます。grep一つとってもEmacsはとても難しくてなかなか人にお勧めできないエディタだなとつくづく思う次第です。

そういえば今回の問題に関連すると思われるメーリングリストの投稿を見ました。

https://lists.gnu.org/archive/html/bug-gnu-emacs/2013-01/msg01211.html

2013年だからもうずいぶん前ですよね。私は英語がとても苦手で中学時代にずっと2を取り続けたくらいなので正確な意味は分かりませんが、コマンドライン引数のエンコーディングに制限を課すべきでは無いと言っているのでしょうか。どうなんでしょうね。まずエスケープ処理をしている段階で既に特定のエンコーディングに制限されてしまっています。文字が\か"か判別する方法はエンコーディングによって変わりますからね。Cygwinですら今やマルチバイト文字を考慮してargvを組み立ててますよ。第一CreateProcessに渡すコマンドライン引数はA版なら現在のコードページ、W版ならUTF-16と決まっています。A版には何でも好きなバイト列を放り込めるわけでは無く、それはUTF-16に変換されて子プロセスに引き渡されます。spellerというのが何か知りませんが、そんな使い方をする人が実際にいるのでしょうか。少なくともWindowsではいないでしょう(出来ないので)。制限を課したくないと言いながら文字列をぶっ壊して特定の文字列を使えなくしてOSにはないEmacs独自の制限を新たに付け加えているのですから何を言っているんだろうという感じです。

誰かこの部分CreateProcessWでUNICODE化してくれませんかね。

既にWSL2上に移行した人も居るようですし今更感もある話題ですが、私はまだまだWindowsのネイティブ版を使い続けるつもりなので今後もおかしな挙動に悩まされ続けることでしょう。