how to speed up org-babel-tangle?

Question

I have an org file of 470 lines, 20 headings and 15 noweb references.

From it I tangle 2 files that are 250 lines and differ very little. Tangling takes over a minute and a lot of painful redisplay:

• the modeline shows clauses being tangled
• the buffer jumps to the different references

How can I speed this up? I tried the following but it has no effect:

;; tangle is too slow, try to speed it up
(add-hook 'org-babel-pre-tangle-hook 
          (defun my-org-babel-pre-tangle-hook () (setq inhibit-redisplay t)))
(add-hook 'org-babel-post-tangle-hook 
          (defun my-org-babel-pre-tangle-hook () (setq inhibit-redisplay nil)))

Also, I'm afraid that if it had effect, an exception (or user-quit) may leave inhibit-display on and lock me out of emacs.

Answer 1

I have a growing org file of 5000 lines, 200 headings and 150 noweb references.

I tangle a 3000 lines file.

Using the built-in org-babel-tangle takes over 10 minutes.

I wrote ob-tangle.pl to do - quickly, under a second - the limited feature tangle I need:

#!/usr/bin/perl
# ob-tangle.pl -- simplified noweb tangle of a named org-mode SRC block
# ob-tangle.pl  file.org  main
#     Named block must start with (just) 2 lines: #+NAME: and #+BEGIN_SRC:
#         #+NAME: main
#         #+BEGIN_SRC ...
#         ...
#         #+END_SRC
#     Tangled code is sent to STDOUT.
#     All BEGIN_SRC parameters (like ":comments noweb") are ignored.

die "Usage: ob-tangle.pl orgFilename srcBlockName"
    if @ARGV != 2;
my ($orgFile, $blockName, @rest) = @ARGV;
my %name_src = readNamedSrcBlocks($orgFile);
tangle($blockName, 0);  # 0 means no added indent

sub tangle {
    my ($blockName, $indent) = @_;
    my $spaces = ' ' x $indent;
    my $src = $name_src{$blockName};
    my @src = split /^/, $src;
    while (my $srcline = shift @src) {
        chomp $srcline;  # remove trailing linefeed
        my ($spaces2, $nowebName) = $srcline =~ /^(\s*)<<(.+?)>>\s*$/;
        if ($nowebName) {
            my $indent2 = length($spaces2);
            tangle($nowebName, $indent2+$indent);
        } 
        else {
            print $spaces, $srcline, "\n";
        }
    }
}

sub readNamedSrcBlocks {
    my ($orgFile) = @_;
    open(my $F, '<', $orgFile) || die "Can't open $orgFile: $!";
    my $text = join('', <$F>);
    close $F;
    (%name_src) = $text =~ /^\s*#\+NAME:\s*(\S+)\s*?\n\s*#\+BEGIN_SRC.*?\n(.*?)\n\s*#\+END_SRC/msig;
}

Works for me -- YMMV.

Answer 2

Partial answer: this does it and reduces tangling time by about 40% (subjective). But I'm looking for more ways to speed it up. Compared to eg the C preprocessor cpp, org-tangle is very slow.

(defadvice org-babel-tangle-single-block (around inhibit-redisplay activate protect compile)
  "inhibit-redisplay and inhibit-message to avoid flicker."
  (let ((inhibit-redisplay t)
        (inhibit-message t))
    ad-do-it))

(defadvice org-babel-tangle (around time-it activate compile)
  "Display the execution time"
  (let ((tim (current-time)))
    ad-do-it
    (message "org-tangle took %f sec" (float-time (time-subtract (current-time) tim)))))