Re: [O] spee-up table refresh

[Thierry Banel]

Le 09/01/2017 00:24, Nicolas Goaziou a écrit :

> Note that recalculating a table is inherently quadratic.

Well, on the test-case your change made recalculation linear (which is
good):

|  rows | seconds |
|---+-|
|  1000 | 1.5 |
| 1 |  13 |
| 2 |  25 |
| 3 |  37 |

>
>> Here is a test case.
>>
>> 1- First create a 1000 row table:
>>
>> #+BEGIN_SRC elisp :results none
>>   (goto-char (point-max))
>>   (let ((i 1000))
>> (while (> i 0)
>>   (insert (format "| %4s | |\n" i))
>>   (setq i (1- i
>>   (insert "#+TBLFM: $2=$1*10\n")
>> #+END_SRC
>>
>> 2- Then, with point in the table, type C-u C-c *
> I limited calls to `org-element-at-point'. It should be much faster now.
> Thank you.
>

And you did so through an impressively light change: swapping two lines
with a test on `suppress-analysis'.

Thanks and regards.
Thierry

Re: [O] spee-up table refresh

[Nicolas Goaziou]

Hello,

> I don't understand those 3 lines

The prevent matching a table below

  #+begin_example
  | I'm not a table |
  #+end_example
  
> without them (the 688 tests work as expected). Those lines indirectly
> call (org-element--cache-put) a quadratic number of times. For a 1000
> rows table this is 501500 times (about 1000x1000/2 times).

Note that recalculating a table is inherently quadratic.

> Here is a test case.
>
> 1- First create a 1000 row table:
>
> #+BEGIN_SRC elisp :results none
>   (goto-char (point-max))
>   (let ((i 1000))
> (while (> i 0)
>   (insert (format "| %4s | |\n" i))
>   (setq i (1- i
>   (insert "#+TBLFM: $2=$1*10\n")
> #+END_SRC
>
> 2- Then, with point in the table, type C-u C-c *

I limited calls to `org-element-at-point'. It should be much faster now.
Thank you.

Regards,

-- 
Nicolas Goaziou

[O] spee-up table refresh

[Thierry Banel]

Re-computing a large table is slow. Hereafter is a test case for a 1000
row table. My computer refreshes it in 44 seconds.

Here is a fast-and-dirty-not-to-be-commited patch which speed-up the
refresh to less than 1 second. I just removed the last 3 lines of
(org-at-table-p).

I don't understand those 3 lines, but everything still works fine
without them (the 688 tests work as expected). Those lines indirectly
call (org-element--cache-put) a quadratic number of times. For a 1000
rows table this is 501500 times (about 1000x1000/2 times).

#+BEGIN_SRC elisp :results none
(defun org-at-table-p ( table-type)
  "Non-nil if the cursor is inside an Org table.
If TABLE-TYPE is non-nil, also check for table.el-type tables.
If `org-enable-table-editor' is nil, return nil unconditionally."
  (and
   org-enable-table-editor
   (save-excursion
 (beginning-of-line)
 (looking-at-p (if table-type "[ \t]*[|+]" "[ \t]*|")))
))
;   (or (not (derived-mode-p 'org-mode))
;   (let ((e (org-element-lineage (org-element-at-point) '(table) t)))
; (and e (or table-type (eq (org-element-property :type e) 'org)))
#+END_SRC

Here is a test case.

1- First create a 1000 row table:

#+BEGIN_SRC elisp :results none
  (goto-char (point-max))
  (let ((i 1000))
(while (> i 0)
  (insert (format "| %4s | |\n" i))
  (setq i (1- i
  (insert "#+TBLFM: $2=$1*10\n")
#+END_SRC

2- Then, with point in the table, type C-u C-c *

Regards,
Thierry