3fc05c1405
Three quality gaps closed, one of them unlocking the C engine for the most common Chinese configuration: - first-line indent now runs on the 1D DP and the C engine (module 1.5: ekp-c-break-with-arrays grows a 15th arg FIRST-LINE-WIDTH). A line starts at box 0 exactly when i = 0, so no (position x line-count) state is needed; only true parshape and looseness still take the 2D Elisp path. Indented Chinese sample, w=400: C engine 82 ms (this configuration previously bypassed C entirely and ran the heaviest Elisp DP). The C-result reconstruction mirrors the per-line width, and an equivalence test pins indent == the equivalent parshape across engines. - LEFTHYPHENMIN / RIGHTHYPHENMIN are parsed from dictionaries and applied (en_US declares 2/3; the hardcoded 2/2 allowed breaks like "gen-cy" that the dictionary forbids). Explicit overrides still win; partial overrides keep the dictionary's other side. - JIS X 4051 line-start prohibition for small kana, the prolonged sound mark and iteration marks (new defcustom ekp-cjk-no-line-start-extra, char-table backed): っょー々 can no longer start a line. Pure break-permission change; spacing and the DP are untouched. Also fixed in passing: - ekp--split-with-hyphen extracted regexp groups AFTER resolving the hyphenator; dictionary compilation clobbers the match data (latent since the resolver was hoisted; exposed by the HYPHENMIN parser) — groups are captured first now. - ekp--first-indent-pixel goes through the width cache; it runs once per rendered line and was re-measuring the reference glyph every time (C path was 397 ms before, 82 ms after). 4 new ERT tests (92 total); fuzz 300/300 against C 1.5. C module must be rebuilt: make -C ekp_c clean all Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> |
||
|---|---|---|
| .. | ||
| ekp_hyphen.c | ||
| ekp_kp.c | ||
| ekp_module.h | ||
| ekp_paragraph.c | ||
| ekp_thread_pool.c | ||
| ekp.c | ||
| Makefile | ||
| README.md | ||
EKP C Dynamic Module
C implementation of the Knuth-Plass DP for emacs-kp (module version 1.4).
The division of labor: Elisp owns all font-dependent data (tokenization, pixel measurement, glue values, prefix sums); the C module runs only the O(n²) dynamic program. This keeps the two engines byte-identical in output while making the hot loop native.
Architecture
ekp_c/
├── ekp_module.h # Core data structures and API declarations
├── ekp.c # Emacs module entry point (emacs_module_init)
├── ekp_kp.c # Knuth-Plass DP + two-pass emergency strategy
├── ekp_thread_pool.c # Thread pool (parallelism across paragraphs)
├── ekp_hyphen.c # Liang hyphenation (experimental path only)
├── ekp_paragraph.c # C-side tokenization (experimental path only)
└── Makefile
Parallelism model: the DP for one paragraph is sequential (each
position depends on all earlier ones), so the thread pool parallelizes
across paragraphs via ekp-c-break-batch — the correct granularity,
with zero synchronization in the inner loop.
Building
cd ekp_c
make # → ekp.dylib (macOS) / ekp.so (Linux) / ekp.dll (Windows)
Requirements: C11 compiler, Emacs 27.1+ headers, pthreads.
make DEBUG=1 # Debug build with sanitizers
make clean
make info
API (as used by ekp.el)
(ekp-c-init) ; init global state + thread pool
(ekp-c-version) ; => "1.4" — checked by ekp-c-module-load
(ekp-c-thread-count) ; => 8
(ekp-c-cleanup)
;; Synced automatically by ekp.el before every call:
(ekp-c-set-penalties LINE HYPHEN FITNESS LAST-RATIO
&optional CONSEC-HYPHEN LAST-SHORT)
;; Single paragraph (11 args):
(ekp-c-break-with-arrays IDEAL-PREFIX MIN-PREFIX MAX-PREFIX
GLUE-IDEALS GLUE-SHRINKS GLUE-STRETCHES
HYPHEN-POS HYPHEN-WIDTH LINE-WIDTH
LEAD-SPACES TRAIL-SPACES)
;; => (BREAKS . TOTAL-COST)
;; Many paragraphs in parallel: vector of 11-element vectors
(ekp-c-break-batch PARAGRAPHS) ; => vector of (BREAKS . COST)
LEAD-SPACES / TRAIL-SPACES are the space-box run widths that the
Elisp renderer strips from line edges; the DP excludes them from line
metrics so both layers agree exactly (since 1.1).
The DP uses the same two-pass strategy as the Elisp engine: a strict Knuth-Plass pass, then — only when the paragraph end is unreachable — a second pass permitting emergency single-box breaks, so overlong unbreakable tokens can never make the result empty. Badness saturates at 10000 exactly like the Elisp side.
Experimental: self-contained C path
ekp-c-break-lines tokenizes and hyphenates in C
(ekp_paragraph.c, ekp_hyphen.c) with a measurement callback into
Emacs. ekp.el does not use this path; its tokenizer is a
simplified approximation of ekp-split-to-boxes. Kept for
experimentation.
(ekp-c-load-hyphenator "/path/to/hyph_en_US.dic") ; => index
(ekp-c-hyphenate 0 "hyphenation") ; => (2 5)
(ekp-c-break-lines "text..." 0 600 #'string-pixel-width)
Performance
Measured with tests/ekp-bench.el (batch Emacs 30.2, Apple Silicon,
byte-compiled Elisp around the C calls, min of 3 cold-cache runs):
| Case | Elisp engine (compiled) | C engine |
|---|---|---|
| justify text-zh.txt w=200 | 96 ms | 57 ms |
| justify mixed text w=300 | 53 ms | 23 ms |
| range-justify zh 340–380 | 294 ms | 75 ms |
| range-justify mix 280–320 | 480 ms | 34 ms |
| DP only, text-zh w=400 | 15 ms | 1.3 ms |
The pure-DP speedup is ~12× (1.3 ms vs 15 ms); end-to-end gains are
smaller because tokenization, measurement and rendering stay in Elisp.
The C engine matters most for range-justify (many widths per text)
and multi-paragraph batches.